A Complete Guide to YOLOv11 Object Detection - From Theory to Deployment

import torch
import ultralytics
from ultralytics import YOLO

print(f"PyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"Ultralytics version: {ultralytics.__version__}")

# Test with a simple model load
model = YOLO('yolo11n.pt')  # n = nano variant
print("YOLOv11 loaded successfully!")

from ultralytics import YOLO
import cv2
import numpy as np

# Load the model
model = YOLO('yolo11m.pt')  # Using medium variant

# Single image inference
results = model('path/to/image.jpg')

# Process results
for result in results:
    # Get bounding boxes
    boxes = result.boxes.xyxy.cpu().numpy()  # x1, y1, x2, y2 format
    confidences = result.boxes.conf.cpu().numpy()
    class_ids = result.boxes.cls.cpu().numpy()

    # Get class names
    names = result.names

    # Print detections
    for box, conf, cls_id in zip(boxes, confidences, class_ids):
        print(f"Detected {names[int(cls_id)]} with confidence {conf:.2f}")
        print(f"Bounding box: {box}")

# Visualize results
annotated_frame = results[0].plot()
cv2.imwrite('output.jpg', annotated_frame)

from pathlib import Path

# Process multiple images
image_dir = Path('data/images')
image_paths = list(image_dir.glob('*.jpg'))

# Batch inference for efficiency
results = model(image_paths, stream=True)  # Stream for memory efficiency

for i, result in enumerate(results):
    print(f"Processing {image_paths[i].name}")
    result.save(f'output/result_{i}.jpg')

# After annotating on roboflow.com, download dataset
from roboflow import Roboflow

rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("workspace-name").project("project-name")
dataset = project.version(1).download("yolov11")

from ultralytics import YOLO

# Load a pretrained model for transfer learning
model = YOLO('yolo11m.pt')

# Train the model
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    name='custom_detection',
    patience=50,  # Early stopping
    save=True,
    device=0  # GPU index, or 'cpu'
)

# Advanced training with hyperparameter tuning
results = model.train(
    data='data.yaml',
    epochs=200,
    imgsz=640,
    batch=16,

    # Learning rate settings
    lr0=0.01,  # Initial learning rate
    lrf=0.01,  # Final learning rate factor

    # Augmentation parameters
    hsv_h=0.015,  # Image HSV-Hue augmentation
    hsv_s=0.7,    # Image HSV-Saturation augmentation
    hsv_v=0.4,    # Image HSV-Value augmentation
    degrees=0.0,  # Image rotation (+/- deg)
    translate=0.1, # Image translation (+/- fraction)
    scale=0.5,    # Image scale (+/- gain)
    shear=0.0,    # Image shear (+/- deg)
    perspective=0.0, # Image perspective (+/- fraction)
    flipud=0.0,   # Image flip up-down (probability)
    fliplr=0.5,   # Image flip left-right (probability)
    mosaic=1.0,   # Image mosaic (probability)
    mixup=0.0,    # Image mixup (probability)

    # Optimizer settings
    optimizer='SGD',  # or 'Adam', 'AdamW'
    momentum=0.937,
    weight_decay=0.0005,

    # Other settings
    cos_lr=True,  # Cosine learning rate scheduler
    warmup_epochs=3.0,
    warmup_momentum=0.8,
    warmup_bias_lr=0.1,

    # Validation and saving
    val=True,
    save_period=10,  # Save checkpoint every N epochs

    # Hardware
    device=0,
    workers=8,  # Dataloader workers

    # Project organization
    project='runs/detect',
    name='custom_model_v1',
    exist_ok=False
)

# Use multiple GPUs
results = model.train(
    data='data.yaml',
    epochs=100,
    batch=32,  # Effective batch size = 32 * num_gpus
    device='0,1,2,3'  # Use GPUs 0, 1, 2, and 3
)

# Resume from last checkpoint
model = YOLO('runs/detect/custom_model_v1/weights/last.pt')
results = model.train(resume=True)

from ultralytics import YOLO

# Load trained model
model = YOLO('runs/detect/custom_model_v1/weights/best.pt')

# Validate on test set
metrics = model.val(
    data='data.yaml',
    split='test',
    batch=16,
    imgsz=640,
    device=0
)

# Access metrics
print(f"mAP50: {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")
print(f"Precision: {metrics.box.p.mean():.3f}")
print(f"Recall: {metrics.box.r.mean():.3f}")

# Get per-class metrics
class_names = model.names
for i, name in enumerate(class_names):
    print(f"\n{name}:")
    print(f"  Precision: {metrics.box.p[i]:.3f}")
    print(f"  Recall: {metrics.box.r[i]:.3f}")
    print(f"  mAP50: {metrics.box.ap50[i]:.3f}")
    print(f"  mAP50-95: {metrics.box.ap[i]:.3f}")

import matplotlib.pyplot as plt
import seaborn as sns

# Generate confusion matrix
metrics = model.val()
confusion_matrix = metrics.confusion_matrix.matrix

# Visualize
plt.figure(figsize=(10, 8))
sns.heatmap(confusion_matrix, annot=True, fmt='g', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.savefig('confusion_matrix.png')

import cv2
from ultralytics import YOLO

model = YOLO('best.pt')

cap = cv2.VideoCapture(0)  # 0 for default webcam

# Set resolution
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

# FPS calculation
import time
fps_start_time = time.time()
fps_counter = 0

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Run inference
    results = model(frame, conf=0.5, iou=0.45)

    # Annotate frame
    annotated_frame = results[0].plot()

    # Calculate FPS
    fps_counter += 1
    if (time.time() - fps_start_time) > 1:
        fps = fps_counter / (time.time() - fps_start_time)
        fps_counter = 0
        fps_start_time = time.time()

    # Display FPS
    cv2.putText(annotated_frame, f'FPS: {fps:.1f}', (10, 30),
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    cv2.imshow('YOLOv11 Detection', annotated_frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

from ultralytics import YOLO

model = YOLO('best.pt')

# Process video file
results = model.predict(
    source='input_video.mp4',
    save=True,
    conf=0.5,
    iou=0.45,
    show=True,  # Display while processing
    stream=True,  # Stream results for memory efficiency
    project='output',
    name='video_detection'
)

# Process frame by frame
for result in results:
    # Custom processing per frame
    boxes = result.boxes
    # Your custom logic here
    pass

# Process IP camera stream
rtsp_url = 'rtsp://username:password@ip_address:port/stream'

results = model.predict(
    source=rtsp_url,
    save=True,
    stream=True
)

for result in results:
    # Process streaming results
    pass

from ultralytics import YOLO

model = YOLO('best.pt')

# Export to ONNX for faster inference
model.export(
    format='onnx',
    dynamic=True,  # Dynamic input shapes
    simplify=True  # Simplify model
)

# Use ONNX model
onnx_model = YOLO('best.onnx')
results = onnx_model('image.jpg')

# Export to TensorRT
model.export(
    format='engine',
    device=0,
    half=True  # FP16 precision
)

# Use TensorRT model
trt_model = YOLO('best.engine')
results = trt_model('image.jpg')  # Significantly faster

# INT8 quantization for edge devices
model.export(
    format='onnx',
    int8=True
)

import glob

# Load all images
image_paths = glob.glob('images/*.jpg')

# Batch inference
results = model(image_paths, batch=32)  # Process 32 images at once

# Process results
for i, result in enumerate(results):
    result.save(f'output/{i}.jpg')

# Use FP16 for 2x speed improvement on compatible GPUs
model = YOLO('best.pt')
model.to('cuda')
model.half()  # Convert to FP16

results = model('image.jpg', half=True)

from fastapi import FastAPI, File, UploadFile
from ultralytics import YOLO
import cv2
import numpy as np
from io import BytesIO

app = FastAPI()
model = YOLO('best.pt')

@app.post("/detect")
async def detect_objects(file: UploadFile = File(...)):
    # Read image
    contents = await file.read()
    nparr = np.frombuffer(contents, np.uint8)
    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

    # Run detection
    results = model(img)

    # Extract detections
    detections = []
    for box in results[0].boxes:
        detection = {
            'class': model.names[int(box.cls)],
            'confidence': float(box.conf),
            'bbox': box.xyxy[0].tolist()
        }
        detections.append(detection)

    return {'detections': detections}

@app.get("/health")
async def health_check():
    return {'status': 'healthy'}

from ultralytics import YOLO

# Use smaller model for edge devices
model = YOLO('yolo11n.pt')

# Export for TensorRT on Jetson
model.export(format='engine', device=0, half=True)

# Load optimized model
edge_model = YOLO('yolo11n.engine')

# Run inference
results = edge_model('image.jpg')

# Use ONNX or OpenVINO for CPU optimization
model = YOLO('yolo11n.pt')
model.export(format='onnx', simplify=True)

# Use with ONNX Runtime
onnx_model = YOLO('yolo11n.onnx')
results = onnx_model('image.jpg')

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Run tracking on video
results = model.track(
    source='video.mp4',
    save=True,
    tracker='bytetrack.yaml',  # or 'botsort.yaml'
    conf=0.5,
    iou=0.5,
    persist=True  # Persist tracks between frames
)

# Access track IDs
for result in results:
    boxes = result.boxes
    if boxes is not None and boxes.id is not None:
        track_ids = boxes.id.cpu().numpy()
        for track_id, box in zip(track_ids, boxes):
            print(f"Track {track_id}: {box.xyxy}")

# YOLOv11 also supports segmentation and pose estimation
seg_model = YOLO('yolo11m-seg.pt')
pose_model = YOLO('yolo11m-pose.pt')

# Instance segmentation
seg_results = seg_model('image.jpg')
masks = seg_results[0].masks  # Get segmentation masks

# Pose estimation
pose_results = pose_model('image.jpg')
keypoints = pose_results[0].keypoints  # Get pose keypoints

# Combine predictions from multiple models
models = [
    YOLO('yolo11m.pt'),
    YOLO('yolo11l.pt'),
    YOLO('yolo11x.pt')
]

def ensemble_predict(image, models, iou_threshold=0.5):
    all_boxes = []

    for model in models:
        results = model(image)
        all_boxes.extend(results[0].boxes)

    # Apply NMS to ensemble predictions
    # Implementation of weighted boxes fusion or NMS
    # ...

    return final_boxes

# Detect defects in products on assembly line
defect_model = YOLO('defect_detection.pt')

def inspect_product(image_path):
    results = defect_model(image_path, conf=0.7)

    defects = []
    for box in results[0].boxes:
        if model.names[int(box.cls)] in ['scratch', 'dent', 'crack']:
            defects.append({
                'type': model.names[int(box.cls)],
                'confidence': float(box.conf),
                'location': box.xyxy[0].tolist()
            })

    return {'pass': len(defects) == 0, 'defects': defects}

# Vehicle counting and classification
traffic_model = YOLO('traffic.pt')

class TrafficCounter:
    def __init__(self, model_path):
        self.model = YOLO(model_path)
        self.vehicle_count = {'car': 0, 'truck': 0, 'motorcycle': 0}
        self.tracked_ids = set()

    def count_vehicles(self, frame):
        results = self.model.track(frame, persist=True)

        if results[0].boxes.id is not None:
            track_ids = results[0].boxes.id.cpu().numpy()
            classes = results[0].boxes.cls.cpu().numpy()

            for track_id, cls in zip(track_ids, classes):
                if track_id not in self.tracked_ids:
                    vehicle_type = self.model.names[int(cls)]
                    self.vehicle_count[vehicle_type] += 1
                    self.tracked_ids.add(track_id)

        return self.vehicle_count

# PPE (Personal Protective Equipment) detection
ppe_model = YOLO('ppe_detection.pt')

def check_safety_compliance(image):
    results = ppe_model(image, conf=0.6)

    people = []
    for box in results[0].boxes:
        class_name = ppe_model.names[int(box.cls)]

        if class_name == 'person':
            person_box = box.xyxy[0]

            # Check for required PPE within person's bounding box
            has_helmet = False
            has_vest = False

            for other_box in results[0].boxes:
                other_class = ppe_model.names[int(other_box.cls)]
                if is_inside(other_box.xyxy[0], person_box):
                    if other_class == 'helmet':
                        has_helmet = True
                    elif other_class == 'safety_vest':
                        has_vest = True

            people.append({
                'compliant': has_helmet and has_vest,
                'helmet': has_helmet,
                'vest': has_vest,
                'bbox': person_box.tolist()
            })

    return people