# Детекция YOLOv8

Запустите обнаружение объектов в реальном времени с Ultralytics YOLOv8 и YOLOv11.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Обновление: YOLOv11 (2025) — на 22% быстрее**

YOLOv11 теперь доступен через тот же `ultralytics` пакет. Он обеспечивает **на 22% более быструю инференцию** и улучшенный mAP по сравнению с YOLOv8 при том же простом API. Новые функции включают обнаружение ориентированных ограничивающих рамок (OBB). Обновитесь, запустив `pip install -U ultralytics`.
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объему VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена по ставке)
4. Настройте ваш заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * Добавьте переменные окружения при необходимости
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Доступ к вашему серверу

* Найдите данные для подключения в **Моих заказах**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Что такое YOLOv8?

YOLOv8 — это высокопроизводительная модель YOLO, предлагающая:

* Обнаружение объектов
* Сегментация экземпляров
* Оценка поз
* Классификация изображений
* Отслеживание объектов

## Что такое YOLOv11?

YOLOv11 (2025) — последнее поколение, добавляющее:

* **на 22% более быструю инференцию** по сравнению с YOLOv8
* Более высокий mAP во всех размерах моделей
* **Ориентированные ограничивающие рамки (OBB)** обнаружение — новая задача
* Улучшенная архитектура (блоки C3k2, SPPF, C2PSA)
* Тот же `ultralytics` пакет, заменяемый на месте

### Поддерживаемые задачи (YOLOv11)

| Задача     | Суффикс | Описание                                                                |
| ---------- | ------- | ----------------------------------------------------------------------- |
| `detect`   | *(нет)* | Обнаружение объектов с ограничивающими рамками                          |
| `segment`  | `-seg`  | Сегментация экземпляров с масками                                       |
| `classify` | `-cls`  | Классификация изображений                                               |
| `pose`     | `-pose` | Оценка поз человека                                                     |
| `obb`      | `-obb`  | **НОВОЕ** Ориентированные ограничивающие рамки (поворотное обнаружение) |

## Размеры моделей

### Модели YOLOv8

| Модель  | Размер | mAP  | Скорость (RTX 3090) |
| ------- | ------ | ---- | ------------------- |
| YOLOv8n | 3.2M   | 37.3 | \~1ms               |
| YOLOv8s | 11.2M  | 44.9 | \~2ms               |
| YOLOv8m | 25.9M  | 50.2 | \~4ms               |
| YOLOv8l | 43.7M  | 52.9 | \~6ms               |
| YOLOv8x | 68.2M  | 53.9 | \~8ms               |

### Модели YOLOv11

| Модель  | Размер | mAP  | Скорость (RTX 3090) |
| ------- | ------ | ---- | ------------------- |
| yolo11n | 2.6M   | 39.5 | \~0.8ms             |
| yolo11s | 9.4M   | 47.0 | \~1.5ms             |
| yolo11m | 20.1M  | 51.5 | \~3.2ms             |
| yolo11l | 25.3M  | 53.4 | \~4.7ms             |
| yolo11x | 56.9M  | 54.7 | \~6.5ms             |

### Сравнение YOLOv8 и YOLOv11

| Метрика               | YOLOv8x | yolo11x | Улучшение        |
| --------------------- | ------- | ------- | ---------------- |
| Параметры             | 68.2M   | 56.9M   | **-17% меньше**  |
| mAP50-95 (COCO)       | 53.9    | 54.7    | **+0.8 mAP**     |
| Инференция (RTX 3090) | \~8ms   | \~6.5ms | **+22% быстрее** |
| FPS (RTX 3090, 640px) | \~150   | \~183   | **+22% быстрее** |
| Задача OBB            | ❌       | ✅       | **Новое в v11**  |

## Быстрое развертывание

**Docker-образ:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Порты:**

```
22/tcp
7860/http
```

**Команда (YOLOv11):**

```bash
pip install ultralytics gradio && \
python -c "
import gradio as gr
from ultralytics import YOLO
from PIL import Image

model = YOLO('yolo11m.pt')

def detect(image):
    results = model(image)
    return Image.fromarray(results[0].plot())

demo = gr.Interface(fn=detect, inputs=gr.Image(type='pil'), outputs=gr.Image(), title='YOLOv11 Detection')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Доступ к вашему сервису

После развертывания найдите ваш `http_pub` URL в **Моих заказах**:

1. Перейдите на **Моих заказах** страницу
2. Нажмите на ваш заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Установка

```bash
pip install ultralytics
```

Один и тот же пакет для YOLOv8 и YOLOv11. Обновитесь, чтобы получить YOLOv11:

```bash
pip install -U ultralytics
```

## Обнаружение объектов YOLOv11

### Базовое обнаружение с yolo11m

```python
from ultralytics import YOLO
from PIL import Image

# Загрузите среднюю модель YOLOv11
model = YOLO('yolo11m.pt')

# Запустите инференцию
results = model('image.jpg')

# Показать результаты
results[0].show()

# Сохранить результаты
results[0].save('output.jpg')
```

### Получение детекций

```python
results = model('image.jpg')

for result in results:
    boxes = result.boxes
    for box in boxes:
        # Координаты
        x1, y1, x2, y2 = box.xyxy[0].tolist()

        # Доверие
        conf = box.conf[0].item()

        # Класс
        cls = int(box.cls[0].item())
        name = model.names[cls]

        print(f"{name}: {conf:.2f} at ({x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f})")
```

### Пакетная обработка

```python
from ultralytics import YOLO
import os

model = YOLO('yolo11m.pt')

input_dir = './images'
output_dir = './detected'
os.makedirs(output_dir, exist_ok=True)

# Обработать все изображения
results = model(input_dir, save=True, project=output_dir)
```

## Задачи YOLOv11

### Сегментация экземпляров

```python
from ultralytics import YOLO

# Загрузите модель сегментации YOLOv11
model = YOLO('yolo11m-seg.pt')

results = model('image.jpg')

for result in results:
    masks = result.masks  # Маски сегментации
    if masks is not None:
        for mask in masks.data:
            # mask — бинарный тензор
            pass
```

### Оценка поз

```python
from ultralytics import YOLO

# Загрузите модель поз YOLOv11
model = YOLO('yolo11m-pose.pt')

results = model('image.jpg')

for result in results:
    keypoints = result.keypoints
    if keypoints is not None:
        for kp in keypoints.data:
            # 17 ключевых точек: нос, глаза, уши, плечи, локти, запястья, бедра, колени, лодыжки
            pass
```

### Классификация

```python
from ultralytics import YOLO

# Загрузите модель классификации YOLOv11
model = YOLO('yolo11m-cls.pt')

results = model('image.jpg')
for result in results:
    # Топ-1 класс и уверенность
    top1 = result.probs.top1
    top1conf = result.probs.top1conf.item()
    print(f"Class: {result.names[top1]} ({top1conf:.2f})")
```

### Ориентированные ограничивающие рамки (OBB) — НОВИНКА в YOLOv11

OBB обнаруживает объекты при любом угле поворота — идеально для аэроснимков/спутниковых снимков, сканирования документов и обнаружения текста.

```python
from ultralytics import YOLO

# Загрузите OBB-модель YOLOv11
model = YOLO('yolo11m-obb.pt')

results = model('aerial_image.jpg')

for result in results:
    obb = result.obb
    if obb is not None:
        for box in obb:
            # Повернутая рамка: x_center, y_center, width, height, angle
            xywhr = box.xywhr[0].tolist()
            conf = box.conf[0].item()
            cls = int(box.cls[0].item())
            print(f"{result.names[cls]}: {conf:.2f} rotated box: {xywhr}")
```

## Обработка видео

### Обработать видео

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Обработать видео
results = model('video.mp4', save=True)
```

### Веб-камера в реальном времени

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11n.pt')  # Используйте nano-модель для работы в реальном времени

cap = cv2.VideoCapture(0)

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

    results = model(frame)
    annotated = results[0].plot()

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

cap.release()
cv2.destroyAllWindows()
```

### Сохранение обработанного видео

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11m.pt')

cap = cv2.VideoCapture('input.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.mp4', cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))

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

    results = model(frame)
    annotated = results[0].plot()
    out.write(annotated)

cap.release()
out.release()
```

## Отслеживание объектов

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Отслеживать объекты в видео
results = model.track('video.mp4', save=True, tracker='bytetrack.yaml')

# Доступ к ID треков
for result in results:
    boxes = result.boxes
    if boxes.id is not None:
        track_ids = boxes.id.tolist()
```

## Пользовательская подготовка

### Подготовка датасета

```yaml

# dataset.yaml
path: /workspace/dataset
train: images/train
val: images/val

names:
  0: cat
  1: dog
  2: bird
```

### Обучение YOLOv11

```python
from ultralytics import YOLO

# Загрузите предварительно обученную модель YOLOv11
model = YOLO('yolo11n.pt')

# Обучение
results = model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)
```

### Аргументы обучения

```python
model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    workers=8,
    patience=50,         # Раннее прекращение
    save=True,
    save_period=10,      # Сохранять каждые N эпох
    cache=True,          # Кешировать изображения
    amp=True,            # Смешанная точность
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    box=7.5,
    cls=0.5,
    dfl=1.5,
    augment=True,
    hsv_h=0.015,
    hsv_s=0.7,
    hsv_v=0.4,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.0,
)
```

## Экспорт модели

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Экспорт в разные форматы
model.export(format='onnx')           # ONNX
model.export(format='tensorrt')       # TensorRT
model.export(format='openvino')       # OpenVINO
model.export(format='coreml')         # CoreML
model.export(format='tflite')         # TensorFlow Lite
```

## API-сервер

```python
from fastapi import FastAPI, UploadFile
from fastapi.responses import JSONResponse
from ultralytics import YOLO
from PIL import Image
import io

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

@app.post("/detect")
async def detect(file: UploadFile):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    results = model(image)

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

    return JSONResponse(content={"detections": detections})

@app.post("/segment")
async def segment(file: UploadFile):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    model_seg = YOLO('yolo11m-seg.pt')
    results = model_seg(image)

    # Вернуть аннотированное изображение
    annotated = results[0].plot()
    # ... конвертировать и вернуть

# Запуск: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Оптимизация производительности

### Экспорт в TensorRT

```python
model = YOLO('yolo11m.pt')
model.export(format='tensorrt', half=True)

# Использовать экспортированную модель
model_trt = YOLO('yolo11m.engine')
results = model_trt('image.jpg')
```

### Пакетная инференция

```python

# Обработать несколько изображений одновременно
images = ['img1.jpg', 'img2.jpg', 'img3.jpg', 'img4.jpg']
results = model(images, batch=4)
```

## Бенчмарки производительности

### FPS YOLOv11 (ввод 640px)

| Модель  | GPU      | FPS    |
| ------- | -------- | ------ |
| yolo11n | RTX 3090 | \~1100 |
| yolo11s | RTX 3090 | \~730  |
| yolo11m | RTX 3090 | \~370  |
| yolo11x | RTX 3090 | \~183  |
| yolo11x | RTX 4090 | \~305  |

### FPS YOLOv8 (ввод 640px) — предыдущее поколение

| Модель  | GPU      | FPS   |
| ------- | -------- | ----- |
| YOLOv8n | RTX 3090 | \~900 |
| YOLOv8s | RTX 3090 | \~600 |
| YOLOv8m | RTX 3090 | \~300 |
| YOLOv8x | RTX 3090 | \~150 |
| YOLOv8x | RTX 4090 | \~250 |

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

### Недостаток памяти

```python

# Используйте меньшую модель
model = YOLO('yolo11n.pt')

# Или уменьшите размер изображения
results = model('image.jpg', imgsz=320)
```

### Медленная обработка

* Используйте экспорт в TensorRT
* Используйте меньшую модель (yolo11n или yolo11s)
* Уменьшите размер изображения

### Низкая точность

* Используйте большую модель (yolo11x вместо yolo11n)
* Обучите на собственных данных
* Увеличьте размер изображения

## Оценка стоимости

Типичные тарифы маркетплейса CLORE.AI (по состоянию на 2025):

| GPU       | Почасовая ставка | Дневная ставка | Сессия 4 часа |
| --------- | ---------------- | -------------- | ------------- |
| RTX 3060  | \~$0.03          | \~$0.70        | \~$0.12       |
| RTX 3090  | \~$0.06          | \~$1.50        | \~$0.25       |
| RTX 4090  | \~$0.10          | \~$2.30        | \~$0.40       |
| A100 40GB | \~$0.17          | \~$4.00        | \~$0.70       |
| A100 80GB | \~$0.25          | \~$6.00        | \~$1.00       |

*Цены варьируются в зависимости от провайдера и спроса. Проверьте* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *для текущих тарифов.*

**Экономьте деньги:**

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены у разных провайдеров

## Дальнейшие шаги

* [Segment Anything](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/segment-anything) - Продвинутая сегментация
* Detectron2 - больше опций обнаружения
* [Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/real-esrgan-upscaling) - Улучшение обнаруженных объектов