[源码解析] 深度学习流水线并行GPipe (2) ----- 梯度累积

0x00 摘要

梯度累积是一种增大训练时 batch size的技术,在本地使用 micro-batch 多次进行正向和反向传播积累梯度后,再进行梯度规约和优化器更新,这是用来均摊通信成本的一种常用策略。本文通过几个框架/库的实现对比,让大家对这个技术有进一步的了解。

0x01 概述

1.1 前文回顾

前文提到,目前分布式模型训练有几个必要并行技术:

  • 流水并行,尤其是如何自动设定流水;
  • 梯度累加(Gradient Accumulation);
  • 后向重计算;
  • 1F1B 策略(我们将采用PipeDream分析);

在前文中,我们介绍了Gpipe如何实施流水线并行技术。本文我们介绍梯度累加(Gradient Accumulation)。

0x02 基本概念

梯度累积是一种用来均摊通信成本的一种常用策略。它在本地使用 micro-batch 多次进行正向和反向传播积累梯度后,再进行梯度规约和优化器更新,相当于扩大了N倍的batch size。

2.1 背景知识

深度学习模型由许多相互连接的层组成,样本在这些层中进行传播,具体传播包含两个过程:前向(forward)过程与反向(backword)过程。

  • 前向过程是从输入计算得到输出。样本在每一步都通过前向传播进行传播,在通过所有层传播后,网络为样本生成预测,然后计算每个样本的损失值,损失值意味着 “对于这个样本,本网络错了多少?”。
  • 然后就是反向过程。神经网络在此过程中计算这些损失值相对于模型参数的梯度。可以认为着就是一个梯度累积的过程。
  • 最后,这些梯度用于计算各个模型参数的更新。

训练中,每个样本的大小由超参数batch size指定,此参数的大小会对最终的模型效果产生很大的影响。一定条件下,batch size设置的越大,模型就会越稳定。

2.2 产生原因

累加梯度顾名思义就是累加后的梯度值。为什么要累加呢?因为运行内存不够用。

在训练模型时,如果一次性将所有训练数据输入到模型,经常会造成内存不足,这时候就需要把一个大 Batch 拆分成若干小批次数据(专业术语为mini-batch)。分成小批次后,带来一个问题,那就是本来应该是所有数据全部送入后计算梯度再更新参数,现在成了每个小批次都要计算梯度更新参数,为了不这么频繁计算梯度,于是就引入了累加梯度。也就是说:

  • 将整个dataset分成多个batch;
  • 分别将每个batch分成多个小批次,将每个小批次喂给神经网络;
  • 每个小批次虽然计算梯度,但是在每次反向传播后,先不进行优化器的迭代更新。
  • 经过若干个小批次后(即一个batch中的所有小批次),用每个小批次计算的梯度的累积和去进行优化器迭代更新参数、梯度清零的操作。

这样就跟把全部数据一次性送入模型进行训练效果一样了。

2.3 本质

梯度累加本质上就是累加 accumulation_stepsbatch_size/accumulation_steps 的梯度, 再根据累加的梯度来更新网络参数,以达到真实梯度类似batch_size 的效果。在使用时,需要注意适当的扩大学习率。

也就是说:

  • 首先将整个dataset分成多个batch,每个 batch size = 32,且假定 accumulation steps = 8
  • 因为 batch size = 32 ,太大了,单机显卡无法跑,于是我们在前向传播的时候以 batch_size = 32 / 8 = 4 来计算梯度;
  • 这样就再分别将每个batch分成多个batch size 为 4 的小批次,将每个小批次逐一喂给神经网络;
  • 每个小批次虽然计算梯度,但是在每次反向传播(在反向传播的时候,会将mean_loss也除以8)后,先不进行优化器的迭代更新。
  • 经过 accumulation steps 个小批次后(即一个batch中的所有小批次),用每个小批次计算梯度的累积和去进行优化器迭代更新参数。
  • 最后进行梯度清零的操作。
  • 处理下一个batch。

这样就跟把 32 batch size 一次性送入模型进行训练效果一样了。

具体如下,时间轴是由左自右:

  1. +-------------------+
  2. | GLOBAL BATCH +--------------------------+
  3. +-------------------+ |
  4. |
  5. |
  6. +<---------------------------------------------------------------------------------+
  7. |
  8. |
  9. | +--------------+ +--------------+ +--------------+ +--------------+
  10. +--> | MINI BATCH 0 +---->+ MINI BATCH 1 +---->+ MINI BATCH 2 +---->+ MINI BATCH 3 |
  11. +-----+--------+ +-------+------+ +------+-------+ +-------+------+
  12. | | | |
  13. | | | |
  14. | | | |
  15. v v v v
  16. +----+-----+ +-----+-----+ +-----+-----+ +----+-----+
  17. | grad 0 | | grad 1 | | grad 2 | | grad 3 |
  18. +----+-----+ +-----+-----+ +-----+-----+ +----+-----+
  19. | | | |
  20. | | | |
  21. | | | |
  22. v v v v
  23. +------+----------------------+-------------------+---------------------+------+
  24. | |
  25. | GLOBAL BATCHGRADIENTS |
  26. | |
  27. +------------------------------------------------------------------------------+
  28. +------------------------------------------------------------------------------------>
  29. Time

2.4 VS 数据并行

micro-batch 跟数据并行有高度的相似性:

  • 数据并行是空间上的,数据被拆分成多个 tensor,同时喂给多个设备并行计算,然后将梯度累加在一起更新。
  • micro-batch 是时间上的数据并行,数据被拆分成多个 tensor,这些 tensor 按照时序依次进入同一个设备串行计算,然后将梯度累加在一起更新。

当总的 batch size 一致,且数据并行的并行度和 micro-batch 的累加次数相等时,数据并行和 Gradient Accumulation 在数学上完全等价。

Gradient Accumulation 通过多个 micro-batch的梯度累加使得下一个 micro-batch 的前向计算不需要依赖上一个 micro-batch 的反向计算,因此可以畅通无阻的进行下去(当然在一个大 batch 的最后一次 micro-batch 还是会触发这个依赖)。

2.5 解决问题

Gradient Accumulation 解决了很多问题:

  • 在单卡下,Gradient Accumulation 可以将一个大的 batch size 拆分成等价的多个小 micro-batch ,从而达到节省显存的目的。
  • 在数据并行下,Gradient Accumulation 解决了反向梯度同步开销占比过大的问题(随着机器数和设备数的增加,梯度的 AllReduce 同步开销也加大),因为梯度同步变成了一个稀疏操作,因此可以提升数据并行的加速比。
  • 在流水线并行下, Gradient Accumulation 使得不同 stage 之间可以并行执行不同的 micro-batch,通过多个 micro-batch的梯度累加使得下一个 micro-batch 的前向计算不需要依赖上一个 micro-batch 的反向计算,因此从而让各个阶段的计算不阻塞,可以畅通无阻的进行下去(当然在一个大 batch 的最后一次 micro-batch 还是会触发这个依赖), 达到流水线的目的。

0x03 PyTorch 梯度累积

3.1 自动累积

PyTorch默认会对梯度进行累加。即,PyTorch会在每一次backward()后进行梯度计算,但是梯度不会自动归零,如果不进行手动归零的话,梯度会不断累加.

至于为什么PyTorch有这样的特点,https://discuss.pytorch.org/t/why-do-we-need-to-set-the-gradients-manually-to-zero-in-pytorch/4903/9 这里给出了一个解释。我们结合其他的解释大致得出如下:

  • 从PyTorch的设计原理上来说,在每次进行前向计算得到预测值时,会产生一个用于梯度回传的计算图,这张图储存了进行反向传播需要的中间结果,当调用了.backward()后,会从内存中将这张图进行释放。

  • 利用梯度累加,可以在最多保存一张计算图的情况下进行多任务的训练。在多任务中,对前面共享的张量进行了多次计算操作后,调用不同任务的backward(),那些张量的梯度会自动累加。

  • 另外一个理由就是在内存大小不够的情况下叠加多个batch的grad作为一个大batch进行迭代,因为二者得到的梯度是等价的。

  • 由于PyTorch的动态图和autograd机制,导致并没有一个确切的点知道何时停止前向操作,因为你不知道什么时候一个计算会结束以及什么时候又会有一个新的开始。所以自动设置梯度为 0 比较棘手。

3.2 代码示例

下面给出一个传统代码示例:

  1. for i,(images,target) in enumerate(train_loader):
  2. # 1. input output
  3. images = images.cuda(non_blocking=True)
  4. target = torch.from_numpy(np.array(target)).float().cuda(non_blocking=True)
  5. outputs = model(images)
  6. loss = criterion(outputs,target)
  7. # 2. backward
  8. optimizer.zero_grad() # reset gradient
  9. loss.backward()
  10. optimizer.step()

然后给出一个梯度累积示例:

  • 获取loss: 输入图像和标签,通过计算得到预测值,计算损失函数;
  • loss.backward()反向传播,计算当前梯度;
  • 多次循环步骤 1-2, 不清空梯度,使梯度累加在已有梯度上;
  • 梯度累加一定次数后,先optimizer.step()根据累积的梯度更新网络参数,然后optimizer.zero_grad()清空过往梯度,为下一波梯度累加做准备;
  1. for i, (images, target) in enumerate(train_loader):
  2. # 1. input output
  3. images = images.cuda(non_blocking=True)
  4. target = torch.from_numpy(np.array(target)).float().cuda(non_blocking=True)
  5. outputs = model(images) # 前向传播
  6. loss = criterion(outputs, target) # 计算损失
  7. # 2. backward
  8. loss.backward() # 反向传播,计算当前梯度
  9. # 3. update parameters of net
  10. if ((i+1)%accumulation)==0:
  11. # optimizer the net
  12. optimizer.step() # 更新网络参数
  13. optimizer.zero_grad() # reset grdient # 清空过往梯度

3.3 DistributedDataParallel 的梯度累积

DistributedDataParallel(DDP)在module级别实现数据并行性。其使用torch.distributed包communication collectives来同步梯度,参数和缓冲区。并行性在单个进程内部和跨进程均有用。

在这种情况下,虽然gradient accumulation 也一样可以应用,但是为了提高效率,需要做相应的调整。

3.3.1 单卡模型梯度累计

我们首先回忆单卡模型,即普通情况下如何进行梯度累加。

  1. # 单卡模式,即普通情况下的梯度累加
  2. for data in enumerate(train_loader # 每次梯度累加循环
  3. optimizer.zero_grad()
  4. for _ in range(K):
  5. prediction = model(data / K)
  6. loss = loss_fn(prediction, label) / K
  7. loss.backward() # 积累梯度,不应用梯度改变,执行K次
  8. optimizer.step() # 应用梯度更新,更新网络参数,执行一次

在 loss.backward() 语句处,DDP会进行梯度规约 all_reduce。

因为每次梯度累加循环之中有K个步骤,所以有K次 all_reduce。但实际上,每次梯度累加循环中,optimizer.step()只有一次,这意味着我们这K次 loss.backward() 之中,其实只进行一次 all_reduce 即可,前面 K - 1 次 all_reduce 是没有用的

3.3.2 DDP如何加速

于是我们就思考,是否可以在 loss.backward() 之中有一个开关,使得我们在前面K-1次 loss.backward() 之中只做反向传播,不做梯度同步(累积)

DDP 已经想到了这个问题,它提供了一个暂时取消梯度同步的context函数 no_sync()。在no_sync()context之下,DDP不会进行梯度同步。但是在no_sync()上下文结束之后的第一次 forward-backward 会进行同步。

最终代码如下:

  1. model = DDP(model)
  2. for data in enumerate(train_loader # 每次梯度累加循环
  3. optimizer.zero_grad()
  4. for _ in range(K-1):# K-1step 不进行梯度同步(累积梯度)。
  5. with model.no_sync(): # 这里实施“不操作”
  6. prediction = model(data / K)
  7. loss = loss_fn(prediction, label) / K
  8. loss.backward() # 积累梯度,不应用梯度改变
  9. prediction = model(data / K)
  10. loss = loss_fn(prediction, label) / K
  11. loss.backward() # 第K个step 进行梯度同步(累积梯度)
  12. optimizer.step() # 应用梯度更新,更新网络参数

3.3.3 no_sync实现

no_sync 的代码如下:

  1. @contextmanager
  2. def no_sync(self):
  3. r"""
  4. A context manager to disable gradient synchronizations across DDP
  5. processes. Within this context, gradients will be accumulated on module
  6. variables, which will later be synchronized in the first
  7. forward-backward pass exiting the context.
  8. Example::
  9. >>> ddp = torch.nn.parallel.DistributedDataParallel(model, pg)
  10. >>> with ddp.no_sync():
  11. >>> for input in inputs:
  12. >>> ddp(input).backward() # no synchronization, accumulate grads
  13. >>> ddp(another_input).backward() # synchronize grads
  14. """
  15. old_require_backward_grad_sync = self.require_backward_grad_sync
  16. self.require_backward_grad_sync = False
  17. try:
  18. yield
  19. finally:
  20. self.require_backward_grad_sync = old_require_backward_grad_sync

具体如何使用?我们在 DistributedDataParallel 的 forward 方法中可以看到,只有在 require_backward_grad_sync 为 True时候,才会调用reducer.prepare_for_forward() 和 reducer.prepare_for_backward,才会把require_forward_param_sync 设置为 True。

  1. def forward(self, *inputs, **kwargs):
  2. with torch.autograd.profiler.record_function("DistributedDataParallel.forward"):
  3. self.reducer.save_thread_local_state()
  4. if torch.is_grad_enabled() and self.require_backward_grad_sync:
  5. # True时候才会进入
  6. self.logger.set_runtime_stats_and_log()
  7. self.num_iterations += 1
  8. self.reducer.prepare_for_forward()
  9. # 省略部分代码
  10. if torch.is_grad_enabled() and self.require_backward_grad_sync:
  11. # True时候才会进入
  12. self.require_forward_param_sync = True
  13. if self.find_unused_parameters and not self.static_graph:
  14. # Do not need to populate this for static graph.
  15. self.reducer.prepare_for_backward(list(_find_tensors(output)))
  16. else:
  17. self.reducer.prepare_for_backward([])
  18. else:
  19. self.require_forward_param_sync = False
  20. # 省略部分代码

再看看 Reducer的两个方法。

prepare_for_forward 只是做统计工作,可以忽略。

  1. void Reducer::prepare_for_forward() {
  2. std::lock_guard<std::mutex> lock(mutex_);
  3. num_iterations_++;
  4. if (should_collect_runtime_stats()) {
  5. record_forward_compute_start_time();
  6. }
  7. }

prepare_for_backward 会做重置和预备工作,与梯度累积相关的是 expect_autograd_hooks_ = true

  1. void Reducer::prepare_for_backward(
  2. const std::vector<torch::autograd::Variable>& outputs) {
  3. std::lock_guard<std::mutex> lock(mutex_);
  4. // Reset accounting.
  5. expect_autograd_hooks_ = true; // 这里是关键
  6. reset_bucket_counting();
  7. // Reset unused parameter accounting.
  8. has_marked_unused_parameters_ = false;
  9. // Reset per iteration marked ready parameters.
  10. perIterationReadyParams_.clear();
  11. // If static graph is not set, search graph to detect unused parameters.
  12. // When static graph is set, unused_parameters_ will be detected and will
  13. // not change after 1st iteration.
  14. // If static_graph_ = false and find_unused_parameters_ is false,
  15. // we assume that autograd hooks for ALL variables will be called,
  16. // and we don't have to search the autograd graph for presence of these hooks.
  17. if (dynamic_graph_find_unused()) {
  18. unused_parameters_.clear();
  19. search_unused_parameters(outputs);
  20. }
  21. }

expect_autograd_hooks_ = true 如何使用?在 Reducer::autograd_hook 之中有,如果不需要进行all-reduce操作,则直接返回。

  1. void Reducer::autograd_hook(VariableIndex index) {
  2. std::lock_guard<std::mutex> lock(this->mutex_);
  3. // Carry over thread local state from main thread. This allows for
  4. // thread-local flags such as profiler enabled to be configure correctly.
  5. at::ThreadLocalStateGuard g(thread_local_state_);
  6. // Ignore if we don't expect to be called.
  7. // This may be the case if the user wants to accumulate gradients
  8. // for number of iterations before reducing them.
  9. if (!expect_autograd_hooks_) { // 如果不需要进行all-reduce操作,则直接返回。
  10. return;
  11. }
  12. // 省略后续代码

有点绕,我们梳理一下:

一个 step 有两个操作:forward 和 backward。

  • forward 操作时候 :require_backward_grad_sync = True 意味着 forward 时候

    • 设置 require_forward_param_sync = True。
    • 会调用reducer.prepare_for_forward() 和 reducer.prepare_for_backward
    • reducer.prepare_for_backward 意味着会设置 expect_autograd_hooks_ = true,expect_autograd_hooks_是关键。
  • backward 操作时候
    • expect_autograd_hooks_ = true 意味着 backward 时候进行 进行all-reduce操作。
    • 否则直接返回,不做 all-reduce操作。

即如下图,

  • 上半部分是 forward 的逻辑,就是 forward()函数,
  • 下半部分是 backward 逻辑,就是 Reducer::autograd_hook() 函数。
  • expect_autograd_hooks_ 是forward 和 backward 之间串联的关键之处。
  1. forward
  2. +---------------------------------------------------------------------------------+
  3. | forward() |
  4. | |
  5. | require_backward_grad_sync == True?? +---------+ |
  6. | + | |
  7. | | | |
  8. | | Yes | |
  9. | | | No |
  10. | v | |
  11. | reducer.prepare_for_forward | |
  12. | + | |
  13. | | | |
  14. | | | |
  15. | v | |
  16. | reducer.prepare_for_backward | |
  17. | + | |
  18. | | | |
  19. | | | |
  20. | v v |
  21. | expect_autograd_hooks_ = true expect_autograd_hooks_ = false |
  22. | + + |
  23. | | | |
  24. +---------------------------------------------------------------------------------+
  25. | |
  26. +--------------------------------------------------------------------------------+
  27. backward | |
  28. | |
  29. +--------------------------------------------------------------------------------+
  30. | | | |
  31. | Reducer::autograd_hook() | | |
  32. | | | |
  33. | | +----------------------------+ |
  34. | | | |
  35. | | | |
  36. | v v |
  37. | expect_autograd_hooks_ == True?? +------------+ |
  38. | + | |
  39. | | Yes | |
  40. | | | No |
  41. | v v |
  42. | Do All-Reduce Return |
  43. | |
  44. | |
  45. +--------------------------------------------------------------------------------+

no_sync 操作就 意味着设置 require_backward_grad_sync = False,最终设置了 expect_autograd_hooks_ = False。这样,backward 时候就不会进行 All-Reduce 操作

0x04 Tensorflow实现

在 pytorch 中,梯度只要不清零默认是累加的,于是很容易实现上述问题。但在Tensorflow中,却不那么容易。

我们从 stackoverflow 得到示例代码如下:

  1. ## 定义优化器
  2. opt = tf.train.AdamOptimizer()
  3. ## 得到你模型中的所有可训练变量
  4. tvs = tf.trainable_variables()
  5. # 用于记录每个变量的累积梯度,初始化为0s
  6. accum_vars = [tf.Variable(tf.zeros_like(tv.initialized_value()), trainable=False) for tv in tvs]
  7. # 定义清零操作
  8. zero_ops = [tv.assign(tf.zeros_like(tv)) for tv in accum_vars]
  9. ## 使用优化器的compute_gradients来计算梯度
  10. gvs = opt.compute_gradients(rmse, tvs)
  11. ## 将当前梯度累加在之前定义的变量上
  12. accum_ops = [accum_vars[i].assign_add(gv[0]) for i, gv in enumerate(gvs)]
  13. ## 定义训练step,梯度下降,更新参数
  14. train_step = opt.apply_gradients([(accum_vars[i], gv[1]) for i, gv in enumerate(gvs)])
  15. ## 训练循环
  16. while ...:
  17. # 使用 zero_ops 初始化
  18. sess.run(zero_ops)
  19. # 使用accum_ops对accum_vars进行'n_minibatches'次梯度累积
  20. for i in xrange(n_minibatches):
  21. sess.run(accum_ops, feed_dict=dict(X: Xs[i], y: ys[i]))
  22. # 使用累积的梯度进行参数更新
  23. sess.run(train_step)

0x05 Gpipe实现

在 GPipe 的流水并行示例中,每个“时间点” 可以在多个阶段(stage)上同时做不同的micro-batch,图中每个方块中的标号表示了第几个 micro-batch;同一个 micro-batch 还是串行的经过所有的 stage,在这种情况下,每个设备的空闲时间只有 25% 左右。

具体代码如下:

5.1 优化器

在 lingvo/core/optimizer.py 中 GradientAggregationOptimizer 中有具体实现,关键代码为apply_gradients,逻辑为:

  • 如果 _num_micro_batches 为 1,则说明不用梯度累积,直接 apply_gradients;
  • 遍历 grads_and_vars 列表,累积梯度;
  • accum_step 为梯度累积条件:
    • 如果达到了小批次迭代数目,则调用 _ApplyAndReset:

      • 调用 apply_gradients 应用梯度;
      • 调用 zero_op 清零梯度;
    • 否则就调用_Accum,实际上是 no_op不做操作;

具体代码如下:

  1. def apply_gradients(self, grads_and_vars, global_step=None, name=None):
  2. if self._num_micro_batches == 1:
  3. return self._opt.apply_gradients(grads_and_vars, global_step)
  4. global_step = global_step or py_utils.GetOrCreateGlobalStepVar()
  5. with tf.init_scope():
  6. self._create_slots([v for (_, v) in grads_and_vars])
  7. accums = []
  8. variables = []
  9. # 遍历,累积梯度
  10. for g, v in grads_and_vars:
  11. accum = self.get_slot(v, 'grad_accum')
  12. variables.append(v)
  13. # pytype: disable=attribute-error
  14. if isinstance(g, tf.IndexedSlices):
  15. scaled_grad = tf.IndexedSlices(
  16. g.values / self._num_micro_batches,
  17. g.indices,
  18. dense_shape=g.dense_shape)
  19. else:
  20. scaled_grad = g / self._num_micro_batches
  21. accum_tensor = accum.read_value()
  22. accums.append(accum.assign(accum_tensor + scaled_grad))
  23. # pytype: enable=attribute-error
  24. # 应用梯度,清零梯度
  25. def _ApplyAndReset():
  26. normalized_accums = accums
  27. if self._apply_crs_to_grad:
  28. normalized_accums = [
  29. tf.tpu.cross_replica_sum(accum.read_value()) for accum in accums
  30. ]
  31. apply_op = self._opt.apply_gradients(
  32. list(zip(normalized_accums, variables)))
  33. with tf.control_dependencies([apply_op]):
  34. zero_op = [tf.assign(accum, tf.zeros_like(accum)) for accum in accums]
  35. return tf.group(zero_op, tf.assign_add(global_step, 1))
  36. # 累积函数,其实是不做操作
  37. def _Accum():
  38. return tf.no_op()
  39. # 梯度累积条件,如果达到了小批次迭代数目,则应用梯度,清零梯度,否则就不做操作
  40. accum_step = tf.cond(
  41. tf.equal(
  42. tf.math.floormod(self._counter + 1, self._num_micro_batches), 0),
  43. _ApplyAndReset, # Apply the accumulated gradients and reset.
  44. _Accum) # Accumulate gradients.
  45. with tf.control_dependencies([tf.group(accums)]):
  46. return tf.group(accum_step, tf.assign_add(self._counter, 1))

5.2 包装器

ShardedAdam 是给 GradientAggregationOptimizer 和 ShardedAdamOptimizer 做了包装,用户可以直接使用。

  1. class ShardedAdam(optimizer.Adam):
  2. """Adam optimizer wrapper that shards the slot variables."""
  3. @classmethod
  4. def Params(cls):
  5. params = super().Params()
  6. params.Define('num_micro_batches', 1, 'Number of accumulated batches.')
  7. return params
  8. def GetOptimizer(self, lr):
  9. p = self.params
  10. opt = ShardedAdamOptimizer(
  11. learning_rate=lr,
  12. beta1=p.beta1,
  13. beta2=p.beta2,
  14. epsilon=p.epsilon,
  15. name=p.name)
  16. if p.num_micro_batches > 1:
  17. tf.logging.info('Applying gradient aggregation.')
  18. opt = optimizer.GradientAggregationOptimizer( # 应用梯度累积
  19. opt, p.num_micro_batches, apply_crs_to_grad=True)
  20. self._cached_opt = opt
  21. return opt

5.3 应用

DenseLm12kWide41BAdam16x16 中有如何使用 ShardedAdam。

  1. @model_registry.RegisterSingleTaskModel
  2. class DenseLm12kWide41BAdam16x16(DenseLm128B16x16):
  3. """41B params LM model with 2D split and ADAM optimizer on v3-512."""
  4. # Each layer has 1.6875B parameters.
  5. SEQUENCE_LENGTH = 2048
  6. NUM_DEVICES_PER_SPLIT = 512
  7. BATCH_DIM_PER_DEVICE = 0.5 # Total batch size 256
  8. DEVICE_MESH_SHAPE = [16, 32]
  9. DEVICE_MESH = gshard_utils.GetNonPod2dMesh(DEVICE_MESH_SHAPE, [16, 16, 2])
  10. NUM_TRANSFORMER_LAYERS = 24
  11. HIDDEN_DIM = 48 * 1024
  12. MODEL_DIM = 12 * 1024
  13. NUM_HEADS = 96
  14. ATTENTION_KEY_VALUE_DIM = 128
  15. GATED_GELU = False
  16. POSITIONAL_EMBEDDING = True
  17. NUM_MICRO_BATCHES = 1
  18. def Task(self):
  19. p = super().Task()
  20. # 使用ShardedAdam
  21. p.train.optimizer = ShardedAdam.Params().Set(
  22. beta1=0.9,
  23. beta2=0.999,
  24. epsilon=1e-6,
  25. num_micro_batches=self.NUM_MICRO_BATCHES)
  26. return p

0xFF 参考

[原创][深度][PyTorch] DDP系列第三篇:实战与技巧

[源码解析] 深度学习流水线并行GPipe (2) ----- 梯度累积的更多相关文章

  1. [源码解析] 深度学习流水线并行Gpipe(1)---流水线基本实现

    [源码解析] 深度学习流水线并行Gpipe(1)---流水线基本实现 目录 [源码解析] 深度学习流水线并行Gpipe(1)---流水线基本实现 0x00 摘要 0x01 概述 1.1 什么是GPip ...

  2. [源码解析] 深度学习流水线并行 GPipe(3) ----重计算

    [源码解析] 深度学习流水线并行 GPipe(3) ----重计算 目录 [源码解析] 深度学习流水线并行 GPipe(3) ----重计算 0x00 摘要 0x01 概述 1.1 前文回顾 1.2 ...

  3. [源码解析] 深度学习流水线并行 PipeDream(2)--- 计算分区

    [源码解析] 深度学习流水线并行 PipeDream(2)--- 计算分区 目录 [源码解析] 深度学习流水线并行 PipeDream(2)--- 计算分区 0x00 摘要 0x01 前言 1.1 P ...

  4. [源码解析] 深度学习流水线并行 PipeDream(3)--- 转换模型

    [源码解析] 深度学习流水线并行 PipeDream(3)--- 转换模型 目录 [源码解析] 深度学习流水线并行 PipeDream(3)--- 转换模型 0x00 摘要 0x01 前言 1.1 改 ...

  5. [源码解析] 深度学习流水线并行 PipeDream(4)--- 运行时引擎

    [源码解析] 深度学习流水线并行 PipeDream(4)--- 运行时引擎 目录 [源码解析] 深度学习流水线并行 PipeDream(4)--- 运行时引擎 0x00 摘要 0x01 前言 1.1 ...

  6. [源码解析] 深度学习流水线并行 PipeDream(5)--- 通信模块

    [源码解析] 深度学习流水线并行 PipeDream(5)--- 通信模块 目录 [源码解析] 深度学习流水线并行 PipeDream(5)--- 通信模块 0x00 摘要 0x01 前言 0x02 ...

  7. [源码解析] 深度学习流水线并行 PipeDream(6)--- 1F1B策略

    [源码解析] 深度学习流水线并行 PipeDream(6)--- 1F1B策略 目录 [源码解析] 深度学习流水线并行 PipeDream(6)--- 1F1B策略 0x00 摘要 0x01 流水线比 ...

  8. [源码解析] 深度学习流水线并行之PopeDream(1)--- Profile阶段

    [源码解析] 深度学习流水线并行之PopeDream(1)--- Profile阶段 目录 [源码解析] 深度学习流水线并行之PopeDream(1)--- Profile阶段 0x00 摘要 0x0 ...

  9. [源码解析] 深度学习分布式训练框架 Horovod (1) --- 基础知识

    [源码解析] 深度学习分布式训练框架 Horovod --- (1) 基础知识 目录 [源码解析] 深度学习分布式训练框架 Horovod --- (1) 基础知识 0x00 摘要 0x01 分布式并 ...

随机推荐

  1. HMAC简介及HMAC-SHA256实现Demo

    一.什么是HMAC HMAC是一种使用单向散列函数来构造消息认证码的方法,其中HMAC中的H就是Hash的意思. HMAC中所使用的单向散列函数并不仅限于一种,任何高强度的单向散列函数都可以被用于HM ...

  2. 题解 guP4552 IncDec Sequence

    这道题是一道差分的题目 差分数组p即p[i]=a[i]-a[i-1] 如果我们把一个区间[l,r]里的数+1,那么我们不难发现p[l]'=a[l]+1-a[l-1]=p[l]+1,p[r+1]'=a[ ...

  3. 让我手把手教你写一个强大、方便使用的 IOC 容器

    一.介绍 1.介绍 最近无聊,也没什么事做,没事做总是要给自己找点事情做吧,毕竟人的生活在与折腾.于是,决定自己手动写一个 IOC 的框架.我们知道在 NetCore 的版本里面已经内置了 IOC 容 ...

  4. python使用笔记26--多线程、多进程

    1.概念 线程.进程 进程是资源的集合,也就是一个程序 线程是一个程序运行的最小单位 线程是在进程里面的 默认,一个进程就只有一个线程 一个电脑有几核CPU就只能同时运行几个任务,比如4核CPU只能同 ...

  5. JAVA基础(代码)练习题61~90

    JAVA基础 61.设计一个方法打印数组{'a','r','g','s','e','r'}中下标为1和3的的元素 package Homework_90; /** * 设计一个方法打印数组{'a',' ...

  6. P2014选课

    洛谷P2014选课 一道树形DP题. f[i][j]表示i个点选j门课程的最大学分. 递推方程: for(int a=n;a>0;a--)//总共选择多少 for(int b=0;b<a; ...

  7. 【洛谷P1140 相似基因】动态规划

    分析 f[i][j] 表示 1数组的第i位和2数组的第j位匹配的最大值 f[1][1]=-2 f[2][1]=-2+5=3 f[3][1]=-2+5+5=8 三个决策: 1.由f[i-1][j-1]直 ...

  8. 将base64Url对应图片保存到本地

    上图中的内容就是base64编码之后对应的Url  图中base64,之前的都是用于声明该图片的格式以及它的编码格式  base64,之后的就是该图片对应的数据了 我们只需要把数据转换为字节保存下来即 ...

  9. odoo ORM中的filed的关系映射的使用详解1

    前言 前面我们详细讲解了odoo ORM中fields中的常见属性的使用,根据不同的属性可以对字段进行不同的限制操作,比如readonly只读,store是否存储到数据库.今天我们继续研究ORM中的关 ...

  10. 对一个sql的分析

    select * FROM LPEdorItem a, LCCont b, LPEdorApp c WHERE a.edoracceptno = c.edoracceptno and a.ContNo ...