YOLOv8 检测

在 Clore.ai 上使用 YOLOv8 和 YOLOv11 进行实时目标检测

使用 Ultralytics YOLOv8 和 YOLOv11 运行实时目标检测。

所有示例都可以在通过以下方式租用的 GPU 服务器上运行 CLORE.AI 市场.

更新：YOLOv11（2025）——快 22%

YOLOv11 现已可通过同样的 ultralytics 包获取。它提供 快 22% 的推理速度 并且比 YOLOv8 具有更高的 mAP，同时保持相同的简洁 API。新功能包括旋转边界框（OBB）检测。通过运行以下命令升级： pip install -U ultralytics.

在 CLORE.AI 上租用

1. 访问 CLORE.AI 市场

2. 按 GPU 类型、显存和价格筛选

3. 选择 按需 （固定费率）或 竞价 （出价）

4. 配置你的订单：

   • 选择 Docker 镜像

   • 设置端口（SSH 用 TCP，Web 界面用 HTTP）

   • 如有需要，添加环境变量

   • 输入启动命令

5. 选择支付方式： CLORE, BTC，或 USDT/USDC

6. 创建订单并等待部署

访问你的服务器

• 在 我的订单

• 中查找连接详情

• Web 界面：使用 HTTP 端口 URL 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	320 万	37.3	约 1 毫秒
YOLOv8s	1120 万	44.9	约 2 毫秒
YOLOv8m	2590 万	50.2	约 4 毫秒
YOLOv8l	4370 万	52.9	约 6 毫秒
YOLOv8x	6820 万	53.9	约 8 毫秒

YOLOv11 模型

模型	大小	mAP	速度（RTX 3090）
yolo11n	260 万	39.5	约 0.8 毫秒
yolo11s	940 万	47.0	约 1.5 毫秒
yolo11m	2010 万	51.5	约 3.2 毫秒
yolo11l	2530 万	53.4	约 4.7 毫秒
yolo11x	5690 万	54.7	约 6.5 毫秒

YOLOv8 与 YOLOv11 对比

指标	YOLOv8x	yolo11x	提升
参数	6820 万	5690 万	减少 17%
mAP50-95（COCO）	53.9	54.7	+0.8 mAP
推理（RTX 3090）	约 8 毫秒	约 6.5 毫秒	快 22%
FPS（RTX 3090，640 像素）	~150	~183	快 22%
OBB 任务	❌	✅	v11 新增

快速部署

Docker 镜像：

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

端口：

22/tcp
7860/http

命令（YOLOv11）：

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 用于下面的示例中。

安装

pip install ultralytics

YOLOv8 和 YOLOv11 使用相同的包。升级即可获取 YOLOv11：

pip install -U ultralytics

YOLOv11 目标检测

使用 yolo11m 的基础检测

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')

获取检测结果

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})")

批量处理

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 任务

实例分割

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

姿态估计

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

分类

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 可检测任意旋转角度的目标——非常适合航空/卫星图像、文档扫描和文本检测。

from ultralytics import YOLO

# 加载 YOLOv11 OBB 模型
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}")

视频处理

处理视频

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# 处理视频
results = model('video.mp4', save=True)

实时摄像头

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()

保存处理后的视频

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()

目标跟踪

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()

自定义训练

准备数据集

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

names:
  0: 猫
  1: 狗
  2: 鸟

训练 YOLOv11

from ultralytics import YOLO

# 加载预训练 YOLOv11 模型
model = YOLO('yolo11n.pt')

# 训练
results = model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)

训练参数

model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    workers=8,
    patience=50,         # 早停
    save=True,
    save_period=10,      # 每 N 个 epoch 保存一次
    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,
)

导出模型

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 服务器

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 导出

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

# 使用导出的模型
model_trt = YOLO('yolo11m.engine')
results = model_trt('image.jpg')

批量推理

# 一次处理多张图像
images = ['img1.jpg', 'img2.jpg', 'img3.jpg', 'img4.jpg']
results = model(images, batch=4)

性能基准

YOLOv11 FPS（640px 输入）

模型	GPU	FPS
yolo11n	RTX 3090	~1100
yolo11s	RTX 3090	~730
yolo11m	RTX 3090	~370
yolo11x	RTX 3090	~183
yolo11x	RTX 4090	~305

YOLOv8 FPS（640px 输入）— 前一代

模型	GPU	FPS
YOLOv8n	RTX 3090	~900
YOLOv8s	RTX 3090	~600
YOLOv8m	RTX 3090	~300
YOLOv8x	RTX 3090	~150
YOLOv8x	RTX 4090	~250

故障排查

内存不足

# 使用更小的模型
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 市场 以获取当前价格。

节省开支：

• 使用 竞价 可中断工作市场——大约三分之一的服务器将现货价格定在低于按需价格的位置（中位数约优惠 13%），其余则与之持平

• 使用 CLORE 代币

• 比较不同提供商的价格

下一步

• Segment Anything - 高级分割

• Detectron2 - 更多检测选项

• Real-ESRGAN - 增强检测到的对象