> 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/yolov8-detection.md).

# Обнаружение YOLOv8

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

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](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](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объёму VRAM и цене
3. Выберите **По требованию** (фиксированная ставка) или **Спот** (цена ставки)
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 | \~1 мс              |
| YOLOv8s | 11.2M  | 44.9 | \~2 мс              |
| YOLOv8m | 25.9M  | 50.2 | \~4 мс              |
| YOLOv8l | 43.7M  | 52.9 | \~6 мс              |
| YOLOv8x | 68.2M  | 53.9 | \~8 мс              |

### Модели YOLOv11

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

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

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

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

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

```
pytorch/pytorch:2.11.0-cuda12.8-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')
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} в ({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:
    # Класс top-1 и уверенность
    top1 = result.probs.top1
    top1conf = result.probs.top1conf.item()
    print(f"Класс: {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} повернутая рамка: {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: кошка
  1: собака
  2: птица
```

### Обучение 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*](https://clore.ai/marketplace) *текущие тарифы.*

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

* Используйте **Спот** рынок для прерываемых задач — примерно треть серверов оценивает spot ниже on-demand (медиана \~13% скидки), остальные совпадают с ним
* Платите **CLORE** токенами
* Сравните цены у разных провайдеров

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

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


---

# 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/yolov8-detection.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.