YOLO安装配置(Windows 11 + RX580 8G)

一、硬件环境

• 显卡：蓝宝石 RX580 8G
• 系统：Windows 11

二、环境安装

2.1 安装 AMD 显卡驱动

RX580 需要 ROCm 支持才能在 PyTorch 中使用 GPU 加速。

1. 下载并安装最新的 AMD 驱动：https://www.amd.com/en/support
2. 安装 AMD Software: Adrenalin Edition（建议 24.x 及以上版本）

2.2 安装 Python

推荐 Python 3.10 或 3.11（兼容性最好）：

# 下载 Python 3.11，安装时勾选 "Add Python to PATH"
# 安装完成后验证
python --version
pip --version

2.3 安装 PyTorch（DirectML 版本）

关键问题：RX580 不支持 ROCm（ROCm 要求 gfx900+ 架构，RX580 是 Polaris 架构不支持）。因此必须使用 DirectML 后端来调用 AMD 显卡加速。

# 创建虚拟环境（推荐）
python -m venv yolo_env

# 激活虚拟环境
.\yolo_env\Scripts\Activate.ps1
# 如果报权限错误，先执行：
# Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

# 安装 PyTorch CPU 版 + DirectML 插件
pip install torch torchvision torchaudio

# 安装 DirectML 后端（核心，让 RX580 参与计算）
pip install torch-directml

# 查看安装位置
pip show torch

2.4 安装 YOLO 框架

# 安装 ultralytics（YOLOv8/v11 官方库）
pip install ultralytics

# 安装 OpenCV（图像处理）
pip install opencv-python

# 安装其他依赖
pip install matplotlib pandas pillow numpy

2.5 验证 GPU 是否可用

# test_gpu.py
import torch
import torch_directml

# 检查 DirectML 设备
dml = torch_directml.device()
print(f"DirectML 设备: {dml}")

# 测试张量计算
x = torch.randn(3, 3).to(dml)
y = torch.randn(3, 3).to(dml)
z = x @ y
print(f"GPU 计算成功: {z.shape}")

# 测试 YOLO
from ultralytics import YOLO
model = YOLO("yolov8n.pt")  # 下载最小的模型测试
print("YOLO 加载成功")

三、推荐模型

3.1 模型选择

模型	参数量	速度	精度(mAP)	推荐场景
YOLOv8n	3.2M	最快	37.3	实时巡检，RX580 首选
YOLOv8s	11.2M	较快	44.9	精度与速度平衡
YOLOv8m	25.9M	中等	50.2	精度要求高
YOLOv8l	43.7M	较慢	52.9	不推荐 RX580
YOLOv11n	2.6M	最快	39.5	最新架构，推荐

3.2 推荐方案

方案一（推荐）：YOLOv11n

• 最新的 nano 版本，速度快，适合无人机实时推理
• RX580 8G 显存足够运行

方案二：YOLOv8n

• 最成熟稳定，社区资源最多
• 灯杆检测有很多现成的预训练权重

四、灯杆检测实现

4.1 使用预训练模型检测（快速测试）

# detect_pole.py
import torch_directml
from ultralytics import YOLO
import cv2

def detect_lamp_pole(image_path):
    """
    使用 YOLO 检测灯杆
    """
    # 加载模型
    model = YOLO("yolov8n.pt")  # 或 "yolo11n.pt"

    # GPU模式：使用RX580加速
    dml_device = torch_directml.device()
    model.model.to(dml_device)  # 把底层PyTorch模型迁移到DirectML
    # CPU模式：注销上面两行，改为 dml_device = "cpu"
    
    # 推理（device参数可省略，ultralytics会自动检测model.model所在设备）
    results = model(
        image_path,
        # device=dml_device,  # 可省略：model.model.to()后自动使用GPU
        conf=0.25,           # 置信度阈值
        iou=0.45,            # NMS IoU 阈值
        classes=[0,1,2,3,5,9],         # 检测类型,可选：限制类别，0: 'person', 1: 'bicycle', 2: 'car'
    )
    # classes 的类别查看
    # print(model.names)

    # 显示结果
    for result in results:
        result.show()
        result.save("output.jpg")

    return results

# 测试
if __name__ == "__main__":
    detect_lamp_pole("test_image.jpg")

4.2 训练灯杆检测模型

图片标注及模型训练: https://www.cnblogs.com/aeolian/p/21715480
图片标注->数据集
数据集 -> 脚本训练 -> pt模型

4.3 无人机巡检实时检测

# drone_detect.py
import torch_directml
from ultralytics import YOLO
import cv2

class DronePoleDetector:
    def __init__(self, model_path="runs/detect/pole_detect/weights/best.pt"):
        self.model = YOLO(model_path)
        self.device = torch_directml.device()
        # GPU模式：使用RX580加速
        self.model.model.to(self.device)  # 把底层PyTorch模型迁移到DirectML
        # CPU模式：注销上面两行，改为 self.device = "cpu"
    
    def detect_frame(self, frame):
        """检测单帧图像"""
        results = self.model(
            frame,
            # device=self.device,  # 可省略，模型已迁移到GPU
            conf=0.3,
            iou=0.5,
            imgsz=640,
            max_det=20,  # 最多检测 20 个目标
        )
        return results
    
    def draw_results(self, frame, results):
        """绘制检测结果"""
        for result in results:
            boxes = result.boxes
            if boxes is not None:
                for box in boxes:
                    x1, y1, x2, y2 = map(int, box.xyxy[0])
                    conf = float(box.conf[0])
                    
                    # 画框
                    cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                    cv2.putText(
                        frame,
                        f"Pole {conf:.2f}",
                        (x1, y1 - 10),
                        cv2.FONT_HERSHEY_SIMPLEX,
                        0.5,
                        (0, 255, 0),
                        2,
                    )
        return frame
    
    def process_video(self, video_path, output_path=None):
        """处理视频流"""
        cap = cv2.VideoCapture(video_path)
        
        if output_path:
            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
            fps = int(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_path, fourcc, fps, (width, height))
        
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            
            results = self.detect_frame(frame)
            frame = self.draw_results(frame, results)
            
            cv2.imshow("Drone Pole Detection", frame)
            if output_path:
                out.write(frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        cap.release()
        if output_path:
            out.release()
        cv2.destroyAllWindows()

# 使用示例
if __name__ == "__main__":
    detector = DronePoleDetector()
    detector.process_video("drone_footage.mp4", "output_detected.mp4")

五、性能优化建议

5.1 RX580 优化推理参数

# 推理时只需 model.model.to(dml_device)，device参数可省略
# ultralytics会自动检测模型所在设备并迁移输入数据
model.model.to(dml_device)

model.predict(
    source=image,
    # device=dml_device,  # 可省略：model.model.to()后自动使用GPU
    imgsz=640,      # 输入尺寸，不要超过 640
    half=False,     # RX580 DirectML 不支持 FP16，必须设为 False
    batch=1,        # 实时推理用 1
    conf=0.25,
    iou=0.45,
    max_det=10,     # 限制最大检测数
)

5.2 推理速度参考

模型	预期 FPS（RX580）	适用场景
YOLOv8n	25-35 FPS	实时巡检
YOLOv8s	15-20 FPS	准实时
YOLOv11n	30-40 FPS	实时巡检（推荐）