> ## Content Index
> Fetch the complete content index at: https://www.hubwiz.com/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# Olmo 3：开源训练过程
- URL: https://www.hubwiz.com/blog/olmo-3-open-source-training-process/
- Published: 2025-11-25T14:10:22.000Z
- Updated: 2025-11-25T14:10:22.000Z
- Description: Allen AI 的 Olmo 3 模型系列不仅仅是“开放权重”，而是完全开源整个训练过程。
- Author: admin
- Tags: MODEL-ZOO, OLMO-3, #Import 2026-10-14 14:41

如果您一直关注开源 AI，您可能已经注意到一个规律：

模型很优秀，但：

- 训练数据是秘密的
- 或者训练代码是封闭的
- 或者强化学习设置含糊不清

Olmo 3 试图打破这种模式。

Allen AI 的 Olmo 3 是一个全新的模型系列——拥有 7B 和 32B 参数——它们不仅仅是“开放权重”，而是完全开放的：

- 数据配方
- 训练代码
- 日志
- 中间检查点
- 详细技术报告

简单来说：他们不仅提供了模型，还提供了完整的使用指南。

本文用浅显易懂的语言解释了 Olmo 3，并包含一些简单的 Python 示例。

## 1、什么是 Olmo 3？

Olmo 3 是一系列语言模型，提供两种主要规模。

- 70 亿参数（规模较小，运行成本更低）
- 320 亿参数（规模较大，性能更强，尤其适用于推理）

官方宣称：

> “最佳 320 亿基础模型 + 最佳 70 亿西方指令和思维模型。”

但除了模型本身的质量之外，关键在于其开放性：

- 预训练数据配方公开
- 训练代码公开
- 训练日志和训练中期检查点可用
- 他们发布了详细的技术报告

大多数“开源”模型都做不到这一点。

可以这样理解：

- Llama / Qwen：“这是最终的蛋糕。”
- Olmo 3：“这是蛋糕，还有所有配料、步骤、烤箱设置，甚至还有半成品的照片。”

## 2、Olmo 3 的四种口味

![](https://www.hubwiz.com/blog/content/images/2025/11/image-112.png)

Olmo 3 飞船有四种主要版本。

- 基础模型 — 原始基础模型（适合预训练/微调）
- 指导模型 — 聊天和任务模型（简短、快速的回答）
- 思考模型 — 长篇推理模型（编写详细的思路链）
- RL Zero — 直接从基础模型通过强化学习微调的模型

你可以像这样在代码中使用它们（伪 Python，使用通用的 `call_model` 函数）：

```
from my_llm_client import call_model

# 1) Base - good starting point for your own fine-tuning
response_base = call_model(
    model="olmo-3-7b-base",
    prompt="Summarize the plot of 'The Matrix' in one paragraph."
)
# 2) Instruct - snappy chatbot / assistant
response_instruct = call_model(
    model="olmo-3-7b-instruct",
    messages=[
        {"role": "user", "content": "Explain Kubernetes like I'm 12."}
    ]
)
# 3) Think - detailed reasoning, long answers
response_think = call_model(
    model="olmo-3-7b-think",
    messages=[
        {"role": "user", "content": "Prove that the square root of 2 is irrational."}
    ],
    # Let it think more tokens than usual
    max_tokens=1024
)
# 4) RL Zero - exploration and research
response_rlzero = call_model(
    model="olmo-3-7b-rlzero-math",
    messages=[
        {"role": "user", "content": "Solve: 3x + 7 = 22. Show your reasoning."}
    ]
)
```

这里的名称仅供参考，但其理念是：

- Base：适用于研究人员和希望在此基础上进行开发的人员。
- Instruct：适用于应用程序和产品。
- Think：适用于您可以承受额外词元和延迟以获得更好推理的情况。
- RL Zero：面向在语言模型上进行强化学习实验的人员。

## 3、Instruct 模型：你的“主力”助手

Olmo 3 的 Instruct 模型定位为：

- Tülu 3 的精神继承者
- “简短、高效、对合成数据友好”
- （据 Olmo 3 称）明显优于 Llama 3.1 8B
- 可能是目前最强大的 70 亿级西方/美国公司模型之一

如果您是一家关注以下方面的企业：

- 数据来源
- 模型训练方式
- 法律/治理/审计要求

……这种透明度至关重要。

以下是如何使用 Instruct 模型创建一个小型“问答”助手：

```
from my_llm_client import call_model

def answer_question(question: str) -> str:
    messages = [
        {"role": "system", "content": "You are a helpful, concise assistant."},
        {"role": "user", "content": question}
    ]
    
    response = call_model(
        model="olmo-3-7b-instruct",
        messages=messages,
        max_tokens=256,
        temperature=0.3
    )
    return response["content"]
print(answer_question("What is vectorization in NumPy?"))
```

重点：这是 Olmo 3 的“即插即用助手”版本——速度足够快，可以用于生产环境；足够智能，可以处理大多数任务；并且足够开放，可以满足合规性要求高的用户。

## 4、Think 模型：推理小精灵

Olmo 3 的 Think 版本专为长篇推理而设计。

> “长篇推理小精灵：推理能力非常强，可与 Qwen3 8B / 32B 相媲美（总分相差 1-2 分）。”

但与一些“纯粹推理”模型不同，Think 模型强调它仍然具有以下特点：

- 擅长执行指令
- 作为聊天机器人运行稳定
- 略带古怪，趣味十足

### 4.1 “思维模型”存在的意义

核心理念很简单：

- 并非每个请求都需要冗长的思考过程。
- 但一些高风险任务（例如数学、规划、编程）则需要模型进行更多思考。

因此，与其……他们提供两种功能齐全的模型：

- 指令（Instruct）——针对简短回答进行优化
- 思考（Think）——针对更长、更深入的推理进行优化

您可以根据自己的“思考预算”（即您能承受的令牌数量和延迟）进行选择。

### 4.2 示例：在“指导”和“思考”之间切换

你可以用代码构建一个简单的路由：

```
from my_llm_client import call_model

def smart_call(prompt: str, mode: str = "auto") -> str:
    # Very simple heuristic:
    # - Short questions -> instruct
    # - Math / proof / complex -> think
    prompt_lower = prompt.lower()
    if mode == "auto":
        if any(word in prompt_lower for word in ["prove", "derive", "step by step", "long answer"]) \
           or len(prompt) > 300:
            model = "olmo-3-7b-think"
            max_tokens = 1500
        else:
            model = "olmo-3-7b-instruct"
            max_tokens = 512
    elif mode == "think":
        model = "olmo-3-7b-think"
        max_tokens = 1500
    else:
        model = "olmo-3-7b-instruct"
        max_tokens = 512
    response = call_model(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        temperature=0.4
    )
    return response["content"]
print(smart_call("Explain gradient descent in two sentences.", mode="auto"))
print("---")
print(smart_call("Prove that the sum of two even numbers is always even.", mode="auto"))
```

到 2026 年，我们可能会看到整个模型族都围绕这种“指令-思考”的权衡进行优化。

Olmo 3 本质上是这一理念的早期版本。

## 5、Think 模型的训练方式：SFT — DPO — RLVR

Think 的训练流程包含三个主要阶段：

- 大型推理 SFT（监督式微调）
- DPO（直接偏好优化）
- RLVR（基于可验证奖励的强化学习）

让我们逐一进行简要说明。

### 5.1 大型推理 SFT：Dolci-Think-SFT

第一阶段是一个名为 Dolci-Think-SFT 的大型监督式数据集，它基于以下数据集：

- OpenThoughts3
- Nemotron 训练后数据集
- SYNETHIC-2
- Tülu 3 / OLMo 2 “提示集”
- 以及其他数据集

您可以这样理解：

> “我们精心挑选了大量优秀的推理示例，并让模型模仿它们。”

如果您曾经使用自己的数据对模型进行过微调，那么这个概念对您来说应该并不陌生。

以下是 SFT 的一个简单概念性代码示例（huggingface 风格的伪代码）：

```
from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
from datasets import load_dataset

model_name = "ai2/olmo-3-7b-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# Hypothetical reasoning dataset
dataset = load_dataset("ai2/dolci-think-sft")
def tokenize(example):
    prompt = example["prompt"]
    completion = example["completion"]
    text = prompt + "\n\n" + completion
    tokens = tokenizer(text, truncation=True, max_length=2048)
    tokens["labels"] = tokens["input_ids"].copy()
    return tokens
tokenized = dataset.map(tokenize, batched=True)
args = TrainingArguments(
    output_dir="./olmo3-think-sft",
    per_device_train_batch_size=2,
    learning_rate=1e-5,
    num_train_epochs=1,
)
trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized["train"]
)
trainer.train()
```

当然，实际的训练规模要大得多，也复杂得多，但从概念上讲，它只是“教模型模仿好的推理”。

他们甚至说，这个数据集的影响力可能与模型本身一样大——因为好的推理数据仍然相对稀缺且宝贵。

### 5.2 DPO 阶段：从差异中学习，而不仅仅是好的答案

SFT 之后是 DPO（直接偏好优化）。

简单来说：

- 你向模型展示同一个问题的两个答案：
- 一个来自一个强模型（例如，Qwen3 32B）
- 另一个来自一个弱模型（例如，Qwen3 0.6B）
- 你标注：“A 比 B 好。”
- 模型不仅学习好的答案，还会学习这个“差值”（即好答案和坏答案之间的差异）。

这种方法借鉴了 SmolLM 3 的训练方式。

DPO（概念）伪代码：

```
from dpo_trainer import DPOTrainer  # pretend helper

dataset = load_dataset("ai2/dpo-qwen3-32b-vs-0_6b")
def format_example(example):
    return {
        "prompt": example["prompt"],
        "chosen": example["answer_strong"],   # from Qwen3 32B
        "rejected": example["answer_weak"]   # from Qwen3 0.6B
    }
formatted = dataset.map(format_example)
trainer = DPOTrainer(
    model=model,  # e.g. Olmo 3 Think SFT
    beta=0.1,
    train_dataset=formatted["train"],
)
trainer.train()
```

重要性：

- DPO 即使在 AIME、GPQA 等高难度基准测试中也能持续提升性能。它支持“增量学习”假说：模型通过显式学习区分好行为和坏行为，性能会显著提升。
- 许多早期的开放式“思考”模型跳过了这一步骤，导致其潜在性能未能得到充分发挥。

Olmo 3 则不然。

### 5.3 RLVR 阶段：基于可验证奖励的强化学习

最后，他们使用了 RLVR——一种基于可验证检查的强化学习方法。（不仅仅是人类的偏好）。

灵感来源包括：

- ServiceNow 的 PipelineRL
- DAPO
- GRPO 博士

简单思路：

- 模型生成答案。
- 验证者/检查者评估答案（例如，代码的测试用例，数学的答案正确性）。
- 模型根据答案的正确性和实用性获得奖励。
- 强化学习更新模型以提高预期奖励。

概念伪代码：

```
def reward_function(prompt, completion):
    """
    A fake verifiable reward function.
    In practice, this might run unit tests, a math checker, etc.
    """
    if "3x + 7 = 22" in prompt:
        # Check if completion contains 'x = 5'
        return 1.0 if "x = 5" in completion.replace(" ", "") else 0.0
    return 0.0

def rl_step(model, batch_prompts):
    completions = model.generate(batch_prompts)
    rewards = [reward_function(p, c) for p, c in zip(batch_prompts, completions)]
    
    # RL update (very abstract)
    loss = -model.logprob(completions) * rewards
    loss.backward()
    optimizer.step()
```

据报道，Olmo 3 采用了缩放算法。 RLVR 规模已达 320 亿，并采用了一些基础设施技巧来增强稳定性，包括：

- “主动填充”（下文详述）
- 异步基础设施能够很好地应对长时间的迭代

## 6、主动填充：在强化学习期间保持 GPU 活跃度

大型模型的强化学习之所以困难，是因为：

- 某些轨迹（迭代）产生的梯度为零（没有学习信号）。
- 长时间的迭代会导致 GPU 闲置，等待其他迭代完成。

Olmo 3 引入了一种名为“主动填充”的技巧：

> “持续生成学习节点，直到生成一个完整的、梯度非零的迭代批次。”

直觉：

- 不要把时间浪费在无法提供学习信号的迭代上。
- 持续采样，直到获得一个真正可用于训练的迭代批次。

非常简略的示例：

```
def collect_useful_batch(env, model, batch_size):
    useful_prompts = []
    useful_completions = []
    useful_rewards = []

while len(useful_prompts) < batch_size:
        prompt = env.sample_prompt()
        completion = model.generate([prompt])[0]
        reward = reward_function(prompt, completion)
        if reward != 0:  # only keep non-zero gradient samples
            useful_prompts.append(prompt)
            useful_completions.append(completion)
            useful_rewards.append(reward)
    return useful_prompts, useful_completions, useful_rewards
```

这对于在 320 亿规模下运行强化学习来说是一个显著的稳定性提升，尤其是在迭代周期较长且基础设施异步运行的情况下。

## 7、RL Zero：直接在基础模型上进行强化学习

DeepSeek R1 提出了一个颇具启发性的想法：

> “如果直接从基础模型开始进行强化学习会怎样？”（而不是像传统方法那样：基础模型 → 结构化框架 → 强化学习。）

Olmo 3 以完全开放的方式探索了这一想法。

他们：

- 在开发过程中直接在基础模型上运行强化学习。
- 有时会在训练过程中加入强化学习反馈。
- 将“强化学习能力”视为基础模型的内置属性，而不是最后添加的步骤。

而且，他们提供的不仅仅是一个强化学习模型，而是一整套工具包。

- 4 个 RL Zero 数据集
- 每个领域 70 亿个检查点，涵盖：数学、代码、指令和混合内容

这意味着您可以真正研究强化学习的动态过程：

- 强化学习如何随时间改变模型？
- 它在不同领域（数学、代码、通用）有何不同？
- 它有哪些优点，又有哪些缺点？

概念示例：加载特定领域的强化学习零模型检查点。

```
from transformers import AutoModelForCausalLM, AutoTokenizer

# Example domain-specialized RL Zero model (illustrative name)
model_name = "ai2/olmo-3-7b-rlzero-math"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
prompt = "Solve the equation: 2(x - 3) = 10. Show your steps."
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(
    **inputs,
    max_length=256,
    do_sample=True,
    top_p=0.9,
    temperature=0.7
)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

对于研究人员来说，这很有价值：您可以探索 RLVR 的异常情况，而不是仅仅依靠单一的“最终”前沿模型进行猜测。

## 8、用 Olmo 3 研究什么？

由于一切都是开放的，Olmo 3 为您提供了回答以下问题的工具：

- 数学/推理基准测试中的污染。模型真的在进行推理吗？还是它们在训练过程中就已经看到了答案？
- 虚假奖励。我们是否在奖励一些技巧，而不是真正的推理？参见：Shao 等人。 （“虚假奖励”）
- 推理 vs. 记忆。冗长的思维链是真正的逻辑还是记忆的模式？参见：Wu 等人（“推理还是记忆？”）

您可以：

- 重现他们的强化学习设置
- 替换奖励函数
- 探测过拟合或奖励作弊
- 逐个检查点检查变化

换句话说：您不再需要将强化学习行为视为黑箱。

## 9、思考预算：延迟 vs. 质量

围绕 Olmo 3 的一个较好的框架理念是“思考预算”。

与其问：

> “我们是否需要一个思考模型？”

不如问：

> “每个任务我们可以承受多少个标记（以及多少延迟）？”

- 用于快速完成用户界面或者，如果需要自动补全：请使用 `Instruct` 并设置较小的 `max_tokens` 值。
- 对于深度推理、规划、定理证明和审计：请使用 `Think` 并设置较大的 `max_tokens` 值。

基于“思考预算”的示例路由：

```
def call_with_budget(prompt: str, budget: str = "low") -> str:
    if budget == "low":
        model = "olmo-3-7b-instruct"
        max_tokens = 256
    elif budget == "medium":
        model = "olmo-3-7b-instruct"
        max_tokens = 512
    else:  # "high"
        model = "olmo-3-7b-think"
        max_tokens = 1500

response = call_model(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens
    )
    return response["content"]
print(call_with_budget("Give me a short summary of attention mechanism.", "low"))
print("---")
print(call_with_budget("Help me plan a 3-month roadmap to learn full-stack web development.", "high"))
```

预计未来的模型系列（2026 年及以后）将沿着这个维度进行清晰的组织。

Olmo 3 的实质是：“我们现在正在这样做，您可以查看所有内容。”

## 10、Olmo 3 之后是什么？

根据路线图提示：

- 混合专家模型 (MoE)。为了更高效地扩展：以更低的推理成本获得更好的性能。
- 更好的角色/风格训练。能够更一致地保持角色、风格和语气的模型。
- 帕累托最优的指令型与思考型模型系列。位于以下各项之间“最佳权衡曲线”上的模型：延迟/成本、推理能力。
- 更大的规模。更大的基础模型和思考型模型，可能会与前沿模型展开更多竞争。

简而言之：Olmo 3 不仅仅是“又一个模型版本”。它是一个用于研究强化学习、推理、污染以及“思考与速度”权衡的平台——而且它足够开放，你可以从中真正学到东西。

## 11、如何在你的项目中使用 Olmo 3

一些具体的想法：

构建一个透明的 AI 助手：

- 使用 7B Instruct 或 7B Think 作为基础架构。
- 清晰地记录训练数据和代码的来源。

尝试你自己的强化学习流程：

- 从 RL Zero 的数学或代码检查点开始。
- 替换你自己的奖励函数和任务。

评估污染或奖励机制优化：

- 使用他们的数据集和检查点。
- 复现推理基准测试并检查异常行为。

研究“思考预算”策略：

- 实现 Instruct 和 Think 之间的路由。
- 衡量质量、延迟和成本。

即使你从未将 Olmo 3 部署到生产环境中，它仍然是学习LLM训练实践的绝佳学习环境。

---

原文连接：[Olmo 3: The Fully-Open 7B & 32B AI Model Taking On Qwen and DeepSeek](https://medium.com/@CodeCoup/olmo-3-the-fully-open-7b-32b-ai-model-taking-on-qwen-and-deepseek-f9c579e9ca56?ref=hubwiz.com)

汇智网翻译整理，转载请标明出处