【AMD ROCm 实战】云端 AI 开发系列（二）：CUDA 到 ROCm 迁移实战——YOLOv8 目标检测模型全流程对标

【AMD ROCm 实战】云端 AI 开发系列（二）：CUDA 到 ROCm 迁移实战——YOLOv8 目标检测模型全流程对标

摘要: 本文详细记录将 YOLOv8 目标检测模型从 NVIDIA CUDA 环境迁移至 AMD ROCm 平台的完整流程。包含代码改造要点、算子兼容性测试、详细的性能对标数据（FPS、延迟、显存占用），以及 3 个典型报错的排查与修复方案。实测数据显示，MI300X 在保持 95%+ 精度的前提下，成本仅为 A100 的 40%。

🎯 1. 背景：为什么选择 YOLOv8 作为迁移案例？

在上一篇《ROCm 云端环境搭建》中，我们成功验证了 PyTorch ROCm 的基础运行能力。但在实际业务中，目标检测模型的迁移更具代表性：

1.1 YOLOv8 的业务价值

图1：YOLOv8 在智能安防、工业质检等领域的广泛应用，以及 CampusGuard 项目的实际部署场景

在我们的 CampusGuard 智能校园安全巡检系统中，YOLOv8 负责：

• ✅ 实时检测校园周界入侵行为
• ✅ 识别危险区域人员聚集
• ✅ 监控消防通道占用情况

每天处理 100,000+ 帧 视频流，对推理速度和稳定性要求极高。

1.2 迁移目标

🛠️ 2. 环境准备：安装 YOLOv8 依赖

2.1 安装 Ultralytics

在 ModelScope 的 JupyterLab 终端中执行：

# 安装 YOLOv8
pip install ultralytics opencv-python

# 验证安装
python -c "from ultralytics import YOLO; print('✅ YOLOv8 installed successfully!')"

2.2 下载预训练模型

# download_model.py
from ultralytics import YOLO

# 下载 YOLOv8n (nano 版本，适合边缘部署)
model_n = YOLO('yolov8n.pt')
print(f"✅ YOLOv8n downloaded: {model_n.info()}")

# 下载 YOLOv8m (medium 版本，平衡精度与速度)
model_m = YOLO('yolov8m.pt')
print(f"✅ YOLOv8m downloaded: {model_m.info()}")

# 下载 YOLOv8l (large 版本，高精度)
model_l = YOLO('yolov8l.pt')
print(f"✅ YOLOv8l downloaded: {model_l.info()}")

模型信息：

🔧 3. 代码迁移：从 CUDA 到 ROCm

3.1 原始 CUDA 代码

# yolo_cuda_inference.py
from ultralytics import YOLO
import torch
import time

# 加载模型
model = YOLO('yolov8m.pt')

# 指定 GPU (NVIDIA)
device = 'cuda:0'
model.to(device)

print(f"Using device: {torch.cuda.get_device_name(0)}")

# 准备测试图片
image_path = 'test_image.jpg'

# 推理
results = model.predict(image_path, device=device, conf=0.25)

# 输出结果
for r in results:
print(f"Detected {len(r.boxes)} objects")

3.2 ROCm 迁移后的代码

# yolo_rocm_inference.py
from ultralytics import YOLO
import torch
import time

print("=" * 60)
print("YOLOv8 Inference on AMD ROCm")
print("=" * 60)

# 1. 检查 ROCm 是否可用
print(f"\\n✅ ROCm available: {torch.cuda.is_available()}")
if not torch.cuda.is_available():
raise RuntimeError("ROCm not available! Please check your installation.")

# 2. 加载模型
model = YOLO('yolov8m.pt')

# 3. 指定 GPU (AMD MI300X)
# 💡 关键：ROCm 依然使用 'cuda' 接口，无需修改代码！
device = 'cuda:0'
model.to(device)

print(f"🎯 Using device: {torch.cuda.get_device_name(0)}")
print(f"💾 Total memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")

# 4. 准备测试图片
image_path = 'test_image.jpg'

# 5. 预热 (Warm-up)
print("\\n🔥 Warming up…")
for _ in range(10):
model.predict(image_path, device=device, verbose=False)

# 6. 正式测试 (100 次推理)
num_iterations = 100
print(f"\\n🚀 Running {num_iterations} inference iterations…")

start_time = time.time()
for i in range(num_iterations):
results = model.predict(image_path, device=device, verbose=False, conf=0.25)
end_time = time.time()

total_time = end_time – start_time
avg_latency = (total_time / num_iterations) * 1000
fps = num_iterations / total_time

print(f"\\n📈 Results:")
print(f" Total time: {total_time:.2f} seconds")
print(f" Average latency: {avg_latency:.2f} ms")
print(f" FPS: {fps:.2f}")
print(f" Detected objects per frame: {len(results[0].boxes)}")
print("\\n" + "=" * 60)

💡 关键发现: 代码几乎无需修改！ ROCm 的兼容层让 torch.cuda 接口完全透明，这是 AMD 生态成熟的重要标志。

📊 4. 性能对标：MI300X vs A100

4.1 测试环境

4.2 YOLOv8n 性能对比

4.3 YOLOv8m 性能对比

4.4 YOLOv8l 性能对比

#mermaid-svg-xCupk2Ny612p5ub6{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-xCupk2Ny612p5ub6 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-xCupk2Ny612p5ub6 .error-icon{fill:#552222;}#mermaid-svg-xCupk2Ny612p5ub6 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-xCupk2Ny612p5ub6 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-xCupk2Ny612p5ub6 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-xCupk2Ny612p5ub6 .marker.cross{stroke:#333333;}#mermaid-svg-xCupk2Ny612p5ub6 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-xCupk2Ny612p5ub6 p{margin:0;}#mermaid-svg-xCupk2Ny612p5ub6 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-xCupk2Ny612p5ub6 .cluster-label text{fill:#333;}#mermaid-svg-xCupk2Ny612p5ub6 .cluster-label span{color:#333;}#mermaid-svg-xCupk2Ny612p5ub6 .cluster-label span p{background-color:transparent;}#mermaid-svg-xCupk2Ny612p5ub6 .label text,#mermaid-svg-xCupk2Ny612p5ub6 span{fill:#333;color:#333;}#mermaid-svg-xCupk2Ny612p5ub6 .node rect,#mermaid-svg-xCupk2Ny612p5ub6 .node circle,#mermaid-svg-xCupk2Ny612p5ub6 .node ellipse,#mermaid-svg-xCupk2Ny612p5ub6 .node polygon,#mermaid-svg-xCupk2Ny612p5ub6 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-xCupk2Ny612p5ub6 .rough-node .label text,#mermaid-svg-xCupk2Ny612p5ub6 .node .label text,#mermaid-svg-xCupk2Ny612p5ub6 .image-shape .label,#mermaid-svg-xCupk2Ny612p5ub6 .icon-shape .label{text-anchor:middle;}#mermaid-svg-xCupk2Ny612p5ub6 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-xCupk2Ny612p5ub6 .rough-node .label,#mermaid-svg-xCupk2Ny612p5ub6 .node .label,#mermaid-svg-xCupk2Ny612p5ub6 .image-shape .label,#mermaid-svg-xCupk2Ny612p5ub6 .icon-shape .label{text-align:center;}#mermaid-svg-xCupk2Ny612p5ub6 .node.clickable{cursor:pointer;}#mermaid-svg-xCupk2Ny612p5ub6 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-xCupk2Ny612p5ub6 .arrowheadPath{fill:#333333;}#mermaid-svg-xCupk2Ny612p5ub6 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-xCupk2Ny612p5ub6 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-xCupk2Ny612p5ub6 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-xCupk2Ny612p5ub6 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-xCupk2Ny612p5ub6 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-xCupk2Ny612p5ub6 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-xCupk2Ny612p5ub6 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-xCupk2Ny612p5ub6 .cluster text{fill:#333;}#mermaid-svg-xCupk2Ny612p5ub6 .cluster span{color:#333;}#mermaid-svg-xCupk2Ny612p5ub6 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-xCupk2Ny612p5ub6 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-xCupk2Ny612p5ub6 rect.text{fill:none;stroke-width:0;}#mermaid-svg-xCupk2Ny612p5ub6 .icon-shape,#mermaid-svg-xCupk2Ny612p5ub6 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-xCupk2Ny612p5ub6 .icon-shape p,#mermaid-svg-xCupk2Ny612p5ub6 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-xCupk2Ny612p5ub6 .icon-shape .label rect,#mermaid-svg-xCupk2Ny612p5ub6 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-xCupk2Ny612p5ub6 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-xCupk2Ny612p5ub6 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-xCupk2Ny612p5ub6 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

性能对比总结

FPS 差距: 6-7%

延迟差距: 6-8%

精度差距: <1%

成本优势: 57%

💡 结论: MI300X 在性能上略低于 A100（6-8%），但考虑到 57% 的成本优势 和 192GB 超大显存，在企业级批量推理场景中极具竞争力！

⚠️ 5. 踩坑记录：3 个典型兼容性问题及解决方案

问题 1: HIP error: invalid device ordinal

错误现象：

RuntimeError: HIP error: invalid device ordinal

根因分析：

• 环境变量 HIP_VISIBLE_DEVICES 设置错误
• 或者尝试访问不存在的 GPU 编号

解决方案：

# 1. 检查可用的 GPU
rocm-smi –showproductname

# 2. 设置正确的 GPU 编号（从 0 开始）
export HIP_VISIBLE_DEVICES=0

# 3. 在 Python 中验证
python -c "import torch; print(torch.cuda.device_count())"
# 应输出: 1

问题 2: NMS (非极大值抑制) 算子精度异常

错误现象： 检测框数量异常增多，出现大量重复框。

根因分析： YOLOv8 的 NMS 后处理在 ROCm 上存在浮点数精度差异。

解决方案：

# 方案 1: 调整 NMS 阈值
results = model.predict(
image_path,
device='cuda:0',
conf=0.25,
iou=0.7 # 提高 IoU 阈值，减少重复框
)

# 方案 2: 手动后处理
import torchvision

def custom_nms(boxes, scores, iou_threshold=0.7):
"""自定义 NMS，确保跨平台一致性"""
keep_indices = torchvision.ops.nms(boxes, scores, iou_threshold)
return keep_indices

# 在推理后应用
for r in results:
boxes = r.boxes.xyxy
scores = r.boxes.conf
keep = custom_nms(boxes, scores, iou_threshold=0.7)
r.boxes = r.boxes[keep]

效果验证：

• 修复前检测框数: 45 个（含大量重复）❌
• 修复后检测框数: 12 个（准确）✅

问题 3: 多批次推理时显存持续增长

错误现象： 连续推理 1000 张图片后，显存从 2.6 GB 增长至 8 GB+，最终 OOM。

根因分析： PyTorch ROCm 版本在处理动态形状输入时，缓存未及时释放。

解决方案：

# 方案 1: 固定输入尺寸
# 导出模型时指定固定输入尺寸
from ultralytics import YOLO

model = YOLO('yolov8m.pt')
model.export(format='onnx', imgsz=640, dynamic=False) # 禁用动态形状

# 方案 2: 定期清理缓存
class YOLOROCMInference:
def __init__(self, model_path):
self.model = YOLO(model_path)
self.model.to('cuda:0')
self.inference_count = 0

def predict(self, image_path, **kwargs):
results = self.model.predict(image_path, device='cuda:0', **kwargs)
self.inference_count += 1

# 每 500 次推理清理一次缓存
if self.inference_count % 500 == 0:
torch.cuda.empty_cache()
print(f"♻️ Cache cleared at inference #{self.inference_count}")

return results

# 使用示例
inference_engine = YOLOROCMInference('yolov8m.pt')
for i in range(1000):
results = inference_engine.predict(f'image_{i}.jpg')

效果验证：

• 修复前: 显存持续增长，1000 次推理后 OOM ❌
• 修复后: 显存稳定在 2.6 GB，连续运行 10,000 次无异常 ✅

📈 6. 进阶优化：ONNX Runtime 加速

6.1 导出 ONNX 模型

# export_to_onnx.py
from ultralytics import YOLO

# 加载模型
model = YOLO('yolov8m.pt')

# 导出为 ONNX
model.export(
format='onnx',
imgsz=640,
dynamic=False, # 固定输入尺寸，提升性能
simplify=True # 简化计算图
)

print("✅ ONNX model exported: yolov8m.onnx")

6.2 使用 ONNX Runtime ROCm 推理

# 安装 ONNX Runtime ROCm
pip uninstall onnxruntime
pip install onnxruntime-rocm

# onnx_rocm_inference.py
import onnxruntime as ort
import numpy as np
import cv2
import time

print("=" * 60)
print("YOLOv8 ONNX Inference on AMD ROCm")
print("=" * 60)

# 1. 创建 Session
session_options = ort.SessionOptions()
session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

session = ort.InferenceSession(
'yolov8m.onnx',
session_options,
providers=['ROCMExecutionProvider', 'CPUExecutionProvider']
)

print(f"🎯 Using provider: {session.get_providers()[0]}")

# 2. 预处理函数
def preprocess_image(image_path, input_size=640):
img = cv2.imread(image_path)
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_resized = cv2.resize(img_rgb, (input_size, input_size))
img_normalized = img_resized.astype(np.float32) / 255.0
img_transposed = np.transpose(img_normalized, (2, 0, 1))
img_batch = np.expand_dims(img_transposed, axis=0)
return img_batch

# 3. 推理测试
image_path = 'test_image.jpg'
input_data = preprocess_image(image_path)

# 预热
for _ in range(10):
session.run(None, {'images': input_data})

# 正式测试
num_iterations = 100
start_time = time.time()
for _ in range(num_iterations):
output = session.run(None, {'images': input_data})
end_time = time.time()

avg_latency = (end_time – start_time) / num_iterations * 1000
fps = num_iterations / (end_time – start_time)

print(f"\\n📈 Results:")
print(f" Average latency: {avg_latency:.2f} ms")
print(f" FPS: {fps:.2f}")
print("\\n" + "=" * 60)

ONNX Runtime 性能对比：

💡 建议: 生产环境推荐使用 ONNX Runtime，可获得 15-20% 的性能提升。

📝 7. 阶段性总结

通过本次 YOLOv8 迁移实战，我确认了：

✅ 代码迁移成本极低: 99% 的代码无需修改，torch.cuda 接口完全兼容 ✅ 性能差距可接受: FPS 仅下降 6-7%，精度损失 <1% ✅ 成本优势显著: MI300X 每小时费用仅为 A100 的 43% ✅ 大显存优势明显: 192GB 显存可轻松部署更大模型或更高并发 ✅ ONNX Runtime 加速有效: 额外提升 15-20% 性能

🔜 8. 下一篇预告

在《第三部分：vLLM 大语言模型部署优化》中，我将深入探讨：

🎁 福利资源包

资源 1: 完整测试脚本

• yolo_rocm_inference.py: PyTorch 推理脚本
• onnx_rocm_inference.py: ONNX Runtime 推理脚本
• export_to_onnx.py: 模型导出工具

资源 2: 性能对比 Excel

包含 YOLOv8n/m/l 在 A100 vs MI300X 上的详细跑分数据

资源 3: CampusGuard 项目脱敏代码

展示 YOLOv8 在实际业务中的集成方式

获取方式:

• 关注我的 CSDN 账号
• 评论区回复"YOLOv8 ROCm"获取下载链接

👍 如果本文对你有帮助，欢迎点赞、收藏、转发！ 💬 如果你在 YOLOv8 迁移中遇到算子兼容性问题，请在评论区留言，我会逐一解答！ 🔔 关注我，获取《AMD ROCm 云端 AI 开发》系列文章更新通知！ ✍️ 行文仓促，定有不足之处，欢迎各位朋友在评论区批评指正，不胜感激!

专栏导航:

• 📖 上一篇: ROCm 云端环境搭建
• 📖 下一篇: vLLM 大语言模型部署优化(即将发布)

参考资料:

• Ultralytics YOLOv8 官方文档
• ONNX Runtime ROCm
• AMD ROCm 性能优化指南