推理与部署 on 扎塔-Zata

vllm

Thu, 30 Oct 2025 01:27:14 +0800

vLLM 是一个非常流行的高性能大语言模型（LLM）推理和服务库。它之所以速度快，关键在于它采用了 PagedAttention 和持续批处理 (Continuous Batching) 等先进技术，极大提高了 GPU 内存的利用率和吞吐量。

这是一个详细的 vLLM 使用教程，分为几个关键步骤。

1. 什么是 vLLM？

高性能：vLLM 的吞吐量远高于传统的 Hugging Face Transformers 实现（快几十倍）。
高效内存管理：通过 PagedAttention，vLLM 像操作系统管理虚拟内存一样管理注意力机制中的 Key 和 Value（KV 缓存），减少了内存浪费和碎片。
OpenAI 兼容：它提供了一个与 OpenAI API 完全兼容的服务器，让您可以无缝替换原有的 API 调用。

2. 🔧 安装

vLLM 的安装非常简单，但它有一个关键的前提条件：

您必须有一块支持 CUDA 的 NVIDIA GPU。
需要安装 Python 3.8 或更高版本。

您可以使用 pip 直接安装：

pip install vllm

3. 🚀 核心用法一：使用 Python API (离线推理)

这是最直接的使用方式，适合在 Python 脚本中进行批量推理。

您只需要导入 LLM 和 SamplingParams 这两个核心类。

LLM：用于加载模型。
SamplingParams：用于指定生成文本时的参数（如温度、top_p 等）。

示例代码：

from vllm import LLM, SamplingParams

# 准备提示词列表
prompts = [
 "Hello, my name is",
 "The president of the United States is",
 "The capital of France is",
 "The future of AI is",
]

# 准备采样参数
# 您可以为所有提示词设置一组参数
sampling_params = SamplingParams(
 temperature=0.8,
 top_p=0.95,
 max_tokens=100
)

# 初始化 LLM 类，指定要加载的模型
# vLLM 会自动从 Hugging Face Hub 下载模型
# 第一次加载模型可能需要一些时间
print("正在加载模型...")
llm = LLM(model="meta-llama/Llama-2-7b-chat-hf")
print("模型加载完毕。")

# 运行批量推理
print("正在生成文本...")
outputs = llm.generate(prompts, sampling_params)
print("生成完毕。")

# 打印输出结果
for output in outputs:
 prompt = output.prompt
 generated_text = output.outputs[0].text

 print(f"--- 提示词 (Prompt) ---")
 print(prompt)
 print(f"--- 生成结果 (Generated) ---")
 print(generated_text)
 print("\n")

4. 🚀 核心用法二：部署 OpenAI 兼容 API 服务器

这是 vLLM 最强大的功能之一：将任何开源大模型部署为一个高速的、与 OpenAI API 格式一致的 API 服务。

第 1 步：启动服务器

您只需要一行命令即可启动服务器。vLLM 推荐使用 vllm serve 命令。

（请注意：meta-llama/Llama-2-7b-chat-hf 是一个需要授权的门控模型，您需要先登录 huggingface-cli login 才能下载。您也可以换成其他开放模型，如 Qwen/Qwen2-1.5B-Instruct）。

# 启动服务器，加载 Llama-2-7b-chat 模型
# 服务器默认运行在 http://localhost:8000
vllm serve meta-llama/Llama-2-7b-chat-hf

服务器启动后，您会看到类似以下的日志：

...
INFO 10-29 10:00:00 server.py:98] Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO 10-29 10:00:00 utils.py:322] Using Eager mode.
INFO 10-29 10:00:00 utils.py:537] Effectively using 1 GPUs.
...

第 2 步：查询服务器 (使用 Python)

现在，您可以使用任何 HTTP 客户端来调用它。最简单的方法是使用 openai 官方 Python 库。

首先，请确保您已安装 openai 库： pip install openai

然后，运行以下 Python 脚本：

from openai import OpenAI

# 1. 初始化 OpenAI 客户端
# 指向您本地 vLLM 服务器的地址
client = OpenAI(
 base_url="http://localhost:8000/v1",
 api_key="vllm" # API 密钥不是必需的，但 OpenAI 库要求填写
)

# 2. 调用聊天接口 (Chat Completions)
print("正在调用 vLLM 服务器...")
chat_response = client.chat.completions.create(
 model="meta-llama/Llama-2-7b-chat-hf", # 确保这里的模型名与服务器加载的_一致
 messages=[
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "What is the capital of France?"}
 ],
 max_tokens=50,
 temperature=0.7
)

print("--- 服务器响应 ---")
print(chat_response.choices[0].message.content)

# 3. (可选) 调用文本补全接口 (Completions)
# print("\n--- 调用文本补全接口 ---")
# completion_response = client.completions.create(
# model="meta-llama/Llama-2-7b-chat-hf",
# prompt="The capital of France is",
# max_tokens=50,
# temperature=0.7
# )
# print(completion_response.choices[0].text)

5. 📚 关键概念：`SamplingParams`

在用法一中，SamplingParams 对象是控制文本生成的关键。以下是一些常用参数：

temperature (浮点数): 控制随机性。0 表示确定性输出，更高的值（如 0.8）表示更多样化的输出。
top_p (浮点数): 核采样 (Nucleus sampling)。仅从累积概率超过 top_p 的最小标记集中进行采样。
max_tokens (整数): 生成的最大 token 数量。
n (整数): 为每个提示词生成多少个独立的输出。
stream (布尔值): 是否以流式（逐个 token）返回结果。
stop (字符串列表): 遇到列表中的任何字符串时停止生成。

6. 🔗 官方资源

vLLM 发展非常快，最准确的信息始终来自官方：

官方文档: https://docs.vllm.ai/
GitHub 仓库: https://github.com/vllm-project/vllm

openbayes算力平台使用教程

Tue, 13 May 2025 14:39:02 +0800

基础知识

vllm使用教程

Tue, 13 May 2025 14:14:39 +0800

参考知乎

常用命令

# 通过魔搭社区构建
VLLM_USE_MODELSCOPE=true vllm serve [魔搭建社区的模型名，如：Qwen/Qwen3-0.6B-FP8] --enable-reasoning --reasoning-parser deepseek_r1

# 通过本地模型文件构建
python -m vllm.entrypoints.openai.api_server --model ~/Qwen3-0.6B --served-model-name Qwen3-0.6B --max-model-len=2048

基本使用

什么是 vLLM？

vLLM 是一个为大型语言模型（LLM）推理和服务而设计的高性能开源库。它通过引入创新的技术，如 PagedAttention 和连续批处理（Continuous Batching），显著提高了吞吐量并有效管理内存，使得在生产环境中部署 LLM 更加高效。

核心优势:

高吞吐量: 通过 PagedAttention 和连续批处理等技术，vLLM 能够处理更多的请求。
内存效率: PagedAttention 有效地管理注意力机制中的键（key）和值（value）缓存，减少内存浪费和碎片。
易用性: 与 Hugging Face Transformers 模型无缝集成，并提供 OpenAI 兼容的 API 服务器。
灵活性: 支持多种解码算法（如并行采样、束搜索等）、张量并行和流水线并行以进行分布式推理。
广泛的模型支持: 支持许多流行的开源 LLM。

1. 安装 vLLM

vLLM 需要 Linux 环境、Python 3.8 或更高版本，以及具有 CUDA 计算能力 7.0 或更高版本的 NVIDIA GPU（例如 V100, T4, RTX20xx, A100, L4, H100 等）。vLLM 通常使用特定版本的 CUDA 进行编译（例如 CUDA 12.1）。

推荐使用 Conda 创建新环境:

conda create -n vllm-env python=3.9 -y
conda activate vllm-env

通过 pip 安装 (通常需要与你的 CUDA 版本匹配):

# 安装与 CUDA 12.1 兼容的 vLLM
pip install vllm

如果你本地的 CUDA 版本不同，或者想使用特定的 PyTorch 版本，可能需要从源码编译或者安装特定 CUDA 版本的预编译包。请参考 vLLM 官方文档获取最新的安装指南和针对不同 CUDA 版本的安装命令。

查看官方文档获取最新和更详细的安装说明: https://docs.vllm.ai/en/latest/getting_started/installation.html

2. 基本离线推理 (Python API)

你可以直接在 Python 脚本中使用 vLLM 进行离线推理。

from vllm import LLM, SamplingParams

# 准备你的提示语列表
prompts = [
 "Hello, my name is",
 "The president of the United States is",
 "The capital of France is",
 "The future of AI is",
]

# 初始化采样参数
# temperature: 控制生成文本的随机性，值越高越随机。
# top_p: 核采样，选择概率总和达到 top_p 的最小词汇集。
# max_tokens: 控制生成的最大 token 数量。
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=50)

# 从 Hugging Face Hub 加载模型
# 你可以选择不同的模型，例如 "meta-llama/Llama-2-7b-chat-hf", "mistralai/Mistral-7B-v0.1" 等
# 确保你已经登录 Hugging Face CLI 并且接受了模型的 license (如果需要)
# export HF_TOKEN=YOUR_HUGGINGFACE_TOKEN (如果模型需要授权)
llm = LLM(model="facebook/opt-125m") # 这是一个小模型，方便快速测试

# 执行推理
outputs = llm.generate(prompts, sampling_params)

# 打印输出结果
for output in outputs:
 prompt = output.prompt
 generated_text = output.outputs[0].text
 print(f"Prompt: {prompt!r}, Generated: {generated_text!r}")

3. 启动 OpenAI 兼容的 API 服务器

vLLM 可以启动一个与 OpenAI API 兼容的服务器，允许你通过 HTTP 请求与模型交互，这对于将 LLM 集成到现有应用中非常方便。

# 启动 API 服务器，将 MODEL_NAME 替换为你想要服务的 Hugging Face 模型名称
# 例如: facebook/opt-125m, meta-llama/Llama-2-7b-chat-hf
# --model: 指定要加载的模型
# --tensor-parallel-size: (可选) 如果你有多个 GPU，可以使用张量并行来加速，例如 --tensor-parallel-size 2 表示使用 2 个 GPU
python -m vllm.entrypoints.openai.api_server --model="facebook/opt-125m"

# 服务器默认运行在 http://localhost:8000
# 你可以通过 --host 和 --port 参数修改
# 例如: python -m vllm.entrypoints.openai.api_server --model="facebook/opt-125m" --host 0.0.0.0 --port 8080

一旦服务器运行起来，你就可以像使用 OpenAI API 一样向它发送请求。

使用 curl 测试 API 服务器 ( Completions API - 适用于非聊天模型 ):

curl http://localhost:8000/v1/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "facebook/opt-125m",
 "prompt": "San Francisco is a",
 "max_tokens": 7,
 "temperature": 0
 }'

使用 curl 测试 API 服务器 ( Chat Completions API - 适用于聊天模型 ):

对于像 Llama-2-chat 这样的聊天模型，你应该使用 /v1/chat/completions 端点。

# 假设你已经使用聊天模型启动了服务器，例如:
# python -m vllm.entrypoints.openai.api_server --model="meta-llama/Llama-2-7b-chat-hf"

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "meta-llama/Llama-2-7b-chat-hf",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Who won the world series in 2020?"}
 ],
 "max_tokens": 50,
 "temperature": 0.7
 }'

使用 Python openai 库与 vLLM 服务器交互:

首先，安装 openai 库: pip install openai

import openai

# 修改 openai.api_base 指向你的 vLLM 服务器
openai.api_base = "http://localhost:8000/v1"
openai.api_key = "YOUR_API_KEY" # 对于本地 vLLM 服务器，API 密钥通常是可选的或任意字符串，如 "EMPTY"

# 列出可用的模型 (会返回你通过 --model 参数指定的模型)
models = openai.Model.list()
print("Available models:", models.data)

if models.data:
 model_name = models.data[0].id # 获取第一个可用的模型名称
 print(f"Using model: {model_name}")

 # Chat Completions 示例
 try:
 chat_completion = openai.ChatCompletion.create(
 model=model_name,
 messages=[
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "What is the capital of France?"}
 ],
 temperature=0.7,
 max_tokens=50
 )
 print("Chat Completion:", chat_completion.choices[0].message['content'])
 except Exception as e:
 print(f"Error in Chat Completion: {e}")

 # Legacy Completions 示例 (如果模型支持)
 try:
 completion = openai.Completion.create(
 model=model_name,
 prompt="The capital of France is",
 max_tokens=10,
 temperature=0
 )
 print("Completion:", completion.choices[0].text)
 except Exception as e:
 print(f"Error in Completion: {e}")
else:
 print("No models available from the server.")

4. 常用参数说明

无论是在 Python API 还是 OpenAI 兼容服务器中，一些核心参数是共通的：

model (字符串): 指定要加载的 Hugging Face 模型仓库的名称 (例如, "facebook/opt-125m", "meta-llama/Llama-2-7b-chat-hf")。
temperature (浮点数, 通常在 0.0 到 2.0 之间): 控制输出的随机性。较低的温度使输出更具确定性和重复性，较高的温度则更具创造性和多样性。建议值：0.7-1.0 适用于创造性任务，0.0-0.2 适用于需要精确和事实性回答的任务。
top_p (浮点数, 通常在 0.0 到 1.0 之间): 核采样参数。模型会从概率总和达到 top_p 的最小词汇集合中进行采样。例如，top_p=0.9 表示只考虑概率加起来达到90%的最可能的词。通常不与 temperature 同时设为非默认值。
top_k (整数): 从 logits 最高的 K 个 token 中进行采样。如果设置为非零值，则会覆盖 top_p。
max_tokens (整数): 生成响应的最大 token 数量。注意这包括了输入提示和输出。
n (整数): 为每个输入提示生成多少个独立的候选项。
presence_penalty (浮点数): 对已经出现在文本中的 token 施加惩罚，降低重复性。
frequency_penalty (浮点数): 与 presence_penalty 类似，但惩罚的程度与 token 在文本中出现的频率成正比。
stop (字符串或列表): 一个或多个停止序列。当模型生成这些序列时，会停止进一步的生成。

查阅 vLLM 和 OpenAI 的文档可以获取更详细的参数列表和解释。

5. 进阶特性 (简介)

vLLM 支持许多高级功能以优化性能和扩展能力：

量化 (Quantization): 支持如 AWQ, GPTQ, SqueezeLLM 等量化方法，以更低的精度（如 INT8, INT4）运行模型，减少内存占用和加速推理，但可能会有轻微的精度损失。
- 示例 (GPTQ): llm = LLM(model="TheBloke/Llama-2-7B-GPTQ")
LoRA (Low-Rank Adaptation): 高效地微调或加载经过 LoRA 适配器调整的模型。vLLM 支持动态加载和卸载 LoRA 适配器。
分布式推理 (Distributed Inference):
- 张量并行 (Tensor Parallelism): 将模型的权重和计算分布到多个 GPU 上，以运行单个大型模型。在启动服务器或 LLM 类时使用 tensor_parallel_size 参数。
```
# Python API
llm = LLM(model="your_large_model", tensor_parallel_size=4) # 使用 4 个 GPU
```
```
# API 服务器
python -m vllm.entrypoints.openai.api_server --model="your_large_model" --tensor-parallel-size 4
```
- 流水线并行 (Pipeline Parallelism): (vLLM 对此的支持可能仍在发展中，主要依赖于底层模型的实现方式，通常张量并行更为直接)
前缀缓存 (Prefix Caching / Automatic Prefix Caching): 自动缓存和重用共享前缀的 KV 缓存，加速具有共同前缀的请求序列。
投机解码 (Speculative Decoding): 使用一个小的、快速的草稿模型来预测多个 token，然后由主模型进行验证，以加速解码过程。
多模态支持: vLLM 正在扩展对多模态模型（如 LLaVA）的支持。

这些高级特性的具体用法请参考 vLLM 的官方文档和示例。

6. 常见用例

vLLM 因其高性能和高吞吐量，非常适合以下场景：

实时聊天机器人和虚拟助手: 需要低延迟响应。
大规模文本生成服务: 如内容创作、代码生成、摘要等。
批处理推理任务: 对大量数据进行离线处理。
需要高效扩展 AI 驱动的工作流: 当用户量或数据量增长时，vLLM 可以帮助系统保持性能。
研究和实验: 快速迭代和测试不同的 LLM。

7. 更多资源

vLLM GitHub 仓库: https://github.com/vllm-project/vllm
vLLM 官方文档: https://docs.vllm.ai/
vLLM 示例: https://docs.vllm.ai/en/latest/getting_started/examples/examples_index.html

实战

vllm部署 Qwen3 ：使用4090 （成功）

https://www.modelscope.cn/models/Qwen/Qwen3-32B

我使用的是bayes平台，首先创建一个容器

我选的是自带vllm环境的容器,所以并没有涉及到安装环境

执行如下命令

VLLM_USE_MODELSCOPE=True vllm serve Qwen/Qwen3-0.6B --enable-reasoning --reasoning-parser deepseek_r1

首先查看有哪些模型

curl http://localhost:8000/v1/models

# 如果jq没安装 apt install jq

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "Qwen/Qwen3-0.6B",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Who won the world series in 2020?"}
 ]
 }' | jq .

也可以使用如下的py代码

from openai import OpenAI
client = OpenAI(
 base_url="http://localhost:8000/v1",
 api_key="token-abc123", # 随便设，只是为了通过接口参数校验
)

completion = client.chat.completions.create(
 model="Qwen/Qwen3-0.6B",
 messages=[
 {"role": "user", "content": "你是什么模型？"}
 ]
)

print(completion.choices[0].message)

vllm部署 Qwen3 ：使用v100_32 （失败）

我使用的是bayes平台，首先创建一个容器

然后是环境的准备

推荐使用uv安装，因为快啊


mkdir qwen3

cd qwen3

pip install uv

uv venv

source ./venv/bin/activate

# uv pip install cudatoolkit=12.1 -y

# uv pip install torch torchvision torchaudio # 也可以配置一下镜像源

# python -c 'import torch; print(torch.cuda.is_available())'

uv pip install vllm ray transformers accelerate

# 创建conda环境
conda create -n qwen3 python=3.10 -y # -y表示无需确认
conda activate qwen3

# 安装CUDA相关依赖（确保与vLLM兼容的CUDA版本）
# vLLM通常编译于CUDA 12.1
conda install cudatoolkit=12.1 -y

# 安装PyTorch（确保与CUDA版本兼容）
pip install torch torchvision torchaudio

# 检查CUDA是否正确安装
python -c 'import torch; print(torch.cuda.is_available())'

pip install vllm ray transformers accelerate

然后配置魔搭（许多服务器不支持翻墙，所以hugging face可能难用）

pip install modelscope

之后vllm应用就可以默认从modelscope上下载镜像了。

https://www.modelscope.cn/models/Qwen/Qwen3-32B

VLLM_USE_MODELSCOPE=True vllm serve Qwen/Qwen3-0.6B --enable-reasoning --reasoning-parser deepseek_r1

然后修改成以下命令

VLLM_USE_MODELSCOPE=True vllm serve Qwen/Qwen3-0.6B --enable-reasoning --reasoning-parser deepseek_r1 --dtype=half

此外，我们也可以用本地的镜像文件进行模型部署，方法如下（我这里选择用本地，比较灵活）。

git lfs clone https://www.modelscope.cn/Qwen/Qwen3-0.6B.git

python -m vllm.entrypoints.openai.api_server --model ~/Qwen3-0.6B --served-model-name Qwen3-0.6B --max-model-len=2048

之后进行测试：可以使用python进行测试：

from openai import OpenAI
client = OpenAI(
 base_url="http://localhost:8000/v1",
 api_key="token-abc123", # 随便设，只是为了通过接口参数校验
)

completion = client.chat.completions.create(
 model="Qwen3-0.6B",
 messages=[
 {"role": "user", "content": "你是什么模型？"}
 ]
)

print(completion.choices[0].message)

深度学习开源框架

Thu, 06 Mar 2025 21:38:33 +0800

DeepSpeed

什么是 DeepSpeed？

DeepSpeed 是一个开源深度学习优化库，专为分布式训练和大规模模型设计。它提供了多种工具和技术，如 ZeRO（零冗余优化器）、混合精度训练和高效的并行策略，帮助开发者在 GPU 上更快、更高效地训练模型。DeepSpeed 的主要目标是降低内存占用并提升训练速度，特别适用于超大型语言模型（LLM）。
deepspeed在深度学习模型软件体系架构中所处的位置是？

核心功能

ZeRO（零冗余优化器）：通过分割优化器状态、分梯度和参数，减少内存冗余，支持更大的模型。
混合精度训练：结合 FP16 和 BF16，加速计算并减少内存需求。
分布式训练支持：支持数据并行、模型并行和流水线并行。
高效激活检查点：优化内存使用，允许更大的批量大小。
超大模型支持：能够训练超过千亿参数的模型。

安装 DeepSpeed

在开始使用 DeepSpeed 之前，需要安装它。以下是安装步骤：

确保环境准备：
- Python 3.6 或更高版本
- PyTorch（建议最新稳定版）
- CUDA（与 PyTorch 兼容的版本）
通过 pip 安装 DeepSpeed：
```
pip install deepspeed
```
验证安装：运行以下命令检查是否成功安装：
```
ds_report
```
这将显示 DeepSpeed 的配置信息和环境兼容性。

集成 DeepSpeed 到 PyTorch

以下是一个简单的例子，展示如何将 DeepSpeed 集成到 PyTorch 训练代码中。

示例代码

import torch
import torch.nn as nn
import deepspeed

# 定义一个简单的模型
class SimpleModel(nn.Module):
 def __init__(self):
 super(SimpleModel, self).__init__()
 self.fc1 = nn.Linear(10, 10)
 self.fc2 = nn.Linear(10, 2)

 def forward(self, x):
 x = torch.relu(self.fc1(x))
 x = self.fc2(x)
 return x

# 初始化模型和数据
model = SimpleModel()
data = torch.randn(32, 10) # 批量大小 32，输入维度 10
labels = torch.randint(0, 2, (32,))

# 定义 DeepSpeed 配置
ds_config = {
 "train_batch_size": 32,
 "gradient_accumulation_steps": 1,
 "fp16": {
 "enabled": True # 启用混合精度训练
 },
 "optimizer": {
 "type": "Adam",
 "params": {
 "lr": 0.001
 }
 }
}

# 初始化 DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
 model=model,
 model_parameters=model.parameters(),
 config=ds_config
)

# 前向传播和反向传播
outputs = model_engine(data)
loss = nn.CrossEntropyLoss()(outputs, labels)
model_engine.backward(loss)
model_engine.step()

代码说明

模型定义：这里使用了一个简单的两层全连接神经网络。
DeepSpeed 配置：ds_config 是一个字典，指定训练参数，如批量大小、优化器类型和混合精度选项。
初始化 DeepSpeed：deepspeed.initialize 将模型和优化器包装为 DeepSpeed 引擎。
训练步骤：使用 model_engine 替代原始 PyTorch 模型进行前向传播、反向传播和参数更新。

配置文件的替代方式

除了在代码中定义 ds_config，你还可以创建一个 JSON 文件（例如 ds_config.json）：

{
 "train_batch_size": 32,
 "gradient_accumulation_steps": 1,
 "fp16": {
 "enabled": true
 },
 "optimizer": {
 "type": "Adam",
 "params": {
 "lr": 0.001
 }
 }
}

然后在初始化时加载：

model_engine, optimizer, _, _ = deepspeed.initialize(
 model=model,
 model_parameters=model.parameters(),
 config="ds_config.json"
)

运行分布式训练

要使用多个 GPU 运行训练，只需通过 deepspeed 命令启动脚本：

deepspeed train.py --deepspeed --deepspeed_config ds_config.json

确保你的脚本支持分布式环境（例如，使用 torch.distributed.launch 或 DeepSpeed 的内置分布式支持）。

高级功能：ZeRO 优化

ZeRO 有三个阶段，可以通过配置启用：

ZeRO-1：分割优化器状态。
ZeRO-2：分割优化器状态和梯度。
ZeRO-3：分割优化器状态、梯度和参数。

示例配置：

{
 "zero_optimization": {
 "stage": 2,
 "allgather_partitions": true,
 "reduce_scatter": true
 }
}

注意事项

硬件要求：DeepSpeed 需要 GPU 支持，建议使用 NVIDIA GPU。
调试：如果遇到问题，可以检查 ds_report 输出或启用详细日志（"verbose": true）。
文档参考：查看 DeepSpeed 官方文档获取更多高级用法。

transformers

transformers 库（通常指 Hugging Face 公司开发的库）是目前深度学习，尤其是自然语言处理（NLP）领域中最重要、最核心的库之一。

它本身是一个 Python 库，但由于其生态系统极其完整和强大，很多人也视它为一个“框架”。它极大地简化了访问和使用最先进（SOTA）的 Transformer 模型（如 BERT, GPT, T5 等）的复杂度。

以下是 Hugging Face transformers 库的主要特点：

🤖 Hugging Face `transformers` 的核心特点

1. 庞大且活跃的模型中心 (Model Hub)

这是 transformers 最核心的优势。Hugging Face 运营着一个巨大的模型仓库（Model Hub），任何人都可以上传、下载和分享预训练模型。

海量模型： 截至目前，上面有数十万个预训练模型，涵盖了文本、图像、音频等多种模态。
社区驱动： 不仅有 Google、Meta、OpenAI 等大公司发布的官方模型，还有大量由社区贡献的、针对特定任务或特定语言微调（Fine-tune）过的模型。
版本控制与复现： 所有模型都与代码和分词器（Tokenizer）绑定，可以轻松复现他人的工作。

2. 极佳的易用性 (Ease of Use)

Hugging Face 的 API 设计哲学是“简单”和“一致”。

pipeline() 抽象： 这是最简单的入门方式。您只需几行代码，就可以完成一个复杂的NLP任务（如情感分析、问答），而无需关心背后的模型和数据处理流程。
AutoModel / AutoTokenizer： 您不需要知道某个具体模型（比如 ‘bert-base-uncased’）是 BertModel 还是 RobertaModel。您只需使用 AutoModel.from_pretrained(...)，它会自动识别并加载正确的模型架构。
一致的 API： 无论您使用的是 BERT 还是 GPT-2，加载模型 (from_pretrained) 和保存模型 (save_pretrained) 的方法都是完全一样的。

3. 框架互操作性 (Framework Interoperability)

transformers 库并不是要取代已有的深度学习框架，而是构建在它们之上。

无缝切换： 它完美支持 PyTorch, TensorFlow 和 JAX。
灵活性： 您可以使用 PyTorch 版本的 transformers 训练一个模型，然后将其保存，再用 TensorFlow 版本的 transformers 加载它，模型权重会自动转换。这为不同技术栈的团队协作提供了巨大便利。

4. 任务导向的抽象 (Task-Oriented Abstraction)

transformers 库围绕“任务”提供了清晰的模型分类。

明确的命名： 当您想做一个分类任务时，您会寻找 ...ForSequenceClassification 结尾的模型（如 BertForSequenceClassification）。
开箱即用： 这些模型已经在基础模型（如 BERT）的顶部添加了适合特定任务的“头部”（Head），例如一个用于分类的全连接层。您加载后只需直接进行微调。

5. 强大且一致的分词 (Tokenization)

文本处理是NLP的第一步。transformers 配套了 tokenizers 库（一个用 Rust 编写的高性能库）。

一致性： 提供了与 AutoModel 对应的 AutoTokenizer，确保您使用的分词器与预训练模型是严格匹配的。
高性能： 分词速度极快，可以并行处理大量文本。

6. 完整的生态系统 (A Complete Ecosystem)

transformers 并不是孤立的，Hugging Face 围绕它构建了一整套工具链：

datasets: 用于高效加载和处理大型数据集（TB级别）。
evaluate: 用于评估模型性能的指标库。
accelerate: 用于简化分布式训练和混合精度训练的工具。
diffusers: 专注于扩散模型（如 Stable Diffusion）的库。