Ubuntu环境AMD AI MAX 395+ ROCm加速本地部署千问Qwen模型

前言

在AMD AI MAX 395+平台上部署千问模型，配合ROCm加速，可以实现高效的本地推理。本文记录完整的实践过程，从ROCm驱动安装到vLLM环境准备，再到Qwen3系列模型的部署与验证。环境基于Ubuntu 22.04，Python 3.10+。

一、ROCm7.0驱动安装

官方安装指南提供了详细的步骤：https://rocm.docs.amd.com/projects/install-on-linux/en/latest/install/quick-start.html。如果需要在其他版本中查找对应版本号，可以查阅：https://repo.radeon.com/amdgpu-install/。

# 更新apt缓存
sudo apt update
sudo apt install wget -y

# 选做：如果之前安装过旧驱动，需要卸载
sudo apt autoremove amdgpu-dkms
sudo rm /etc/apt/sources.list.d/amdgpu.list
sudo rm -rf /var/cache/apt/*
sudo apt clean all
sudo apt update

# 选择7.0.3版本的ROCm
wget https://repo.radeon.com/amdgpu-install/7.0.3/ubuntu/jammy/amdgpu-install_7.0.3.70003-1_all.deb
sudo apt install ./amdgpu-install_7.0.3.70003-1_all.deb
sudo apt install python3-setuptools python3-wheel
sudo usermod -a -G render,video $LOGNAME # Add the current user to the render and video groups
sudo apt install rocm

# 安装驱动
sudo apt update
sudo apt install "linux-headers-$(uname -r)" "linux-modules-extra-$(uname -r)"
sudo apt install amdgpu-dkms

# 将当前用户加入 render 和 video 用户组
sudo usermod -aG render $USER
sudo usermod -aG video $USER

# 重启
reboot

# 出现Agent2 GPU即可
rocminfo

# 最后可以确认GPU代号，这里是gfx1151
rocminfo | grep gfx

安装完成后重启，通过rocminfo确认Agent2 GPU出现，并用rocminfo | grep gfx检查代号为gfx1151。

二、Docker环境准备（vLLM）

1.安装并配置docker

# 1. 更新Ubuntu系统软件源
sudo apt update -y

# 2. 安装Docker依赖的基础软件包
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common lrzsz -y

# 3. 添加阿里云Docker GPG密钥
sudo curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -

# 4. 添加阿里云Docker软件源
sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

# 5. 再次更新软件源
sudo apt update -y

# 6. 安装Docker CE
sudo apt-get install docker-ce -y

# 7. 验证Docker版本
docker version

# 8. 创建Docker镜像翻跟斗配置文件
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://docker.1panel.live",
    "https://hub.rat.dev"
  ]
}
EOF

# 9. 重新加载Docker配置并重启服务
sudo systemctl daemon-reload
sudo systemctl restart docker

2.拉取vLLM镜像

如果目标主机无法联网，可以提前打包镜像到U盘，在有网络的主机上完成拉取和打包。否则可以直接在部署机上拉取。

2.1 将镜像文件打包进U盘

# 准备一个有docker可以正常拉取外网镜像的主机，可以调整docker保存镜像的文件，方便后续拷贝
# 1.拉取（版本可选）
docker pull rocm/vllm:rocm7.0.0_vllm_0.11.2

# 2.在当前目录下生成vllm_rocm7.tar文件
docker sa ve -o vllm_rocm7.tar rocm/vllm:rocm7.0.0_vllm_0.11.2

# 3.复制文件到U盘（确保U盘格式为exFAT或NTFS）

2.2 加载镜像

# 1. 找到U盘路径（通常在 /media/你的用户名/U盘名称 下，可以在文件管理器右键空白处选择"Open in Terminal"）
# 2. 或者手动拷贝
cp /media/iristar/MyUSB/vllm_rocm7.tar ~/
# 3. 导入镜像（可以直接在U盘里加载）
docker load -i vllm_rocm7.tar
# 4. 验证，出现TAG: rocm7.0.0_vllm_0.11.2
docker images

三、千问模型部署

1.Qwen3-32B

1.1 下载模型

# 1.按需创建文件
mkdir -p /home/iristar/models/Qwen-32B-AWQ
export MODEL_DIR=/home/iristar/models/Qwen-32B-AWQ

# 2. 安装/升级modelscope依赖
pip3 install modelscope

# 3. 下载Qwen-32B-AWQ模型
python3 -c """
import os
from modelscope.hub.snapshot_download import snapshot_download
model_id = 'qwen/Qwen-32B-AWQ'
snapshot_download(model_id=model_id,
                  cache_dir=os.environ.get('MODEL_DIR'),
                  revision='master')
"""

1.2 启动模型

# 启动模型
# 注意：-v /home/iristar/models/Qwen3-32B:/model 请替换为真实模型路径
# -e HSA_OVERRIDE_GFX_VERSION=11.0.0 用于让程序识别为RX 7900 XTX，从而在Ryzen AI Max 395+上运行
# （ROCm7.1.0已支持gfx1151，但官方文档尚未明确列出）
# --quantization awq 使用AWQ量化版本
# --dtype float16 配合AWQ使用
# --max-model-len 8192 限制上下文长度
docker run -it --network=host --group-add=video --ipc=host --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --device /dev/kfd --device /dev/dri -v /home/iristar/models/Qwen3-32B-AWQ/qwen/Qwen3-32B-AWQ:/model -e HSA_OVERRIDE_GFX_VERSION=11.0.0 rocm/vllm:rocm7.0.0_vllm_0.11.2_20251210 vllm serve /model --quantization awq --dtype float16 --served-model-name Qwen3-32B-AWQ --trust-remote-code --max-model-len 8192

1.3 验证模型

# 新开一个终端，发送请求测试
curl http://localhost:8000/v1/completions -H "Content-Type: application/json" -d '{
  "model": "Qwen3-32B-AWQ",
  "prompt": "你是谁？",
  "max_tokens": 2000,
  "temperature": 0.7
}'

成功的话会返回包含response的JSON。

2. Qwen3-Embedding

2.1 下载模型

python3 -c """
from modelscope import snapshot_download
snapshot_download('Qwen/Qwen3-Embedding-8B', cache_dir='/home/iristar/models')
"""

2.2 启动模型

# 注意更改模型地址与端口号，模型名可自行设置
docker run -d --name vllm-embedding --restart=always --network=host --group-add=video --ipc=host --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --device /dev/kfd --device /dev/dri -v /home/iristar/models/Qwen3-Embedding-8B:/model -e HSA_OVERRIDE_GFX_VERSION=11.0.0 rocm/vllm:rocm7.0.0_vllm_0.11.2_20251210 vllm serve /model --port 8001 --task embed --dtype float16 --max-model-len 8192 --gpu-memory-utilization 0.4 --trust-remote-code --served-model-name qwen-embedding

2.3 验证模型

# 查看容器是否存在
docker ps
# 查看日志
docker logs vllm-embedding
# 发送测试请求
curl http://localhost:8001/v1/embeddings -H "Content-Type: application/json" -d '{
  "model": "qwen-embedding",
  "input": "你好，测试一下向量化服务"
}'

返回一堆数字向量即成功。

3. Qwen3-Reranker

3.1 下载模型

python3 -c """
from modelscope import snapshot_download
snapshot_download('Qwen/Qwen3-Reranker-8B', cache_dir='/home/iristar/models')
"""

3.2 配置启动脚本与uv管理

vLLM当前版本不支持直接启动Qwen3的Rerank模型，因此采用手动脚本启动。魔塔社区提供了相应示例与要求：https://www.modelscope.cn/models/Qwen/Qwen3-Reranker-8B。

# 创建文件目录
mkdir -p /home/iristar/qwen_project
cd /home/iristar/qwen_project
# 创建Python文件
sudo nano rerank_service.py

Python文件中写入以下脚本：

import torch
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
from transformers import AutoModelForCausalLM, AutoTokenizer

# ===== 配置区域 =====
MODEL_PATH = "/model"
PORT = 8002
# ====================

app = FastAPI()

print(f"Loading model from {MODEL_PATH} ...")

# 1. 加载 Tokenizer
tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, padding_side='left', trust_remote_code=True)

# 2. 加载模型
model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    trust_remote_code=True,
    device_map="auto",
    torch_dtype=torch.float16,
    attn_implementation="flash_attention_2"
).eval()

# 3. 准备 Token IDs
token_false_id = tokenizer.convert_tokens_to_ids("no")
token_true_id = tokenizer.convert_tokens_to_ids("yes")

# 4. 准备前后缀
prefix = "<|im_start|>system\nJudge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be \"yes\" or \"no\".<|im_end|><|im_start|>user\n"
suffix = "<|im_end|><|im_start|>assistant\n"

prefix_tokens = tokenizer.encode(prefix, add_special_tokens=False)
suffix_tokens = tokenizer.encode(suffix, add_special_tokens=False)
max_length = 8192

print("Model loaded successfully!")

# ===== 核心处理逻辑 =====
def format_instruction(instruction, query, doc):
    if instruction is None or instruction == "":
        instruction = 'Given a web search query, retrieve relevant passages that answer the query'
    return ": {instruction}: {query}: {doc}".format(
        instruction=instruction, query=query, doc=doc
    )

def process_inputs(pairs):
    inputs = tokenizer(pairs, padding=False, truncation='longest_first',
                       return_attention_mask=False, max_length=max_length - len(prefix_tokens) - len(suffix_tokens))
    for i, ele in enumerate(inputs['input_ids']):
        inputs['input_ids'][i] = prefix_tokens + ele + suffix_tokens
    inputs = tokenizer.pad(inputs, padding=True, return_tensors="pt", max_length=max_length)
    for key in inputs:
        inputs[key] = inputs[key].to(model.device)
    return inputs

@torch.no_grad()
def compute_scores(inputs):
    batch_scores = model(**inputs).logits[:, -1, :]
    true_vector = batch_scores[:, token_true_id]
    false_vector = batch_scores[:, token_false_id]
    batch_scores = torch.stack([false_vector, true_vector], dim=1)
    batch_scores = torch.nn.functional.log_softmax(batch_scores, dim=1)
    scores = batch_scores[:, 1].exp().tolist()
    return scores

# ===== API 定义 =====
class RerankRequest(BaseModel):
    model: str = "qwen-reranker"
    query: str
    documents: List[str]
    top_n: Optional[int] = None
    instruction: Optional[str] = None

@app.post("/v1/rerank")
async def rerank(request: RerankRequest):
    try:
        query = request.query
        documents = request.documents
        instruction = request.instruction
        if not documents:
            return {"results": []}
        pairs = [format_instruction(instruction, query, doc) for doc in documents]
        inputs = process_inputs(pairs)
        scores = compute_scores(inputs)
        results = []
        for i, score in enumerate(scores):
            results.append({
                "index": i,
                "relevance_score": float(score),
                "document": documents[i]
            })
        results.sort(key=lambda x: x["relevance_score"], reverse=True)
        if request.top_n:
            results = results[:request.top_n]
        return {
            "model": request.model,
            "results": results,
            "usage": {"total_tokens": inputs.input_ids.numel()}
        }
    except Exception as e:
        print(f"Error: {e}")
        raise HTTPException(status_code=500, detail=str(e))

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=PORT)

为了更好地管理与迁移，可以使用uv来管理依赖。在同一个目录下创建pyproject.toml文件，写入相关依赖，注意不把torch写在这里，而是使用系统自带的AMD版本。

sudo nano pyproject.toml
# 写入以下内容
[project]
name = "qwen3-reranker-service"
version = "0.1.0"
description = "Rerank service using Qwen3 and ROCm"
readme = "README.md"
requires-python = ">=3.10"
dependencies = [
    "transformers>=4.51.0",
    "fastapi",
    "uvicorn",
    "modelscope",
    "accelerate",
    "pydantic"
]
# 注意：故意不把 torch 写在这里，使用系统自带的 AMD 版本

3.3 启动镜像

为了让镜像迁移后可以直接使用，将依赖环境和业务代码打包进镜像。这里利用临时容器完成构建。

# 启动临时容器，挂载项目目录
docker run -it --name builder --network=host -v /home/iristar/qwen_project:/tmp_build rocm/vllm:rocm7.0.0_vllm_0.11.2_20251210 bash

# 进入容器后执行以下操作
# 1. 安装uv
pip install uv -i https://pypi.tuna.tsinghua.edu.cn/simple

# 2. 创建应用目录
mkdir -p /app

# 3. 复制代码和配置
cp /tmp_build/rerank_service.py /app/
cp /tmp_build/pyproject.toml /app/

# 4. 进入应用目录
cd /app

# 5. 使用uv安装依赖
uv pip install --system -r pyproject.toml -i https://pypi.tuna.tsinghua.edu.cn/simple

# 6. 验证
pip list | grep transformers   # 版本号应大于4.51.0
ls /app   # 确保能看到python脚本

# 7. 退出容器
exit

确认无误后，提交为新镜像：

# 提交为新镜像
docker commit builder qwen-rerank:v1

# 删除临时构建容器
docker rm builder

# 后续如果需要导出镜像文件
docker sa ve -o qwen-rerank-v1.tar qwen-rerank:v1

启动最终服务：

# 调整挂载模型路径（/home/iristar/models/Qwen3-Reranker-8B替换为实际路径）
docker run -d --name final_reranker --restart=always --network=host --group-add=video --ipc=host --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --device /dev/kfd --device /dev/dri -v /home/iristar/models/Qwen3-Reranker-8B:/model -e HSA_OVERRIDE_GFX_VERSION=11.0.0 qwen-rerank:v1 python3 /app/rerank_service.py

3.4 检验模型

# 查看容器是否存在
docker ps
# 查看日志
docker logs final_reranker
# 访问http://localhost:8002/docs，可看到FastAPI的绿色POST
# 终端发送请求测试
curl http://localhost:8002/v1/rerank -H "Content-Type: application/json" -d '{
  "model": "qwen-reranker",
  "query": "中国的首都在哪里？",
  "documents": [
    "重力是万有引力。",
    "中国的首都是北京。",
    "香蕉很好吃。"
  ]
}'

返回包含相关性得分的JSON即为成功。