> 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 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](/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.