DeepSeek-R1 推理模型

在 Clore.ai 的 GPU 上运行 DeepSeek-R1 开源推理模型

所有示例都运行在通过以下平台租用的 GPU 服务器上： CLORE.AI 市场。RTX 4090 实例起价约为每天 0.50 美元。

概览

DeepSeek-R1 是一个 671B 参数的开权重推理模型，于 2025 年 1 月由 DeepSeek 发布，采用以下许可： Apache 2.0 。它是首个在数学、编程和科学基准上与 OpenAI o1 持平的开源模型——同时通过显式的 <think> 标签暴露其完整的思维链。

完整模型使用 混合专家（MoE） 架构，每个 token 仅激活 37B 参数，这使得尽管参数总数惊人，推理仍然可行。对大多数实践者来说， 蒸馏版本 （1.5B → 70B）更实用：它们通过将知识蒸馏到 Qwen-2.5 和 Llama-3 基础架构中，继承了 R1 的推理模式，并可在普通 GPU 上运行。

主要特性

• 显式思维链 — 每个回复都以一个 <think> 块开头，模型会在其中进行推理、回溯并自我纠正，然后再给出最终答案

• 通过强化学习训练 — 推理能力源自 RL 奖励信号，而不是人工编写的思维链数据

• 六个蒸馏版本 — 从完整 671B 模型蒸馏而来的 1.5B、7B、8B、14B、32B、70B 参数模型，基于 Qwen 和 Llama 架构

• Apache 2.0 许可 — 可完全商用，无版税，无使用限制

• 广泛框架支持 — Ollama、vLLM、llama.cpp、SGLang、Transformers、TGI 开箱即用

• AIME 2024 Pass@1：79.8% — 在竞赛数学上与 OpenAI o1 持平

• Codeforces 2029 Elo — 超过 o1 的 1891，适用于算法竞赛编程

模型变体

变体	参数量	架构	FP16 显存	Q4 VRAM	Q4 磁盘
DeepSeek-R1（完整 MoE）	671B（37B 激活）	DeepSeek MoE	约 1.3 TB	约 350 GB	约 340 GB
R1-Distill-Llama-70B	70B	Llama 3	140 GB	40 GB	42 GB
R1-Distill-Qwen-32B	32B	Qwen 2.5	64 GB	22 GB	20 GB
R1-Distill-Qwen-14B	14B	Qwen 2.5	28 GB	10 GB	9 GB
R1-Distill-Llama-8B	8B	Llama 3	16 GB	6 GB	5.5 GB
R1-Distill-Qwen-7B	7B	Qwen 2.5	14 GB	5 GB	4.5 GB
R1-Distill-Qwen-1.5B	1.5B	Qwen 2.5	3 GB	2 GB	1.2 GB

选择变体

使用场景	推荐变体	Clore 上的 GPU
快速实验、边缘测试	R1-Distill-Qwen-1.5B	任意 GPU
预算部署、快速推理	R1-Distill-Qwen-7B	RTX 3090（约每天 0.30–1 美元）
单 GPU 生产的最佳平衡点	R1-Distill-Qwen-14B Q4	RTX 4090 （约每天 0.50–2 美元）
性价比最高（推荐）	R1-Distill-Qwen-32B Q4	RTX 4090 24 GB 或 A100 40 GB
蒸馏后最高质量	R1-Distill-Llama-70B	2× A100 80 GB
研究、全保真推理	DeepSeek-R1 671B	8× H100 集群

HuggingFace 仓库

变体	仓库
完整 R1	deepseek-ai/DeepSeek-R1
Llama-70B 蒸馏版	deepseek-ai/DeepSeek-R1-Distill-Llama-70B
Qwen-32B 蒸馏版	deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
Qwen-14B 蒸馏版	deepseek-ai/DeepSeek-R1-Distill-Qwen-14B
Llama-8B 蒸馏版	deepseek-ai/DeepSeek-R1-Distill-Llama-8B
Qwen-7B 蒸馏版	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
Qwen-1.5B 蒸馏版	deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

要求

组件	最低配置（7B Q4）	推荐配置（32B Q4）
GPU 显存	6 GB	24 GB
系统内存	16 GB	32 GB
磁盘	10 GB	30 GB
CUDA	12.1+	12.4+
Docker	24.0+	25.0+

Ollama 快速开始

Ollama 会自动处理量化、下载和服务——这是启动 DeepSeek-R1 最快的路径。

安装并运行

# 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 拉取并运行（选择你的变体）：
ollama run deepseek-r1:1.5b    # 边缘 / 测试
ollama run deepseek-r1:7b      # 低预算——适配任何 8 GB+ GPU
ollama run deepseek-r1:14b     # RTX 4090 最佳选择
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB

交互式示例会话

>>> 证明 √2 是无理数。

<think>
我将使用反证法。
假设 √2 是有理数，因此 √2 = p/q，其中 p,q 是整数且 gcd(p,q) = 1。
那么 2 = p²/q²，因此 p² = 2q²。
这意味着 p² 是偶数，所以 p 必为偶数。设 p = 2k。
代入得到：(2k)² = 2q² → 4k² = 2q² → q² = 2k²。
所以 q² 也是偶数，这意味着 q 是偶数。
但如果 p 和 q 都是偶数，则 gcd(p,q) ≥ 2，这与我们的假设矛盾。
</think>

**√2 是无理数的证明（反证法）：**

设 √2 = p/q，且已化为最简形式（gcd(p,q) = 1）。平方后得到 p² = 2q²。
由于 p² 是偶数，所以 p 是偶数——设 p = 2k。于是 4k² = 2q²，因此 q² = 2k²，
这意味着 q 也是偶数。这与 gcd(p,q) = 1 矛盾。∎

使用与 OpenAI 兼容的 API

# 将 Ollama 启动为服务器（如果尚未运行）
ollama serve &

# 通过 curl 查询
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "将 x^4 - 1 在整数范围内完全分解。"}],
    "temperature": 0.6
  }' | python3 -m json.tool

Python 客户端（通过 OpenAI SDK）

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "编写一个 Python 函数来寻找最长回文子串。"}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)

vLLM 生产环境部署

vLLM 通过连续批处理、PagedAttention 和前缀缓存，为多用户服务提供最高吞吐量。

单 GPU — 7B / 14B

pip install vllm

# 7B 适用于任何 16 GB+ GPU
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B 适用于 RTX 4090（24 GB）
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92

多 GPU — 32B（推荐）

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching

提示： 32B Q4 的 GPTQ 或 AWQ 检查点可放入单张 RTX 4090（24 GB）：

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --quantization awq --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

多 GPU — 70B

vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90

查询 vLLM 端点

curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "求解：找出所有满足 p^2 + 2 也为素数的素数 p。"}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'

Transformers / Python（带 <think> 标签解析）

当你需要对生成过程进行细粒度控制，或者想将 R1 集成到 Python 流水线中时，请使用 HuggingFace Transformers。

基础生成

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch, re

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "前 100 个正整数的和是多少？"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)

解析 <think> 标签

def parse_r1_response(text: str) -> dict:
    """将 DeepSeek-R1 的回复拆分为思考部分和答案部分。"""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"模型进行了 {result['thinking_tokens']} 个词的推理")
print(f"答案：{result['answer']}")

流式输出与 <think> 状态跟踪

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="unused")

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "从 ax² + bx + c = 0 推导二次公式。"}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[推理] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[答案] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()

在 Clore.ai 上的 Docker 部署

Ollama Docker（最简单）

Docker 镜像： ollama/ollama 端口： 22/tcp, 11434/http

# 在 Clore 实例上
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# 拉取并提供模型服务
docker exec deepseek-r1 ollama pull deepseek-r1:32b

vLLM Docker（生产环境）

Docker 镜像： vllm/vllm-openai:latest 端口： 22/tcp, 8000/http

# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:

在 Clore.ai 上部署：

1. 打开 clore.ai/marketplace

2. 筛选条件： 2× GPU，总显存 48 GB+ （例如 2× RTX 4090 或 A100 80 GB）

3. 将 Docker 镜像设置为 vllm/vllm-openai:latest

4. 将端口映射为 8000 作为 HTTP

5. 将上面的 compose 文件中的命令粘贴到启动命令中

6. 健康检查通过后，通过 HTTP 端点连接

Clore.ai 部署提示

选择合适的 GPU

预算	GPU	每日成本	最佳变体
最低	RTX 3090（24 GB）	$0.30 – 1.00	R1-Distill-Qwen-7B 或 14B Q4
标准	RTX 4090（24 GB）	$0.50 – 2.00	R1-Distill-Qwen-14B FP16 或 32B Q4
生产	A100 80 GB	$3 – 8	R1-Distill-Qwen-32B FP16
高质量	2× A100 80 GB	$6 – 16	R1-Distill-Llama-70B FP16

性能调优

• Temperature 0.6 是推理任务推荐的默认值——DeepSeek 自己的论文也使用这个数值

• 设置 max_tokens 尽量大 — 推理模型会生成较长的 <think> 块；对于非平凡问题，建议 4096 以上

• 启用前缀缓存 (--enable-prefix-caching （在 vLLM 中）当使用共享系统提示时

• 限制并发 (--max-num-seqs 16）用于推理工作负载——每个请求比标准聊天消耗更多计算资源

• 使用 Q4 量化 以在单张 24 GB GPU 上容纳 32B，并尽量减少质量损失（蒸馏本身已压缩了 R1 的知识）

上下文长度注意事项

由于 <think> 块，推理模型比标准聊天模型消耗更多上下文：

任务复杂度	典型思考长度	所需总上下文
简单算术	约 100 tokens	约 300 tokens
代码生成	约 500–1000 tokens	约 2000 tokens
竞赛数学（AIME）	约 2000–4000 tokens	约 5000 tokens
多步骤研究分析	约 4000–8000 tokens	约 10000 tokens

故障排查

内存不足（OOM）

# 缩短上下文长度
--max-model-len 8192    # 而不是 32768

# 限制并发序列数
--max-num-seqs 8

# 使用量化
--quantization awq      # 或 gptq

模型不输出 <think> 块

某些系统提示会抑制思考。避免使用诸如“简洁一点”或“不要解释你的推理”之类的指令。使用最小化的系统提示，或者干脆不使用：

# 好的——保留推理
messages = [{"role": "user", "content": "..."}]

# 不好的——可能会抑制思考
messages = [
    {"role": "system", "content": "极其简短。不要解释。"},
    {"role": "user", "content": "..."}
]

重复或循环 <think> 输出

降低 temperature 以减少推理链中的随机性：

temperature = 0.0   # 确定性——最适合数学/代码
temperature = 0.3   # 略有变化——适合分析

首个 token 很慢（TTFT 高）

这是正常的——模型会先生成 <think> tokens，然后才显示答案。对于不需要推理、且对延迟敏感的应用，请使用 DeepSeek-V3 替代。

Clore 实例上的下载停滞

HuggingFace 下载在某些提供商上可能较慢。将模型预缓存到持久化卷中：

# 一次性下载到卷中
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# 将 vLLM 指向本地路径
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000

延伸阅读

• DeepSeek-R1 论文 — 通过强化学习激励 LLM 的推理能力

• DeepSeek-R1 GitHub — 含模型卡的官方仓库

• DeepSeek-V3 指南 — 同一实验室的非推理通用模型

• vLLM 指南 — 完整的生产服务部署方案

• Ollama 指南 — 适用于任何模型的简单本地部署

• Open WebUI 指南 — 支持原生 <think> 标签渲染的聊天界面

• Qwen 2.5 指南 — 大多数 R1 蒸馏版本所使用的基础架构