Please enable JavaScript.

Coggle requires JavaScript to display documents.

并行训练 (并行策略 (模型并行（Model Parallelism） (分类 (模型计算流水线并行模型计算流水线并行 …

- - - - 模型计算流水线并行
        
        模型计算流水线并行
        
        在处理来自不同流水线的数据更新时进行参数异步更新，不同流水线之间互不影响
        
        在计算一批简单的样例时，允许进行“填充间隙”（空余时间计算别流水线），这可以充分利用空闲的设备资源
      - 模型并行
        
        描述
        分布式系统中的不同机器（GPU/CPU等）负责网络模型的不同部分
        
        例子
        RNN模型并行DeviceWrapper
    - - 系统结构
        
        Client
        
        C++
        
        Python
        
        Java
        
        Others
        
        Client API
        
        执行系统
        
        后端
        
        Distributed Runtime
        
        Distributed Master
        
        Work Services
        
        Worker
        
        Parameter Service
        
        Dataflow Executor
        
        Kernel Implements
        
        Networker Layer
        
        RPC
        
        RDMA
        
        Device Layer
        
        CPU
        
        GPU
        
        TPU
      - 各组件工作原理
        
        client
        
        将整个计算过程转义成一个数据流graph
        
        创建session，通过session，将graph传递给master执行
        
        Distributed Master
        
        基于client在run中指定的节点，从整个完整的graph中截取所需要的subgraph
        
        将所需要执行的subgraph划分成参数更新和迭代优化两部分
        
        在划分好的subgraph上添加所需要的发送和接收接口，为真实任务分发做准备
        
        将subgraph进一步划分成多个pieces，使其可以将每个piece映射到不同的执行设备上
        将每个piece通过分布式task分发到真实的节点去运行
        
        将划分好的pieces缓存起来，以备后面的其他run的触发
        
        Worker Service
        
        处理从master发来的请求
        
        基于接收到的subgraph，规划所需要执行的kernels。将所需要执行的kernels指派给本地的devices，并尽可能的并行执行kernels
        
        与其他task直接进行消息交换，具体化源和目标device的Send和Recv操作
        
        使用cudaMemcpAsync()来进行本地CPU和GPU设备之间的数据传输操作
        
        使用点对点的DMA进行GPU之间的传输，以避免需要通过host CPU主内存进行数据传输的高代价
  - - - 描述
        
        数据并行训练方法都需要一些组合结果和在每个worker之间同步模型参数的方法
      - 根据更新方式分类
        
        参数平均
        
        描述
        
        各个设备根据loss计算各自的gradient，更新各自的参数，然后在一段时间后同步梯度
        
        步骤
        
        根据模型配置随机初始化网络参数
        
        把当前参数分发到每个worker
        
        在数据子集上训练每个worker
        
        在全局参数设置为每个worker上参数的均值
        
        如果还有数据处理，回到第二步
        
        原理
        
        参数平均法的结果在数学意义上等同于用单个机器进行训练
        
        假设该集群有n个工作节点，每个节点处理m个样本，则总共是对nxm个样本求均值。如果我们在单台机器上处理所有nxm个样本，学习率设置为α，权重更新的方程为
        
        假设我们把样本分配到n个工作节点，每个节点在m个样本上进行学习（节点1处理样本1，……，m，节点2处理样本m+1，……，2m，以此类推），则得到
        
        每个工作节点更新参数，并求平均，里面的求和是将数据平均分割成n段数据，求和时截取每一段
        
        因为数据的分布式随机的，所以右边可以合并成这样
        
        如何求平均值？
        
        问题描述
        
        最简单的办法就是简单地将每轮迭代之后的参数进行平均。一旦这样实现了，我们会发现此方法在计算之外的额外开销非常巨大
        
        网络通信和同步的开销也许就能抵消额外机器带来的效率收益
        
        解决方法
        
        设置一个大于1的平均周期averaging period
        
        什么样的平均的周期算是过高
        
        问题描述
        
        如果求均值周期太长，那么每个节点得到的局部参数更多样化，求均值之后的模型效果非常差。我们的想法是N个局部最小值的均值并不保证就是局部最小
        
        解决方法
        
        还没有结论性的回答，究结论（比如[16]）建议平均的周期为每10~20个minibatch计算一次（每个工作节点）能够取得比较好的效果
        
        基于更新（梯度）平局
        
        描述
        
        每个GPU根据loss计算各自的gradient，汇总所有GPU的gradient，求平均梯度，根据平均梯度更新模型参数
        
        步骤
        
        读取数据并根据GPU个数进行均分
        
        使用每个GPU上的minibatch计算损失函数的梯度
        
        通过GPU通信计算梯度的平均值
        
        更新模型
        
        原理
        
        参数平均和基于更新的数据并行之间存在等价关系
        
        等价平均梯度的转换
        
        新W等于旧W减去平均梯度
        
        因为每个节点的旧W都一样，所以等于每个节点求和后平均（在Horovod中因为float的不准确性，会导致参数慢慢就会变得不一样，所以需要定时同步参数）
        
        最后等于梯度平均
        
        这种等价性也适用于多个平均step和其他updater（不仅仅是简单的SGD）
      - 根据同步方式分类
        
        同步数据并行
        
        描述
        等待所有计算节点完成计算后统一更新参数
        
        缺点
        同步数据并行的速度取决于最慢的GPU，当各个GPU的性能相差不大时适用
        
        异步数据并行
        
        描述
        
        在处理来自不同设备的数据更新时进行异步更新，不同设备之间互不影响，对于每一个图副本都有一个单独的客户端线程与其对应
        
        步骤
        
        读取数据并根据GPU个数进行均分
        
        将神经网络中前向过程分配给不同的gpu训练不同的样本
        
        计算平均梯度并共享给其他设备
        
        用上一步计算的梯度更新模型参数
        
        问题
        
        陈旧梯度问题(stale gradient problem)
        
        定义
        
        梯度（更新）的计算需要时间。当worker完成这些计算并将结果应用于全局参数向量时，参数可能已经多次更新
        
        问题描述
        
        平均梯度陈旧度等于worker的数量从生成到完成传输总共需要n-1次
        
        有N个执行器，这意味着在将梯度应用于全局参数向量时，梯度将平均过时N步（每个一步，就是N步）
        
        高梯度过时会显著降低网络收敛速度，甚至会阻止某些配置收敛。早期的异步SGD实现（例如Google的DistBelief系统[2]）没有考虑到这种影响，因此学习效率远远低于原本应有水平
        
        解决方法
        
        基于梯度的陈旧性，针对每次更新ΔWi,j分别缩放值λ。参数服务器不是立即更新全局参数向量，而是等待从n个learner中的(其中1≤s≤n)收集数量s个更新ΔWj
        
        实现‘软’同步协议
        
        使用同步来绑定陈旧性(Use synchronization to bound staleness.)。例如，系统在必要时延迟更快的worker，以确保最大陈旧度低于某个阈值
        
        优点
        
        即使有部分设备性能特别差甚至中途退出训练，对训练结果和训练效率都不会造成太大影响
        
        虽然会有参数抖动，但是整体的趋势是向着最好的结果进行的。所以说这种方式更适用于数据量大，更新次数多的情况
        
        可以在分布式系统中获得更高的吞吐量：worker可以花更多的时间执行有用的计算，而不是等待参数平均步骤完成
        
        worker可能比使用同步（每N步）更新时更快地合并来自其他worker的信息（参数更新）
        
        缺点
        
        陈旧梯度问题(stale gradient problem)：由于设备间互不影响，所以在更新参数时可能其他设备已经更好的更新过了，所以会造成参数的抖动
      - 根据分布方式分类
        
        Parameter Server Architecture
        
        中心化同步
        
        结构
        
        Parameter Server：存放模型参数
        
        Worker：计算参数的梯度
        
        步骤
        
        Worker从PS中获得参数（第一步才有，后面的步骤是下面的循环）
        
        Worker计算的梯度返回给PS
        
        PS聚合从Worker传回的梯度，然后更新参数
        
        PS将新的参数广播给worker
        
        计算量
        
        Worker计算梯度后返回给PS时：(P-1)*N（P是GPU数，N是每个GPU分得的块数）
        
        PS将新的参数广播给worker时：(P-1)*N
        
        缺点
        
        GPU之间的通信是在大规模环境中训练分布式深度学习模型时的众多挑战之一。在所有GPU上交换梯度的延迟是数据并行同步分布式深度学习中的严重瓶颈
        
        Ring-Allreduce Architecture
        
        分布式同步
        
        结构
        
        每一个GPU都是一个Process
        
        步骤
        
        scatter-reduce
        
        每个Process将自己的数组分成P个子数组
        
        第p个process，把chunk[p]发给下一个process
        
        process把接受到的chunk[p-1]和自己的chunk[p-1]一起计算reduce，并把计算后的chunk值发给下一个process
        
        经过P－1次之后，每个process都持有已经reduce过的结果的一部分
        
        allgather
        
        通过p-1次传递，把scatter-reduce中每个process有的数组传输给别的process
        
        计算量
        
        scatter-reduce：N*(P-1)/P（总共N是总份数，每份平均分给P，每次P-1次传输）
        
        allgather：N*(P-1)/P
        
        优点
        
        通信量和P没有关系