yolo Documentation

In streaming mode, the model infers the most recent frame and draws bounding boxes by default (if the save flag is enabled).

In other modes, predictions are saved by default to the following directory structure: runs/inference/{exp_name}/outputs/

When iterating through a StreamDataLoader (used for inference tasks), each iteration returns:

• images: The input image tensor.
• rev_tensor: A reverse tensor used to revert bounding boxes and images back to their original input shape.
• origin_frame: The original input image tensor.

The YOLOv9 forward process is a multi-stage pipeline designed to extract features and generate object detections in a single pass. The architecture consists of the following components:

• BackBone: Responsible for extracting features from the input image.
• FPN (Feature Pyramid Network): Aggregates features across different scales.
• PAN (Region Proposal Network): Proposes regions of interest.
• Main Prediction: The primary output containing the detected objects.
• Auxiliary Prediction: An additional prediction path used to assist and improve the accuracy of the Main Prediction.

YOLOv9 optimizes its performance using a composite loss function that evaluates the accuracy of both class predictions and bounding box regressions. The total loss is composed of:

• IoU Loss: Measures the overlap (Intersection over Union) between the predicted bounding boxes and the Ground Truth boxes.
• BCE (Binary Cross-Entropy) Loss: Used to optimize class prediction accuracy.
• DFL (Distribution Focal Loss): Used to improve the precision and refinement of bounding box regression.

When iterating through a YoloDataLoader (used for train or validation tasks), each iteration returns a batch containing:

• batch_size: The size of the current batch (useful for calculating batch average loss).
• images: The input image tensors.
• targets: The ground truth data corresponding to the images based on the current task.

The model's output format depends on the YOLO version:

• YOLOv7: Predicts Anchor (Anc).
• YOLOv9: Predicts Vector (Vec).

A converter is required to transform these predictions into bounding boxes. The data flow follows this pattern:

Input $\rightarrow$ Model $\rightarrow$ (Class $\rightarrow$ NMS) AND (Anc/Vec $\rightarrow$ Converter $\rightarrow$ Box $\rightarrow$ NMS) $\rightarrow$ Output.

You can install YOLO using two methods depending on whether you want to modify the source code or just use the package.

Method 1: Clone for Development

Use this method if you intend to make customizations. You must work inside the cloned folder.

Method 2: Pip Install for Simple Changes

Use this method for simple changes or standard usage.

Note: When running commands via the script, replace python yolo/lazy.py with the yolo command if you installed via pip. Most tasks are accessible via the yolo/lazy.py prefix.

# Method 1: Clone and install dependencies
git clone https://github.com/WongKinYiu/YOLO.git
cd YOLO
pip install -r requirements-dev.txt

# Method 2: Install via pip
pip install git+https://github.com/WongKinYiu/YOLO.git

If you provide the auto_download configuration in your dataset settings, the system will automatically download and unzip the dataset from a specified {prefix}/{postfix}.

After downloading, the system:

1. Verifies the dataset contains the expected {file_num} files.
2. Generates {train, validation}.cache files in Tensor format to accelerate subsequent dataset preparation.

YOLO uses hydra to manage its configuration. You must generate a configuration class based on yolo.config.config.Config. The resulting configuration object contains settings for your task, including general settings, dataset information, and task-specific parameters for train, inference, and validation.

import hydra
from yolo import ProgressLogger
from yolo.config.config import Config

@hydra.main(config_path="config", config_name="config", version_base=None)
def main(cfg: Config):
    progress = ProgressLogger(cfg, exp_name=cfg.name)
    pass

To manage the training process, use the ModelTrainer class. Before calling the solver, you must start the progress logger to enable status logging and integration with Weights & Biases (wandb) or TensorBoard.

1. Initialize ModelTrainer with your configuration, model, converter, progress logger, device, and DDP settings.
2. Call progress.start().
3. Call solver.solve(dataloader) to begin training.

from yolo import ModelTrainer
solver = ModelTrainer(cfg, model, converter, progress, device, use_ddp)
progress.start()
solver.solve(dataloader)