## 探索大模型训练中的关键标签：system、user、role、content、assistant、observation、function

在大语言模型（如 GPT-4、GPT-5）的训练和使用过程中，标签（tags）起到了至关重要的作用。通过这些标签，模型能够理解并处理不同类型的信息，准确识别对话的角色、内容、功能调用以及外部工具交互。这些标签帮助模型保持对话的上下文连贯性，执行复杂任务并生成高质量的响应。在这篇博客中，我们将深入探讨七个重要的标签：**system**、**user**、**role**、**content**、**assistant**、**observation** 和 **function**，并探讨它们在大模型训练中的作用和重要性。




### 什么是标签？

在对话系统或大模型的训练过程中，标签（tags）是为不同类型的对话数据赋予特定含义的标记。每个标签代表特定的信息片段或操作，帮助模型理解对话结构和交互行为。这些标签在数据集构建和模型训练中起到了组织和分类的作用，使模型能够从大量数据中有效地学习。

### 七个关键标签的作用

#### 1. **System（系统）**

**定义**: "system" 标签用于为模型提供系统级的指导或规则，定义模型在对话中的行为或目标。系统提示告诉模型它应该如何回应用户，设定了对话的基础框架。

**举例**: 比如，一个系统提示可以是：“你是一个虚拟助手，你的任务是帮助用户回答与技术相关的问题。”

**作用**: 系统标签为模型提供了初始的指令和上下文，使得模型能够根据这些指令在对话中保持一致的行为。例如，在对话中，系统提示可以为模型设定特定的规则，如回答要简洁明了、不可偏离主题等。

**训练中的意义**: 在大模型训练时，系统提示（system prompt）为模型提供了背景信息，帮助模型确定它在对话中应该扮演的角色。这确保了模型能够保持上下文一致性，并为用户提供符合预期的回应。尤其在多轮对话中，明确的系统提示可以帮助模型更好地理解对话的框架和方向。

#### 2. **User（用户）**

**定义**: "user" 标签用来标记对话中由用户发出的输入。它表示模型的对话对象，也就是使用模型的用户所提供的信息或问题。

**举例**: 假设用户输入了：“如何提高我的编程能力？” 这个问题会被标记为用户输入。

**作用**: 用户标签告诉模型，这段内容是由用户提供的，因此模型需要分析并回应这个输入。它明确了模型的角色是回应用户的问题或请求。

**训练中的意义**: 用户标签在训练数据中区分了用户的输入与其他类型的输入（如系统指令或工具调用），这帮助模型理解它什么时候需要认真倾听并提供针对性回答。通过大量的标记训练，模型能够学会识别用户意图并生成适合的响应，从而提升用户体验。

#### 3. **Role（角色）**

**定义**: "role" 标签用于标记对话中不同实体的身份，如用户、助手、系统等。每个角色都有不同的任务和行为模式。

**举例**: 在一个对话中，用户输入的问题会被标记为“human”角色，而模型的回应则标记为“assistant”角色。

**作用**: 角色标签帮助模型理解不同对话参与者的身份，以及他们在对话中的任务。例如，用户是提问者，而助手是回答者。通过这些标签，模型能够更准确地为不同的对话参与者生成相应的内容。

**训练中的意义**: 角色标签的明确区分有助于模型适应多角色对话场景，确保它知道何时该生成回答，何时该继续等待输入。特别是在复杂的对话场景中，角色标签可以帮助模型在不同角色之间切换，提高对话的流畅性和一致性。

#### 4. **Content（内容）**

**定义**: "content" 标签用于标识对话的实际内容，即用户的输入或模型生成的文本。这是对话的核心信息。

**举例**: 用户输入的文本，如：“推荐一些机器学习的学习资料。” 就是对话的内容部分。

**作用**: 内容标签包含了对话的语义信息，是模型进行理解和生成的核心数据。通过分析内容标签，模型能够确定用户的具体需求和意图，并生成相应的答案。

**训练中的意义**: 内容标签为模型提供了直接的语言输入，帮助模型分析语义并生成高质量的响应。在训练中，通过对大量内容数据的学习，模型能够更好地理解自然语言，并生成与上下文高度相关的回答。

#### 5. **Assistant（助手）**

**定义**: "assistant" 标签标记模型本身的输出，表示模型扮演的是一个助手的角色，目的是帮助用户解决问题或提供建议。

**举例**: 当模型生成了回答：“你可以从 Coursera 或 edX 上找到优质的机器学习课程。” 这段内容会被标记为助手生成的文本。

**作用**: 助手标签明确了模型的角色是提供帮助和建议，它需要根据用户的输入生成有用的信息。通过标记助手的输出，模型可以在训练中学会如何作为一个助手提供支持。

**训练中的意义**: 在训练过程中，assistant 标签帮助模型区分用户输入与自己生成的内容。通过这种方式，模型可以更好地理解自己在对话中的任务，从而生成更加符合用户需求的响应。

#### 6. **Observation（观察）**

**定义**: "observation" 标签通常用于标记外部工具或系统返回的结果。它表示模型调用外部资源后的反馈信息。

**举例**: 如果模型调用了一个计算工具来求解数学问题，计算结果就会被标记为“observation”。

**作用**: 当模型需要通过外部工具获取信息时，观察标签标记了工具返回的数据。这帮助模型将外部工具的结果整合到对话中，使得对话能够包含更多复杂的推理和计算过程。

**训练中的意义**: 在训练过程中，observation 标签使模型能够处理复杂任务和工具调用。通过这些标签，模型可以学习如何从外部工具获取数据，并将其整合到对话中，为用户提供完整的回答。

#### 7. **Function（函数）**

**定义**: "function" 标签用于标记模型调用外部函数或工具的行为。它通常与“observation”标签配合使用。

**举例**: 当模型调用了一个天气API来获取某个城市的天气情况时，这个调用行为会被标记为“function”。

**作用**: 函数标签帮助模型执行复杂任务，例如调用外部API或使用某些功能模块。通过标记函数调用，模型能够进行更复杂的操作，超越简单的对话生成，执行实际任务。

**训练中的意义**: 通过训练，模型学习如何调用外部工具完成特定任务，并根据函数返回的结果生成回答。这使得模型在面对复杂请求时能够具备更高的灵活性和扩展性。

---

### 为什么训练大模型需要这些标签？

1. **提高对话上下文的理解**  
   标签提供了清晰的结构和上下文，帮助模型理解每个对话片段的角色和含义。通过这些标签，模型可以更好地区分用户的需求、系统的指令、助手的反馈以及外部工具的调用结果，从而在多轮对话中保持上下文一致性。

2. **明确任务与角色**  
   不同的角色标签让模型知道在对话中它该扮演什么角色，并如何处理不同角色的输入。例如，模型会根据用户的输入生成回答，而不会对系统提示进行生成，这大大提高了对话的流畅性。

3. **工具调用和任务执行**  
   现代大语言模型不仅能够生成文本，还可以通过调用外部工具或API来完成复杂任务。通过函数和观察标签，模型可以准确调用工具并处理返回的数据，使其具备了执行现实任务的能力。

4. **提升模型的多任务处理能力**  
   标签不仅帮助模型处理对话，还能够在多任务环境中高效工作。通过训练模型使用不同的标签，它可以在多个复杂的对话和任务之间进行切换，从而在处理多种类型的问题时表现出色。

5. **数据标注与分类**  
   在大模型的训练中，标签还用于为训练数据集进行分类和标注。通过精细化的标注，模型可以学习到更为复杂的对话模式和任务执行逻辑，从而显著提高模型的泛化能力和应用场景。


### 总结

在大语言模型的训练过程中，标签（tags）起到了不可或缺的作用。通过清晰定义对话中的不同元素和角色，标签为模型提供了结构和上下文支持，确保模型能够理解


## 如何发生作用

在大语言模型的训练和推理过程中，**System**语句（即系统提示）和其他标签（如**User**、**Role**、**Content**等）是如何输入给模型的？模型又是如何理解和区分这些不同标签的？这个问题涉及到自然语言处理模型的输入编码、结构化信息标注以及如何通过预训练来学习这些标签的不同功能。接下来，我将详细探讨这两个关键问题。

### 一、**System 语句如何给入到大模型中**

在对话系统中，**System**语句（系统提示）通常是一个帮助大模型理解当前对话框架的提示信息。它为模型提供初始背景信息，定义模型的行为规范或目标。我们可以通过几种不同的方式将**System**语句输入到大模型中：

#### 1. **直接作为对话的一部分输入**
最直接的方式是将**System**语句作为对话的开头，像普通文本一样输入给模型。例如，如果系统提示是“你是一个虚拟助手，帮助用户解决问题”，它可以被添加到对话流的最前面，并与其他用户输入和模型输出一起被处理。输入的数据流可能类似如下结构：

```json
{
  "role": "system",
  "content": "你是一个虚拟助手，帮助用户解决问题"
}
```

在这种情况下，系统提示可以作为对话的背景信息，直接影响模型的响应生成。模型将把它视为对话的一部分，并在生成后续响应时参考这个系统提示。

#### 2. **特殊的编码方式**
另一种方式是通过特殊的编码来引入**System**语句。例如，可以使用特殊的符号或标记来明确表示这个文本是系统提示，而不是普通对话。像在预训练阶段使用的句子分类任务中，我们可以用[CLS]（分类标记）等特殊标记来表示不同的输入类型。

在这种方式中，系统提示的输入可能会被用一些独特的标识符来区分，例如：

```plaintext
<SYSTEM>: 你是一个虚拟助手，帮助用户解决问题
```

大模型通过这些标记符，理解到这段文本是系统提示，而不是普通的用户或助手输入。通过这样的标记，大模型能够在处理过程中分辨这类提示信息。

#### 3. **嵌入到模型的上下文中**
**System**语句也可以通过嵌入的方式传递给模型。在某些架构中，系统提示的作用不仅限于对话的第一句话，而是作为隐含信息，在整个对话过程中被用来指导模型的行为。通过将系统提示嵌入上下文向量，模型能够持续参考这个系统提示。

这种方式下，系统提示可能不会直接显示在每个模型的输入序列中，而是在模型的上下文编码中保留。具体实现可能涉及对输入序列中隐藏状态的调整，确保模型在生成每一步时都能参考系统提示。

### 二、**大模型如何区分不同的标签（tags）**

大语言模型并不是天生能够理解诸如**User**、**Assistant**、**Content**、**System**、**Observation**等标签的不同意义。这些能力是通过**预训练**和**微调**过程中学到的。让我们来详细探讨大模型如何通过训练区分这些标签，以及这些标签如何在输入处理中扮演不同的角色。

#### 1. **基于标记的输入格式**
一种非常常见的方式是给每个输入标签都添加特定的标记（Token），通过不同的标记使模型能够区分输入的不同角色和功能。例如，在对话系统中，模型可能会通过以下方式接受不同标签的输入：

- **User（用户）** 输入：
  ```plaintext
  <USER>: 我想知道今天天气怎么样？
  ```
- **Assistant（助手）** 回复：
  ```plaintext
  <ASSISTANT>: 今天天气晴朗，气温大约在25摄氏度左右。
  ```
- **System（系统提示）**：
  ```plaintext
  <SYSTEM>: 你是一个虚拟助手，帮助用户解决问题。
  ```

通过这种基于标记的输入格式，大模型可以通过这些特定的标签（如 `<USER>`、`<ASSISTANT>` 等）来理解输入的角色和作用。

#### 2. **编码和位置嵌入（Positional Encoding）**
另一种常见的技术是**位置嵌入**（Positional Encoding）。在大模型中，每个输入词通常都会有一个对应的向量表示（**embedding**），并且模型会根据输入的词在序列中的位置进行编码。在包含角色或功能标签的输入序列中，不同的标签会对应不同的编码，从而帮助模型区分这些标签。

例如，一个标注为“User”的输入可能会带有一个与“Assistant”输入不同的嵌入向量或位置信息，从而使模型能够区分这些不同的角色。

对于这种实现，标签的信息被嵌入到模型的编码空间中，大模型通过**自注意力机制**来理解并区分不同标签的含义。通过多轮训练，模型能够学会如何根据这些位置和角色标签做出不同的响应。

#### 3. **训练时的明确标注**
在模型训练过程中，数据集会明确标注每个输入的角色。例如，在对话数据中，训练数据会通过以下方式明确地标注输入和输出：

```json
{
  "role": "user",
  "content": "请推荐一些机器学习的书籍。"
},
{
  "role": "assistant",
  "content": "你可以阅读《机器学习实战》和《深度学习》。"
}
```

通过大量带有这种标签标注的数据，模型会在训练过程中学会如何基于这些不同的角色做出响应。模型会学习到，**“user”**角色通常提出问题或发出请求，而**“assistant”**角色需要生成回答或提供帮助。

#### 4. **通过任务微调学习标签的作用**
在微调阶段，模型不仅通过输入的标记和位置嵌入来理解标签，还通过特定任务的设计来进一步区分标签的作用。比如，在微调过程中，模型可能会被专门训练去理解不同的对话角色如何相互作用。

例如，**System**提示通常会出现在对话的开头，而用户的输入通常需要被模型认真分析和理解。通过任务微调，模型可以学会如何使用这些标签，如何基于系统提示来调整它的行为，如何根据用户输入生成合适的回答，如何理解函数调用和外部工具的结果。

#### 5. **自注意力机制的工作原理**
在大语言模型（如GPT架构）中，**自注意力机制**是理解和处理这些标签的关键。自注意力机制通过分析整个输入序列中的所有词汇和标记之间的关系，确定哪些信息是相关的。通过这种机制，模型不仅能够理解文本的语义，还能够将标签信息与文本内容联系起来。

例如，当模型处理“system”提示时，自注意力机制可以帮助模型聚焦在这个提示上，并将其与用户的输入联系起来，从而在生成回答时参考系统提示的信息。

### 三、如何区分复杂的对话场景

在真实应用中，复杂对话场景通常涉及多个角色、多轮对话和外部工具调用。为了处理这些复杂场景，标签的使用显得尤为重要。

#### 1. **多轮对话中的角色管理**
在多轮对话中，**Role**标签帮助模型保持对不同参与者的清晰理解。比如，用户可能多次提问，模型通过“User”标签清楚地知道这些输入都是来自用户的，而“Assistant”标签则标识模型自己生成的回答。

通过自注意力机制和嵌入向量，模型能够记住角色之间的互动，并在生成回答时考虑到整个对话的上下文。

#### 2. **外部工具调用的区分**
在涉及外部工具调用的任务中，**Function**和**Observation**标签非常关键。模型可以根据这些标签明确知道它何时需要调用外部工具（如API查询），何时需要处理工具返回的结果（观察）。

例如，当模型调用了一个天气API，它可以通过观察（observation）标签接收到API的返回值。随后，模型会根据这个返回值生成对用户的问题的回答。

### 总结

大模型通过标记化的输入、位置编码、训练时的标签标注和自注意力机制来区分不同的标签（如**System**、**User**、**Role**等）。这些标签为模型提供了结构和角色信息，帮助它理解对话的复杂性，并在多轮对话中保持上下文一致性。在训练过程中，模型通过大量带有标签的标注数据，学会如何根据不同的标签生成合适的回答，并执行复杂任务，如调用外部工具和处理函数结果。

【深度学习】探索大模型训练中的关键标签：system、user、role、content、assistant、observation、function

PPO（Proximal Policy Optimization，近端策略优化）是一种强化学习算法，由OpenAI于2017年提出，主要用于解决强化学习中策略更新时的不稳定性问题。PPO是深度强化学习领域中非常流行的一种策略优化方法，因其高效性和稳定性，广泛应用于许多复杂任务中，如机器人控制、视频游戏AI和自然语言处理等。

### 背景与问题
在强化学习中，智能体（agent）通过与环境交互，学习一个策略（policy），以便最大化累积奖励。经典的强化学习方法如策略梯度（Policy Gradient）和Q学习（Q-Learning）在策略更新时会遇到一些问题：

1. **策略更新过大**：当策略在更新时，如果变化过大，可能会导致策略的性能急剧下降，甚至偏离最优解。这种不稳定性使得算法在许多复杂环境下表现不佳。
2. **样本效率低**：在高维度环境中，传统的强化学习方法往往需要大量的样本才能找到较好的策略，样本效率较低。





### PPO的主要思想
PPO的主要目标是解决策略更新中的不稳定性问题。PPO通过对策略更新进行约束，确保每次策略更新不会偏离当前策略过远。这种方法使得更新过程更加稳定，同时保留了较高的学习效率。

PPO结合了策略梯度和信任域策略优化（Trust Region Policy Optimization, TRPO）的优势。与TRPO相比，PPO的实现更加简单，且能达到相似甚至更好的效果。PPO的核心思想可以分为以下几点：

1. **目标函数（Objective Function）**：PPO引入了一个修正后的目标函数，用于限制策略更新的幅度。传统的策略梯度方法直接优化策略，但这种方式容易导致大的策略变化。而PPO通过限制新旧策略的比率，避免了策略发生过大的更新。

2. **策略裁剪（Clipping）**：PPO使用了一种称为“裁剪”（clipping）的技术，对策略变化的范围进行约束。具体来说，PPO会限制策略变化的比率，使其在一个预定义的区间内。如果策略变化超出该区间，PPO会放弃这种更新。这种方式既能保证策略的稳定性，又能提高学习效率。

3. **多次更新（Multiple Updates）**：PPO允许在同一批数据上进行多次策略更新，从而提高数据的利用效率。传统的策略梯度方法通常只进行一次更新，而PPO能够多次使用同一批样本，从而提升了样本效率。

### PPO的算法流程
PPO的训练流程与其他策略优化算法类似，主要包括以下几个步骤：

1. **与环境交互**：智能体在当前策略下与环境交互，生成一个轨迹（trajectory），即一系列的状态、动作和奖励。
  
2. **计算优势函数（Advantage Function）**：PPO使用优势函数来估计当前策略相较于基准策略的表现提升。优势函数能够衡量某个动作在某个状态下的相对价值，是策略更新的关键。

3. **更新策略**：通过最大化PPO的目标函数，智能体对策略进行更新。PPO的目标函数结合了裁剪机制，确保策略更新的幅度不会过大。

4. **重复迭代**：重复上述步骤，直到智能体在环境中的表现达到预期的标准或停止条件。

### 关键技术细节
PPO的设计旨在解决策略更新时的平衡问题：既要让策略更新能有效提高表现，又要避免策略发生过大的变化。以下是PPO中几个关键技术点的解释：

1. **裁剪比率在目标函数中的应用**：PPO 引入了一个裁剪比率来限制新策略与旧策略的差异幅度，避免策略更新过大。假设旧策略为 $ \pi_{\text{old}} $，新策略为 $ \pi $，裁剪比率 $ r(\theta) $ 定义为：

    $$
    r(\theta) = \frac{\pi(a|s; \theta)}{\pi_{\text{old}}(a|s; \theta_{\text{old}})}
    $$

    PPO 对比率 $ r(\theta) $ 进行限制，使其保持在 1 附近（通常范围设定为 0.8 到 1.2），以防止新旧策略间的变化过大，从而自动抑制极端策略更新。

2. **样本效率提升**：PPO 的策略允许对同一数据进行多次梯度更新，极大地提高了样本效率。在实际应用中，数据获取成本往往较高，因此样本效率的提升具有显著的实用价值。

3. **优势估计（Advantage Estimation）**：PPO 通常使用广义优势估计（GAE）来更精确地估计优势函数。GAE 对奖励在时间维度上进行加权平滑处理，有效减少策略估计中的方差，从而提高算法的稳定性。

### PPO的优缺点
#### 优点：
1. **易于实现**：相比于其他强化学习算法如TRPO，PPO的实现相对简单且计算效率高。
2. **稳定性强**：通过裁剪机制，PPO在策略更新时保持了较好的稳定性，避免了策略更新时的剧烈变化。
3. **高样本效率**：PPO能够在相同的数据上进行多次更新，提高了样本的利用率。
4. **适应性强**：PPO适用于多种复杂的任务，表现出很好的通用性。

#### 缺点：
1. **超参数调优困难**：PPO虽然相对简单，但在实际应用中，其性能对超参数（如裁剪范围、学习率等）非常敏感，可能需要大量实验来找到最佳的超参数设置。
2. **对策略随机性的依赖**：PPO假设策略是随机的（即带有一定的概率分布），因此在确定性策略问题中可能不如一些专门针对该类问题的算法。

### PPO的应用
PPO在许多复杂环境和任务中表现出了优异的性能，特别是在需要高效策略优化的任务中。以下是PPO的几个典型应用：

1. **机器人控制**：PPO被广泛应用于机器人控制任务中，包括机械臂的运动控制和自动驾驶等。其高效的策略更新和稳定性，使得机器人能够在复杂的动态环境中学习有效的动作策略。
  
2. **游戏AI**：PPO在强化学习中的表现也使其成为开发游戏AI的理想选择。例如，OpenAI使用PPO训练了Dota 2的AI，并且在多人竞技场中与人类顶级玩家进行对抗，取得了很好的效果。

3. **自然语言处理**：在语言模型的训练中，PPO被用来优化生成文本的策略。特别是在一些对话系统和文本生成任务中，PPO通过与环境交互，学习如何生成更自然、连贯的文本。

4. **推荐系统**：PPO也被应用于推荐系统中，通过与用户交互，学习个性化的推荐策略，从而提高用户的满意度和系统的推荐效果。

### 总结
PPO作为一种高效且稳定的策略优化算法，解决了传统策略梯度方法中策略更新不稳定的问题，适用于多种复杂的强化学习任务。其核心思想在于通过裁剪比率，限制策略变化的幅度，从而保证策略的渐进优化。PPO在实际应用中表现出良好的效果，尤其是在机器人控制、游戏AI和自然语言处理等领域。

PPO的成功也进一步推动了强化学习领域的发展，其易于实现和良好的样本效率使得它成为了许多研究和应用的首选算法。尽管PPO在超参数调优方面存在一定的挑战，但它仍然是目前最为流行和有效的强化学习算法之一。

【深度学习】什么是PPO训练?

分享issues：

https://github.com/hiyouga/LLaMA-Factory/issues/5398

从中获取到Deepspeed zero 3 在如何使用。





## Freeze Method Log:


```bash
deepspeed --include localhost:0,1,2,3 --master_port=19915 src/train.py  \
    --deepspeed ./mine/ds_z3_config.json \
    --stage pt \
    --model_name_or_path /tmp/Qwen2-72B-Instruct \
    --do_train \
    --dataset xxx \
    --template qwen \
    --finetuning_type freeze \
    --freeze_trainable_layers 3 \
    --freeze_trainable_modules all \
    --output_dir xxx \
    --overwrite_cache \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 64 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 100 \
    --learning_rate 1e-5 \
    --num_train_epochs 6.0 \
    --plot_loss \
    --preprocessing_num_workers 48 \
    --bf16 \
    --tokenized_path xxx \
    --cutoff_len 8000 \
    --ddp_timeout 18000 \
    --save_total_limit 5
```
1. Set trainable layers: 77,78,79
2. trainable params: 2633054208 || all params: 72706203648 || trainable%: 3.6215
3. epochs:10
4. train_runtime = 20:36:14.47
5. train_samples_per_second = 1.051
6. train_steps_per_second = 0.008



## LoRA Method Log:

```bash
deepspeed --include localhost:0,1,2,3,4,5,6,7 --master_port=25091 src/train.py  \
    --deepspeed ./mine/ds_z3_config.json \
    --stage pt \
    --model_name_or_path /tmp/Qwen2-72B-Instruct \
    --do_train \
    --dataset xxx \
    --template qwen \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --output_dir xxx \
    --overwrite_cache \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 32 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 100 \
    --learning_rate 1e-4 \
    --num_train_epochs 6.0 \
    --plot_loss \
    --preprocessing_num_workers 48 \
    --bf16 \
    --tokenized_path xxx \
    --cutoff_len 8000 \
    --ddp_timeout 18000 \
    --save_total_limit 10 \
    --save_only_model
```

1. trainable params: 16384000 || all params: 72722587648 || trainable%: 0.0225
2. epochs:6
3. train_runtime = 1 day, 8:57:44.99
4. train_samples_per_second = 0.394
5. train_steps_per_second = 0.002

## Deepspeed：

```bash
{
  "train_batch_size": "auto",
  "train_micro_batch_size_per_gpu": "auto",
  "gradient_accumulation_steps": "auto",
  "gradient_clipping": "auto",
  "zero_allow_untested_optimizer": true,
  "fp16": {
    "enabled": "auto",
    "loss_scale": 0,
    "loss_scale_window": 1000,
    "initial_scale_power": 16,
    "hysteresis": 2,
    "min_loss_scale": 1
  },
  "bf16": {
    "enabled": "auto"
  },
  "zero_optimization": {
    "stage": 3,
    "overlap_comm": true,
    "contiguous_gradients": true,
    "sub_group_size": 1e9,
    "reduce_bucket_size": "auto",
    "stage3_prefetch_bucket_size": "auto",
    "stage3_param_persistence_threshold": "auto",
    "stage3_max_live_parameters": 1e9,
    "stage3_max_reuse_distance": 1e9,
    "stage3_gather_16bit_weights_on_model_save": true
  }
}
```


lora requires more activation recomputes. see https://arxiv.org/pdf/2403.13372

【深度学习】LLaMA-Factory，Why is LoRA much slower than Freeze?

【深度学习】使用ms-swift微调训练Qwen2-VL做印章识别

## 计算随机取汉字的概率与期望次数

在一个包含2万个汉字的集合中，如果我们每次随机取一个汉字，想要取到全部汉字的概率是多少？又需要取多少次，才能期望取到所有汉字？这些问题可以借助概率论中的“优惠券收集问题（Coupon Collector's Problem）”来解答。





### 优惠券收集问题（Coupon Collector's Problem）

优惠券收集问题的经典表述是：假设有 $N$ 种不同的优惠券，每次随机抽取一种，问需要抽取多少次才能收集到所有不同的优惠券。它的期望次数可以表示为：

$$
E(T) = N \times \left( 1 + \frac{1}{2} + \frac{1}{3} + \dots + \frac{1}{N} \right)
$$

其中，$T$ 是收集到所有优惠券所需的抽取次数。

这个公式的和可以近似表示为：

$$
E(T) \approx N \times (\ln(N) + \gamma)
$$

其中，$\gamma$ 是欧拉-马歇罗尼常数，约等于 0.577。

### 计算2万个汉字的期望抽取次数

现在，假设我们有 $N = 20000$ 个汉字，将其代入上述公式，首先计算 $\ln(20000)$ 的近似值：

$$
\ln(20000) \approx 9.903
$$

因此期望的抽取次数为：

$$
E(T) \approx 20000 \times (9.903 + 0.577) = 20000 \times 10.48 \approx 209600
$$

这意味着，**在期望情况下，你需要大约 209600 次随机抽取，才能取到全部的2万个汉字**。

### 随机取到全部汉字的概率

随着每次抽取进行，取到新的汉字的概率会逐渐下降。假设第 $i$ 次抽取时已经有 $k$ 个不同的汉字被取到，那么再取到一个新的汉字的概率是：

$$
P(\text{新汉字}) = \frac{N-k}{N}
$$

这个概率随着取到不同汉字的数量增加而减少。由于该过程的复杂性，计算每次抽取后全部汉字都被取到的概率需要累积多个概率值，可以通过数值模拟进行解答。

### Python模拟方案

我们可以使用Python进行蒙特卡洛模拟，估算取到全部汉字所需的随机抽取次数。下面是一个示例代码：

```python
import random

def simulate_draws(num_chars):
    # 存储已经取到的汉字
    drawn_chars = set()
    draws = 0
    
    while len(drawn_chars) < num_chars:
        # 随机取一个汉字
        drawn_chars.add(random.randint(1, num_chars))
        draws += 1
        
    return draws

# 模拟多次实验，取平均值
def estimate_expected_draws(num_chars, simulations=1000):
    total_draws = 0
    for _ in range(simulations):
        total_draws += simulate_draws(num_chars)
    return total_draws / simulations

num_chars = 20000
simulations = 1000  # 运行1000次模拟
expected_draws = estimate_expected_draws(num_chars, simulations)
print(f"平均需要随机取 {expected_draws} 次才能取到全部汉字。")
```

这个代码将模拟多次随机抽取，并计算取到全部汉字所需的平均次数。结果大致会接近理论期望值 209600 次。

### 总结

1. **期望抽取次数**：对于一个包含2万个汉字的集合，期望需要大约 **209600** 次抽取，才能取到全部的汉字。
2. **概率变化**：随着每次抽取后，取到新汉字的概率逐步降低，可以通过公式 $P(\text{新汉字}) = \frac{N-k}{N}$ 来描述。
3. **Python模拟**：可以使用Python进行数值模拟，验证期望抽取次数与实际情况的接近程度。

通过数学推导与编程模拟，我们可以更好地理解随机抽取汉字时的期望次数以及概率的变化趋势。这种问题不仅在语言处理上有趣，也在概率论和算法设计中有着广泛的应用。

优惠券收集问题的应用：如何在随机抽取中得到所有汉字

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。