YOLOv8x 昇腾 NPU 迁移项目

# 从华为云镜像安装核心依赖
pip install torch==2.7.1 torchvision==0.22.1 --no-deps \
  -i https://mirrors.huaweicloud.com/repository/pypi/simple

pip install torch_npu==2.7.1 --no-deps \
  -i https://mirrors.huaweicloud.com/repository/pypi/simple

pip install ultralytics==8.3.0 pycocotools onnx \
  -i https://mirrors.huaweicloud.com/repository/pypi/simple

# ⚠️ ultralytics 会自动升级 torch，安装后必须回退
pip install torch==2.7.1 --no-deps \
  -i https://mirrors.huaweicloud.com/repository/pypi/simple

source /usr/local/Ascend/cann-8.5.0/set_env.sh
python3 src/ascend_train.py

# 确认 NPU 数量 ≥ 2
python3 -c "import torch; print(torch.npu.device_count())"

source /usr/local/Ascend/cann-8.5.0/set_env.sh

# 启动 4 卡训练
# WORLD_SIZE=4 表示总卡数，RANK=0/1/2/3 表示当前卡编号
python3 -m torch.distributed.launch \
    --nproc_per_node=4 \
    --nnodes=1 \
    --node_rank=0 \
    --master_addr=127.0.0.1 \
    --master_port=29500 \
    src/ascend_train_ddp.py

import torch.distributed as dist
import torch_npu
from torch_npu.contrib import transfer_to_npu

# HCCL 后端（NPU 专用）
dist.init_process_group(backend="hccl")

# 每个进程绑定对应 NPU 设备
local_rank = int(os.environ["LOCAL_RANK"])
torch.npu.set_device(f"npu:{local_rank}")

# 加载模型并分布式包装
model = YOLO('yolov8x.pt').model
model = model.to(f"npu:{local_rank}")
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[local_rank])

# 训练时使用 local_rank 对应的设备
model.train(data='coco128.yaml', ..., device=str(local_rank), ...)

source /usr/local/Ascend/cann-8.5.0/set_env.sh
python3 src/ascend_infer.py

import torch
from ultralytics import YOLO
model = YOLO('yolov8x.pt').model.eval()
torch.onnx.export(model, torch.randn(1, 3, 640, 640),
    'yolov8x.onnx', opset=11,
    input_names=['images'], output_names=['output'],
    dynamic_axes={'images': {0: 'batch'}, 'output': {0: 'batch'}})

atc --model=yolov8x.onnx --framework=5 --output=yolov8x \
    --soc_version=Ascend910B3 --input_shape="images:1,3,640,640"

from ultralytics import YOLO

model = YOLO('yolov8x.pt')
cpu_results = model.val(data='coco128.yaml', device='cpu', imgsz=640, batch=8)
print(f"CPU mAP50: {cpu_results.box.map50:.6f}")
print(f"CPU mAP50-95: {cpu_results.box.map:.6f}")

from ultralytics import YOLO

model = YOLO('yolov8x.pt')
npu_results = model.val(data='coco128.yaml', device='npu:0', imgsz=640, batch=8)
print(f"NPU mAP50: {npu_results.box.map50:.6f}")
print(f"NPU mAP50-95: {npu_results.box.map:.6f}")

import json

cpu = json.load(open('cpu_val_result.json'))
npu = json.load(open('npu_val_result.json'))

metrics = ['mAP50', 'mAP50-95', 'precision', 'recall']
for m in metrics:
    diff = npu[m] - cpu[m]
    rel_pct = diff / cpu[m] * 100 if cpu[m] != 0 else 0
    print(f"{m}: CPU={cpu[m]:.6f}, NPU={npu[m]:.6f}, diff={diff:.6f} ({rel_pct:.4f}%)")

import time, json

# NPU 训练计时
start = time.time()
# ... NPU 训练代码 ...
npu_time = time.time() - start

# 产出 timing JSON
timing = {
    "total_train_ms": int(npu_time * 1000),
    "avg_step_ms": int(npu_time * 1000 / steps),
    "throughput_samples_per_sec": round(batch * steps / npu_time, 2),
}

import time
from ultralytics import YOLO

# 准备测试图像
img_files = sorted(Path('/workspace/Yolov8x/dataset/coco128/images/train2017').glob('*.jpg'))[:50]

# NPU 推理计时
model_npu = YOLO('yolov8x.pt')
npu_times = []
for img in img_files:
    t0 = time.time()
    model_npu(img, device='npu:0', verbose=False)
    npu_times.append((time.time() - t0) * 1000)

npu_mean = sum(npu_times) / len(npu_times)
print(f"NPU mean latency: {npu_mean:.2f}ms")

# GPU 推理计时（同理，device='0' on GPU machine）
# gpu_mean = ...

Yolov8x/
├── README.md                           # 迁移指导书（本文件）
├── src/
│   ├── ascend_train.py                  # NPU 单卡训练脚本
│   ├── ascend_train_ddp.py              # NPU 多卡 DDP 训练脚本（≥2卡时使用）
│   ├── ascend_infer.py                  # NPU 推理脚本
│   ├── ascend_infer_benchmark.py       # NPU 推理性能评测脚本
│   ├── coco128.yaml                    # 数据集配置
│   ├── requirements.txt                 # 核心依赖清单
│   ├── npu_timing.json                  # 单卡训练 timing（7字段）
│   ├── ddp_timing.json                  # 多卡 DDP 训练 timing（7字段）
│   ├── npu_loss_b1.log                 # 单卡训练 loss 日志
│   ├── ddp_loss.log                    # 多卡训练 loss 日志
│   ├── npu_phase4_val_report.json     # Phase 4 精度验证报告
│   ├── four_phase_accuracy_summary.json # 四阶段精度汇总
│   ├── benchmark_results.json           # 推理性能统计
│   ├── accuracy_summary.json            # CPU vs NPU 精度统计
│   ├── perf_summary.json                # 推理性能（原始）
│   ├── cpu_val_result.json              # CPU 推理结果（精度基线）
│   ├── npu_val_result.json              # NPU 推理结果（精度验证）
│   └── single_vs_multicard.json         # 单卡 vs 多卡性能对比