> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/kompyuternoe-zrenie/yolov9-v10.md).

# Обнаружение 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](https://github.com/WongKinYiu/yolov9) — 8K+ ⭐
* **GitHub YOLOv10:** [THU-MIG/yolov10](https://github.com/THU-MIG/yolov10) — 10K+ ⭐
* **Ultralytics (единый):** [ultralytics/ultralytics](https://github.com/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      | **Не требуется** |

{% hint style="success" %}
**YOLOv10 работает без NMS** — без этапа постобработки Non-Maximum Suppression. Это позволяет разворачивать модель end-to-end и особенно полезно для edge/встраиваемых сценариев и развертывания TensorRT.
{% endhint %}

***

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

* **Безопасность и видеонаблюдение** — обнаружение людей/транспортных средств/объектов в реальном времени
* **Автономные транспортные средства** — обнаружение пешеходов и препятствий
* **Контроль качества в производстве** — обнаружение дефектов на производственных линиях
* **Аналитика розничной торговли** — поток клиентов и обнаружение товаров
* **Медицинская визуализация** — обнаружение аномалий на рентгеновских снимках и сканах
* **Спортивная аналитика** — отслеживание игроков и мяча
* **Сельское хозяйство** — обнаружение болезней растений и вредителей

***

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

* Аккаунт Clore.ai с арендой GPU
* Данные для обучения (для обучения собственной модели) или использование предобученных весов COCO
* Базовые знания Python и командной строки

***

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

1. Перейдите на [маркетплейсе clore.ai](https://clore.ai) → **Маркетплейс**
2. Выберите GPU в зависимости от задачи:
   * **Только инференс:** RTX 3080/3090 или RTX 4080 — отличное соотношение цены и производительности
   * **Обучение небольших моделей:** RTX 4090 24GB
   * **Обучение больших моделей (YOLOv9e/YOLOv10x):** A100 40/80GB

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

***

## Шаг 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 — Подключитесь и проверьте

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

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

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

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

***

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

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

```python
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

```python
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 раза
)
```

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

```python
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
```

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

```bash
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 (рекомендуется)

```python
# Установить 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

```python
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

```python
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
)
```

{% hint style="info" %}
**Советы по обучению:**

* **Размер batch:** Начните с `batch=16` для RTX 4090, `batch=32` для A100 40GB
* **Размер изображения:** `imgsz=640` — стандарт; используйте 1280 для задач с высоким разрешением
* **Эпохи:** 100 эпох обычно достаточно для дообучения, 300+ — для обучения с нуля
* **AMP (смешанная точность):** Всегда включайте `amp=True` для ускорения в 1.5–2 раза
  {% endhint %}

***

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

```python
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

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

***

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

```bash
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 — Проверьте и сравните производительность своей модели

```python
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"
)
```

***

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

```bash
# С вашей локальной машины:
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 во время обучения

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

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

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

```python
# Включить кэширование (загружает датасет в 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 / плохое обнаружение

```bash
# Проверить, что разметка корректна (нормализована, в диапазоне 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](https://docs.ultralytics.com/)
* [Статья о YOLOv9](https://arxiv.org/abs/2402.13616)
* [Статья о YOLOv10](https://arxiv.org/abs/2405.14458)
* [Roboflow Universe](https://universe.roboflow.com/) — более 100 тыс. общедоступных наборов данных
* [Ultralytics HUB](https://hub.ultralytics.com/) — облачная платформа для обучения
* [Набор данных COCO](https://cocodataset.org/) — стандартный эталонный набор данных

***

*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 ГБ        | [голое железо](https://clore.ai/bare-metal) |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/kompyuternoe-zrenie/yolov9-v10.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.