利用Sum盘算Loss息争决梯度累积（Gradient Accumulation）的Bug

利用Sum盘算Loss息争决梯度累积的Bug

学习 https://unsloth.ai/blog/gradient：Bugs in LLM Training - Gradient Accumulation Fix 这篇文章的记载。
在深度学习练习过程中，尤其是在大批量（large batch）练习中，怎样高效地盘算丧失函数（Loss）并克制内存溢出不停是一个紧张的标题。在很多情况下，为了实现更高效的练习，我们会利用梯度累积（Gradient Accumulation）计谋，模仿大批量练习的结果，但同时淘汰对显存的需求。然而，这种方法大概引发一些数值盘算错误，尤其是在丧失盘算时。因此，明白如那里理梯度累积并确保盘算准确性就变得尤为紧张。
为什么要利用Sum盘算Loss？

在代码中，reduce_loss="sum"表现我们选择将每个小批量（mini-batch）的丧失值相加而不是取匀称。这种做法有几个目的：

• 权重每个样本的影响划一：在利用大批量练习时，如果直接取每个样本的匀称丧失，大概会使得样本数量更多的批次对模子练习产生不须要的影响。而通过将丧失值求和，确保了每个样本都以雷同的权重到场模子更新。
  
• 克制梯度累积带来的毛病：如果只利用小批量练习的匀称丧失举行梯度累积（梯度更新），随着梯度累积步调（gradient accumulation step）增多，丧失的盘算会变得不准确。由于简朴地将每个小批量的丧失相加，大概会导致终极盘算的丧失过大。
  

梯度累积中的标题

当我们利用梯度累积时，目的是在显存限定下模仿大批量练习的结果。假设每个小批量的盘算后，我们累积其梯度，末了再举行一次反向传播。这种方法可以明显淘汰显存的利用，但也带来了数值毛病，特殊是在丧失的盘算上。
梯度累积是否和完备批次练习数学上等价？

答案是： 不完全等价，尤其是如果我们不准确地处理处罚梯度的累积。在数学上，丧失函数通常表现为：
                                    L                         =                                   1                            n                                            ∑                                       i                               =                               1                                      n                                            L                            i                                        L = \frac{1}{n} \sum_{i=1}^{n} L_i                   L=n1​i=1∑n​Li​
此中，(                                        L                         i                                  L_i               Li​ ) 是每个样本的丧失，(                               n                          n               n ) 是样本总数。我们通常会对每个小批量的丧失举行归一化处理处罚，使得每个样本对丧失的贡献相称。
但是，在梯度累积时，我们的处理处罚方法是：
                                              L                            accumulated                                  =                                   ∑                                       k                               =                               1                                      G                                            L                            k                                        L_{\text{accumulated}} = \sum_{k=1}^{G} L_k                   Laccumulated​=k=1∑G​Lk​
此中，(                               G                          G               G ) 是梯度累积的步数， (                                        L                         k                                  L_k               Lk​ ) 是每个小批量的丧失值。这导致累积丧失和原来应盘算的丧失差别，由于没有举行准确的归一化利用。
为什么梯度累积会导致标题？

由于梯度累积在盘算丧失时没有准确处理处罚每个小批量的权重，终极的丧失值大概比现实应有的丧失大，特殊是当批次巨细不划一时。此时，我们必要对每个小批量的丧失举行缩放，以使终极的结果与大批量练习的丧失符合。
办理方案：修正梯度累积中的丧失盘算

为相识决梯度累积中丧失盘算的毛病，我们可以在每次盘算梯度时对每个小批量的丧失举行缩放。详细来说，假设我们在练习过程中设置了 (                               G                          G               G ) 步梯度累积，那么每次盘算丧失时，我们必要将每个小批量的丧失除以 (                               G                          G               G )，以确保终极的梯度更新符合预期。
数学公式如下：
                                              L                            final                                  =                                   1                            G                                            ∑                                       k                               =                               1                                      G                                                       L                               k                                                 m                               k                                                  L_{\text{final}} = \frac{1}{G} \sum_{k=1}^{G} \frac{L_k}{m_k}                   Lfinal​=G1​k=1∑G​mk​Lk​​
此中，(                                        m                         k                                  m_k               mk​ ) 是第 (                               k                          k               k ) 个小批量的有用样本数（即去除添补后的token数），(                               G                          G               G ) 是梯度累积的步数。如许做的目的是在每次梯度累积时确保丧失值的加权匀称，而不是简朴地将其相加。
小结

• Loss的求和：在利用 reduce_loss="sum" 时，我们通过求和的方式来盘算丧失，而不是简朴的匀称。这可以确保每个样本对丧失盘算的贡献划一，克制了梯度累积中的毛病。
  
• 梯度累积的毛病：梯度累积在盘算丧失时轻易出现数值毛病，尤其是在差别小批量的丧失和有用样本数不划一的情况下。为相识决这一标题，我们必要对每个小批量的丧失举行缩放处理处罚，使得终极的丧失与大批量练习的结果划一。
  

通过准确处理处罚梯度累积的丧失盘算，我们可以在不增长内存斲丧的情况下模仿大批量练习的结果，从而进步练习服从。
附录：代码分析

下面是open instruct框架提供的sum盘算 loss的代码，它实现了一个丧失盘算和梯度累积的处理处罚流程。

1. if args.reduce_loss == "mean":
2.     loss = outputs.loss
3. else:
4.     # reduce loss is sum
5.     # this ensures that we weight all tokens in the dataset equally,
6.     # rather than weighting each overall example equally when
7.     # using high amounts of gradient accumulation.
8.     # this can result in > 5 point improvements in AlpacaEval
9.     # see https://github.com/huggingface/transformers/issues/24725 for
10.     # more discussion and details.
11.     logits = outputs.logits
12.     labels = batch["labels"]
13.     # Shift so that tokens < n predict n
14.     shift_logits = logits[..., :-1, :].contiguous()
15.     shift_labels = labels[..., 1:].contiguous()
16.     # Flatten the tokens
17.     loss_fct = torch.nn.CrossEntropyLoss(reduction="sum")
18.     shift_logits = shift_logits.view(-1, embedding_size)
19.     shift_labels = shift_labels.view(-1)
20.     # Enable model parallelism
21.     shift_labels = shift_labels.to(shift_logits.device)
22.     loss = loss_fct(shift_logits, shift_labels)
23.     if args.load_balancing_loss:
24.         aux_loss = args.load_balancing_weight * outputs.aux_loss
25.         loss += aux_loss
26. # We keep track of the loss at each logged step
27. total_loss += loss.detach().float()
28. accelerator.backward(loss)

复制代码

1. Loss的选择（reduce_loss参数）

代码的第一部门是根据args.reduce_loss参数来决定利用匀称（mean）还是求和（sum）的丧失盘算方式。如果选择的是mean，则直接利用outputs.loss（通常是模子自带的丧失）。如果选择的是sum，则利用后续的处理处罚方式。
2. 处理处罚sum模式的丧失盘算

如果reduce_loss为sum，代码会进入求和模式，详细步调如下：

• 获取logits和labels：从模子的输出outputs中获取logits（推测值）和batch["labels"]（标签）。
  
• Shift利用：为了盘算交织熵丧失，模子的输出logits会做一个移位利用，使得每个token的推测目的对应下一个token。这是由于语言模子任务中的推测是基于上一个token的。
  
  1. shift_logits = logits[..., :-1, :].contiguous()
  2. shift_labels = labels[..., 1:].contiguous()

  复制代码
  这里logits[..., :-1, :]表现撤消末了一个token的logits，而labels[..., 1:]表现去掉第一个token的标签。如许处理处罚的目的是确保每个token的推测值与下一个token的真实标签举行比力。
  
• Flatten利用：对处理处罚后的logits和labels举行flatten，展平为一维向量，以便交织熵丧失函数盘算。
  
  1. shift_logits = shift_logits.view(-1, embedding_size)
  2. shift_labels = shift_labels.view(-1)

  复制代码
  这一步是为了将shift_logits和shift_labels转换为恰当交织熵丧失函数的格式，即shift_logits变为 [batch_size * sequence_length, embedding_size] 维度，shift_labels变为 [batch_size * sequence_length] 维度。
  
• 交织熵丧失函数：利用torch.nn.CrossEntropyLoss盘算丧失。这里的reduction="sum"表现对全部token的丧失求和，而不是取匀称。如许可以确保每个token的贡献雷同。
  
  1. loss_fct = torch.nn.CrossEntropyLoss(reduction="sum")
  2. loss = loss_fct(shift_logits, shift_labels)

  复制代码
  这段代码盘算了每个token的丧失，并将全部token的丧失求和。对于大批量练习，如许做是为了克制梯度累积时丧失盘算的不准确。
  
• 负载平衡丧失（Load Balancing Loss）：如果args.load_balancing_loss为True，表现必要加上额外的负载平衡丧失。负载平衡丧失用于调解模子在差别任务之间的负载，以确保练习过程的稳固性。
  
  1. if args.load_balancing_loss:
  2.     aux_loss = args.load_balancing_weight * outputs.aux_loss
  3.     loss += aux_loss

  复制代码
  这部门代码将outputs.aux_loss（辅助丧失）加权后加到主丧失上，以加强练习的稳固性。
  

3. 反向传播

末了，代码通过accelerator.backward(loss)实验反向传播，盘算梯度。total_loss用于累积丧失，以便记载每个步调的丧失值。

1. total_loss += loss.detach().float()
2. accelerator.backward(loss)

复制代码

loss.detach().float()表现将丧失从盘算图中分离，并将其转换为浮动范例，以便举行记载和后续的反向传播。
小结

• Loss的盘算方式：如果选择sum，会对每个token的丧失举行求和，而不是取匀称，以确保每个token对梯度更新的贡献相称。这对于大批量练习非常紧张，可以大概克制在梯度累积过程中出现毛病。
  
• 梯度累积：通过徐徐盘算小批量的梯度并累积，可以大概在不增长显存利用的情况下模仿大批量练习。必要确保在每次累积时准确盘算丧失，并举行恰当的缩放。
  

这段代码的计划和实现思量到了梯度累积和丧失盘算中的数值稳固性标题，确保在大批量练习时可以大概准确更新模子参数。
梯度累积公式表明

在梯度累积的公式中，(                                        L                         k                                  L_k               Lk​ ) 表现第 (                               k                          k               k ) 步梯度累积中的丧失值。详细来说，假设我们将练习数据分成 (                               G                          G               G ) 个小批量（mini-batches）举行梯度累积，那么在第 (                               k                          k               k ) 步（即第 (                               k                          k               k ) 个小批量）中，我们盘算的丧失为 (                                        L                         k                                  L_k               Lk​ )。这些丧失是通过模子对第 (                               k                          k               k ) 小批量的数据举行前向传播后得到的。
梯度累积的配景

梯度累积的目的是在多个小批量上盘算梯度，并在肯定命目的步数之后再举行一次反向传播。如许，我们可以模仿更大的批量巨细，从而进步练习稳固性和服从，而不必要一次性处理处罚过大的批量数据。
表明公式

公式中的 (                                        L                         k                                  L_k               Lk​ ) 是每个小批量的丧失值，详细来说，它是模子在第 (                               k                          k               k ) 步盘算得到的丧失。公式可以表现为：
                                              L                            accumulated                                  =                                   ∑                                       k                               =                               1                                      G                                            L                            k                                        L_{\text{accumulated}} = \sum_{k=1}^{G} L_k                   Laccumulated​=k=1∑G​Lk​
这意味着我们将每个小批量（即每个 (                               k                          k               k )）的丧失 (                                        L                         k                                  L_k               Lk​ ) 累积起来，直到举行 (                               G                          G               G ) 步梯度累积。此时的累积丧失 (                                        L                         accumulated                                  L_{\text{accumulated}}               Laccumulated​ ) 还没有举行任何梯度更新利用，它只是全部小批量丧失的总和。
举个例子

假设我们有一个批量巨细为 8 的练习数据集，而且我们渴望模仿一个批量巨细为 32 的练习过程，但由于显存限定，我们决定利用梯度累积来分 4 个小批量来盘算梯度：

• 第一步：盘算第一小批量（batch 1）的丧失 (                                              L                            1                                       L_1                  L1​ )。
  
• 第二步：盘算第二小批量（batch 2）的丧失 (                                              L                            2                                       L_2                  L2​ )。
  
• 第三步：盘算第三小批量（batch 3）的丧失 (                                              L                            3                                       L_3                  L3​ )。
  
• 第四步：盘算第四小批量（batch 4）的丧失 (                                              L                            4                                       L_4                  L4​ )。
  

此时，梯度累积的总丧失就可以表现为：
                                              L                            accumulated                                  =                                   L                            1                                  +                                   L                            2                                  +                                   L                            3                                  +                                   L                            4                                        L_{\text{accumulated}} = L_1 + L_2 + L_3 + L_4                   Laccumulated​=L1​+L2​+L3​+L4​
然后，我们对这个累积丧失举行一次反向传播，更新模子参数。
为什么要举行梯度累积？

梯度累积的长处是可以模仿大批量练习而不会导致显存溢出。通太过步盘算丧失并累积梯度，我们可以在不增长显存需求的情况下利用较大的有用批量巨细举行练习。
丧失值求和的例子

通过一个简朴的例子来阐明为什么在利用大批量练习时，丧失值求和的方式比丧失值匀称更能包管每个样本都以雷同的权重到场模子更新。
配景阐明

在大批量练习中，丧失的匀称和丧失的求和对练习结果的影响差别。详细来说，如果我们采取丧失匀称，每个样本对模子更新的贡献会受到批次巨细的影响；而如果我们采取丧失求和，每个样本对更新的贡献将保持划一，无论批次巨细有多大。
例子表明

假设我们有两个差别的批次，分别包罗差别数量的样本：

• 批次 A：包罗 4 个样本。
  
• 批次 B：包罗 8 个样本。
  

假设这两个批次的丧失分别如下：

• 批次 A 的丧失：每个样本的丧失分别为 2, 3, 1, 4，合计为 10。
  
• 批次 B 的丧失：每个样本的丧失分别为 1, 2, 3, 1, 2, 1, 4, 3，合计为 20。
  

如果利用丧失的匀称值：

• 批次 A：匀称丧失为 (                                              10                            4                                  =                         2.5                              \frac{10}{4} = 2.5                  410​=2.5 )。
  
• 批次 B：匀称丧失为 (                                              20                            8                                  =                         2.5                              \frac{20}{8} = 2.5                  820​=2.5 )。
  

如果我们采取丧失匀称的方式，两个批次的丧失匀称值雷同。因此，无论是批次 A 还是批次 B，它们对模子的练习贡献是雷同的。也就是说，每个样本的贡献被"划一化"了。这个方法在样本数差别较大的情况下大概会引入毛病，特殊是当批次巨细不划一时，每个批次的影响大概不成比例。
如果利用丧失的求和：

• 批次 A：总丧失为 10。
  
• 批次 B：总丧失为 20。
  

在这种情况下，两个批次的丧失对模子的影响是按批次巨细加权的。详细来说，批次 B 有更多的样本，以是它的丧失总和较大，也就意味着在梯度更新时，批次 B 会对模子参数的更新产生更大的影响。如果我们将这两个批次的丧失求和，终极总丧失会更大，这会导致模子在练习过程中更多地"倾向"于批次 B，尤其是当利用梯度累积时，批次 B 会对模子产生更大的影响。
为什么丧失求和更故意义？

通过将丧失求和，确保每个样本的丧失对模子更新的影响是等量的。而利用匀称丧失时，由于批次巨细差别，大概会出现以下标题：

• 样本较多的批次（如批次 B）会占据更大的权重，由于匀称值会"稀释"了丧失的影响，使得较大的批次对团体丧失的影响低落。
  
• 样本较少的批次（如批次 A）则大概被忽视，由于它对终极的丧失盘算贡献较小。
  

梯度累积中的影响

在梯度累积中，采取丧失求和可以克制差别批次间因批次巨细差别而导致的权重不均的标题。如许，在举行多次梯度累积时，差别批次的丧失就可以通过求和确保每个样本都具有雷同的影响力。
举个详细的例子：

假设我们有 2 个小批量，分别为 A 和 B，批次巨细分别为 4 和 8。每个批次的总丧失分别为 10 和 20。如果我们直接举行匀称盘算，得到的丧失为：
                                              L                            avg                                  =                                              10                               +                               20                                                 4                               +                               8                                            =                                   30                            12                                  =                         2.5                               L_{\text{avg}} = \frac{10 + 20}{4 + 8} = \frac{30}{12} = 2.5                   Lavg​=4+810+20​=1230​=2.5
而如果我们举行丧失求和，得到的丧失为：
                                              L                            sum                                  =                         10                         +                         20                         =                         30                               L_{\text{sum}} = 10 + 20 = 30                   Lsum​=10+20=30
在举行梯度累积时，采取求和丧失可以克制批次巨细的不平衡影响，从而确保每个样本的贡献是等量的。
如果batch size都一样的话，还会有这个标题吗？

   如果batch size都一样的话，还会有这个标题吗？现实中大规模练习batch size开的不一样吗？
  如果batch size 都一样，那么利用丧失的匀称大概求和不会产生太大的差别。由于在这种情况下，每个批次对模子更新的贡献是平衡的，无论是盘算丧失的匀称值还是求和，终极对模子参数的影响都是划一的。
如果 batch size 雷同：

• 匀称丧失：丧失的匀称值会反映每个样本的丧失在练习中的影响，由于每个样本的数量是雷同的，盘算匀称值不会受到影响。
  
• 求和丧失：由于批次巨细雷同，求和后的丧失也是一个与批次巨细成正比的值，而在练习过程中，更新的频率和力度会基于每个批次的巨细，进而影响练习的稳固性和收敛性。
  

以是，如果每个批次巨细一样，通常来说，不会出现上述标题。两种方式（匀称丧失和求和丧失）的练习结果是差不多的。

---

现实中大规模练习的情况

在现实中的大规模练习中，批次巨细（batch size）通常是差别的，这取决于多个因素，比方：

• 显存限定：差别的硬件装备（如 GPU、TPU）的显存巨细差别，支持的 batch size 也差别。在显存较小的装备上，大概无法一次性处理处罚大量数据，因此会选择较小的批次举行梯度累积，而在显存较大的装备上则可以利用较大的 batch size 举行练习。
  
• 分布式练习：在多卡（multi-GPU）大概多机（multi-node）练习的情况下，为了充实利用盘算资源，批次巨细也会有所差别。通常，跨多个 GPU 或节点分布练习时，为了平衡每个卡上的负载，大概会采取差别的 batch size。
  
• 性能优化：偶然为了加快练习，练习职员大概会根据任务的必要举行优化，选择差别的批次巨细以提升盘算服从。比方，在某些任务中，增大批次巨细可以进步并行服从，但也大概导致练习不稳固，这时就必要举行梯度累积。
  
• 模子计划：有些模子架构（好比必要大输入的模子）大概会必要更大的批次以顺应内存需求，大概为了更高效地练习。
  

---

在大批量练习中为什么利用梯度累积？

即便batch size 差别，如果我们必要模仿一个大批量练习的结果，而且又不能增长显存的利用，我们通常会利用梯度累积来应对这个标题。

• 模仿大批量结果：如果显存不敷，无法处理处罚大批量数据，我们可以通过梯度累积模仿大批量练习的结果。通过在多个小批量上盘算丧失并累积梯度，我们可以到达雷同大批量练习的结果，克制了显存溢出的标题。
  
• 差别批次巨细的影响：如果差别批次的巨细不划一，在盘算丧失时，丧失求和的方式就显得更为紧张了，由于批次巨细较大的批次对总丧失的贡献较大，而匀称丧失的盘算大概会减弱这种差别。而丧失求和方式则会包管较大批次对总丧失的影响相对较大，从而保持了每个样本的影响力划一。
  

---

总结

• 如果batch size 雷同，那么丧失求和和丧失匀称不会有太大差别。
  
• 现实中大规模练习确实大概会有差别的 batch size，尤其是在显存和盘算资源有限的情况下。为了应对这个标题，梯度累积是一个常见的办理方案，用于模仿大批量练习的结果。
  
• 在利用差别巨细的 batch size 时，丧失求和可以大概包管每个样本在练习中的权重划一，而丧失匀称大概会导致较大批次的样本对练习过程的影响被稀释。
  

为什么要除以                                       m                         k                                  m_k               mk​，直接用                                       L                         k                                  L_k               Lk​不可吗?

这是一个非常紧张且值得深入思考的标题。让我们细致分析为什么在梯度累积时，每个小批量的丧失还必要除以 (                                       m                         k                                  m_k               mk​)，即有用token数。
1. 有用token数量的影响

起首必要明白的是，丧失 (                                       L                         k                                  L_k               Lk​) 通常是基于每个小批量的有用token盘算的。每个小批量中的有用token数量（去除添补后的部门）大概是差别的，因此直接用 (                                       L                         k                                  L_k               Lk​) 来累积会导致练习时某些小批量（包罗更多有用token的批次）对终极梯度的贡献过大。
比方：

• 假设有两个批次：批次 1 包罗 3 个有用token，批次 2 包罗 6 个有用token。
  
• 如果我们直接将 (                                             L                            1                                       L_1                  L1​) 和 (                                             L                            2                                       L_2                  L2​) 累加，批次 2 的丧失会占据过多权重，由于它包罗更多有用token。如许会导致更新方向于包罗更多token的批次，从而影响梯度的准确性。
  

2. 丧失求和和匀称的逻辑

不除以 (                                       m                         k                                  m_k               mk​) 的标题：

• 如果不除以有用token数 (                                             m                            k                                       m_k                  mk​)，我们现实上在做丧失累积时忽视了每个批次的“贡献”巨细，特殊是当批次中有用token数量差别较大时。如许会使得丧失盘算不平衡。
  
• 丧失 (                                             L                            k                                       L_k                  Lk​) 并不直接便是每个token的丧失之和，它现实上是对有用token的丧失的总和。以是，批次巨细的差别会导致丧失的总和不成比例地反映出每个批次的有用学习。
  

除以 (                                       m                         k                                  m_k               mk​) 的长处：

• 通过除以每个小批量的有用token数 (                                             m                            k                                       m_k                  mk​)，我们现实上是在对每个小批量的丧失举行“加权匀称”。
  
• 如许做的目的就是包管每个token对终极梯度更新的贡献是公平的，不会由于某个小批量有更多有用token而对终极梯度产生不公道的影响。
  

3. 为什么必要如许做？

假设你利用了梯度累积，目的是模仿大批量练习的结果。如果每个小批量中有用token的数量差别，直接将丧失加起来会导致更大的小批量（含有更多有用token的批次）对终极梯度更新产生更大的影响。为了克制这种毛病，我们必要对每个小批量的丧失举行标准化处理处罚，即通过除以 (                                       m                         k                                  m_k               mk​) 来校准每个小批量的丧失。
数学表明

• 公式：
                                                            L                                  final                                          =                                           1                                  G                                                      ∑                                               k                                     =                                     1                                              G                                                                   L                                     k                                                           m                                     k                                                              L_{\text{final}} = \frac{1}{G} \sum_{k=1}^{G} \frac{L_k}{m_k}                         Lfinal​=G1​k=1∑G​mk​Lk​​
  这里的 (                                                                L                                  k                                                      m                                  k                                                       \frac{L_k}{m_k}                     mk​Lk​​ ) 表现对每个小批量的丧失举行标准化，确保每个小批量在梯度累积中的贡献是按有用token数量来加权的，而不是简朴地将全部小批量的丧失直接加起来。
  

举个简朴的例子

假设我们有两个批次：

• 批次 1：3 个有用token，丧失 (                                             L                            1                                  =                         1.5                              L_1 = 1.5                  L1​=1.5)
  
• 批次 2：6 个有用token，丧失 (                                             L                            2                                  =                         3.0                              L_2 = 3.0                  L2​=3.0)
  

如果我们直接累加丧失：
                                              L                            accumulated                                  =                                   L                            1                                  +                                   L                            2                                  =                         1.5                         +                         3.0                         =                         4.5                               L_{\text{accumulated}} = L_1 + L_2 = 1.5 + 3.0 = 4.5                   Laccumulated​=L1​+L2​=1.5+3.0=4.5
但是，如果我们将丧失除以每个批次的有用token数：
                                              L                            final                                  =                                   1                            2                                            (                                                   L                                  1                                                      m                                  1                                                 +                                                   L                                  2                                                      m                                  2                                                 )                                  =                                   1                            2                                            (                                       1.5                               3                                      +                                       3.0                               6                                      )                                  =                                   1                            2                                            (                            0.5                            +                            0.5                            )                                  =                         0.5                               L_{\text{final}} = \frac{1}{2} \left( \frac{L_1}{m_1} + \frac{L_2}{m_2} \right) = \frac{1}{2} \left( \frac{1.5}{3} + \frac{3.0}{6} \right) = \frac{1}{2} \left( 0.5 + 0.5 \right) = 0.5                   Lfinal​=21​(m1​L1​​+m2​L2​​)=21​(31.5​+63.0​)=21​(0.5+0.5)=0.5
如许做的目的是确保每个批次（无论它的巨细怎样）对丧失的贡献是公平的。如果没有这种标准化，丧失较大的批次会导致终极的梯度更新不准确，方向于更多token的批次。
总结：

除以 (                                             m                            k                                       m_k                  mk​) 的目的是为了对丧失举行标准化处理处罚，确保每个小批量的有用token对梯度累积的贡献是平衡的，特殊是在批次之间有用token数量差别较大的情况下。如许可以克制某些批次因包罗更多有用token而在梯度更新中占据不成比例的权重，从而使练习更加稳固和准确。
跋文

2025年1月18日15点45分于上海， 在OpenAI o1大模子辅助下完成。