Opinion: YOLO 9.0 Is the Best Object Detection Model for 2026, Ditch Detectron2 0.6

import os
import sys
import yaml
import torch
import logging
from pathlib import Path
from ultralytics import YOLO
from ultralytics.utils.errors import HUBModelError, UltralyticsError

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger("yolo9_trainer")

def validate_dataset_config(config_path: Path) -> dict:
    """Validate custom dataset YAML matches YOLO 9.0 requirements, return parsed config."""
    if not config_path.exists():
        raise FileNotFoundError(f"Dataset config not found at {config_path}")

    with open(config_path, "r") as f:
        dataset_cfg = yaml.safe_load(f)

    required_keys = ["path", "train", "val", "names"]
    for key in required_keys:
        if key not in dataset_cfg:
            raise ValueError(f"Missing required dataset key: {key}")

    # Verify dataset paths exist
    base_path = Path(dataset_cfg["path"])
    for split in ["train", "val"]:
        split_path = base_path / dataset_cfg[split]
        if not split_path.exists():
            raise FileNotFoundError(f"{split} split path not found: {split_path}")

    logger.info(f"Validated dataset config with {len(dataset_cfg['names'])} classes")
    return dataset_cfg

def train_yolo9_custom(
    model_size: str = "yolov9c",
    dataset_config: Path = Path("data/custom_dataset.yaml"),
    epochs: int = 100,
    batch_size: int = 16,
    img_size: int = 640,
    device: str = "cuda:0"
) -> Path:
    """
    Train YOLO 9.0 model on custom dataset with full error handling and checkpointing.
    Returns path to best performing checkpoint.
    """
    try:
        # Validate inputs
        if not torch.cuda.is_available() and device.startswith("cuda"):
            raise EnvironmentError("CUDA requested but no GPU available")

        dataset_cfg = validate_dataset_config(dataset_config)

        # Initialize YOLO 9.0 model from pretrained weights
        # Canonical repo: https://github.com/ultralytics/ultralytics
        model = YOLO(f"{model_size}.pt")
        logger.info(f"Initialized YOLO 9.0 {model_size} model on {device}")

        # Configure training parameters
        train_args = {
            "data": str(dataset_config),
            "epochs": epochs,
            "batch": batch_size,
            "imgsz": img_size,
            "device": device,
            "patience": 20,  # Early stopping patience
            "save_period": 10,  # Save checkpoint every 10 epochs
            "project": "yolo9_custom_training",
            "name": f"{model_size}_run_{Path(dataset_config).stem}",
            "exist_ok": True
        }

        # Start training with error catching
        logger.info(f"Starting training with args: {train_args}")
        results = model.train(**train_args)

        # Extract best checkpoint path
        best_ckpt = Path(results.save_dir) / "weights" / "best.pt"
        if not best_ckpt.exists():
            raise UltralyticsError("Best checkpoint not found after training")

        logger.info(f"Training complete. Best checkpoint saved to {best_ckpt}")
        return best_ckpt

    except HUBModelError as e:
        logger.error(f"HUB model loading failed: {e}")
        raise
    except UltralyticsError as e:
        logger.error(f"YOLO training error: {e}")
        raise
    except Exception as e:
        logger.error(f"Unexpected training error: {e}")
        raise

if __name__ == "__main__":
    # Example usage for 2026 retail shelf object detection use case
    try:
        best_checkpoint = train_yolo9_custom(
            model_size="yolov9c",
            dataset_config=Path("data/retail_shelf_2026.yaml"),
            epochs=150,
            batch_size=32,
            img_size=640,
            device="cuda:0"
        )
        print(f"Successfully trained YOLO 9.0. Best checkpoint: {best_checkpoint}")
    except Exception as e:
        logger.error(f"Training pipeline failed: {e}")
        sys.exit(1)

import time
import torch
import cv2
import numpy as np
from pathlib import Path
from ultralytics import YOLO
from detectron2.config import get_cfg
from detectron2.engine import DefaultPredictor
from detectron2.data import MetadataCatalog
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("inference_benchmarker")

class DetectionBenchmarker:
    """Benchmark inference latency and accuracy for YOLO 9.0 vs Detectron2 0.6."""

    def __init__(self, yolo_ckpt: Path, detectron2_cfg: Path, device: str = "cuda:0"):
        self.device = device
        self.yolo_model = self._init_yolo(yolo_ckpt)
        self.detectron2_predictor = self._init_detectron2(detectron2_cfg)
        self.yolo_latencies = []
        self.detectron2_latencies = []

    def _init_yolo(self, ckpt_path: Path) -> YOLO:
        """Initialize YOLO 9.0 model from checkpoint."""
        if not ckpt_path.exists():
            raise FileNotFoundError(f"YOLO checkpoint not found: {ckpt_path}")
        # Canonical YOLO 9.0 repo: https://github.com/ultralytics/ultralytics
        model = YOLO(str(ckpt_path))
        model.to(self.device)
        logger.info(f"Initialized YOLO 9.0 model from {ckpt_path}")
        return model

    def _init_detectron2(self, cfg_path: Path):
        """Initialize Detectron2 0.6 predictor from config."""
        if not cfg_path.exists():
            raise FileNotFoundError(f"Detectron2 config not found: {cfg_path}")
        # Canonical Detectron2 repo: https://github.com/facebookresearch/detectron2
        cfg = get_cfg()
        cfg.merge_from_file(str(cfg_path))
        cfg.MODEL.WEIGHTS = cfg.MODEL.WEIGHTS  # Assume weights path in config
        cfg.MODEL.DEVICE = self.device
        cfg.freeze()
        predictor = DefaultPredictor(cfg)
        MetadataCatalog.get("custom_val").thing_classes = cfg.DATASETS.TEST[0]  # Adjust as needed
        logger.info(f"Initialized Detectron2 0.6 predictor from {cfg_path}")
        return predictor

    def run_benchmark(self, image_dir: Path, num_warmup: int = 10, num_runs: int = 100):
        """Run inference benchmark on directory of test images."""
        if not image_dir.exists():
            raise FileNotFoundError(f"Image directory not found: {image_dir}")

        image_paths = list(image_dir.glob("*.jpg")) + list(image_dir.glob("*.png"))
        if len(image_paths) < num_runs:
            raise ValueError(f"Not enough images: {len(image_paths)} < {num_runs}")

        # Warmup runs to stabilize GPU
        logger.info(f"Running {num_warmup} warmup runs...")
        for i in range(num_warmup):
            img = cv2.imread(str(image_paths[i % len(image_paths)]))
            self.yolo_model(img, verbose=False)
            self.detectron2_predictor(img)

        # Timed runs
        logger.info(f"Running {num_runs} timed inference runs...")
        for i in range(num_runs):
            img_path = image_paths[i]
            img = cv2.imread(str(img_path))
            if img is None:
                logger.warning(f"Failed to load image: {img_path}")
                continue

            # YOLO 9.0 inference
            yolo_start = time.perf_counter()
            yolo_results = self.yolo_model(img, verbose=False)
            yolo_end = time.perf_counter()
            self.yolo_latencies.append((yolo_end - yolo_start) * 1000)  # ms

            # Detectron2 0.6 inference
            detectron_start = time.perf_counter()
            detectron_results = self.detectron2_predictor(img)
            detectron_end = time.perf_counter()
            self.detectron2_latencies.append((detectron_end - detectron_start) * 1000)  # ms

            if i % 20 == 0:
                logger.info(f"Completed {i+1}/{num_runs} runs")

    def get_results(self) -> dict:
        """Return benchmark statistics."""
        return {
            "yolo_9_p50_latency_ms": np.percentile(self.yolo_latencies, 50),
            "yolo_9_p95_latency_ms": np.percentile(self.yolo_latencies, 95),
            "yolo_9_avg_latency_ms": np.mean(self.yolo_latencies),
            "detectron2_06_p50_latency_ms": np.percentile(self.detectron2_latencies, 50),
            "detectron2_06_p95_latency_ms": np.percentile(self.detectron2_latencies, 95),
            "detectron2_06_avg_latency_ms": np.mean(self.detectron2_latencies),
            "speedup_factor": np.mean(self.detectron2_latencies) / np.mean(self.yolo_latencies)
        }

if __name__ == "__main__":
    try:
        benchmarker = DetectionBenchmarker(
            yolo_ckpt=Path("weights/yolov9c_retail_best.pt"),
            detectron2_cfg=Path("configs/detectron2_retail_config.yaml"),
            device="cuda:0"
        )
        benchmarker.run_benchmark(
            image_dir=Path("data/retail_test_images_2026"),
            num_warmup=10,
            num_runs=100
        )
        results = benchmarker.get_results()
        print("\n=== Benchmark Results ===")
        for k, v in results.items():
            print(f"{k}: {v:.2f}")
        print(f"\nYOLO 9.0 is {results['speedup_factor']:.1f}x faster than Detectron2 0.6 on average")
    except Exception as e:
        logger.error(f"Benchmark failed: {e}")
        raise

import torch
import onnx
import onnxruntime
import tensorrt as trt
from pathlib import Path
from ultralytics import YOLO
from detectron2.export import TracingAdapter
from detectron2.checkpoint import DetectionCheckpointer
from detectron2.config import get_cfg
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("model_exporter")

class EdgeModelExporter:
    """Export YOLO 9.0 and Detectron2 0.6 models to edge-optimized formats."""

    def __init__(self, device: str = "cuda:0"):
        self.device = device
        self.trt_logger = trt.Logger(trt.Logger.WARNING)

    def export_yolo9_onnx(self, yolo_ckpt: Path, output_path: Path, img_size: int = 640):
        """Export YOLO 9.0 to ONNX with dynamic axes for edge deployment."""
        if not yolo_ckpt.exists():
            raise FileNotFoundError(f"YOLO checkpoint not found: {yolo_ckpt}")

        # Load YOLO 9.0 model
        # Canonical repo: https://github.com/ultralytics/ultralytics
        model = YOLO(str(yolo_ckpt))
        model.to(self.device)

        # Export to ONNX with dynamic batch and image size
        export_args = {
            "format": "onnx",
            "imgsz": img_size,
            "dynamic": True,
            "simplify": True,
            "opset": 17,
            "device": self.device
        }
        onnx_path = model.export(**export_args)
        onnx_path = Path(onnx_path)

        # Validate ONNX model
        if not onnx_path.exists():
            raise RuntimeError("ONNX export failed: output file not found")
        onnx_model = onnx.load(str(onnx_path))
        onnx.checker.check_model(onnx_model)
        logger.info(f"Validated YOLO 9.0 ONNX model at {onnx_path}")

        # Optional: Convert to TensorRT for Jetson/edge GPUs
        trt_path = output_path / f"{yolo_ckpt.stem}.trt"
        self._convert_onnx_to_trt(onnx_path, trt_path, img_size)
        return trt_path

    def export_detectron2_onnx(self, detectron2_cfg: Path, output_path: Path, img_size: int = 640):
        """Export Detectron2 0.6 to ONNX (note: limited dynamic axis support)."""
        if not detectron2_cfg.exists():
            raise FileNotFoundError(f"Detectron2 config not found: {detectron2_cfg}")

        # Canonical Detectron2 repo: https://github.com/facebookresearch/detectron2
        cfg = get_cfg()
        cfg.merge_from_file(str(detectron2_cfg))
        cfg.MODEL.DEVICE = self.device

        # Load model and weights
        model = TracingAdapter.build_model(cfg)
        DetectionCheckpointer(model).load(cfg.MODEL.WEIGHTS)
        model.eval()
        model.to(self.device)

        # Create dummy input for tracing
        dummy_input = torch.randn(1, 3, img_size, img_size).to(self.device)

        # Trace model
        with torch.no_grad():
            tracing_adapter = TracingAdapter(model, dummy_input)
            onnx_path = output_path / f"{Path(detectron2_cfg).stem}.onnx"
            torch.onnx.export(
                tracing_adapter,
                dummy_input,
                str(onnx_path),
                input_names=["input"],
                output_names=["boxes", "scores", "classes"],
                dynamic_axes={
                    "input": {0: "batch_size", 2: "height", 3: "width"},
                    "boxes": {0: "batch_size"},
                    "scores": {0: "batch_size"},
                    "classes": {0: "batch_size"}
                },
                opset_version=14
            )

        # Validate ONNX
        onnx_model = onnx.load(str(onnx_path))
        onnx.checker.check_model(onnx_model)
        logger.info(f"Exported Detectron2 0.6 ONNX model at {onnx_path}")
        return onnx_path

    def _convert_onnx_to_trt(self, onnx_path: Path, trt_path: Path, img_size: int):
        """Convert ONNX model to TensorRT engine for edge inference."""
        builder = trt.Builder(self.trt_logger)
        network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
        parser = trt.OnnxParser(network, self.trt_logger)

        # Parse ONNX
        with open(onnx_path, "rb") as f:
            if not parser.parse(f.read()):
                for error in range(parser.num_errors):
                    logger.error(f"TensorRT parse error: {parser.get_error(error)}")
                raise RuntimeError("Failed to parse ONNX for TensorRT conversion")

        # Configure builder
        config = builder.create_builder_config()
        config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 30)  # 1GB workspace
        if self.device.startswith("cuda"):
            config.set_flag(trt.BuilderFlag.GPU_UPPER_BOUND)

        # Build engine
        engine = builder.build_engine(network, config)
        if not engine:
            raise RuntimeError("TensorRT engine build failed")

        # Save engine
        with open(trt_path, "wb") as f:
            f.write(engine.serialize())
        logger.info(f"Saved TensorRT engine to {trt_path}")

    def benchmark_onnx_latency(self, onnx_path: Path, num_runs: int = 100) -> float:
        """Benchmark ONNX model latency on CPU/GPU."""
        session = onnxruntime.InferenceSession(
            str(onnx_path),
            providers=["CUDAExecutionProvider"] if torch.cuda.is_available() else ["CPUExecutionProvider"]
        )
        input_name = session.get_inputs()[0].name
        dummy_input = np.random.randn(1, 3, 640, 640).astype(np.float32)

        # Warmup
        for _ in range(10):
            session.run(None, {input_name: dummy_input})

        # Timed runs
        latencies = []
        for _ in range(num_runs):
            start = time.perf_counter()
            session.run(None, {input_name: dummy_input})
            latencies.append((time.perf_counter() - start) * 1000)

        return np.mean(latencies)

if __name__ == "__main__":
    try:
        exporter = EdgeModelExporter(device="cuda:0")

        # Export YOLO 9.0
        yolo_trt = exporter.export_yolo9_onnx(
            yolo_ckpt=Path("weights/yolov9c_retail_best.pt"),
            output_path=Path("exported_models"),
            img_size=640
        )
        yolo_onnx_latency = exporter.benchmark_onnx_latency(
            Path("exported_models/yolov9c_retail_best.onnx")
        )
        print(f"YOLO 9.0 ONNX avg latency: {yolo_onnx_latency:.2f}ms")

        # Export Detectron2 0.6 (note: TensorRT conversion often fails for Detectron2)
        detectron2_onnx = exporter.export_detectron2_onnx(
            detectron2_cfg=Path("configs/detectron2_retail_config.yaml"),
            output_path=Path("exported_models"),
            img_size=640
        )
        detectron2_onnx_latency = exporter.benchmark_onnx_latency(detectron2_onnx)
        print(f"Detectron2 0.6 ONNX avg latency: {detectron2_onnx_latency:.2f}ms")

    except Exception as e:
        logger.error(f"Export failed: {e}")
        raise

from ultralytics import YOLO

# Initialize YOLO 9.0 model
model = YOLO("yolov9c.pt")

# Run hyperparameter tuning for 100 iterations
results = model.tune(
    data="retail_shelf_2026.yaml",
    epochs=50,
    iterations=100,
    optimizer="AdamW",
    project="yolo9_hyperparam_tune",
    name="retail_tune_run1"
)
print(f"Best hyperparameters: {results.best_hyp}")

from ultralytics import YOLO

# Load YOLO 9.0 multi-task (detection + segmentation) model
model = YOLO("yolov9c-seg.pt")

# Train on dataset with both bounding boxes and masks
results = model.train(
    data="retail_shelf_seg_2026.yaml",
    epochs=100,
    imgsz=640,
    batch=32,
    device="cuda:0"
)

# Run inference with both detection and segmentation
results = model("test_shelf_image.jpg")
results[0].show()  # Displays boxes and masks

# Convert legacy Detectron2 COCO labels to YOLO 9.0 format
# CLI command (no code needed for most use cases)
ultralytics data convert \
  --source-format coco \
  --target-format yolo \
  --input-dir data/retail_detectron2_labels \
  --output-dir data/retail_yolo_labels

# Verify converted dataset
from ultralytics.data.utils import check_det_dataset
dataset_info = check_det_dataset("data/retail_shelf_2026.yaml")
print(f"Converted dataset has {dataset_info['nc']} classes and {dataset_info['n']} images")