OpenAI 开源 GPT OSS 模型家族：gpt-oss-120b 与 gpt-oss-20b 采用 Apache 2.0 许可
Welcome GPT OSS, the new open-source model family from OpenAI!
OpenAI 发布开源权重模型家族 GPT OSS，包含 117B 参数的 gpt-oss-120b 和 21B 参数的 gpt-oss-20b，均采用 MoE 架构和 MXFP4 4-bit 量化，以 Apache 2.0 许可发布。
原文给出两个模型的参数规模、量化方案和各硬件下的部署优化路径，读者可以据此快速选择本地或云端运行方式。
GPT OSS 是 OpenAI 备受期待的开放权重发布，专为强大的推理、代理任务和多样化的开发者用例而设计。它包含两个模型：一个拥有 117B 参数的大模型（gpt-oss-120b），以及一个拥有 21B 参数的较小模型（gpt-oss-20b）。两者均为专家混合（MoE）模型，并采用 4 位量化方案（MXFP4），从而实现快速推理（得益于更少的活跃参数，详见下文），同时保持低资源占用。大模型可适配单个 H100 GPU，而小模型可在 16GB 内存内运行，非常适合消费级硬件和设备端应用。
为了使其对社区更加出色和更具影响力，这些模型采用 Apache 2.0 许可证 授权，并附带一份极简使用政策：
我们的目标是让工具能够安全、负责任且民主地使用，同时最大化您对使用方式的控制权。使用 gpt-oss 即表示您同意遵守所有适用法律。
据 OpenAI 称，此次发布是他们致力于开源生态系统的重要一步，符合其让 AI 惠及大众的既定使命。许多用例依赖于私有和/或本地部署，我们 Hugging Face 非常高兴地欢迎 OpenAI 加入社区。我们相信这些将是长久、鼓舞人心且具有影响力的模型。
目录
- 简介
- 概述
- 通过推理提供商访问 API
- Local Inference
- 微调
- Deploy on Hugging Face Partners
- 评估模型
- Chats and Chat Templates
能力与架构概述
- 总参数分别为 21B 和 117B，活跃参数分别为 3.6B 和 5.1B。
- 使用 mxfp4 格式的 4 位量化方案。仅应用于 MoE 权重。如前所述，120B 可适配单个 80 GB GPU，20B 可适配单个 16GB GPU。
- 推理、纯文本模型；具有思维链和可调节的推理努力级别。
- 支持指令遵循和工具使用。
- 使用 transformers、vLLM、llama.cpp 和 ollama 的推理实现。
- 推荐使用 Responses API 进行推理。
- 许可证：Apache 2.0，附带一份简短的补充使用政策。
架构
- 采用 SwiGLU 激活的 Token-choice MoE。
- 在计算 MoE 权重时，对选定的专家进行 softmax（softmax-after-topk）。
- 每个注意力层使用 RoPE，上下文长度为 128K。
- 交替注意力层：全上下文和滑动 128 token 窗口。
- 注意力层使用每个头的学习注意力汇，其中 softmax 的分母有一个额外的加性值。
- It uses the same tokenizer as GPT-4o and other OpenAI API models.
- 已引入一些新 token 以实现与 Responses API 的兼容性。
o3 和 o4-mini 对比（来源：OpenAI）。
通过推理提供商访问 API
OpenAI GPT OSS 模型可通过 Hugging Face 的 Inference Providers 服务访问，让你使用相同的 JavaScript 或 Python 代码向任何支持的提供商发送请求。这与驱动 gpt-oss.com 上 OpenAI 官方演示的基础设施相同，你可以将其用于自己的项目。
下面是一个使用 Python 和超快的 Cerebras 提供商的示例。如需更多信息和其他代码片段，请查看模型卡中的推理提供商部分以及我们为这些模型专门编写的指南。
import os
from openai import OpenAI
client = OpenAI(
base_url="https://router.huggingface.co/v1",
api_key=os.environ["HF_TOKEN"],
)
completion = client.chat.completions.create(
model="openai/gpt-oss-120b:cerebras",
messages=[
{
"role": "user",
"content": "How many rs are in the word 'strawberry'?",
}
],
)
print(completion.choices[0].message)
Inference Providers 还实现了与 OpenAI 兼容的 Responses API，这是 OpenAI 最先进的聊天模型接口，专为更灵活、更直观的交互而设计。
下面是一个使用 Responses API 与 Fireworks AI 提供商的示例。如需更多详情，请查看开源项目 responses.js。
import os
from openai import OpenAI
client = OpenAI(
base_url="https://router.huggingface.co/v1",
api_key=os.getenv("HF_TOKEN"),
)
response = client.responses.create(
model="openai/gpt-oss-20b:fireworks-ai",
input="How many rs are in the word 'strawberry'?",
)
print(response)
本地推理
使用 Transformers
你需要安装最新的 transformers 版本（v4.55.1 或更高版本），以及 accelerate 和 kernels。我们还建议安装 triton 3.4 或更高版本，因为它可以解锁在 CUDA 硬件上对 mxfp4 量化的支持：
pip install --upgrade transformers kernels accelerate "triton>=3.4"
模型权重以 mxfp4 格式量化，该格式最初仅在 Hopper 或 Blackwell 系列的 GPU 上可用，但现在也可在更早的 CUDA 架构（包括 Ada、Ampere 和 Tesla）上运行。安装 triton 3.4 以及 kernels 库，可以在首次使用时下载优化的 mxfp4 内核，从而大幅节省内存。有了这些组件，你可以在具有 16 GB 内存的 GPU 上运行 20B 模型。这包括许多消费级显卡（3090、4090、5080）以及 Colab 和 Kaggle！
如果未安装上述库（或者你没有兼容的 GPU），加载模型将回退到 bfloat16，从量化权重中解包。
以下代码片段展示了使用 20B 模型进行简单推理。如前所述，使用 mxfp4 时它可在 16 GB GPU 上运行，而在 bfloat16 下则需要约 48 GB。
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "openai/gpt-oss-20b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
torch_dtype="auto",
)
messages = [
{"role": "user", "content": "How many rs are in the word 'strawberry'?"},
]
inputs = tokenizer.apply_chat_template(
messages,
add_generation_prompt=True,
return_tensors="pt",
return_dict=True,
).to(model.device)
generated = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(generated[0][inputs["input_ids"].shape[-1]:]))
Flash Attention 3
这些模型使用了注意力汇聚（attention sinks），这是 vLLM 团队使其与 Flash Attention 3 兼容的一项技术。我们已将他们的优化内核打包并集成到 kernels-community/vllm-flash-attn3 中。在撰写本文时，这个超快的内核已在 Hopper 显卡上使用 PyTorch 2.7 和 2.8 进行了测试。我们预计未来几天覆盖范围会扩大。如果你在 Hopper 显卡（例如 H100 或 H200）上运行这些模型，你需要 pip install --upgrade kernels 并在代码片段中添加以下行：
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "openai/gpt-oss-20b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
torch_dtype="auto",
+ # Flash Attention with Sinks
+ attn_implementation="kernels-community/vllm-flash-attn3",
)
messages = [
{"role": "user", "content": "How many rs are in the word 'strawberry'?"},
]
inputs = tokenizer.apply_chat_template(
messages,
add_generation_prompt=True,
return_tensors="pt",
return_dict=True,
).to(model.device)
generated = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(generated[0][inputs["input_ids"].shape[-1]:]))
此代码片段将从 kernels-community 下载优化的预编译内核代码，如我们在之前的博客文章中所述。transformers 团队已构建、打包并测试了该代码，因此你完全可以放心使用。
其他优化
如果你的 GPU 支持，我们建议你使用 mxfp4。如果你还能使用 Flash Attention 3，那就一定要启用它！
如果你的 GPU 与
mxfp4不兼容，那么我们建议你使用 MegaBlocks MoE 内核以获得不错的速度提升。为此，你只需像这样调整你的推理代码：
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "openai/gpt-oss-20b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
torch_dtype="auto",
+ # Optimize MoE layers with downloadable` MegaBlocksMoeMLP
+ use_kernels=True,
)
messages = [
{"role": "user", "content": "How many rs are in the word 'strawberry'?"},
]
inputs = tokenizer.apply_chat_template(
messages,
add_generation_prompt=True,
tokenize=True,
return_tensors="pt",
return_dict=True,
).to(model.device)
generated = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(generated[0][inputs["input_ids"].shape[-1]:]))
MegaBlocks 优化的 MoE 内核要求模型在
bfloat16上运行，因此内存消耗会比在mxfp4上运行更高。如果可以，我们建议你使用mxfp4，否则通过use_kernels=True选择启用 MegaBlocks。
AMD ROCm 支持
OpenAI GPT OSS 已在 AMD Instinct 硬件上通过验证，我们很高兴地宣布，我们的 kernels 库已初步支持 AMD 的 ROCm 平台，为 Transformers 中即将推出的优化 ROCm kernels 奠定了基础。MegaBlocks MoE kernel 加速现已可用于 AMD Instinct（例如 MI300 系列）上的 OpenAI GPT OSS，从而实现更好的训练和推理性能。你可以使用上面展示的相同推理代码进行测试。
AMD 还准备了一个 Hugging Face Space，供用户在 AMD 硬件上试用该模型。
可用优化概览
在撰写本文时，此表总结了基于 GPU 兼容性和我们的测试得出的建议。我们预计 Flash Attention 3（带 sink attention）将兼容更多 GPU。
| mxfp4 | Flash Attention 3（带 sink attention） | MegaBlocks MoE kernels | |
|---|---|---|---|
| Hopper GPU（H100、H200） | ✅ | ✅ | ❌ |
| 具有 16+ GB 内存的 CUDA GPU | ✅ | ❌ | ❌ |
| 其他 CUDA GPU | ❌ | ❌ | ✅ |
| AMD Instinct（MI3XX） | ❌ | ❌ | ✅ |
| 如何启用 | triton 3.4 + kernels 库 | 使用来自 kernels-community 的 vllm-flash-attn3 | use_kernels |
尽管 120B 模型可以放在单个 H100 GPU 上（使用 mxfp4），你也可以使用 accelerate 或 torchrun 轻松地在多个 GPU 上运行它。Transformers 提供了默认的并行化方案，你还可以利用优化的 attention kernels。以下代码片段可以在具有 4 个 GPU 的系统上使用 torchrun --nproc_per_node=4 generate.py 运行：
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.distributed import DistributedConfig
import torch
model_path = "openai/gpt-oss-120b"
tokenizer = AutoTokenizer.from_pretrained(model_path, padding_side="left")
device_map = {
"tp_plan": "auto", # Enable Tensor Parallelism
}
model = AutoModelForCausalLM.from_pretrained(
model_path,
torch_dtype="auto",
attn_implementation="kernels-community/vllm-flash-attn3",
**device_map,
)
messages = [
{"role": "user", "content": "Explain how expert parallelism works in large language models."}
]
inputs = tokenizer.apply_chat_template(
messages,
add_generation_prompt=True,
return_tensors="pt",
return_dict=True,
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1000)
# Decode and print
response = tokenizer.decode(outputs[0])
print("Model response:", response.split("<|channel|>final<|message|>")[-1].strip())
OpenAI GPT OSS 模型经过了大量训练，以利用工具使用作为其推理工作的一部分。我们为 transformers 精心设计的聊天模板提供了很大的灵活性，请查看我们本文后面的专门章节。
Llama.cpp
Llama.cpp 通过 Flash Attention 提供原生 MXFP4 支持，从发布首日起就在 Metal、CUDA 和 Vulkan 等各种后端上提供最佳性能。
要安装它，请遵循 llama.cpp Github 仓库中的指南。
# MacOS
brew install llama.cpp
# Windows
winget install llama.cpp
推荐的方式是通过 llama-server 使用它：
llama-server -hf ggml-org/gpt-oss-120b-GGUF -c 0 -fa --jinja --reasoning-format none
# Then, access http://localhost:8080
我们支持 120B 和 20B 模型。如需更详细的信息，请访问此 PR或GGUF 模型合集。
vLLM
如前所述，vLLM 开发了支持 sink attention 的优化 Flash Attention 3 kernels，因此你将在 Hopper 显卡上获得最佳结果。Chat Completion 和 Responses API 均受支持。你可以使用以下代码片段安装并启动服务器，该片段假设使用了 2 个 H100 GPU：
vllm serve openai/gpt-oss-120b --tensor-parallel-size 2
或者，像这样直接在 Python 中使用：
from vllm import LLM
llm = LLM("openai/gpt-oss-120b", tensor_parallel_size=2)
output = llm.generate("San Francisco is a")
transformers serve
你可以使用 transformers serve 在本地试验这些模型，无需任何其他依赖。你只需这样即可启动服务器：
transformers serve
然后你可以使用 Responses API 向其发送请求。
# responses API
curl -X POST http://localhost:8000/v1/responses \
-H "Content-Type: application/json" \
-d '{"input": [{"role": "system", "content": "hello"}], "temperature": 1.0, "stream": true, "model": "openai/gpt-oss-120b"}'
你也可以使用标准的 Completions API 发送请求：
# completions API
curl -X POST http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"messages": [{"role": "system", "content": "hello"}], "temperature": 1.0, "max_tokens": 1000, "stream": true, "model": "openai/gpt-oss-120b"}'
微调
GPT OSS 模型已与 trl 完全集成。我们使用 SFTTrainer 开发了几个微调示例，帮助你入门：
- OpenAI cookbook 中的一个 LoRA 示例，展示了如何微调模型以使用多种语言进行推理。
- 一个基础微调脚本，你可以根据自己的需求进行调整。
在 Hugging Face 合作伙伴上部署
Azure
Hugging Face 与 Azure 合作，在其 Azure AI Model Catalog 上引入最受欢迎的开源模型——涵盖文本、视觉、语音和多模态任务——直接进入客户环境，实现安全部署到托管在线端点，并利用 Azure 的企业级基础设施、自动扩缩容和监控能力。
GPT OSS 模型现已在 Azure AI Model Catalog 上提供（GPT OSS 20B、GPT OSS 120B），可部署到在线端点进行实时推理。
Dell
Dell Enterprise Hub 是一个安全的在线门户，可简化使用 Dell 平台在本地训练和部署最新的开放 AI 模型。它由 Hugging Face 与 Dell 合作开发，提供优化容器、对 Dell 硬件的原生支持以及企业级安全功能。
GPT OSS 模型现已在 Dell Enterprise Hub 上提供，可使用 Dell 平台在本地部署。
评估模型
GPT OSS 模型是推理模型：因此它们需要非常大的生成规模（新 token 的最大数量）来进行评估，因为它们的生成内容会先包含推理过程，然后才是实际答案。使用过小的生成规模可能会导致预测在推理过程中被中断，从而造成假阴性。随后，在计算指标之前，应从模型答案中移除推理轨迹，以避免解析错误，尤其是在数学或指令评估中。
以下是一个使用 lighteval 评估模型的示例（你需要从源码安装）。
git clone https://github.com/huggingface/lighteval
pip install -e .[dev] # make sure you have the correct transformers version installed!
lighteval accelerate \
"model_name=openai/gpt-oss-20b,max_length=16384,skip_special_tokens=False,generation_parameters={temperature:1,top_p:1,top_k:40,min_p:0,max_new_tokens:16384}" \
"extended|ifeval|0|0,lighteval|aime25|0|0" \
--save-details --output-dir "openai_scores" \
--remove-reasoning-tags --reasoning-tags="[('<|channel|>analysis<|message|>','<|end|><|start|>assistant<|channel|>final<|message|>')]"
对于 20B 模型，这应该会给出 IFEval（严格提示）的 69.5（+/-1.9），以及 AIME25（pass@1）的 63.3（+/-8.9），这些分数在此规模推理模型的预期范围内。
如果你想编写自定义评估脚本，请注意，为了正确过滤掉推理标签，你需要在 tokenizer 中使用 skip_special_tokens=False，以便在模型输出中获取完整轨迹（使用与上面示例中相同的字符串对来过滤推理）——你可以在下面了解原因。
对话与对话模板
OpenAI GPT OSS 在其输出中使用了“通道”的概念。大多数情况下，你会看到一个“analysis”通道，其中包含不打算发送给最终用户的内容，例如思维链，以及一个“final”通道，其中包含实际打算展示给用户的消息。
假设没有使用任何工具，模型输出的结构如下所示：
<|start|>assistant<|channel|>analysis<|message|>CHAIN_OF_THOUGHT<|end|><|start|>assistant<|channel|>final<|message|>ACTUAL_MESSAGE
大多数情况下，你应该忽略除 <|channel|>final<|message|> 之后的文本之外的所有内容。只有这段文本应作为助手消息追加到对话中，或展示给用户。不过，这条规则有两个例外：在训练期间，或者当模型调用外部工具时，你可能需要在历史记录中包含 analysis 消息。
训练时： 如果你正在为训练格式化示例，通常希望将思维链包含在最终消息中。正确的做法是将其放在 thinking 键中。
chat = [
{"role": "user", "content": "Hi there!"},
{"role": "assistant", "content": "Hello!"},
{"role": "user", "content": "Can you think about this one?"},
{"role": "assistant", "thinking": "Thinking real hard...", "content": "Okay!"}
]
# add_generation_prompt=False is generally only used in training, not inference
inputs = tokenizer.apply_chat_template(chat, add_generation_prompt=False)
你可以随意在之前的轮次中包含 thinking 键，或者在推理而非训练时使用它们，但它们通常会被忽略。聊天模板只会包含最近的思维链，而且仅在训练时（当 add_generation_prompt=False 且最后一轮是助手轮次时）。
我们这样做的原因很微妙：OpenAI gpt-oss 模型是在多轮数据上训练的，其中除最后一轮外的所有思维链都被丢弃了。这意味着，当你想微调一个 OpenAI gpt-oss 模型时，你也应该这样做。
- 让聊天模板丢弃除最后一轮之外的所有思维链
- 屏蔽除最后一轮助手轮次之外所有轮次的标签，否则你将在没有思维链的先前轮次上训练它，这会教它在没有 CoT 的情况下发出响应。这意味着你不能将整个多轮对话作为单个样本进行训练；相反，你必须将其拆分为每个助手轮次一个样本，每次只取消屏蔽最后一轮助手轮次，这样模型可以从每一轮中学习，同时每次仍然只在最后一条消息上正确看到思维链。
系统消息和开发者消息
OpenAI GPT OSS 不寻常之处在于，它在聊天开始时区分“system”消息和“developer”消息，但大多数其他模型只使用“system”。在 GPT OSS 中，系统消息遵循严格格式，包含当前日期、模型身份和要使用的推理努力级别等信息，而“developer”消息则更自由，这使得它（非常令人困惑地）类似于大多数其他模型的“system”消息。
为了让 GPT OSS 更易于与标准 API 一起使用，聊天模板会将角色为“system”或“developer”的消息视为 developer 消息。如果你想修改实际的系统消息，可以将特定参数 model_identity 或 reasoning_effort 传递给聊天模板：
chat = [
{"role": "system", "content": "This will actually become a developer message!"}
]
tokenizer.apply_chat_template(
chat,
model_identity="You are OpenAI GPT OSS.",
reasoning_effort="high" # Defaults to "medium", but also accepts "high" and "low"
)
在 transformers 中使用工具
GPT OSS 支持两种工具：“内置”工具 browser 和 python，以及用户提供的自定义工具。要启用内置工具，请将其名称以列表形式传递给聊天模板的 builtin_tools 参数，如下所示。要传递自定义工具，你可以将其作为 JSON schema 传递，或作为带有类型提示和文档字符串的 Python 函数通过 tools 参数传递。有关更多详细信息，请参阅 聊天模板工具文档，或者你可以直接修改下面的示例：
def get_current_weather(location: str):
"""
Returns the current weather status at a given location as a string.
Args:
location: The location to get the weather for.
"""
return "Terrestrial." # We never said this was a good weather tool
chat = [
{"role": "user", "content": "What's the weather in Paris right now?"}
]
inputs = tokenizer.apply_chat_template(
chat,
tools=[weather_tool],
builtin_tools=["browser", "python"],
add_generation_prompt=True,
return_tensors="pt"
)
如果模型选择调用工具（由以 <|call|> 结尾的消息表示），那么你应该将工具调用添加到聊天中，调用该工具，然后将工具结果添加到聊天中并再次生成：
tool_call_message = {
"role": "assistant",
"tool_calls": [
{
"type": "function",
"function": {
"name": "get_current_temperature",
"arguments": {"location": "Paris, France"}
}
}
]
}
chat.append(tool_call_message)
tool_output = get_current_weather("Paris, France")
tool_result_message = {
# Because GPT OSS only calls one tool at a time, we don't
# need any extra metadata in the tool message! The template can
# figure out that this result is from the most recent tool call.
"role": "tool",
"content": tool_output
}
chat.append(tool_result_message)
# You can now apply_chat_template() and generate() again, and the model can use
# the tool result in conversation.
致谢
这对社区来说是一个重要的发布，跨团队和公司付出了巨大努力，以全面支持生态系统中的新模型。
这篇博客文章的作者是从为文章本身贡献内容的人中选出的，并不代表对项目的奉献。除作者名单外，其他人也贡献了重要的内容审阅，包括 Merve 和 Sergio。谢谢！
集成和启用工作涉及数十人。排名不分先后，我们要特别感谢开源团队的 Cyril、Lysandre、Arthur、Marc、Mohammed、Nouamane、Harry、Benjamin、Matt。TRL 团队的 Ed、Lewis 和 Quentin 也参与其中。我们还要感谢 Evaluations 团队的 Clémentine，以及 Kernels 团队的 David 和 Daniel。在商业合作方面，我们得到了 Simon、Alvaro、Jeff、Akos、Alvaro 和 Ivar 的重大贡献。Hub 和产品团队贡献了 Inference Providers 支持、llama.cpp 支持以及许多其他改进，这一切都要感谢 Simon、Célina、Pierric、Lucain、Xuan-Son、Chunte 和 Julien。法务团队的 Magda 和 Anna 也参与其中。
Hugging Face 的角色是让社区能够有效使用这些模型。我们感谢 vLLM 等公司推动该领域的发展，并珍视与推理提供商持续的合作，以提供越来越简单的方式来基于它们进行构建。
当然，我们深深感谢 OpenAI 决定向广大社区发布这些模型。敬未来更多！
来源：Hugging Face：Blog · huggingface.co