YOLOv9

https://github.com/wongkinyiu/yolov9
Admin
YOLOv9 is an open-source deep learning framework implementing programmable gradient information...
Tokens:34,618
Snippets:360
Trust Score:8.5
License:GPL-3.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Configure Shortcut in YAML

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/modules.md

Example configuration for residual connection addition.

```yaml
[[-1, -3], 1, Shortcut, [0]]  # Add outputs: y = x1 + x2
```

--------------------------------

### Load Model Example

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Demonstrates loading a specific model checkpoint onto a designated device.

```python
from models.experimental import attempt_load

model = attempt_load('yolov9-c.pt', device='cuda:0')
model.eval()
```

--------------------------------

### Initialize and Run Conv

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Example usage of the Conv module to process a tensor.

```python
from models.common import Conv

conv = Conv(64, 128, k=3, s=2, p=1)
x = torch.randn(1, 64, 32, 32)
y = conv(x)  # Output: [1, 128, 16, 16]
```

--------------------------------

### Usage Example for Profile

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Demonstrates how to use the Profile context manager to time a model forward pass.

```python
from utils.general import Profile

dt = Profile()
with dt:
    pred = model(im)
print(f'Inference time: {dt}')
```

--------------------------------

### Configure Docker Environment

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Commands to initialize a Docker container and install necessary dependencies for YOLOv9.

```shell
# create the docker container, you can change the share memory size if you have more.
nvidia-docker run --name yolov9 -it -v your_coco_path/:/coco/ -v your_code_path/:/yolov9 --shm-size=64g nvcr.io/nvidia/pytorch:21.11-py3

# apt install required packages
apt update
apt install -y zip htop screen libgl1-mesa-glx

# pip install required packages
pip install seaborn thop

# go to code folder
cd /yolov9
```

--------------------------------

### Iterate LoadImages

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Example of iterating through a LoadImages dataset to retrieve preprocessed images and metadata.

```python
from utils.dataloaders import LoadImages

dataset = LoadImages('data/images', img_size=640, stride=32)
for path, im, im0, vid_cap, s in dataset:
    # path: str - file path
    # im: np.ndarray - preprocessed image [3, H, W]
    # im0: np.ndarray - original image
    # vid_cap: cv2.VideoCapture or None
    # s: str - log string
```

--------------------------------

### Configure LoadStreams Sources

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Examples of initializing LoadStreams with different input types including webcams, multiple streams, and video files.

```python
# Single webcam
dataset = LoadStreams('0')

# Multiple sources
dataset = LoadStreams(['rtsp://camera1/stream', 'rtsp://camera2/stream'])

# Video files
dataset = LoadStreams(['video1.mp4', 'video2.mp4'])
```

--------------------------------

### YAML Model Configuration Format

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Example structure for defining backbone and head layers in a YAML configuration file.

```yaml
backbone:
  - [-1, 1, Conv, [64, 6, 2, 2]]        # from, number, module, args
  - [-1, 1, Conv, [128, 3, 2]]
  - [-1, 3, Bottleneck, [128]]

head:
  - [-1, 1, Conv, [256]]
  - [[-1, -3], 1, Concat, [1]]          # concatenate outputs
  - [-1, 1, Detect, [num_classes]]
```

--------------------------------

### Model Parsing Logic

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/modules.md

Example of how YAML definitions are mapped to Python class instances.

```python
1. from_indices = -1          # Use previous layer
2. num_repeats = 3            # Create 3 instances
3. module_name = "Bottleneck" # Look up in globals()
4. module_args = [128]        # Pass to constructor

# Result: nn.Sequential(*[Bottleneck(128) for _ in range(3)])
```

--------------------------------

### Get model statistics with model_info

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Calculates and prints model parameters, gradients, and FLOPs.

```python
def model_info(
    model: nn.Module,
    imgsz: tuple = (640, 640),
    verbose: bool = False,
    img_size: int = 640
) -> tuple
```

```python
from utils.torch_utils import model_info

params, grads, flops = model_info(model, imgsz=(1, 3, 640, 640))
```

--------------------------------

### Standard Metric Output Structure

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Example dictionary structure representing the standard metrics returned after model validation.

```python
Results = {
    'metrics/precision(B)': 0.85,
    'metrics/recall(B)': 0.90,
    'metrics/mAP50(B)': 0.88,        # AP @ IoU=0.50
    'metrics/mAP50-95(B)': 0.65,     # AP @ IoU=0.50:0.95 (primary)
    'val/box_loss': 0.025,            # Box regression loss
    'val/cls_loss': 0.018,            # Classification loss
    'val/dfl_loss': 0.012,            # DFL loss
}
```

--------------------------------

### YOLOv9 YAML Model Configuration

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

Example YAML configuration for a YOLOv9 model variant defining classes, multipliers, and network architecture.

```yaml
# YOLOv9 Nano configuration
nc: 80                      # Number of classes
depth_multiple: 0.33        # Model depth multiplier
width_multiple: 0.25        # Model width multiplier
activations:
  - SiLU
  - LeakyReLU

backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 6, 2, 2]]      # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]        # 1-P2/4
  - [-1, 3, RepNBottleneck, [128]]    # 2

head:
  - [-1, 1, Conv, [256, 3, 1]]
  - [[-1, -3], 1, Concat, [1]]
  - [-1, 1, RepNCSPELAN4, [256, 256, 128, 3]]
  - [-1, 1, DualDetect, [80]]
```

--------------------------------

### Evaluation Output Example

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Sample output showing Average Precision (AP) and Average Recall (AR) metrics.

```text
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.530
 Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.702
 Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.578
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.362
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.585
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.693
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.392
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.652
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.702
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.541
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.760
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.844
```

--------------------------------

### Resolve Export Dependency Errors

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Install missing dependencies when encountering runtime errors during model export.

```bash
# Error: TensorRT export without TensorRT installed
python export.py --weights weights.pt --format engine
# RuntimeError: Could not import tensorrt

# Solution: Install required package
pip install tensorrt
```

--------------------------------

### Configure Concat in YAML

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/modules.md

Example configuration for concatenating layers -1 and -3 along dimension 1.

```yaml
[[-1, -3], 1, Concat, [1]]  # Concatenate layers -1 and -3 along dim 1
```

--------------------------------

### Apply letterbox to image

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Example usage of the letterbox function to resize an image loaded via OpenCV.

```python
from utils.dataloaders import letterbox

im = cv2.imread('image.jpg')
im_sized, ratio, pad = letterbox(im, new_shape=(640, 640))
```

--------------------------------

### Validate Image Files with PIL

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Use this snippet to identify corrupted or unsupported image files before starting the training process.

```python
# Solution: Validate image files before training
from PIL import Image
for img_path in image_list:
    try:
        Image.open(img_path).verify()
    except Exception as e:
        print(f"Corrupted: {img_path}")
        # Remove or fix image
```

--------------------------------

### Initialize Multi-GPU Training

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Set environment variables and launch the training script using torch.distributed.launch.

```bash
export RANK=0              # Global process rank
export WORLD_SIZE=4        # Total processes
export MASTER_ADDR=localhost
export MASTER_PORT=9527

# Launch:
python -m torch.distributed.launch --nproc_per_node=4 train.py ...
```

--------------------------------

### Initialize model for inference

Source: https://github.com/wongkinyiu/yolov9/blob/main/tools/reparameterization.ipynb

Sets up the model architecture, loads weights from a checkpoint, and prepares for evaluation.

```python
device = torch.device("cpu")
cfg = "./models/detect/gelan-c.yaml"
model = Model(cfg, ch=3, nc=80, anchors=3)
#model = model.half()
model = model.to(device)
_ = model.eval()
ckpt = torch.load('./yolov9-c.pt', map_location='cpu')
model.names = ckpt['model'].names
model.nc = ckpt['model'].nc
```

--------------------------------

### Run SPPF Forward Pass

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Example usage of the SPPF module with a random input tensor.

```python
sppf = SPPF(512, 512, k=5)
x = torch.randn(1, 512, 20, 20)
y = sppf(x)  # Concatenates original + 3 max-pool levels
```

--------------------------------

### Initialize YOLOv9 Model from Config

Source: https://github.com/wongkinyiu/yolov9/blob/main/tools/reparameterization.ipynb

Sets up the model architecture from a YAML configuration file and loads pre-trained weights.

```python
device = torch.device("cpu")
cfg = "./models/detect/gelan-e.yaml"
model = Model(cfg, ch=3, nc=80, anchors=3)
#model = model.half()
model = model.to(device)
_ = model.eval()
ckpt = torch.load('./yolov9-e.pt', map_location='cpu')
model.names = ckpt['model'].names
model.nc = ckpt['model'].nc
```

--------------------------------

### Load YOLOv9 Model Configuration

Source: https://github.com/wongkinyiu/yolov9/blob/main/tools/reparameterization.ipynb

Initialize the model architecture and load pre-trained weights from a checkpoint file.

```python
device = torch.device("cpu")
cfg = "./models/detect/gelan-s.yaml"
model = Model(cfg, ch=3, nc=80, anchors=3)
#model = model.half()
model = model.to(device)
_ = model.eval()
ckpt = torch.load('./yolov9-s.pt', map_location='cpu')
model.names = ckpt['model'].names
model.nc = ckpt['model'].nc
```

```python
device = torch.device("cpu")
cfg = "./models/detect/gelan-m.yaml"
model = Model(cfg, ch=3, nc=80, anchors=3)
#model = model.half()
model = model.to(device)
_ = model.eval()
ckpt = torch.load('./yolov9-m.pt', map_location='cpu')
model.names = ckpt['model'].names
model.nc = ckpt['model'].nc
```

--------------------------------

### Execute Training Pipeline

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/INDEX.md

Command-line execution for training a YOLOv9 model using specific configuration and data files.

```bash
# See configuration.md for hyperparameter definitions
# See training-inference.md for training pipeline overview
python train_dual.py \
    --weights '' \
    --cfg models/detect/yolov9-c.yaml \
    --data data/coco.yaml \
    --epochs 100 \
    --batch-size 32 \
    --imgsz 640 \
    --device 0
```

--------------------------------

### Load and Run Inference with DetectMultiBackend

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/INDEX.md

Initializes a model from a weights file and performs inference on a dummy tensor. Requires the models.common and torch modules.

```python
# See api-reference.md for DetectMultiBackend class definition
from models.common import DetectMultiBackend
import torch

model = DetectMultiBackend('yolov9-c.pt', device='cuda:0')
im = torch.randn(1, 3, 640, 640)
pred = model(im)
```

--------------------------------

### detect.py Command-Line Arguments

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

List of available flags for configuring model inference, detection parameters, and output behavior in detect.py.

```python
# Model & input
--weights           Path to model weights
--source            Input source (image/video/directory/URL/webcam)
--data              Dataset config (for class names)
--imgsz / --img-size  Inference image size (default: 640)

# Detection parameters
--conf-thres        Confidence threshold (default: 0.25)
--iou-thres         NMS IoU threshold (default: 0.45)
--max-det           Max detections per image (default: 1000)
--device            Device (cuda:0, cpu, etc.)
--classes           Filter by class: --class 0, or --class 0 2 3

# Augmentation & inference modes
--augment           Augmented inference
--visualize         Visualize features
--half              Use FP16 half-precision
--dnn               Use OpenCV DNN for ONNX

# Output & visualization
--view-img          Show results
--save-txt          Save results as .txt
--save-conf         Save confidence scores
--save-crop         Save cropped predictions
--nosave            Don't save images/videos
--hide-labels       Hide class labels
--hide-conf         Hide confidence scores
--line-thickness    Bounding box thickness (pixels, default: 3)

# File organization
--project           Project directory (default: runs/detect)
--name              Experiment name (default: exp)
--exist-ok          Overwrite existing project
--vid-stride        Video frame stride (default: 1)
```

--------------------------------

### Initialize LoadScreenshots

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Constructor for the LoadScreenshots class used to capture frames from the screen.

```python
class LoadScreenshots:
    def __init__(
        self,
        screennum: int | str = 0,
        img_size: int = 640,
        stride: int = 32,
        auto: bool = True
    )
```

--------------------------------

### Training Command Arguments

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

Lists available command-line arguments for train.py and train_dual.py, categorized by function.

```python
# Core arguments
--weights           Path to pretrained weights (.pt file)
--cfg              Model configuration file (models/detect/*.yaml)
--data             Dataset configuration file (data/*.yaml)
--epochs           Number of training epochs (default: 100)
--batch-size       Training batch size (default: 16)
--img-size / --imgsz  Input image size (default: 640)
--rect             Use rectangular training (variable aspect ratio)

# Optimization
--optimizer        Optimizer: SGD, Adam, AdamW (default: SGD)
--lr0              Initial learning rate (default: 0.01)
--lrf              Final LR / initial LR (default: 0.01)
--momentum         SGD momentum (default: 0.937)
--weight-decay     Weight decay (default: 0.0005)
--warmup-epochs    Warmup epochs (default: 3)
--warmup-momentum  Warmup initial momentum (default: 0.8)
--warmup-bias-lr   Warmup bias LR (default: 0.1)

# Augmentation
--hsv-h            HSV hue augmentation (default: 0.015)
--hsv-s            HSV saturation augmentation (default: 0.7)
--hsv-v            HSV value augmentation (default: 0.4)
--degrees          Rotation augmentation degrees (default: 10)
--translate        Translation augmentation fraction (default: 0.1)
--scale            Scale augmentation min (default: 0.5)
--flipud           Flip UD probability (default: 0)
--fliplr           Flip LR probability (default: 0.5)
--mosaic           Mosaic augmentation probability (default: 1.0)
--mixup            Mixup augmentation probability (default: 0)

# Regularization & callbacks
--copy-paste       Copy-paste augmentation probability
--perspective      Perspective augmentation probability
--erasing          Random erasing probability
--patience         EarlyStopping patience (epochs)
--label-smoothing  Class label smoothing epsilon (default: 0)

# Distributed & device
--device           Device (cuda:0, cpu, or GPU IDs)
--workers          Dataloader workers (default: 8)
--sync-bn          Use SyncBatchNorm
--local-rank       DDP local rank

# Logging & saving
--project          Project directory (default: runs/train)
--name             Experiment name (default: exp)
--exist-ok         Overwrite existing project/name
--save-dir         Save results directory
--save-period      Model save interval (epochs, default: -1 = never)
--save-txt         Save results to *.txt
--save-conf        Save confidences in --save-txt labels
--save-json        Save COCO-formatted JSON results

# Validation & testing
--val              Validate every N epochs (default: 1)
--conf-thres       Confidence threshold for evaluation
--iou-thres        NMS IoU threshold for evaluation
--max-det          Maximum detections per image
--augment          Use augmentation during validation
--nosave           Do not save weights
--evolve           Run evolution search (N=300)

# Callbacks & debugging
--hyp              Hyperparameter YAML path
--linear-lr        Linear learning rate schedule
--multi-scale      Train with variable input sizes
--single-cls       Train as single-class
--quad             Use 4x memory dataset
--cache            Cache images in memory (options: ram, disk, None)
--image-weights    Use weighted image selection
--close-mosaic     Close mosaic at N epochs
--overlap          Allow overlap in labels
--min-items        Min items per grid cell (default: 0)
--bucket           Epoch bucket for resuming
--resume           Resume training from checkpoint
--v5-metric        Use YOLOv5 metric calculations
--noplots          Don't save plots
--upload-dataset   Upload final dataset to Roboflow
--bbox-interval    GIF bbox interval (frames)
--artifact-alias   Artifact alias for W&B
```

--------------------------------

### Channel Tracking Flow

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/modules.md

Demonstrates how channel dimensions are tracked through the backbone.

```python
# Backbone flow
input_channels = 3
└─ Conv(64)      → c = 64
   └─ Conv(128)  → c = 128
      └─ Bottleneck(128) → c = 128
         └─ Conv(256, stride=2) → c = 256
```

--------------------------------

### Environment Variables Configuration

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

Environment variables for setting dataset paths, distributed training parameters, and hardware optimization settings.

```bash
# Dataset directory
export YOLOv5_DATASETS_DIR=/path/to/datasets

# Auto-install requirements
export YOLOv5_AUTOINSTALL=true

# Verbose logging
export YOLOv5_VERBOSE=true

# Config directory
export YOLOV5_CONFIG_DIR=/path/to/config

# Distributed training
export RANK=0                    # Global process rank
export WORLD_SIZE=8              # Total processes
export MASTER_ADDR=localhost
export MASTER_PORT=9527

# Optimization
export OMP_NUM_THREADS=8         # OpenMP threads
export NUMEXPR_MAX_THREADS=8     # NumExpr threads
export CUDA_VISIBLE_DEVICES=0,1  # GPU devices
```

--------------------------------

### Train Models on Single GPU

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Commands to initiate training for YOLOv9 or GELAN models on a single GPU device.

```shell
# train yolov9 models
python train_dual.py --workers 8 --device 0 --batch 16 --data data/coco.yaml --img 640 --cfg models/detect/yolov9-c.yaml --weights '' --name yolov9-c --hyp hyp.scratch-high.yaml --min-items 0 --epochs 500 --close-mosaic 15

# train gelan models
# python train.py --workers 8 --device 0 --batch 32 --data data/coco.yaml --img 640 --cfg models/detect/gelan-c.yaml --weights '' --name gelan-c --hyp hyp.scratch-high.yaml --min-items 0 --epochs 500 --close-mosaic 15
```

--------------------------------

### LoadStreams

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Initializes a data loader for video streams, webcams, or video files.

```APIDOC
## LoadStreams

### Description
Loads images from video streams, webcam indices, or video files.

### Constructor
`LoadStreams(sources: str | list, img_size: int = 640, stride: int = 32, auto: bool = True, vid_stride: int = 1)`

### Parameters
- **sources** (str or list) - Required - Stream URLs, webcam index (e.g., '0'), or file paths
- **img_size** (int) - Optional - Target image size
- **stride** (int) - Optional - Model stride
- **auto** (bool) - Optional - Auto-pad
- **vid_stride** (int) - Optional - Frame stride
```

--------------------------------

### Enable Verbose Logging

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Configure detailed logging to output model architecture, layer shapes, and training metrics.

```python
# Enable verbose logging
from utils.general import set_logging
set_logging(verbose=True)

# LOGGER output includes:
# - Model architecture
# - Layer shapes
# - Parameter counts
# - Data loading progress
# - Training metrics
```

--------------------------------

### ComputeLoss Class Initialization

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Initialization parameters for the loss computation class used in YOLOv9 and GELAN architectures.

```python
def __init__(
    self,
    model: nn.Module,
    autobalance: bool = False,
    obj_pw: float = 1.0,
    cls_pw: float = 1.0,
    tal_topk: int = 10
)
```

--------------------------------

### LoadScreenshots

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Initializes a data loader for capturing frames from the screen.

```APIDOC
## LoadScreenshots

### Description
Loads frames from screen capture.

### Constructor
`LoadScreenshots(screennum: int | str = 0, img_size: int = 640, stride: int = 32, auto: bool = True)`

### Parameters
- **screennum** (int | str) - Optional - Screen identifier
- **img_size** (int) - Optional - Target image size
- **stride** (int) - Optional - Model stride
- **auto** (bool) - Optional - Auto-pad
```

--------------------------------

### Configure export.py arguments

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

List of available command-line arguments for model export, including precision, optimization, and format selection.

```python
--weights           Path to model weights (.pt)
--img-size / --imgsz  Input image size (default: 640)
--batch-size        Export batch size (default: 1)
--device            Device (cuda:0, cpu)
--half              Export with FP16 precision
--inplace           Fuse Conv+BN inplace
--keras             Export as TensorFlow Keras model
--optimize          TorchScript optimize for mobile
--int8              Export TensorRT with INT8 quantization
--dynamic           Dynamic axes (ONNX batch size -1)
--simplify          Simplify ONNX model (requires onnx-simplifier)
--opset             ONNX opset version (default: 12)
--workspace         TensorRT workspace GB (default: 4)
--nms               Add NMS to model
--agnostic-nms      Class-agnostic NMS

# Export formats
--format (pt|torchscript|onnx|engine|coreml|saved_model|pb|tflite|edgetpu|tfjs|paddle)
```

--------------------------------

### Initialize DualDetect Head

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Defines the constructor signature for the dual-stream detection head used in dual-branch architectures.

```python
class DualDetect(nn.Module):
    def __init__(self, nc: int = 80, ch: tuple = (), inplace: bool = True)
```

--------------------------------

### Initialize Detect Head

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Defines the constructor signature for the standard YOLO detection head.

```python
class Detect(nn.Module):
    def __init__(self, nc: int = 80, ch: tuple = (), inplace: bool = True)
```

--------------------------------

### Initialize and Bias Detect Head

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Initializes the detection head and applies bias initialization based on stride and class frequency.

```python
from models.yolo import Detect

detect = Detect(nc=80, ch=(256, 512, 1024))
detect.bias_init()
```

--------------------------------

### Image Preprocessing Steps

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Sequential steps to transform raw image input into a model-ready tensor format.

```python
1. Load image (PIL.Image or cv2)
   └─ shape: (H, W, 3)
   
2. Apply letterbox (pad and resize)
   └─ Preserve aspect ratio
   └─ Pad with gray (114, 114, 114)
   └─ shape: (640, 640, 3)
   
3. Convert to tensor
   └─ Permute: (H, W, 3) → (3, H, W)
   └─ Add batch dim: (1, 3, H, W)
   └─ dtype: uint8
   
4. Normalize
   └─ Divide by 255: [0, 255] → [0, 1.0]
   └─ dtype: float32
   
5. Move to device
   └─ GPU if CUDA available
```

--------------------------------

### Resolve Dataset Loading Errors

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Shows how to verify dataset paths and structure to avoid FileNotFoundError.

```python
# Error occurs when:
from utils.dataloaders import LoadImages
dataset = LoadImages('/invalid/path')
```

```python
# Verify path exists
from pathlib import Path
assert Path('data/images').exists()

# Check structure
# data/
# ├─ images/
# │  ├─ train/
# │  └─ val/
# └─ labels/
#    ├─ train/
#    └─ val/
```

--------------------------------

### Download model weights with attempt_download

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Use this function to ensure model weights are available locally, downloading them from a specified repository if they are missing.

```python
def attempt_download(
    repo: str = 'ultralytics/yolov9',
    file: str = 'yolov9-c.pt',
    release_tag: str = 'v0.1'
) -> str
```

--------------------------------

### Synchronize Model and Metrics

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Convert batch normalization to sync version and wrap model in DDP, then use gather/reduce for metrics.

```python
# Sync batch norm across GPUs
model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[rank])

# Reduce metrics across GPUs
all_gather(metric_tensor)  # Collect from all ranks
all_reduce(loss_tensor)    # Sum across ranks
```

--------------------------------

### Dataset and Label Format Documentation

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/INDEX.md

Reference for the expected directory structure and label file format for YOLOv9 datasets.

```text
# See types.md for label format
# See configuration.md for dataset YAML schema
# Dataset structure:
# data/
# ├─ images/
# │  ├─ train/
# │  └─ val/
# └─ labels/
#    ├─ train/
#    └─ val/

# Label format (one per image):
# <class_id> <x_center> <y_center> <width> <height>
# 0 0.5 0.5 0.4 0.6
```

--------------------------------

### Train Models on Multiple GPUs

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Commands to initiate distributed training for YOLOv9 or GELAN models across multiple GPUs using torch.distributed.launch.

```shell
# train yolov9 models
python -m torch.distributed.launch --nproc_per_node 8 --master_port 9527 train_dual.py --workers 8 --device 0,1,2,3,4,5,6,7 --sync-bn --batch 128 --data data/coco.yaml --img 640 --cfg models/detect/yolov9-c.yaml --weights '' --name yolov9-c --hyp hyp.scratch-high.yaml --min-items 0 --epochs 500 --close-mosaic 15

# train gelan models
# python -m torch.distributed.launch --nproc_per_node 4 --master_port 9527 train.py --workers 8 --device 0,1,2,3 --sync-bn --batch 128 --data data/coco.yaml --img 640 --cfg models/detect/gelan-c.yaml --weights '' --name gelan-c --hyp hyp.scratch-high.yaml --min-items 0 --epochs 500 --close-mosaic 15
```

--------------------------------

### LoadImages

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Initializes a data loader for images from a file or directory path.

```APIDOC
## LoadImages

### Description
Loads images from a file, directory, or glob pattern for processing.

### Constructor
`LoadImages(path: str, img_size: int = 640, stride: int = 32, auto: bool = True, vid_stride: int = 1)`

### Parameters
- **path** (str) - Required - File/directory path or glob pattern
- **img_size** (int) - Optional - Target image size
- **stride** (int) - Optional - Model stride for size adjustment
- **auto** (bool) - Optional - Auto-pad images to multiple of stride
- **vid_stride** (int) - Optional - Video frame stride
```

--------------------------------

### Define Training Hyperparameters in YAML

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

Use this YAML structure to define optimizer, loss, and augmentation settings. Ensure the file is referenced during the training process.

```yaml
# Optimizer settings
lr0: 0.01                  # Initial learning rate
lrf: 0.01                  # Final LR = initial LR * lrf
momentum: 0.937            # SGD momentum / beta1 for Adam
weight_decay: 0.0005       # L2 regularization
warmup_epochs: 3.0         # Number of warmup epochs
warmup_momentum: 0.8       # Initial momentum for warmup
warmup_bias_lr: 0.1        # Initial bias LR for warmup

# Loss function weights
box: 7.5                   # Bounding box loss weight
cls: 1.0                   # Classification loss weight
cls_pw: 1.0                # Classification loss power
obj: 1.0                   # Objectness loss weight
obj_pw: 1.0                # Objectness loss power
iou_t: 0.20                # IoU training threshold
anchor_t: 4.0              # Anchor multiple threshold
fl_gamma: 0.0              # Focal loss gamma (0 = disabled)

# Data augmentation
hsv_h: 0.015               # HSV hue augmentation (0-180°)
hsv_s: 0.7                 # HSV saturation augmentation (0.0-1.0)
hsv_v: 0.4                 # HSV value augmentation (0.0-1.0)
degrees: 10.0              # Rotation degrees
translate: 0.1             # Translation as fraction of image size
scale: 0.5                 # Scale augmentation min (0.5 = 0.5x to 1.5x)
flipud: 0.0                # Flip upside-down probability
fliplr: 0.5                # Flip left-right probability
mosaic: 1.0                # Mosaic augmentation probability
mixup: 0.0                 # Mixup augmentation probability
copy_paste: 0.0            # Copy-paste augmentation probability
paste_in: 0.15             # Copy-paste as portion of image
perspective: 0.0           # Perspective augmentation probability
erasing: 0.0               # Random erasing probability
```

--------------------------------

### YOLOv9 Directory Structure

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/README.md

Visual representation of the project file hierarchy, highlighting model configurations and utility modules.

```text
yolov9/
├── models/
│   ├── detect/              # Detection model YAML configs
│   │   ├── yolov9-t.yaml
│   │   ├── yolov9-s.yaml
│   │   ├── yolov9-c.yaml   # Default configs
│   │   └── gelan-c.yaml
│   ├── segment/             # Segmentation model configs
│   ├── panoptic/            # Panoptic model configs
│   ├── common.py            # Core neural network modules
│   ├── experimental.py      # Experimental modules
│   ├── yolo.py              # Model architecture parser
│   └── tf.py                # TensorFlow utilities
├── utils/
│   ├── dataloaders.py       # Image/video loading
│   ├── general.py           # General utilities (60+ functions)
│   ├── metrics.py           # Evaluation metrics
│   ├── augmentations.py     # Data augmentation
│   ├── loss.py              # Loss functions
│   ├── plots.py             # Visualization
│   ├── torch_utils.py       # PyTorch utilities
│   ├── activations.py       # Activation functions
│   └── loggers/             # Logging integrations
├── data/
│   ├── coco.yaml            # COCO dataset config
│   └── images/              # Sample images
├── detect.py                # Inference script
├── detect_dual.py           # YOLOv9 dual-branch inference
├── train.py                 # Training script
├── train_dual.py            # YOLOv9 dual-branch training
├── val.py                   # Validation script
├── export.py                # Model export script
└── requirements.txt         # Dependencies
```

--------------------------------

### Define Shortcut Module

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/modules.md

Specifies the dimension for element-wise addition.

```python
Shortcut: [dimension]
```

--------------------------------

### Train Instance Segmentation Model

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Command to train the GELAN-C instance segmentation model.

```shell
# coco/labels/{split}/*.txt
# polygon (1 instance 1 line)
python segment/train.py --workers 8 --device 0 --batch 32  --data coco.yaml --img 640 --cfg models/segment/gelan-c-seg.yaml --weights '' --name gelan-c-seg --hyp hyp.scratch-high.yaml --no-overlap --epochs 300 --close-mosaic 10
```

--------------------------------

### Validate YAML Configuration

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Illustrates common YAML errors and the required structure for model configuration files.

```yaml
# Error: Invalid YAML
# File: models/detect/broken.yaml
nc: 80
# Missing backbone/head sections!

# Error during model initialization:
model = Model(cfg='models/detect/broken.yaml')
# ValueError: Expected dict for backbone, got None
```

```yaml
# Valid YAML structure
nc: 80
depth_multiple: 1.0
width_multiple: 1.0

backbone:
  - [-1, 1, Conv, [64, 6, 2, 2]]
  
head:
  - [-1, 1, Detect, [80]]
```

--------------------------------

### Initialize LoadImages

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Constructor for the LoadImages class used to load images from files or directories.

```python
class LoadImages:
    def __init__(
        self,
        path: str,
        img_size: int = 640,
        stride: int = 32,
        auto: bool = True,
        vid_stride: int = 1
    )
```

--------------------------------

### Define SP class

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Initializes the Spatial Pooling module.

```python
class SP(nn.Module):
    def __init__(self, k: int = 3, s: int = 1)
```

--------------------------------

### Select device with select_device

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Configures the target device for PyTorch operations. Supports explicit GPU IDs, CPU, or automatic selection.

```python
def select_device(device: str = '') -> torch.device
```

```python
from utils.torch_utils import select_device

device = select_device('cuda:0')  # Explicit GPU
device = select_device('')        # Auto-select best GPU
device = select_device('cpu')     # Force CPU
```

--------------------------------

### Handle Model Loading Errors

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/INDEX.md

Basic try-except block for catching missing weight files during model initialization.

```python
# See errors.md for error patterns
try:
    model = DetectMultiBackend('weights.pt')
except FileNotFoundError:
    # See errors.md "Model Loading Errors" section
    print("Download weights first")
```

--------------------------------

### Initialize DetectMultiBackend

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Defines the constructor signature for the multi-backend inference wrapper.

```python
class DetectMultiBackend(nn.Module):
    def __init__(
        self,
        weights: str | list = 'yolo.pt',
        device: torch.device = torch.device('cpu'),
        dnn: bool = False,
        data: str | None = None,
        fp16: bool = False,
        fuse: bool = True
    )
```

--------------------------------

### Define Shortcut Module

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/api-reference.md

Defines the Shortcut module for performing element-wise addition in skip connections.

```python
class Shortcut(nn.Module):
    def __init__(self, dimension: int = 0)
```

--------------------------------

### Handle Model Loading Errors

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Demonstrates how to trigger and resolve FileNotFoundError when loading model weights.

```python
# Error occurs when:
model = DetectMultiBackend('nonexistent.pt')
# OR
model = DetectMultiBackend('yolov9-c.pt')  # if file not in current directory
```

```python
# Download weights first
from models.experimental import attempt_download
weight_path = attempt_download('yolov9-c.pt')

# Or specify full path
model = DetectMultiBackend('/full/path/to/yolov9-c.pt')
```

--------------------------------

### Model Post-processing Steps

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Steps to convert raw model output into final bounding box detections using NMS.

```python
1. Model inference
   └─ output shape: [1, 25200, 6]
   └─ Contains all candidate detections
   
2. Confidence filtering
   └─ Keep only: conf > conf_thres
   └─ Reduces to ~1000-5000 detections
   
3. NMS (Non-Maximum Suppression)
   └─ For each class:
   │   ├─ Sort by confidence
   │   ├─ Suppress overlapping boxes (IoU > iou_thres)
   │   └─ Keep highest confidence
   └─ Final: ~10-100 detections per image
   
4. Scale boxes
   └─ From 640×640 → original image size
   └─ Account for letterbox padding
   
5. Format output
   └─ Convert to numpy arrays
   └─ Save to files or display
```

--------------------------------

### Implement Automatic Mixed Precision

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Use autocast for FP16 computation and a scaler to manage loss scaling during backpropagation.

```python
with torch.cuda.amp.autocast(enabled=amp):
    pred = model(im)  # FP16 computation
    loss = compute_loss(pred, targets)

scaler.scale(loss).backward()  # Scale loss for FP16
scaler.step(optimizer)          # Unscale before optimizer step
scaler.update()
```

--------------------------------

### Common Module Arguments

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

Reference for argument structures required by various YOLOv9 modules.

```yaml
# Conv: [output_channels, kernel_size, stride, padding]
Conv: [64, 3, 1, 1]

# DWConv: [output_channels, kernel_size, stride]
DWConv: [128, 3, 1]

# Bottleneck: [output_channels, shortcut, groups, expansion_ratio]
Bottleneck: [128, True, 1, 0.5]

# CSP: [output_channels, num_blocks, shortcut, groups, expansion]
CSP: [256, 3, True, 1, 0.5]

# RepNBottleneck: [output_channels, shortcut, expansion]
RepNBottleneck: [128, True, 0.5]

# SPPF: [output_channels, kernel_size]
SPPF: [512, 5]

# ELAN1: [output_channels]
ELAN1: [256]

# RepNCSPELAN4: [in_ch, out_ch, hidden_ch, num_blocks]
RepNCSPELAN4: [256, 256, 128, 3]

# Detect: [num_classes, anchors_list]
Detect: [80, [[10,13, 16,30], [30,61], [116,90]]]

# DualDetect: [num_classes]
DualDetect: [80]

# Concat: [concatenation_dimension]
Concat: [1]
```

--------------------------------

### Initialize ComputeLoss

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Constructor for the ComputeLoss class used to calculate training losses in YOLOv9.

```python
class ComputeLoss:
    def __init__(
        self,
        model: nn.Module,
        autobalance: bool = False,
        obj_pw: float = 1.0,
        cls_pw: float = 1.0
    )
```

--------------------------------

### Initialize LoadStreams

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Constructor for the LoadStreams class used to handle video streams or webcam inputs.

```python
class LoadStreams:
    def __init__(
        self,
        sources: str | list,
        img_size: int = 640,
        stride: int = 32,
        auto: bool = True,
        vid_stride: int = 1
    )
```

--------------------------------

### attempt_download

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/utilities.md

Downloads model weights from a specified repository if they are not already present in the local environment.

```APIDOC
## attempt_download

### Description
Downloads model weights if not present locally.

### Signature
`def attempt_download(repo: str = 'ultralytics/yolov9', file: str = 'yolov9-c.pt', release_tag: str = 'v0.1') -> str`

### Parameters
- **repo** (str) - Optional - The repository name (default: 'ultralytics/yolov9')
- **file** (str) - Optional - The filename of the weights (default: 'yolov9-c.pt')
- **release_tag** (str) - Optional - The release tag to download from (default: 'v0.1')

### Returns
- **str** - Path to the local weight file
```

--------------------------------

### Dataset YAML Configuration

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/configuration.md

Defines the dataset root path, image directories, class count, and class names for training and validation.

```yaml
path: /path/to/dataset         # Dataset root directory
train: images/train2017        # Training images (relative to 'path')
val: images/val2017            # Validation images (relative to 'path')
test: images/test2017          # Test images (optional)

nc: 80                         # Number of classes

names:
  0: person
  1: bicycle
  2: car
  # ... 77 more classes
  79: toothbrush
```

--------------------------------

### Evaluate YOLOv9 Models

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Commands to run evaluation scripts for converted, standard, and GELAN YOLOv9 models.

```shell
# evaluate converted yolov9 models
python val.py --data data/coco.yaml --img 640 --batch 32 --conf 0.001 --iou 0.7 --device 0 --weights './yolov9-c-converted.pt' --save-json --name yolov9_c_c_640_val

# evaluate yolov9 models
# python val_dual.py --data data/coco.yaml --img 640 --batch 32 --conf 0.001 --iou 0.7 --device 0 --weights './yolov9-c.pt' --save-json --name yolov9_c_640_val

# evaluate gelan models
# python val.py --data data/coco.yaml --img 640 --batch 32 --conf 0.001 --iou 0.7 --device 0 --weights './gelan-c.pt' --save-json --name gelan_c_640_val
```

--------------------------------

### Inspect Model and Weights

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/errors.md

Print model summaries and check for NaN values in weights to ensure model integrity.

```python
from utils.torch_utils import model_info

# Print model summary
params, grads, flops = model_info(model, imgsz=(1, 3, 640, 640))
# Output: 25.3M parameters, 102.1G FLOPs

# Check for NaN weights
if torch.isnan(model.state_dict()['model.0.conv.weight']).any():
    print("NaN detected in model weights!")
```

--------------------------------

### Export Quality and Optimization Options

Source: https://github.com/wongkinyiu/yolov9/blob/main/_autodocs/training-inference.md

Configuration flags for controlling model precision and graph optimization during the export process.

```python
# Precision options
--half              # FP16 (faster, slight accuracy loss)
--int8              # INT8 quantization (TensorRT, significant speedup)
--dynamic           # Dynamic batch size (ONNX)

# Optimization options
--simplify          # Simplify ONNX graph (onnx-simplifier)
--optimize          # TorchScript mobile optimization
--nms               # Add NMS to model (faster inference)
```

--------------------------------

### Train Object Detection Model

Source: https://github.com/wongkinyiu/yolov9/blob/main/README.md

Command to train the GELAN-C object detection model.

```shell
# coco/labels/{split}/*.txt
# bbox or polygon (1 instance 1 line)
python train.py --workers 8 --device 0 --batch 32 --data data/coco.yaml --img 640 --cfg models/detect/gelan-c.yaml --weights '' --name gelan-c-det --hyp hyp.scratch-high.yaml --min-items 0 --epochs 300 --close-mosaic 10
```
Tokens:
Raw