YOLO11 - NPU推理部署

from ultralytics import YOLO

# 动态加载模型（推理时根据请求参数加载）
model = YOLO("/app/models/yolo11n.pt")

# 推理（官方简化接口）
results = model("image.jpg")

# 带参数的推理
results = model("image.jpg", imgsz=640, conf=0.25, iou=0.45)

# 创建模型目录
mkdir -p /Users/yanlp/models

# 方法1: 使用Python下载
python3 -c "from ultralytics import YOLO; YOLO('yolo11n.pt')"
python3 -c "from ultralytics import YOLO; YOLO('yolo11s-seg.pt')"
# 模型会下载到 ~/.cache/ultralytics/
# 然后复制到 /Users/yanlp/models/

# 方法2: 从AtomGit下载
# https://ai.atomgit.com/hf_mirrors/Ultralytics/YOLO11/tree/main
# 下载所需的模型文件到 /Users/yanlp/models/

# 方式 1: 使用 Makefile（推荐）
make build  # 构建镜像（NPU版本）
make run    # 启动服务

# 方式 2: 使用 Docker Compose
docker-compose up -d

# 方式 3: 使用 docker build + run（NPU版本）
docker build -t yolo11-npu:latest .
docker run -d --name yolo11-api -p 18004:8000 \
  -v /Users/yanlp/models/YOLO11:/app/models \
  -e LOCAL_MODEL_PATH=/app/models/yolo11n.pt \
  yolo11-npu:latest

# 如需启用NPU设备，添加设备挂载：
# --device /dev/davinci0:/dev/davinci0 \
# --device /dev/davinci_manager:/dev/davinci_manager \
# -e ASCEND_VISIBLE_DEVICES=0

# 查看日志
docker-compose logs -f

# 等待看到 "Application startup complete"

# 使用Shell测试脚本（默认使用bus.jpg）
./test_api.sh

# 自定义地址和图片
./test_api.sh http://localhost:18004 ./bus.jpg

# 使用Python测试脚本
python3 test_inference.py

# 自定义地址和图片
python3 test_inference.py http://localhost:18004 ./bus.jpg

{
  "source": "base64编码的图像数据",
  "model": "yolo11s-seg.pt",
  "imgsz": 640,
  "conf": 0.25,
  "iou": 0.45
}

{
  "images": [
    {
      "results": [
        {
          "class": 0,
          "name": "person",
          "confidence": 0.92,
          "box": {
            "x1": 118.0,
            "y1": 112.0,
            "x2": 416.0,
            "y2": 660.0
          }
        }
      ],
      "shape": [750, 600],
      "speed": {
        "inference": 200.8,
        "preprocess": 2.8,
        "postprocess": 0.8
      }
    }
  ],
  "metadata": {
    "model": "yolo11n.pt",
    "task": "detect",
    "detections": 1
  }
}

import requests
import base64

# 读取图像并转为base64
with open("test_image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode()

# 发送请求（Ultralytics API格式）
response = requests.post(
    "http://localhost:18004/yolo11",
    json={
        "source": image_base64,
        "model": "yolo11n.pt",
        "imgsz": 640,
        "conf": 0.25,
        "iou": 0.45
    }
)

result = response.json()
print(f"检测到 {len(result['images'][0]['results'])} 个目标")
for det in result['images'][0]['results']:
    print(f"  - {det['name']}: {det['confidence']:.2%}")

curl -X POST "http://localhost:18004/yolo11" \
  -H "Content-Type: application/json" \
  -d '{
    "source": "base64编码的图像数据",
    "model": "yolo11n.pt",
    "imgsz": 640,
    "conf": 0.25,
    "iou": 0.45
  }'

curl http://localhost:18004/health

{
  "status": "healthy",
  "model_loaded": true,
  "version": "1.0.0",
  "model_id": "yolo11n.pt",
  "task": "detect"
}

curl http://localhost:18004/metrics

# 使用检测模型
response = requests.post(
    "http://localhost:18004/yolo11",
    json={"source": image_base64, "model": "yolo11n.pt"}
)

# 使用分割模型
response = requests.post(
    "http://localhost:18004/yolo11",
    json={"source": image_base64, "model": "yolo11s-seg.pt"}
)

# 使用姿态估计模型
response = requests.post(
    "http://localhost:18004/yolo11",
    json={"source": image_base64, "model": "yolo11n-pose.pt"}
)

model:
  model_id: "yolo11n.pt"
  local_model_path: "/app/models/yolo11n.pt"
  task: "detect"
  imgsz: 640      # 输入图像尺寸
  conf: 0.25      # 置信度阈值
  iou: 0.45       # NMS IoU阈值
  max_det: 300    # 最大检测数量

# Shell测试（默认使用bus.jpg）
./test_api.sh

# 自定义地址和图像
./test_api.sh http://localhost:18004 ./bus.jpg

# Python测试
python3 test_inference.py http://localhost:18004 ./bus.jpg

# 检查模型文件
ls -lh /Users/yanlp/models/yolo11n.pt

# 确保文件存在且可读

volumes:
  - /Users/yanlp/models:/app/models
environment:
  - LOCAL_MODEL_PATH=/app/models/yolo11n.pt

# 实时日志
docker-compose logs -f

# 查看错误
docker-compose logs | grep -i error

# 检查容器状态
docker ps | grep yolo

yolo11/
├── api/                  # 核心代码（极简版）
│   ├── __init__.py       (7行)
│   ├── main.py           (261行 - 含动态加载)
│   └── inference.py      (164行 - 工具函数)
├── config/
│   └── config.yaml       # 配置文件
├── bus.jpg               # 测试图片
├── Dockerfile            # Docker 镜像（华为昇腾NPU）
├── docker-compose.yml    # Docker Compose（NPU配置）
├── entrypoint.sh         # 启动脚本（NPU检测）
├── Makefile              # 便捷命令
├── requirements.txt      # Python 依赖
├── test_api.sh           (103行 - 仅测试推理)
├── test_inference.py     (144行 - 仅测试推理)
└── README.md             # 项目文档（本文件）

# 下载模型
make download-model

# 构建镜像
make build

# 启动服务
make run

# 查看日志
make logs

# 停止服务
make stop

# 健康检查
make health

# 测试 API
make test

from ultralytics import YOLO

# 加载模型
model = YOLO("/Users/yanlp/models/yolo11n.pt")

# 推理（最简洁的方式）
results = model("image.jpg")

# 带参数的推理
results = model("image.jpg", imgsz=640, conf=0.25, iou=0.45)

# 视频追踪
results = model.track(source="video.mp4", show=True)

# 批量推理
results = model(["img1.jpg", "img2.jpg"])

import requests
import base64

# 使用 /yolo11 接口（Ultralytics格式 - base64）
with open("test_image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode()

# 发送请求
response = requests.post(
    "http://localhost:18004/yolo11",
    json={
        "source": image_base64,
        "model": "yolo11n.pt",
        "imgsz": 640,
        "conf": 0.25,
        "iou": 0.45
    }
)

# 处理结果
result = response.json()
print(f"检测到 {len(result['images'][0]['results'])} 个目标")
for det in result['images'][0]['results']:
    print(f"  - {det['name']}: {det['confidence']:.2%}")

from ultralytics import YOLO

# 加载模型
model = YOLO("yolo11n.pt")

# 图像推理
results = model.predict(source="image.jpg", imgsz=640, conf=0.25)

# 访问结果
for result in results:
    boxes = result.boxes  # 边界框
    masks = result.masks  # 分割掩码（如果是分割模型）
    keypoints = result.keypoints  # 关键点（如果是姿态模型）
    probs = result.probs  # 分类概率（如果是分类模型）

from ultralytics import YOLO

# 加载模型
model = YOLO("yolo11n.pt")

# 视频追踪
results = model.track(source="video.mp4", show=True)

# 使用ByteTrack追踪器
results = model.track(source="video.mp4", tracker="bytetrack.yaml")

from ultralytics import YOLO

# 从预训练模型开始训练
model = YOLO("yolo11n.pt")
results = model.train(data="coco8.yaml", epochs=3)

# 验证模型
results = model.val()

from ultralytics import YOLO

# 加载模型
model = YOLO("yolo11n.pt")

# 导出为ONNX格式
success = model.export(format="onnx")

# 导出为TensorRT格式
success = model.export(format="engine", device=0)