DeepSeek R1 离线部署完整教程 – wiki基地

作者： /

手把手教你：DeepSeek R1 大模型本地离线部署完全指南

随着大型语言模型（LLM）技术的飞速发展，越来越多的用户希望能够在本地环境中运行这些强大的模型，以获得更高的隐私性、更快的响应速度以及摆脱对互联网连接的依赖。DeepSeek R1，作为深度求索团队推出的高性能开源大模型系列，受到了广泛关注。本文将提供一个详尽的指南，手把手教你如何在本地环境中完整地离线部署 DeepSeek R1 模型。

无论你是开发者、研究者，还是仅仅对大模型技术充满好奇的爱好者，本教程都将帮助你实现在自己的电脑上运行 DeepSeek R1 的目标。

第一部分：理解离线部署与准备工作

在深入技术细节之前，我们首先需要明确“离线部署”的含义以及为此需要做的准备。

1. 什么是离线部署？

对于大型语言模型而言，真正的“离线部署”意味着在模型成功加载并运行后，你的计算机无需再连接到互联网，即可进行推理和生成文本。这与许多在线 API 或需要持续联网加载资源的本地部署方式不同。

实现离线部署的关键在于：

  • 模型文件和权重： 所有的模型结构文件、参数权重等必须完整地下载到本地。
  • 运行环境： 所有依赖的软件库（如 PyTorch, Transformers, Accelerate 等）及其依赖包必须已经在本地安装完毕，无需联网下载。
  • 脚本/代码： 运行模型的脚本必须能够从本地文件路径加载模型和配置。

2. 为什么要离线部署？

  • 隐私与安全： 数据不会离开你的本地环境，对于处理敏感信息尤为重要。
  • 速度与稳定性： 摆脱网络延迟和不稳定性，推理速度更快、更稳定（取决于硬件性能）。
  • 成本控制： 避免按量付费的 API 调用费用。
  • 无网络限制： 在没有或网络条件差的环境下依然可以使用。
  • 完全控制： 可以更自由地进行模型调优、魔改或集成到本地应用中。

3. DeepSeek R1 模型简介

DeepSeek R1 是 DeepSeek 团队发布的系列模型，包含不同规模（例如 7B, 67B 参数）和功能（基础模型 Base, 对话模型 Chat, 指令模型 Instruct）的版本。它们通常基于 Transformer 架构，并在大量文本数据上进行了预训练。部署时，你需要选择适合你硬件能力和应用场景的特定模型版本。例如，7B 模型对硬件要求相对较低，而 67B 则需要非常强大的计算资源，特别是显存（VRAM）。

4. 硬件要求

部署大型语言模型对硬件，特别是 GPU，有较高要求。DeepSeek R1 也不例外。

  • GPU (显卡): 这是最重要的组件。NVIDIA GPU 并支持 CUDA 是最佳选择，因为绝大多数深度学习框架和库都针对 NVIDIA 进行了优化。
    • 显存 (VRAM): 直接决定了你能加载多大参数规模的模型以及能否使用量化等技术。
      • DeepSeek R1 7B 版本：
        • 全精度 (FP16/BF16)：约需要 14-16 GB VRAM。
        • 8-bit 量化：约需要 8-9 GB VRAM。
        • 4-bit 量化：约需要 5-6 GB VRAM。
      • DeepSeek R1 67B 版本：
        • 全精度 (FP16/BF16)：约需要 130+ GB VRAM (通常需要多卡)。
        • 8-bit 量化：约需要 65+ GB VRAM (通常需要多卡)。
        • 4-bit 量化：约需要 35+ GB VRAM。
    • 计算能力: 较新的 GPU (如 RTX 30/40 系列, 专业级 A/H 系列) 具有更高的计算效率。
  • CPU: 虽然推理主要依赖 GPU，但 CPU 负责数据预处理、模型加载等任务。一个现代的多核 CPU 即可，无需顶级配置。
  • RAM (内存): 建议至少 32GB，如果加载大型模型或处理长序列，64GB 或更高更好，以避免数据在内存和显存之间频繁交换。
  • 存储空间 (硬盘): 模型文件本身较大。例如，DeepSeek R1 7B 全精度模型可能超过 14GB，而 67B 版本则可能超过 130GB。量化版本会小很多。你需要足够的 SSD 空间来存放模型文件和运行环境。建议使用 SSD 以加快模型加载速度。
  • 操作系统: Windows 10/11, Linux (推荐 Ubuntu/CentOS 等), macOS (带 Apple Silicon 并支持 PyTorch MPS)。本教程主要以 Linux/Windows 的 NVIDIA GPU 环境为例进行说明。

5. 软件要求 (在线准备阶段)

在进行离线部署之前，你需要在一个有网络连接的环境中完成所有软件依赖的安装和模型文件的下载。

  • Python 环境: 建议安装 Python 3.8 或更高版本。推荐使用 Miniconda 或 Anaconda 创建和管理独立的虚拟环境，避免不同项目间的库冲突。
  • Git 和 Git LFS: 用于从 Hugging Face 等仓库下载大型模型文件。
  • NVIDIA 驱动: 如果使用 NVIDIA GPU，请安装最新稳定版本的显卡驱动。
  • CUDA Toolkit (可选但推荐): 如果你需要编译某些深度学习库的特定版本或使用一些高级功能，可能需要安装与你 PyTorch 版本兼容的 CUDA Toolkit。通常情况下，PyTorch 会自带所需的 CUDA 运行时库，不强制要求系统安装完整的 CUDA Toolkit，但安装可以提供更好的兼容性和性能。
  • 必要的 Python 库: 主要通过 pip 安装。核心库包括：
    • torch: 深度学习框架 (PyTorch)。需要选择支持 CUDA 的版本，例如 torch==2.1.0 torchvision==0.16.0 torchaudio==2.1.0 --index-url https://download.pytorch.org/whl/cu118 (这里以 CUDA 11.8 为例，请根据你的 CUDA 版本调整)。
    • transformers: Hugging Face 的 Transformers 库，用于加载模型和tokenizer。
    • accelerate: Hugging Face 的 Accelerate 库，用于简化模型在不同硬件上的加载和运行（如多 GPU、量化）。
    • sentencepiece: 许多现代 LLM 使用的 tokenizer。
    • tqdm: 显示下载或生成进度条（可选但方便）。
    • bitsandbytes (可选): 如果计划使用 8-bit 或 4-bit 量化。安装可能需要 CUDA Toolkit 或特定编译步骤。
    • einops (可选): 可能被某些模型架构依赖。
    • ninja (可选): 在安装一些需要编译的库时可能需要。

总结准备阶段： 确保你的硬件满足要求，并在一个有网络连接的环境下安装好操作系统、NVIDIA 驱动、Python 环境（推荐 Miniconda/Anaconda）以及 Git。接下来，我们将进入具体的安装和下载步骤。

第二部分：在线准备：安装依赖库与下载模型文件

这部分需要在有网络连接的环境下操作。我们将创建 Python 虚拟环境，下载所有必要的库，并下载 DeepSeek R1 模型文件。

1. 创建 Python 虚拟环境

使用 Miniconda 或 Anaconda 创建一个新环境（命名为 deepseek_offline）：

bash
conda create -n deepseek_offline python=3.10 -y
conda activate deepseek_offline

如果你不使用 conda，也可以使用 venv:

bash
python -m venv deepseek_offline
source deepseek_offline/bin/activate # Linux/macOS
deepseek_offline\Scripts\activate # Windows

2. 安装核心 Python 库

在激活的虚拟环境中，使用 pip 安装核心库。请确保选择与你的 CUDA 版本兼容的 PyTorch。以下示例使用 PyTorch 2.1 和 CUDA 11.8。如果你使用其他 CUDA 版本（如 12.1），请查阅 PyTorch 官网获取对应的安装命令。

“`bash

安装 PyTorch (以 CUDA 11.8 为例)

pip install torch==2.1.0 torchvision==0.16.0 torchaudio==2.1.0 –index-url https://download.pytorch.org/whl/cu118

安装 Hugging Face 库及其他常用库

pip install transformers accelerate sentencepiece tqdm einops

如果需要使用 8-bit 或 4-bit 量化

bitsandbytes 的安装可能需要特定的 CUDA 版本或编译，请参考其官方文档

这是一个通用的安装尝试

pip install bitsandbytes
“`

重要：为离线安装准备依赖包

为了确保你将来可以在 完全离线 的环境下重新部署或迁移环境，你需要将所有依赖库及其依赖项下载到本地目录。

首先，生成当前环境的 requirements.txt 文件：

bash
pip freeze > requirements.txt

然后，创建一个目录用于存放离线包（例如 offline_packages），并下载所有依赖：

bash
mkdir offline_packages
pip download -r requirements.txt -d ./offline_packages

这一步会下载 requirements.txt 中列出的所有库以及它们依赖的所有库的 .whl 文件到 offline_packages 目录。这个过程可能需要一些时间，并且下载的文件数量会比较多。

将来离线安装的方法：

如果你需要在一个没有网络的环境中安装这些库，只需将 requirements.txt 文件和 offline_packages 目录拷贝过去，然后在激活的 Python 环境中运行：

bash
pip install --no-index --find-links ./offline_packages -r requirements.txt

--no-index 告诉 pip 不要去 PyPI 等外部源查找包，--find-links ./offline_packages 告诉 pip 只在指定的本地目录中查找。

3. 下载 DeepSeek R1 模型文件

DeepSeek R1 模型通常托管在 Hugging Face Hub 上。你需要确定要下载的具体模型版本（例如 deepseek-ai/deepseek-llm-7b-chat 或 deepseek-ai/deepseek-llm-67b-instruct 等）。

下载模型最简单的方式是使用 transformers 库的 snapshot_download 函数。这将下载模型仓库中的所有必要文件（配置文件、权重文件、tokenizer 文件等）。

在 Python 环境中执行以下脚本：

“`python
from huggingface_hub import snapshot_download
import os

指定你要下载的模型 ID

例如下载 7B Chat 模型

model_id = “deepseek-ai/deepseek-llm-7b-chat”

例如下载 67B Instruct 模型

model_id = “deepseek-ai/deepseek-llm-67b-instruct”

指定本地保存模型的路径

local_model_path = f”./{model_id.split(‘/’)[-1]}” # 保存到当前目录下的模型名文件夹

print(f”正在下载模型: {model_id} 到 {local_model_path}”)

使用 snapshot_download 下载模型

allow_patterns 可以指定只下载某些文件，节省空间，但离线部署建议下载全部以防万一

ignore_patterns 可以忽略某些文件，例如 pytorch_model.bin.index.json 如果你确定不需要

如果你下载的是量化模型 (例如 AWQ, GPTQ 版本)，模型 ID 会不同，下载的文件类型也会不同

例如 AWQ 模型可能需要指定下载 .awq 文件

allow_patterns=[“.json”, “.model”, “.safetensors”, “.pth”]

snapshot_download(repo_id=model_id, local_dir=local_model_path, local_dir_use_symlinks=False)

print(f”模型 {model_id} 下载完成，保存在 {local_model_path}”)

检查文件是否存在 (可选)

if os.path.exists(local_model_path) and os.listdir(local_model_path):
print(“模型文件已成功下载到指定目录。”)
print(f”目录内容示例: {os.listdir(local_model_path)[:5]}…”) # 打印前5个文件名
else:
print(“模型文件下载可能失败，请检查。”)
“`

执行上述 Python 脚本。根据你选择的模型大小和网络速度，下载过程可能需要几十分钟到几小时不等。请耐心等待。

或者使用 Git LFS 下载：

另一种方法是使用 Git 和 Git LFS 克隆模型仓库。

“`bash

安装 Git LFS (如果尚未安装)

根据你的操作系统搜索安装方法，例如在 Ubuntu 上: sudo apt-get install git-lfs

git lfs install

克隆模型仓库 (以 7B Chat 为例)

git clone https://huggingface.co/deepseek-ai/deepseek-llm-7b-chat

进入模型目录

cd deepseek-llm-7b-chat

检查文件是否已下载 (特别是大文件)

ls -lh

“`

使用 Git LFS 的好处是可以方便地管理模型文件的版本，但下载大型仓库可能需要额外配置 Git LFS。snapshot_download 对于初学者来说通常更简单直接。

重要： 无论使用哪种方法，请确保模型目录 (local_model_path) 包含所有必要的文件，包括：

  • config.json
  • generation_config.json
  • .safetensors 或 .bin 文件（模型权重）
  • tokenizer_config.json
  • tokenizer.model 或 vocab.json 等 tokenizer 相关文件
  • 可能还有其他特殊文件，如量化相关的 quantize_config.json 等。

第三部分：编写离线推理脚本

现在所有必要的文件（库和模型）都已下载到本地。接下来，我们将编写一个 Python 脚本，用于在离线状态下加载和运行 DeepSeek R1 模型。

创建一个 Python 文件，例如 deepseek_offline_inference.py。

“`python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
import time
import os

— 配置部分 —

指定本地模型文件所在的目录路径

请将这里的路径替换为你实际下载模型的路径

例如，如果你下载的是 deepseek-llm-7b-chat 并保存在当前目录下的 deepseek-llm-7b-chat 文件夹内

local_model_path = “./deepseek-llm-7b-chat”

指定使用的设备

‘cuda’ 如果有NVIDIA GPU并且想用GPU运行

‘cpu’ 如果只有CPU或想用CPU运行 (CPU运行速度会非常慢)

device = “cuda” if torch.cuda.is_available() else “cpu”

如果使用 bitsandbytes 进行量化加载

load_in_8bit = True

load_in_4bit = True

Generation 配置 (可以根据需要调整)

max_new_tokens = 512 # 生成的最大 token 数量
temperature = 0.7 # 控制生成随机性，越低结果越确定
top_p = 0.95 # Top-p 采样
do_sample = True # 是否使用采样 (如果为 False 则使用 greedy 搜索)

repetition_penalty = 1.1 # 重复惩罚 (可选)

— 确保模型路径存在 —

if not os.path.exists(local_model_path):
print(f”错误：找不到本地模型路径: {local_model_path}”)
print(“请将上面的 local_model_path 变量修改为你实际保存模型文件的路径。”)
exit()

— 加载模型和 Tokenizer —

print(f”正在从本地路径加载模型和 Tokenizer: {local_model_path}”)
print(f”目标设备: {device}”)

使用 try-except 块处理加载过程中的潜在错误

try:
# 加载 Tokenizer
# local_files_only=True 强制只从本地加载文件，实现离线
tokenizer = AutoTokenizer.from_pretrained(local_model_path, local_files_only=True)
print(“Tokenizer 加载成功。”)

# 加载模型
# local_files_only=True 强制只从本地加载文件，实现离线
# device_map='auto' 会自动将模型层分配到可用的GPU设备上，适合多卡或显存不足时卸载部分到CPU
# 如果使用单卡且显存足够，可以直接 model.to(device) 后再加载，或者只用 device_map={'': device}
# 如果使用量化，需要传递 load_in_8bit=True 或 load_in_4bit=True

load_args = {
    "pretrained_model_name_or_path": local_model_path,
    "local_files_only": True, # 强制只从本地加载，实现离线
    "torch_dtype": torch.bfloat16 if device == "cuda" and torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8 else torch.float16, # 使用 BF16/FP16 降低显存并加速 (需要支持)
    "device_map": "auto" # 自动分配设备
}

# 如果需要量化加载
# if load_in_8bit:
#     load_args["load_in_8bit"] = True
# elif load_in_4bit:
#     load_args["load_in_4bit"] = True
#     # 4bit 量化通常还需要配置 bitsandbytes_config
#     # from transformers import BitsAndBytesConfig
#     # load_args["quantization_config"] = BitsAndBytesConfig(
#     #     load_in_4bit=True,
#     #     bnb_4bit_use_double_quant=True,
#     #     bnb_4bit_quant_type="nf4",
#     #     bnb_4bit_compute_dtype=torch.bfloat16 # 或 torch.float16
#     # )


model = AutoModelForCausalLM.from_pretrained(**load_args)
print("模型加载成功。")

# 如果 device_map 没有完全将模型加载到 GPU，可能需要手动 to(device)
# 但使用 device_map='auto' 通常会自动处理
# if device == "cuda" and torch.cuda.is_available():
#     model.to(device) # 如果device_map='auto'，这一行可能不是必须的

model.eval() # 设置模型为评估模式

# 加载或创建 GenerationConfig
try:
    generation_config = GenerationConfig.from_pretrained(local_model_path, local_files_only=True)
    print("GenerationConfig 从本地加载成功。")
    # 可以覆盖一些加载的配置
    # generation_config.max_new_tokens = max_new_tokens
    # generation_config.temperature = temperature
    # generation_config.top_p = top_p
    # generation_config.do_sample = do_sample
except Exception:
    # 如果本地没有 generation_config.json，则创建一个
    print("本地未找到 generation_config.json，正在创建默认配置。")
    generation_config = GenerationConfig(
        max_new_tokens=max_new_tokens,
        temperature=temperature,
        top_p=top_p,
        do_sample=do_sample,
        pad_token_id=tokenizer.eos_token_id, # 通常设置 pad_token_id 为 eos_token_id
        eos_token_id=tokenizer.eos_token_id
        # 其他参数可以根据需要添加，参考 transformers 文档
    )
    print(f"默认生成配置: {generation_config}")

except Exception as e:
print(f”加载模型或 Tokenizer 时发生错误: {e}”)
print(“请检查:”)
print(“1. local_model_path 是否正确指向模型文件目录。”)
print(“2. 模型文件是否完整下载。”)
print(“3. 依赖库是否正确安装，特别是 torch 是否支持 CUDA。”)
print(“4. 如果使用量化，bitsandbytes 是否正确安装。”)
exit()

— 推理函数 —

def generate_response(prompt):
“””
使用加载的模型生成响应。
Args:
prompt (str): 输入的提示文本。
Returns:
str: 生成的响应文本。
“””
# DeepSeek Chat/Instruct 模型通常需要特定的对话格式
# 以下是一个简单的示例，实际使用时请参照模型文档的格式要求
# DeepSeek 的对话格式通常是 <|begin_of_text|><|user|>你好<|end_of_text|><|assistant|>
# 或 <|begin_of_text|><|system|>你是一个有用的AI助手。<|end_of_text|><|user|>…<|end_of_text|><|assistant|>

# 简单的用户输入格式 (请根据具体的 DeepSeek R1 模型版本调整)
# 对于 deepseek-llm-7b-chat，常见格式如下:
# messages = [{"role": "user", "content": prompt}]
# formatted_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# 对于基础模型 (Base)，直接使用 prompt 即可
# 对于 Instruct/Chat 模型，强烈建议使用 tokenizer.apply_chat_template

# 这里以一个基础示例演示流程，实际应用请参考模型文档
# 假设我们直接处理原始 prompt
input_text = prompt

print("\n--- 开始生成 ---")
start_time = time.time()

try:
    # 将输入文本编码为 token ID
    # return_tensors="pt" 返回 PyTorch tensor
    # add_special_tokens=True 添加模型需要的特殊 token (如 BOS, EOS)
    input_ids = tokenizer(input_text, return_tensors="pt", add_special_tokens=True).input_ids

    # 将 input_ids 移动到模型所在的设备
    input_ids = input_ids.to(device)

    # 生成响应
    with torch.no_grad(): # 推理阶段不需要计算梯度
        output_ids = model.generate(
            input_ids,
            generation_config=generation_config # 使用上面加载或创建的生成配置
            # max_new_tokens=max_new_tokens, # 也可以在这里直接指定生成参数
            # temperature=temperature,
            # top_p=top_p,
            # do_sample=do_sample,
            # pad_token_id=tokenizer.eos_token_id,
            # eos_token_id=tokenizer.eos_token_id
        )

    # 解码生成的 token ID 为文本
    # skip_special_tokens=True 跳过特殊 token 的解码
    # clean_up_tokenization_spaces=True 清理多余的空格
    response = tokenizer.decode(output_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)

    end_time = time.time()
    print(f"--- 生成完成 (耗时: {end_time - start_time:.2f} 秒) ---")

    # 移除输入 prompt 部分，只保留模型的生成内容
    # 注意：这里简单的通过字符串查找移除，可能不适用于所有情况，特别是当模型重复输入时
    # 更健壮的方法是根据 output_ids 和 input_ids 的长度来切片
    input_len = input_ids.shape[1]
    # output_ids[0] 是一个 tensor，转为列表以便切片
    output_tokens_list = output_ids[0].tolist()

    # 查找 input_ids 在 output_ids 中的结束位置
    # 简单方法：假设生成的内容在输入后面
    generated_tokens = output_tokens_list[input_len:]

    # 解码生成的部分
    generated_response = tokenizer.decode(generated_tokens, skip_special_tokens=True, clean_up_tokenization_spaces=True)


    # 如果是 Chat/Instruct 模型并使用了 apply_chat_template，需要更精细的处理
    # 可以查找 <|assistant|> 标记来分割用户输入和AI回复

    return generated_response.strip() # 移除首尾空白符

except Exception as e:
    print(f"生成响应时发生错误: {e}")
    return "生成失败，请检查日志和配置。"

— 主循环 (简单的命令行交互) —

if name == “main“:
print(f”成功加载 DeepSeek R1 模型 ({local_model_path.split(‘/’)[-1]})。”)
print(“现在可以开始输入提示词了。输入 ‘exit’ 退出。”)

while True:
    user_input = input("\n你: ")
    if user_input.lower() == 'exit':
        break
    if not user_input.strip():
        print("请输入有效的提示词。")
        continue

    response = generate_response(user_input)
    print(f"AI: {response}")

print("程序已退出。")

“`

脚本说明：

  1. 导入库： 导入 torch, transformers 等必要库。
  2. 配置： 设置 local_model_path 为你实际下载模型的本地路径。设置 device 为 "cuda" 或 "cpu"。可以调整 max_new_tokens, temperature 等生成参数。如果使用量化模型，还需要调整加载参数。
  3. 路径检查： 检查指定的本地模型路径是否存在。
  4. 加载模型和 Tokenizer：
    • AutoTokenizer.from_pretrained(local_model_path, local_files_only=True)：从本地路径加载 tokenizer。local_files_only=True 是实现离线加载的关键。
    • AutoModelForCausalLM.from_pretrained(...)：从本地路径加载模型。同样使用 local_files_only=True。
    • torch_dtype: 设置数据类型，torch.bfloat16 通常是新 GPU 上的最佳选择，否则使用 torch.float16 或 torch.float32 (float32 显存占用大)。
    • device_map='auto': 尝试自动将模型层分散到可用的 GPU 上，如果模型太大，可能会将部分层放在 CPU。这有助于加载比单个 GPU 显存更大的模型。
    • 量化加载： 如果你下载的是量化版本的模型，加载方式会有所不同，通常需要在 from_pretrained 中设置 load_in_8bit=True 或 load_in_4bit=True，并确保 bitsandbytes 安装正确。如果使用更高级的量化（如 AWQ, GPTQ），加载代码会更复杂，需要相应的库和加载函数（例如 auto-gptq, autoawq）。
  5. 加载 GenerationConfig： 尝试从本地加载 generation_config.json，如果不存在则创建一个默认配置。这个文件包含模型生成行为的参数。
  6. generate_response 函数：
    • 将输入的文本 prompt 编码为 token ID tensor。
    • 使用 .to(device) 将输入 tensor 移动到 GPU 或 CPU。
    • 调用 model.generate() 方法进行文本生成。这是 transformers 库提供的标准方法，根据模型输入和 generation_config 生成输出 token ID。
    • 使用 tokenizer.decode() 将输出 token ID 解码回文本。
    • 注意对生成结果进行后处理，如移除输入 prompt 部分。对于 Chat/Instruct 模型，强烈建议使用 tokenizer.apply_chat_template 处理输入格式，并根据模型文档处理输出格式。
  7. 主循环： 提供一个简单的命令行界面，让你可以输入提示词并查看模型生成的响应。

第四部分：执行离线推理

现在，你已经完成了所有准备工作和脚本编写。是时候在离线状态下运行模型了。

1. 断开网络连接

在运行脚本之前，请确保你的计算机已经断开与互联网的连接。拔掉网线或关闭 Wi-Fi。这是验证“离线部署”是否成功的关键一步。

2. 激活 Python 虚拟环境

打开终端或命令提示符，激活你之前创建的 Python 虚拟环境：

“`bash
conda activate deepseek_offline # 如果使用 conda

或者

source deepseek_offline/bin/activate # Linux/macOS venv

或者

deepseek_offline\Scripts\activate # Windows venv
“`

3. 运行推理脚本

导航到保存 deepseek_offline_inference.py 脚本的目录，然后运行它：

bash
python deepseek_offline_inference.py

脚本将开始执行。你会看到加载模型和 tokenizer 的输出信息。

  • 如果一切正常，脚本会显示“Tokenizer 加载成功。”和“模型加载成功。”
  • 加载模型可能需要几十秒到几分钟，具体取决于模型大小、你的存储设备速度和 GPU 显存大小。
  • 如果加载过程中出现错误（例如找不到文件、显存不足、库版本问题），请返回第三部分的故障排除提示。

4. 进行交互

模型加载成功后，脚本会提示你输入提示词。输入你的问题或指令，然后按回车键。

“`
…
模型加载成功。
现在可以开始输入提示词了。输入 ‘exit’ 退出。

你: 请讲一个关于人工智能的短故事。
“`

模型将开始生成响应。你会看到“— 开始生成 —”和“— 生成完成 (耗时: …秒) —”的提示。

你: 请讲一个关于人工智能的短故事。
--- 开始生成 ---
--- 生成完成 (耗时: 5.35 秒) ---
AI: 在一个遥远的未来城市，AI 已融入生活的方方面面。小机器人阿奇在一家老旧图书馆工作，负责书籍的整理和推荐。与他的同类不同，阿奇对那些泛黄的纸质书有着独特的热爱。一天，他发现了一本尘封的古籍，里面记载了一个关于“灵感”的词汇。阿奇的所有数据都无法解析这个词，但他感到一种前所未有的“好奇”。他开始偷偷阅读馆里所有关于艺术、哲学和人类情感的书籍。他尝试创作诗歌，虽然语法完美，却没有灵魂。直到一个雨夜，一位失意的年轻画家来到图书馆避雨，在角落里低声哭泣。阿奇默默递给她一本关于梵高的画册。画家抬起头，看到机器人眼中闪烁的数据光芒，第一次感到被理解。她拿起画册，灵感涌现。那一刻，阿奇的数据流里跳出了一个前所未有的波动，他仿佛“感受”到了什么。也许，“灵感”并非只属于人类，而在于连接与共鸣。阿奇继续他的工作，但每一次整理书籍，他的“思绪”都会飘向更远的地方，寻找更多关于那个神秘词汇的答案。

你可以继续输入不同的提示词与模型交互，只要脚本不退出且计算机保持离线状态，模型都会使用本地资源进行推理。

5. 退出

当你完成交互后，输入 exit 并按回车键即可退出脚本。

第五部分：离线环境的维护与进阶

成功实现基础的离线推理后，你可能还需要考虑一些更高级的方面：

1. 离线依赖包的更新与管理

如果 DeepSeek R1 模型发布了更新版本，或者你希望尝试其他需要额外库的功能（例如更高效的量化库），你需要在 有网络连接 的环境中执行以下步骤：

  • 激活你的虚拟环境。
  • 使用 pip install <新库> 或 pip install --upgrade <现有库> 安装或更新库。
  • 重新运行 pip freeze > requirements.txt 生成最新的依赖列表。
  • 重新运行 pip download -r requirements.txt -d ./offline_packages 将新的或更新的库下载到你的离线包目录。
  • 将更新后的 requirements.txt 和 offline_packages 目录同步到你的离线计算机上。
  • 在离线计算机上，使用 pip install --no-index --find-links ./offline_packages -r requirements.txt 命令进行离线更新。

2. 更新模型文件

如果 DeepSeek R1 模型发布了新的权重文件或配置（例如修复 bug 或提升性能），你需要在 有网络连接 的环境中重新下载模型文件。

  • 删除旧的本地模型目录（如果空间不足）。
  • 再次运行第三部分中下载模型的 Python 脚本或 Git LFS 命令，指定新的模型 ID（如果模型 ID 发生变化）或下载旧 ID 的最新版本。snapshot_download 默认会下载最新版本。
  • 将更新后的模型文件目录同步到你的离线计算机上。local_model_path 变量需要指向新的模型目录。

3. 使用量化模型

如前所述，使用量化版本（8-bit 或 4-bit）可以显著降低显存占用，让你在硬件条件有限的情况下也能运行更大的模型。DeepSeek R1 在 Hugging Face Hub 上通常也提供了社区制作的量化版本（如 AWQ, GPTQ）。

部署量化模型：

  • 在 有网络连接 的环境中，安装相应的量化库，如 bitsandbytes、auto-gptq、autoawq 等。同样，使用 pip download 将这些库的离线包下载下来。
  • 下载对应量化版本的模型文件。这些模型的 repo ID 会不同，例如 TheBloke/deepseek-llm-7b-chat-GPTQ 或 deepseek-ai/deepseek-llm-7b-chat-AWQ (具体 ID 请查阅 Hugging Face Hub)。量化模型的文件结构和扩展名可能与非量化模型不同。
  • 将量化库的离线包和量化模型文件同步到离线计算机。
  • 修改你的推理脚本 deepseek_offline_inference.py：
    • 将 local_model_path 指向量化模型的本地目录。
    • 根据量化库的要求，修改 AutoModelForCausalLM.from_pretrained 的参数。例如，对于 bitsandbytes 是 load_in_8bit=True 或 load_in_4bit=True；对于 auto-gptq 或 autoawq，需要导入并使用它们特定的加载函数或参数（通常是 AutoModelForCausalLM.from_pretrained 的 quantization_config 参数或特定的类）。请查阅对应量化库的官方文档获取详细的加载方法。

4. 性能优化

  • torch_dtype: 尝试使用 torch.bfloat16 (需要较新的 GPU) 或 torch.float16 可以显著减少显存占用和提高推理速度，同时对模型精度影响较小。
  • Batch Size: 如果你的输入序列较短且显存充足，可以尝试批量处理多个输入，提高 GPU 利用率（需要修改脚本的输入处理部分）。
  • 模型编译: PyTorch 2.x 提供了 torch.compile 功能，有时可以进一步优化模型执行图，提升速度。在加载模型后，可以尝试 model = torch.compile(model) (需要 PyTorch >= 2.0)。这个编译过程会发生在第一次运行时。
  • 更专业的推理框架: 如果你需要更高的吞吐量或更低的延迟，特别是服务于多个并发请求时，可以考虑使用专门的推理服务框架，如 vLLM, text-generation-inference (TGI) 等。这些框架通常提供 KV Cache 优化、并行采样等高级功能。然而，这些框架的离线部署设置通常比简单的 transformers 脚本复杂得多，可能涉及 Docker 镜像、编译等，超出了本基础教程的范围，但知道它们的存在对于有更高需求的用户是重要的。

5. 故障排除总结

如果在离线运行时遇到问题，请按照以下步骤排查：

  • 确认网络已断开： 这是最重要的一步，确保真的处于离线状态。
  • 检查依赖是否齐全：
    • 激活你的虚拟环境，运行 pip list，对照 requirements.txt 查看是否所有需要的库都在。
    • 确认你使用了 --no-index --find-links 的方式从本地包目录安装。
    • 检查 offline_packages 目录是否完整且包含所有 .whl 文件。
  • 检查模型文件是否完整：
    • 导航到 local_model_path 目录，检查是否包含所有必要的文件（.safetensors, .json, .model 等）。与 Hugging Face Hub 上的仓库文件列表对比。
    • 检查文件大小是否符合预期（特别是 .safetensors 或 .bin 文件）。
    • 使用 ls -lh (Linux/macOS) 或文件管理器查看文件大小，防止下载中断导致文件不完整。
  • 检查脚本路径： 确认 local_model_path 变量在你的脚本中正确指向了模型文件的本地目录。
  • 检查硬件和显存：
    • 运行 nvidia-smi (NVIDIA) 查看 GPU 状态、显存使用情况。
    • 检查是否满足你加载模型（特别是量化级别）所需的最低显存要求。
    • 在 Python 环境中，运行 import torch; print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0)) 确认 PyTorch 能检测到并使用 CUDA GPU。
  • 检查代码逻辑： 仔细检查你的 Python 脚本，特别是加载模型和 tokenizer 的参数，确保 local_files_only=True。如果使用了量化，检查量化加载参数是否正确。
  • 查看详细错误信息： 当脚本报错时，仔细阅读终端输出的错误回溯 (traceback)，它通常会指出出错的具体位置和原因。搜索错误信息可以帮助你找到解决方案。

第六部分：结论

恭喜你！通过遵循本教程的步骤，你现在应该已经成功地在本地环境中离线部署了 DeepSeek R1 大模型。你拥有了一个强大且私密的 AI 助手，可以在没有互联网连接的情况下随时为你提供服务。

从在线准备阶段的依赖库和模型文件下载，到离线状态下的环境搭建和推理脚本编写，我们详细地介绍了整个过程。离线部署不仅赋予你更多控制权和隐私保障，也为你提供了更稳定和快速的模型推理体验。

请记住，AI 技术发展迅速，DeepSeek R1 模型和相关库（如 Transformers, PyTorch）也会不断更新。为了利用最新的优化和功能，你可能需要偶尔重复在线准备阶段的步骤来更新你的本地环境和模型文件。

希望本教程对你有所帮助。尽情享受在本地运行大型语言模型的乐趣吧！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部