AnZhihe | 安志合修改

2026-01-05 21:16:14

Qwen2.5-32B 和 Qwen2.5-VL-32B 是通义千问（Qwen）系列中的两个大模型，分别对应纯语言模型（LLM）和多模态视觉-语言模型（VLM）。Docker环境安装与配置 NVIDIA Container Toolk，下载大模型参考 Docker部署bge-m3/bge-reranker模型。

模型简介

注意：Qwen2.5-VL 基于 Qwen2.5 语言主干 + 视觉编码器（如 SigLIP 或 CLIP 变体），需同时加载视觉和语言组件。

部署前的硬件准备

部署前，需确认硬件环境满足基本要求。由于Qwen2.5-VL-32B是多模态模型，其显存需求通常高于纯文本模型。

OpenLLM - Qwen

model    version                repo     required GPU RAM    platforms
-------  ---------------------  -------  ------------------  -----------
qwen2.5  qwen2.5:0.5b           default  12G                 linux
         qwen2.5:1.5b           default  12G                 linux
         qwen2.5:3b             default  12G                 linux
         qwen2.5:7b             default  24G                 linux
         qwen2.5:14b            default  80G                 linux
         qwen2.5:14b-ggml-q4    default                      macos
         qwen2.5:14b-ggml-q8    default                      macos
         qwen2.5:32b            default  80G                 linux
         qwen2.5:32b-ggml-fp16  default                      macos
         qwen2.5:72b            default  80Gx2               linux
         qwen2.5:72b-ggml-q4    default                      macos

硬件要求

• Qwen2.5-32B（纯文本）：

• 推荐：2×A100 80GB（FP16）或 4×A10 24GB（INT4 量化）

• 最低：单卡 A100 80GB（INT4）

• Qwen2.5-VL-32B（多模态）：

• 推荐：2×A100 80GB（FP16）或 4×A10 24GB（INT4）

• 需额外加载视觉编码器（如 ViT），显存需求略高

基于vLLM的Docker部署通用流程

下面以 vLLM框架 为例，介绍在Docker中部署这两个模型的通用步骤。vLLM是一个高效的推理和服务框架。

步骤一：准备环境与下载模型

1.安装依赖：确保系统已安装Docker、NVIDIA驱动和NVIDIA Container Toolkit（使Docker支持GPU）。

2.下载模型：推荐使用国内镜像源（如ModelScope）下载模型到本地目录。

# 示例：通过ModelScope下载Qwen2.5-32B-Instruct
pip install modelscope
modelscope download --model Qwen/Qwen2.5-32B-Instruct --local_dir /your/local/model/path

3.拉取Docker镜像：拉取官方vLLM镜像。

docker pull vllm/vllm-openai:latest

步骤二：启动Docker容器并运行模型

使用以下命令启动容器。请务必将命令中的 /your/local/model/path 和 Qwen2.5-32B-Instruct 替换为你实际部署的模型路径和名称（例如，部署VL模型时需替换为Qwen2.5-VL-32B-Instruct）。

docker run -d \
  --gpus all \
  -p 8000:8000 \
  -v /your/local/model/path:/model \  # 将宿主机模型目录挂载到容器
  --name vllm-qwen \
  vllm/vllm-openai:latest \
  --model /model \  # 容器内的模型路径
  --served-model-name Qwen2.5-32B \  # 服务名称，可按需修改
  --tensor-parallel-size 1 \  # 使用的GPU数量，单卡设为1
  --gpu-memory-utilization 0.9 \  # GPU内存利用率，可调整以防OOM
  --max-model-len 8192 \  # 最大序列长度，可根据需要调整
  --trust-remote-code  # Qwen模型需要此参数

部署 Qwen2.5-VL-32B-Instruct

docker run -d \
  --gpus all \  # 允许容器使用所有GPU
  -p 8000:8000 \  # 映射端口（主机端口:容器端口）
  -v /your/local/model/path:/model \  # 挂载模型目录到容器内
  --name vllm-qwen-vl \  # 容器名称
  vllm/vllm-openai:latest \  # 使用的镜像
  --model /model \  # 容器内模型路径 外部调用时入参model 需要与此处相同 注意此处有 /
  --served-model-name Qwen2.5-VL-32B \  # 服务名称，可按需修改
  --port 8000 \  # 容器内服务端口
  --host 0.0.0.0 \  # 允许外部访问
  --tensor-parallel-size 1 \  # 若单卡则设1，多卡按实际数量调整
  --gpu-memory-utilization 0.9 \  # 允许使用90%的GPU内存（避免OOM）
  --trust-remote-code  # 信任远程模型代码（Qwen模型需要）

关键参数说明：

• --tensor-parallel-size：根据你使用的GPU数量设置。例如，单卡设为1，双卡可设为2。

• --gpu-memory-utilization：控制显存使用率。如果启动时出现内存不足（OOM）错误，可以尝试降低此值（如调整为0.8）。

• --max-model-len：根据模型支持的上下文长度和你的需求调整。

• --dtype float16：模型运行的数据类型：float16 是半精度浮点类型，相比 float32 可减少 GPU 内存占用（约节省一半），同时保持较好的推理精度。Qwen2.5 模型支持 float16，推荐使用（若 GPU 支持 bfloat16，也可改为 bfloat16）。

测试与验证部署

服务启动后，可以通过以下方式验证模型是否正常工作：

1.检查服务状态：

curl http://localhost:8000/health

如果返回 {"status":"OK"} 或类似信息，说明服务已就绪。

2.发送推理请求进行测试：

Qwen2.5-32B (文本)：直接向其 /v1/completions 或 /v1/chat/completions 端点发送文本Prompt。

1. 测试聊天接口（推荐）

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen2.5-32B",
    "messages": [
      {"role": "user", "content": "你好，请介绍一下你自己。"}
    ],
    "max_tokens": 100,
    "temperature": 0.7
  }'

2. 测试流式输出（streaming）

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen2.5-32B",
    "messages": [{"role": "user", "content": "写一首关于春天的诗。"}],
    "stream": true,
    "max_tokens": 150
  }'

Qwen2.5-VL-32B (多模态)：需要构建一个包含图像和文本的多模态请求。可以参考官方GitHub仓库中的示例代码。

自定义 FastAPI + Transformers

1. Dockerfile（多模态）

# Dockerfile（多模态）
FROM nvcr.io/nvidia/pytorch:24.06-py3

RUN pip install --upgrade pip && \
    pip install "transformers>=4.40" "accelerate" "torch" "torchvision" \
    "pillow" "fastapi" "uvicorn" "einops" "timm" "qwen-vl-utils" \
    -i https://pypi.tuna.tsinghua.edu.cn/simple

COPY app_vl.py /app/app.py
WORKDIR /app
EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

2.app_vl.py（简化版）

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from PIL import Image
import base64
import io
from transformers import AutoModelForVision2Seq, AutoTokenizer

app = FastAPI()

# 加载模型（启动时加载）
model = AutoModelForVision2Seq.from_pretrained(
    "Qwen/Qwen2.5-VL-32B",
    device_map="auto",
    trust_remote_code=True,
    torch_dtype="auto"
)
processor = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-VL-32B", trust_remote_code=True)

class VLRequest(BaseModel):
    image_b64: str  # Base64 编码的图片
    question: str

@app.post("/vl")
async def vision_language(request: VLRequest):
    try:
        # 解码图片
        image_data = base64.b64decode(request.image_b64)
        image = Image.open(io.BytesIO(image_data)).convert("RGB")

        # 构造消息
        messages = [{
            "role": "user",
            "content": [
                {"type": "image", "image": image},
                {"type": "text", "text": request.question}
            ]
        }]

        # 预处理
        inputs = processor(messages, return_tensors="pt", padding=True)
        inputs = {k: v.to(model.device) for k, v in inputs.items()}

        # 生成
        output = model.generate(**inputs, max_new_tokens=256)
        response = processor.decode(output[0], skip_special_tokens=True)

        return {"response": response}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

3. 构建并运行

docker build -t qwen25-vl-32b -f Dockerfile.vl .
docker run -d --gpus all -p 8001:8000 qwen25-vl-32b

4.curl 测试（需 Base64 图片）

# 先将图片转为 base64
base64_image=$(base64 -i cat.jpg | tr -d '\n')

curl http://localhost:8001/vl \
  -H "Content-Type: application/json" \
  -d "{
    \"image_b64\": \"$base64_image\",
    \"question\": \"图片中有什么动物？\"
  }"

参考：

• NVIDIA GPU架构演进及使用场景

• 英伟达GPU参数速查表

• 常用AI模型介绍及多模型组合使用场景

• 大语言模型级别划分及使用场景

• Docker部署bge-m3/bge-reranker模型

• vLLM/Docker 部署Qwen2.5-VL-32B模型

2025-12-31 14:24:49

如2024年终总结预想的一样，2025确实是奔波的一年，虽然结束北漂回到二线城市工作，但是在这一年里大多数时间都是在上海、广州等一线做项目交付，只是base在二线而已，相当于出差去一线干活，工作模式也与之前的工作有所区别，需要一个人将整个项目交付搞定，自己给自己兜底，之前至少还是有backup。工作上今年最大的收获算是从0到1将AI项目落地交付，2B项目交付这块也积累了很多宝贵的经验。生活上陪伴小孩和亲人的时间多了些，但是也仅仅是周末和节假日，不过也算比之前好多了。个人提升这块，这一年奔波来奔波去，尤其12月赶项目上线连续加了一个月班，周末都没休，加班加得都有点想吐了🤮。总体来说个人提升、学习这块今年是有所懈怠，退步了，一个是长期出差，加班没时间，一个是来回奔波比较累，有时也懒得学习了，这块2026年还得提起来。

苦功、内功、外功，苦功其实对于个人来说是收益最低的，但是为了工作生活大多时候又不得不做，而且做得多，最后的效果也不一定好，当然这其中也有些是个人性格、工作习惯原因。工作已然十多年了，人生也已过半，还记得当时去小米面试，经理问我喜欢做什么样的工作，我回答的是有挑战性的工作，后面的工作大抵都是如此。后来接触佛学，禅宗后，明白了发愿，承诺都不是件简单的事。信愿证行，人是自我的主宰，心是天地的主宰，求锤得锤，所求必应。正所谓“祸福无门，唯人自召；善恶之报，如影随形。”这让我想起了《西游记》里的那首诗“人心生一念，天地悉皆知，善恶若无报，乾坤必有私”。

2026对个人来说大概率是伏吟局，还是多学习，多提升，多行善积德，干就完事了。“天行健，君子以自强不息；地势坤，君子以厚德载物”。如何在逆境中跃升？如何自利自他？如何修齐治平？“破山中贼易，破心中贼难”，人生尔尔，也不过如些而已。最后就以一首诗——《道心》，一首歌作为2025年，也是人生上半生的总结吧。在新的征途里，祝诸君武运昌隆，所求皆如愿，所行化坦途，多喜乐，长安宁。

[hermit autoplay="false" mode="circulation" preload="none"]remote#:610[/hermit]

参考：

• 转折2024

• 周易《大象传》详解
  

2025-12-29 18:21:08

《道心》

半生清贫半生缘，

心无归处道未明，

轮回路上日夜苦，

回首已是万千年。

                  -- 2025.12.11

2025-12-26 05:31:13

上一篇我们使用 Docker部署bge-m3/bge-reranker模型，由于测试环境GPU卡资源紧张，基于成本考虑，需要在同一张卡上运行多个模型。现在以 bge-m3/bge-reranker 模型为例，将两个模型部署在同一张英伟达 L20 GPU卡上。

🎯 同时运行的方案

方案1：使用不同端口分别部署（推荐）

这是最直接和稳定的方式：

# 启动 embedding 模型（使用端口 8080）
docker run -d --name bge-embedding --runtime nvidia --gpus '"device=0"' \
  -v /path/to/embedding-model:/mnt/models \
  -p 8080:8080 --ipc=host \
  --entrypoint=text-embeddings-router \
  ghcr.io/huggingface/text-embeddings-inference:1.6 \
  --model-id /mnt/models --port 8080 \
  --max-batch-tokens 16384 --max-concurrent-requests 256 \
  --max-client-batch-size 16

# 启动 rerank 模型（使用端口 8081）
docker run -d --name bge-reranker --runtime nvidia --gpus '"device=0"' \
  -v /path/to/reranker-model:/mnt/models \
  -p 8081:8080 --ipc=host \
  --entrypoint=text-embeddings-router \
  ghcr.io/huggingface/text-embeddings-inference:1.6 \
  --model-id /mnt/models --port 8080 \
  --max-batch-tokens 8192 --max-concurrent-requests 128 \
  --max-client-batch-size 8

方案2：使用不同GPU内存限制

如果担心资源竞争，可以为每个容器设置GPU内存限制：

# 为embedding模型分配较多显存
docker run -d --name bge-embedding --runtime nvidia --gpus '"device=0"' \
  -e NVIDIA_VISIBLE_DEVICES=1 \
  -e NVIDIA_DRIVER_CAPABILITIES=compute,utility \
  --memory=8g --memory-swap=10g \
  -p 8080:8080 \
  # ... 其他参数

# 为reranker模型分配较少显存
docker run -d --name bge-reranker --runtime nvidia --gpus '"device=0"' \
  -e NVIDIA_VISIBLE_DEVICES=1 \
  -e NVIDIA_DRIVER_CAPABILITIES=compute,utility \
  --memory=4g --memory-swap=6g \
  -p 8081:8080 \
  # ... 其他参数

📊 资源规划建议

GPU显存需求估算

NVIDIA L20有48GB显存，同时运行两个模型绰绰有余。

性能优化配置

# Embedding模型（通常需要更高吞吐量）
--max-concurrent-requests 256
--max-client-batch-size 16
--max-batch-tokens 16384

# Reranker模型（通常延迟更敏感）
--max-concurrent-requests 128  
--max-client-batch-size 8
--max-batch-tokens 8192

🔧 验证同时运行状态

1. 检查容器状态

docker ps | grep -E "(bge-embedding|bge-reranker)"

2. 监控GPU使用情况

# 实时监控GPU使用
watch -n 1 nvidia-smi

# 或使用更详细的监控
nvidia-smi --query-gpu=index,name,utilization.gpu,utilization.memory,memory.used,memory.total --format=csv -l 2

3. 分别测试两个服务

# 测试embedding服务
curl -X POST http://localhost:8080/embed \
  -H "Content-Type: application/json" \
  -d '{"inputs": "测试文本"}'

# 测试rerank服务  
curl -X POST http://localhost:8081/rerank \
  -H "Content-Type: application/json" \
  -d '{
    "query": "测试查询",
    "texts": ["文档1", "文档2"]
  }'

⚠️ 注意事项

1. 显存竞争：虽然可以同时运行，但在高并发时可能会有显存竞争

2. 性能隔离：一个模型的负载高峰可能影响另一个模型的响应时间

3. 故障隔离：一个容器崩溃不会影响另一个容器

4. 资源监控：建议设置监控告警，及时发现资源瓶颈

🚀 生产环境建议

对于生产环境，推荐：

1. 使用Kubernetes进行资源管理和弹性伸缩

2. 设置资源限制确保公平性

3. 实现健康检查和自动恢复

4. 使用负载均衡在多个实例间分发请求

总结：在L20 GPU上同时运行embedding和reranker模型是完全可行的，只需合理分配端口和调整资源参数即可，对于多个模型利用同一张GPU卡，生产环境还是慎用。

参考：

• 常用AI模型介绍及多模型组合使用场景
  

• 英伟达GPU参数速查表
  

2025-12-22 23:34:57

安装与配置 NVIDIA Container Toolkit

1. 确认前置条件
   在开始之前，请确保系统已经安装了NVIDIA GPU驱动程序（NVIDIA 驱动≥535.86.10，支持 CUDA 12.2+），并且可以正常运行 nvidia-smi 命令。同时，Docker Engine（版本建议 Docker 24.0+）也需要被安装好。

2. 安装 NVIDIA Container Toolkit
   具体的安装命令会根据操作系统有所不同。以下是一些常见系统的安装方法，可以参考 NVIDIA Docker 安装指南：

• 对于Ubuntu或Debian系统：

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
apt-get update
apt-get install -y nvidia-container-toolkit

• 对于CentOS或RHEL系统：

curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repoyum clean expire-cacheyum install -y nvidia-container-toolkit

nvidia-container-runtime --version
nvidia-ctk runtime configure --runtime=docker
systemctl restart docker

# 查看Docker Runtime配置
cat /etc/docker/daemon.json
{
    "default-runtime": "nvidia",
    "runtimes": {
        "nvidia": {
            "runtimeArgs": [],
            "path": "/usr/bin/nvidia-container-runtime"
        }
    },
    "insecure-registries": [
	  "xxx:5000"
    ]
}

验证 Docker GPU 支持

配置完成后，必须验证GPU是否真的可以在Docker容器中使用了。

运行测试容器：
使用一个标准的CUDA镜像启动一个容器，并执行 nvidia-smi 命令。如果容器内能正常显示出GPU信息，就说明配置成功了。

docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi

这个命令会启动一个临时容器，并执行 nvidia-smi。如果配置正确，将看到与在宿主机上直接运行 nvidia-smi 类似的GPU状态信息。

部署bge-m3/bge-reranker模型

bge-m3/bge-reranker模型，TEI框架介绍参考 常用AI模型介绍及多模型组合使用场景。

下载模型（推荐提前下载，避免容器内耗时）

通过 ModelScope 下载（推荐）

# 安装ModelScope工具
pip install modelscope

# 创建模型存储目录
mkdir -p /data/models

# 下载模型（国内源，速度快）
modelscope download --model BAAI/bge-m3 --local_dir /data/models/bge-m3
modelscope download --model BAAI/bge-reranker-v2-m3 --local-dir /data/models/bge-reranker-v2-m3

通过 Hugging Face 国内镜像下载（备用）

# 安装huggingface-cli
pip install huggingface-hub

# 设置国内镜像（hf-mirror）
export HF_ENDPOINT=https://hf-mirror.com

# 下载模型
huggingface-cli download --resume-download BAAI/bge-m3 --local-dir /data/models/bge-m3
huggingface-cli download --resume-download BAAI/bge-reranker-v2-m3 --local-dir /data/models/bge-reranker-v2-m3

• text-embeddings-inference 国内镜像下载地址

模型部署

两个模型的核心部署命令对比：

NVIDIA GPU卡对应的text-embeddings-inference镜像：

Architecture    Image
CPU ghcr.io/huggingface/text-embeddings-inference:cpu-1.6
Volta   NOT SUPPORTED
Turing (T4, RTX 2000 series, …) ghcr.io/huggingface/text-embeddings-inference:turing-1.6 (experimental)
Ampere 80 (A100, A30)   ghcr.io/huggingface/text-embeddings-inference:1.6
Ampere 86 (A10, A40, A4000, …)  ghcr.io/huggingface/text-embeddings-inference:86-1.6
Ada Lovelace (RTX 4000 series, …)   ghcr.io/huggingface/text-embeddings-inference:89-1.6
Hopper (H20, H100)  ghcr.io/huggingface/text-embeddings-inference:hopper-1.6 (experimental)

1.部署 BGE-M3 嵌入模型
此命令会拉取本地镜像、加载本地模型并启动服务，使用NVIDIA L20卡部署。

docker run -d \
  --name bge-m3 \
  --runtime nvidia \
  --gpus '"device=0"' \
  --ipc=host \
  -v /data/models/bge-m3:/mnt/models\
  -p 8080:8080 \
  --entrypoint=text-embeddings-router \
  ghcr.io/huggingface/text-embeddings-inference:1.6 \
  --model-id /mnt/models \
  --port 8080 \
  --max-batch-tokens 16384 \
  --max-concurrent-requests 512 \
  --max-client-batch-size 32

参数详细解释：

2.部署 BGE-Reranker-V2-M3 重排序模型

docker run -d \
  --name bge-reranker \
  --runtime nvidia \
  --gpus '"device=1"' \
  --ipc=host \
  -v /data/models/bge-reranker-v2-m3:/mnt/models\
  -p 8081:8080 \
  --entrypoint=text-embeddings-router \
  ghcr.io/huggingface/text-embeddings-inference:1.6 \
  --model-id /mnt/models \
  --port 8080 \
  --max-batch-tokens 16384 \
  --max-concurrent-requests 512 \
  --max-client-batch-size 32

执行 nvidia-smi 命令查看模型运行进程：

服务验证与问题排查

部署后，请按顺序验证服务状态。

1.检查容器状态

docker ps | grep -E "bge-m3|bge-reranker"

确认两个容器的状态（STATUS）均为 Up。

2.查看容器日志

# 查看BGE-M3日志
docker logs bge-m3 --tail 50

# 查看BGE-Reranker日志
docker logs bge-reranker --tail 50

关注日志末尾，确认出现类似 "Server started on 0.0.0.0:8080" 、"Ready"的成功信息，并且没有显存的报错。

3.发送测试请求

• 测试 BGE-M3 (嵌入)：成功会返回一个浮点数向量。

curl -X POST "http://localhost:8080/embed" \
  -H "Content-Type: application/json" \
  -d '{"inputs": "Hello, world!"}'

# 预期结果：
[[-0.015909059,0.026837891,...,-0.03666923,0.0015528625]]

• 测试 BGE-Reranker (重排序)：

text-embeddings-inference 服务的 /rerank 端点通常期望一个包含query和texts列表的JSON。成功会返回一个相关性分数列表。

curl -X POST "http://localhost:8081/rerank" \
      -H 'Content-Type: application/json' \
    -d '{"query":"What is Deep Learning?", "texts": ["Deep Learning is not...", "Deep learning is..."], "raw_scores": false}'

# 预期结果：
[{"index":1,"score":0.9976404},{"index":0,"score":0.12527926}]

问题排查

1.CUDA计算能力兼容性错误

docker run 启动模型容器报错：ERROR text_embeddings_backend: backends/src/lib.rs:388: Could not start Candle backend: Could not start backend: Runtime compute cap 89 is not compatible with compile time compute cap 90

这是问题原因是CUDA计算能力（90）与目前部署的GPU的实际计算能力（89）不匹配。确认使用的GPU具体型号和计算能力：

nvidia-smi --query-gpu=name,compute_cap --format=csv

常见计算能力对应表：详见 CUDA GPU 计算能力

解决方案：替换适配NVIDIA L20卡的镜像，Nvidia L20使用 ghcr.io/huggingface/text-embeddings-inference:1.6 镜像，H20使用 text-embeddings-inference:hopper-1.6 镜像

参考：

• NVIDIA GPU架构演进及使用场景

• 英伟达GPU参数速查表

• 常用AI模型介绍及多模型组合使用场景

• CentOS、Ubuntu、Windows NVIDIA 显卡驱动安装

• 手把手教你离线安装 nvidia-docker以及docker (在线环境亦可)

• Docker容器中使用Nvidia GPU