Обнаружение YOLOv9/v10

Современное обнаружение объектов в реальном времени — обучайте и разворачивайте новейшие модели YOLO на GPU

YOLO (You Only Look Once) по-прежнему является золотым стандартом обнаружения объектов в реальном времени. В YOLOv9 были представлены Programmable Gradient Information (PGI) и Generalized Efficient Layer Aggregation Network (GELAN), а YOLOv10 принес обнаружение без NMS с двойным присвоением меток. Обе модели обеспечивают первоклассный баланс точности и скорости на GPU NVIDIA.

• GitHub YOLOv9: WongKinYiu/yolov9 — 8K+ ⭐

• GitHub YOLOv10: THU-MIG/yolov10 — 10K+ ⭐

• Ultralytics (единый): ultralytics/ultralytics — 32K+ ⭐

---

YOLOv9 vs YOLOv10 vs YOLOv8 — краткое сравнение

Модель	mAP50-95	Скорость (A100)	Параметры	NMS
YOLOv8x	53.9	14.2ms	68.2M	Требуется
YOLOv9e	55.6	16.8ms	57.3M	Требуется
YOLOv10x	54.4	10.7ms	29.5M	Не требуется
YOLOv10b	53.0	8.8ms	19.1M	Не требуется
YOLOv10s	46.8	4.2ms	7.2M	Не требуется

YOLOv10 работает без NMS — без этапа постобработки Non-Maximum Suppression. Это позволяет разворачивать модель end-to-end и особенно полезно для edge/встраиваемых сценариев и развертывания TensorRT.

---

Сценарии использования

• Безопасность и видеонаблюдение — обнаружение людей/транспортных средств/объектов в реальном времени

• Автономные транспортные средства — обнаружение пешеходов и препятствий

• Контроль качества в производстве — обнаружение дефектов на производственных линиях

• Аналитика розничной торговли — поток клиентов и обнаружение товаров

• Медицинская визуализация — обнаружение аномалий на рентгеновских снимках и сканах

• Спортивная аналитика — отслеживание игроков и мяча

• Сельское хозяйство — обнаружение болезней растений и вредителей

---

Предварительные требования

• Аккаунт Clore.ai с арендой GPU

• Данные для обучения (для обучения собственной модели) или использование предобученных весов COCO

• Базовые знания Python и командной строки

---

Шаг 1 — Арендуйте GPU на Clore.ai

1. Перейдите на маркетплейсе clore.ai → Маркетплейс

2. Выберите GPU в зависимости от задачи:

   • Только инференс: RTX 3080/3090 или RTX 4080 — отличное соотношение цены и производительности

   • Обучение небольших моделей: RTX 4090 24GB

   • Обучение больших моделей (YOLOv9e/YOLOv10x): A100 40/80GB

Для инференса в реальном времени (видеопотоки), RTX 3090 или RTX 4090 обеспечивает 100–500 FPS в зависимости от варианта модели. Даже самый маленький YOLOv10n работает на 4090 со скоростью 1000+ FPS с TensorRT.

---

Шаг 2 — Разверните контейнер Ultralytics

Официальный образ Docker Ultralytics поддерживает YOLOv8, YOLOv9 и YOLOv10 через единый API:

Docker-образ:

ultralytics/ultralytics:latest

Порты:

22
8000

Переменные среды:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Диск: Минимум 20 ГБ (предобученные веса + ваш датасет)

---

Шаг 3 — Подключитесь и проверьте

ssh root@<server-ip> -p <ssh-port>

# Проверить GPU
nvidia-smi

# Проверить установку Ultralytics
python3 -c "import ultralytics; ultralytics.checks()"

# Должна отображаться информация о GPU, версии CUDA и доступности модели

---

Шаг 4 — Быстрый инференс с предобученными моделями

Инференс YOLOv10 (без NMS)

from ultralytics import YOLO
import cv2

# Загрузить модель YOLOv10 (автоматически скачивается, если отсутствует)
model = YOLO("yolov10x.pt")  # Варианты: n, s, m, b, l, x

# Запустить инференс на изображении
results = model("https://ultralytics.com/images/bus.jpg")

# Показать результаты
for result in results:
    boxes = result.boxes
    print(f"Обнаружено {len(boxes)} объектов")
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].tolist()
        print(f"  {model.names[cls]}: {conf:.2f} по {[int(x) for x in xyxy]}")

# Сохранить размеченное изображение
results[0].save("output.jpg")

Инференс YOLOv9

from ultralytics import YOLO

# Загрузить модель YOLOv9
model = YOLO("yolov9e.pt")  # Варианты: t, s, m, c, e

# Пакетный инференс для максимальной пропускной способности
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # Обрабатывать 8 изображений параллельно
    device="cuda",
    conf=0.25,      # Порог уверенности
    iou=0.45,       # Порог IoU для NMS (для v10 не нужен)
    imgsz=640,
    half=True       # FP16 для ускорения в 2 раза
)

Инференс видеопотока в реальном времени

from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# Для веб-камеры (device=0) или видеофайла
cap = cv2.VideoCapture("input_video.mp4")

# Получить свойства видео
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# Запись выходного файла
out = cv2.VideoWriter(
    "output_video.mp4",
    cv2.VideoWriter_fourcc(*"mp4v"),
    fps,
    (width, height)
)

frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame, conf=0.25, verbose=False)
    annotated = results[0].plot()
    out.write(annotated)
    frame_count += 1
    
    if frame_count % 100 == 0:
        print(f"Обработано {frame_count} кадров")

cap.release()
out.release()
print("Готово! Выходной файл сохранён как output_video.mp4")

---

Шаг 5 — Обучите собственную модель

Подготовьте свой датасет

YOLO использует определённую структуру каталогов и формат разметки:

dataset/
├── images/
│   ├── train/          # Изображения для обучения (.jpg/.png)
│   ├── val/            # Изображения для валидации
│   └── test/           # Тестовые изображения (необязательно)
└── labels/
    ├── train/          # Файлы разметки (.txt)
    ├── val/
    └── test/

Каждый файл разметки (с тем же именем, что и изображение, .txt расширение) содержит:

# class_id center_x center_y width height (все значения нормализованы от 0 до 1)
0 0.512 0.334 0.256 0.412
1 0.123 0.654 0.089 0.123

Создать конфиг датасета

cat > /workspace/custom_dataset.yaml << 'EOF'
# Конфигурация датасета
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

# Количество классов
nc: 3

# Имена классов
names:
  0: person
  1: car
  2: bicycle
EOF

Импорт из Roboflow (рекомендуется)

# Установить Roboflow
pip install roboflow

from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("your-workspace").project("your-project")
version = project.version(1)
dataset = version.download("yolov9")

# Датасет теперь находится в ./your-project-1/

Обучить YOLOv10

from ultralytics import YOLO

# Загрузить предобученную модель YOLOv10 (transfer learning)
model = YOLO("yolov10m.pt")  # Средний вариант — хороший баланс

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=16,               # Настройте в зависимости от VRAM вашей GPU
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov10_custom",
    patience=50,            # Раннее прекращение
    save=True,
    save_period=10,         # Сохранять чекпойнт каждые 10 эпох
    plots=True,
    val=True,
    augment=True,           # Аугментация данных
    degrees=10.0,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.1,
    copy_paste=0.1,
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    amp=True                # Автоматическое смешанное представление (FP16)
)

print(f"Обучение завершено! Лучшая mAP: {results.results_dict['metrics/mAP50-95(B)']:.3f}")

Обучить YOLOv9

from ultralytics import YOLO

model = YOLO("yolov9e.pt")

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=8,               # v9e больше, нужен меньший batch
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)

Советы по обучению:

• Размер batch: Начните с batch=16 для RTX 4090, batch=32 для A100 40GB

• Размер изображения: imgsz=640 — стандарт; используйте 1280 для задач с высоким разрешением

• Эпохи: 100 эпох обычно достаточно для дообучения, 300+ — для обучения с нуля

• AMP (смешанная точность): Всегда включайте amp=True для ускорения в 1.5–2 раза

---

Шаг 6 — Экспорт в TensorRT для максимальной скорости

from ultralytics import YOLO

# Загрузить обученную модель
model = YOLO("/workspace/runs/yolov10_custom/weights/best.pt")

# Экспорт в TensorRT (FP16 для лучшего баланса скорости и точности)
model.export(
    format="engine",        # Ядро TensorRT
    device="cuda",
    half=True,              # FP16
    dynamic=False,          # Статические формы для максимальной оптимизации TRT
    batch=1,                # Оптимизировать для batch size 1 (в реальном времени)
    imgsz=640,
    workspace=4             # Область TRT в ГБ
)
# Сохранено как: best.engine

# Загрузить и запустить TRT-движок
trt_model = YOLO("best.engine")
results = trt_model("image.jpg")

Экспорт в ONNX

# Экспорт в ONNX для гибкости развёртывания
model.export(
    format="onnx",
    opset=17,
    half=True,              # Веса FP16
    dynamic=True,           # Динамический размер batch
    simplify=True
)

---

Шаг 7 — Развернуть как REST API

pip install fastapi uvicorn python-multipart

cat > /workspace/yolo_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse, FileResponse
from ultralytics import YOLO
from PIL import Image
import io
import uuid
import os

app = FastAPI(title="YOLOv10 Detection API")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ok", "model": "yolov10x", "device": "cuda"}

@app.post("/detect")
async def detect(
    file: UploadFile = File(...),
    conf: float = 0.25,
    iou: float = 0.45,
    return_image: bool = False
):
    # Прочитать загруженное изображение
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    
    # Запустить обнаружение
    results = model(img, conf=conf, iou=iou, verbose=False)
    result = results[0]
    
    # Сформировать ответ
    detections = []
    for box in result.boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": round(float(box.conf[0]), 4),
            "bbox": [round(x, 2) for x in box.xyxy[0].tolist()],
            "class_id": int(box.cls[0])
        })
    
    response = {
        "count": len(detections),
        "detections": detections,
        "image_size": list(result.orig_shape)
    }
    
    if return_image:
        output_path = f"/tmp/{uuid.uuid4()}.jpg"
        result.save(filename=output_path)
        return FileResponse(output_path, media_type="image/jpeg")
    
    return JSONResponse(response)

@app.post("/detect/batch")
async def detect_batch(files: list[UploadFile] = File(...)):
    results = []
    for file in files:
        data = await file.read()
        img = Image.open(io.BytesIO(data)).convert("RGB")
        res = model(img, verbose=False)[0]
        results.append({
            "filename": file.filename,
            "count": len(res.boxes),
            "detections": [
                {"class": model.names[int(b.cls[0])], "conf": float(b.conf[0])}
                for b in res.boxes
            ]
        })
    return JSONResponse({"results": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/yolo_api.py &

# Проверить API
curl -X POST "http://localhost:8000/detect" \
    -F "file=@test_image.jpg" | python3 -m json.tool

---

Шаг 8 — Проверьте и сравните производительность своей модели

from ultralytics import YOLO

model = YOLO("yolov10x.pt")

# Проверить на датасете COCO
metrics = model.val(
    data="coco.yaml",
    imgsz=640,
    batch=32,
    device="cuda",
    half=True
)

print(f"mAP50:    {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")
print(f"Точность: {metrics.box.mp:.3f}")
print(f"Полнота:    {metrics.box.mr:.3f}")

# Сравнить скорость
model.benchmark(
    format="engine",   # Сравнить несколько форматов экспорта
    imgsz=640,
    half=True,
    device="cuda"
)

---

Скачать результаты

# С вашей локальной машины:
scp -P <ssh-port> root@<server-ip>:/workspace/runs/yolov10_custom/weights/best.pt ./
scp -P <ssh-port> root@<server-ip>:/workspace/output_video.mp4 ./

# Скачать весь результат обучения
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/runs/ \
    ./yolo_training_runs/

---

Устранение неполадок

Недостаток памяти CUDA во время обучения

# Уменьшите размер батча
model.train(data="data.yaml", batch=4, imgsz=640)

# Или включите checkpointing градиентов
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)

Медленная скорость обучения

# Включить кэширование (загружает датасет в RAM/GPU)
model.train(data="data.yaml", cache=True)  # Кэшировать в RAM
model.train(data="data.yaml", cache="disk")  # Кэшировать на диск

# Увеличить число workers (осторожно: слишком большое значение может замедлить)
model.train(data="data.yaml", workers=8)

Низкий mAP / плохое обнаружение

# Проверить, что разметка корректна (нормализована, в диапазоне 0–1)
python3 -c "
from ultralytics.data.utils import check_det_dataset
check_det_dataset('custom_dataset.yaml')
"

# Визуализировать примеры обучения
python3 -c "
from ultralytics import YOLO
model = YOLO('yolov10m.pt')
model.train(data='data.yaml', epochs=1, batch=4, plots=True)
# Проверьте /workspace/runs/train/exp/train_batch*.jpg
"

---

Справочник по производительности (GPU Clore.ai)

Модель	GPU	Пакет	FPS (инференс)	mAP50-95
YOLOv10n	RTX 3090	1	1,200	38.5
YOLOv10s	RTX 3090	1	780	46.8
YOLOv10m	RTX 4090	1	950	51.3
YOLOv10x	RTX 4090	1	380	54.4
YOLOv9e	A100 40G	1	720	55.6
YOLOv10x TRT	RTX 4090	1	920	54.2

---

Дополнительные ресурсы

• Документация Ultralytics

• Статья о YOLOv9

• Статья о YOLOv10

• Roboflow Universe — более 100 тыс. общедоступных наборов данных

• Ultralytics HUB — облачная платформа для обучения

• Набор данных COCO — стандартный эталонный набор данных

---

YOLOv9 и YOLOv10 на аренде GPU в Clore.ai предоставляют доступный путь к обучению пользовательских моделей обнаружения объектов и развертыванию конвейеров инференса в реальном времени — без накладных расходов AWS SageMaker или Google Vertex AI.

---

Рекомендации по GPU для Clore.ai

Сценарий использования	Рекомендуемый GPU	Оценочная стоимость на Clore.ai
Разработка/тестирование	RTX 3090 (24 ГБ)	$0.07–0.21/гпу/ч
Инференс в продакшене	RTX 4090 (24 ГБ)	$0.14–0.42/гпу/ч
Обучение на больших батчах	A100 80 ГБ	голое железо

💡 Все примеры в этом руководстве можно развернуть на Clore.ai GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.