`

tensorflow 单机多卡示例--数据并行

 
阅读更多
本文参考自官方的cifar10分类示例:
https://www.tensorflow.org/tutorials/deep_cnn/

多机多卡(未验证):


本文只保留了必要的代码, 更适合于概念的理解。

在tensorflow中,变量是复用的,变量通过变量名唯一确定。
计算图也会和设备绑定,如果一个图计算时需要用到变量a,而变量a不在该设备上,则会自动生成相应的通信代码,将变量a加载到该设备上。因而,变量的存放设备对于程序的正确性没有影响,但会导致通信开销有所差异。


测试结果: 对于全连接网络,通信开销占比大,,,单卡最为理想。。。
网络大小:输入2000*600, 中间层: 512, 128, 128, 1
运行时间:单位:秒




# coding=utf-8
'''
Created on Jan 4, 2017
@author: colinliang

tensorflow 单机多卡程序示例, 
参考: tensorflow示例cifar10_multi_gpu_train.py
'''
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf
import numpy as np

def _allocate_variable(name, shape, initializer, dtype=tf.float32):
    # 分配变量,Tensorflow 会自动处理变量在不同设备间的通信问题,因而可以放在GPU上,也可以放在CPU上
    # 如果是单机单卡,都放在GPU上比较快 (无需显式指定device, tf自动分配即可)
    # 如果是单机多卡,则放在CPU上略快;  可能是我这里使用了SLI连接两块GPU,GPU间通信速度还算可以
    with tf.device('/cpu:0'): #强制放在主内存上
#     with tf.device(None): # 默认放在当前设备上
        var = tf.get_variable(name, shape, initializer=initializer, dtype=dtype)
    print('%s: %s' % (var.op.name, var.device))
    return var

# 创建网络 y=xw+b
def tower(input_tensor, target_tensor, scope, dims=[]):
    for i, d in enumerate(dims):
        with tf.variable_scope('affine%d' % i) as varscope:  # 仅仅用于生成变量的全名,与存放设备无关
            w = _allocate_variable('w', shape=[input_tensor.get_shape()[1], d], initializer=tf.truncated_normal_initializer(0, 1));
            b = _allocate_variable('b', shape=[], initializer=tf.zeros_initializer);
        input_tensor = tf.matmul(input_tensor, w) + b;
        input_tensor = tf.nn.relu(input_tensor)
    
    with tf.variable_scope('affine_last') as varscope:  # 仅仅用于生成变量的全名,与存放设备无关
#         w = _allocate_variable('w', shape=[input_tensor.get_shape()[1], 1], initializer=tf.truncated_normal_initializer(0, 1));
        w = _allocate_variable('w', shape=[input_tensor.get_shape()[1], 1], initializer=tf.constant_initializer(value=1));
        b = _allocate_variable('b', shape=[], initializer=tf.zeros_initializer);
    
    y = tf.matmul(input_tensor, w) + b;
    l = tf.reduce_mean(tf.square(y - target_tensor));
    tf.add_to_collection('losses', l)
    return y, l

# 合并所有tower上的梯度,取平均, 对于单机多卡程序,这段代码是通用的
def average_tower_grads(tower_grads):
    print('towerGrads:')
    idx = 0
    for grads in tower_grads:  # grads 为 一个list,其中元素为 梯度-变量 组成的二元tuple
        print('grads---tower_%d' % idx)
        for g_var in grads:
            print(g_var)
            print('\t%s\n\t%s' % (g_var[0].op.name, g_var[1].op.name))
#             print('\t%s: %s'%(g_var[0].op.name,g_var[1].op.name))
        idx += 1
    
    if(len(tower_grads) == 1):
        return tower_grads[0]
    avgGrad_var_s = []
    for grad_var_s in zip(*tower_grads):
        grads = []
        v = None
        for g, v_ in grad_var_s:
            g = tf.expand_dims(g, 0)
            grads.append(g)
            v = v_
        all_g = tf.concat(0, grads)
        avg_g = tf.reduce_mean(all_g, 0, keep_dims=False)
        avgGrad_var_s.append((avg_g, v));
    return avgGrad_var_s

# 方案1 ,每组输入分别用对应的placeholder作为输入;  未测试
def generate_towers_v1(NUM_GPU=2):  
    
    input_tensors = []
    target_tensors = []
    
    towerGrads = []
    lr = 1e-3
    opt = tf.train.AdamOptimizer(lr)
    
    for i in range(NUM_GPU):
        with tf.device('/gpu:%d' % i):
            with tf.name_scope('tower_%d' % i) as scope:
                input_tensor = tf.placeholder(tf.float32, shape=[None, 1], name='input_%d' % i);
                input_tensors.append(input_tensor)
                target_tensor = tf.placeholder(tf.float32, shape=[None, 1], name='target_%d' % i);
                target_tensors.append(target_tensor)
                y, loss = tower(input_tensor=input_tensor, target_tensor=target_tensor, scope=scope)
                # Reuse variables for the next tower.
                tf.get_variable_scope().reuse_variables()
                grads = opt.compute_gradients(loss)
                towerGrads.append(grads)
    avgGrad_var_s = average_tower_grads(towerGrads)
    apply_gradient_op = opt.apply_gradients(avgGrad_var_s, global_step=None)
    loss = tf.Print(loss, data=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES))
    return input_tensors, target_tensors, y, loss, apply_gradient_op

# 方案2: 一组placeholder, 再根据tower数量分割成n组输入,分别送人对应的tower
def generate_towers_v2(NUM_GPU=2, dim_in=1, dims=None, batch_size=None):   
    if(dims is None): dims = []
    
    input_tensor = tf.placeholder(tf.float32, shape=[batch_size, dim_in], name='input');
    target_tensor = tf.placeholder(tf.float32, shape=[batch_size, dim_in], name='target');
    input_tensors = tf.split(0, NUM_GPU, input_tensor)  # batch_size必须可以被dim_in整除
    target_tensors = tf.split(0, NUM_GPU, target_tensor)
    
    towerGrads = []
    lr = 1e-2
    opt = tf.train.AdamOptimizer(lr)  # 与GradientDescentOptimizer相比,会自动分配一些中间变量
    opt = tf.train.GradientDescentOptimizer(lr)
    for i in range(NUM_GPU):
        with tf.device('/gpu:%d' % i):
            with tf.name_scope('tower_%d' % i) as scope:
                input_sub = input_tensors[i]
                print("device:%s" % input_sub.device)
                target_sub = target_tensors[i]
                y, loss = tower(input_tensor=input_sub, target_tensor=target_sub, scope=scope, dims=dims)
                # Reuse variables for the next tower.
                tf.get_variable_scope().reuse_variables()
                grads = opt.compute_gradients(loss)
                towerGrads.append(grads)
    avgGrad_var_s = average_tower_grads(towerGrads)
    loss = tf.Print(loss, data=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES))
    
    apply_gradient_op = opt.apply_gradients(avgGrad_var_s, global_step=None)
    
    print('ALL variables:')
    for v in tf.all_variables():
        print('\t%s' % v.op.name)
    
    return input_tensor, target_tensor, y, loss, apply_gradient_op
        
if __name__ == '__main__':
    sess = tf.Session()
    NUM_GPU = 1  # 由于只有两块GPU,如果设为3,会报错:Could not satisfy explicit device specification '/device:GPU:2'
    dim_in = 600; # 输入变量x 的维度
    dims = [512, 128, 128] #隐层单元数,设置为[]时表示 y=xw+b的线性变换,否则表示多层的全连接网络
    batch_size = 2000; 
    
    input_tensor, target_tensor, y, loss, apply_gradient_op = generate_towers_v2(NUM_GPU=NUM_GPU, dim_in=dim_in, dims=dims)
    sess.run(tf.initialize_all_variables())
    
    inputs = np.random.rand(batch_size, dim_in)
    targets = inputs * 2 + 1;
    feed_dict = {input_tensor:inputs, target_tensor:targets}
    
    import time
    tstart = time.time()
    for i in range(10000):
#         _, l = sess.run([apply_gradient_op, loss], feed_dict=feed_dict)  #will print w, b
#         print(l)
        sess.run([apply_gradient_op], feed_dict=feed_dict)  # do not print w, b
    telapse = time.time() - tstart
    print(u'%d块GPU用时: %.2fs' % (NUM_GPU, telapse))


示例输出:
引用
affine0/w: /device:CPU:0
affine0/b: /device:CPU:0
affine1/w: /device:CPU:0
affine1/b: /device:CPU:0
affine2/w: /device:CPU:0
affine2/b: /device:CPU:0
affine_last/w: /device:CPU:0
affine_last/b: /device:CPU:0
towerGrads:
grads---tower_0
(<tf.Tensor 'tower_0/gradients/tower_0/MatMul_grad/tuple/control_dependency_1:0' shape=(600, 512) dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c7144d0>)
tower_0/gradients/tower_0/MatMul_grad/tuple/control_dependency_1
affine0/w
(<tf.Tensor 'tower_0/gradients/tower_0/add_grad/tuple/control_dependency_1:0' shape=() dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c7140d0>)
tower_0/gradients/tower_0/add_grad/tuple/control_dependency_1
affine0/b
(<tf.Tensor 'tower_0/gradients/tower_0/MatMul_1_grad/tuple/control_dependency_1:0' shape=(512, 128) dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c7146d0>)
tower_0/gradients/tower_0/MatMul_1_grad/tuple/control_dependency_1
affine1/w
(<tf.Tensor 'tower_0/gradients/tower_0/add_1_grad/tuple/control_dependency_1:0' shape=() dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c6cb850>)
tower_0/gradients/tower_0/add_1_grad/tuple/control_dependency_1
affine1/b
(<tf.Tensor 'tower_0/gradients/tower_0/MatMul_2_grad/tuple/control_dependency_1:0' shape=(128, 128) dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c6cb750>)
tower_0/gradients/tower_0/MatMul_2_grad/tuple/control_dependency_1
affine2/w
(<tf.Tensor 'tower_0/gradients/tower_0/add_2_grad/tuple/control_dependency_1:0' shape=() dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c6f48d0>)
tower_0/gradients/tower_0/add_2_grad/tuple/control_dependency_1
affine2/b
(<tf.Tensor 'tower_0/gradients/tower_0/MatMul_3_grad/tuple/control_dependency_1:0' shape=(128, 1) dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c6f47d0>)
tower_0/gradients/tower_0/MatMul_3_grad/tuple/control_dependency_1
affine_last/w
(<tf.Tensor 'tower_0/gradients/tower_0/add_3_grad/tuple/control_dependency_1:0' shape=() dtype=float32>, <tensorflow.python.ops.variables.Variable object at 0x7f8b6c69f950>)
tower_0/gradients/tower_0/add_3_grad/tuple/control_dependency_1
affine_last/b
ALL variables:
affine0/w
affine0/b
affine1/w
affine1/b
affine2/w
affine2/b
affine_last/w
affine_last/b
  • 大小: 13.3 KB
分享到:
评论

相关推荐

    Resnet实战:单机多卡DDP方式、混合精度训练

    本例提取了植物幼苗数据集中的部分数据做数据集,数据集共有12种类别,模型使用最经典的resnet50,演示如何实现混合精度训练以及如何使用DDP的方式实现多卡并行训练。 通过本文你和学到: 1、如何使用混合精度训练...

    「分布式训练」+ DDP单机多卡并行指南 PPT

    在这个"「分布式训练」+ DDP单机多卡并行指南"中,我们将深入探讨DDP的工作原理以及如何在实践中应用。 分布式训练的核心目标是通过分割工作负载来加速模型的训练过程。在单机多卡环境中,每块GPU都会处理一部分...

    保姆教程白嫖GPU T4*2!Kaggle实现chatglm微调任务-单机多卡训练测试

    由于我们有两个GPU,我们可以设置模型为多GPU训练,通过DataParallel或DistributedDataParallel来实现数据并行和模型并行。 4. **数据预处理**:对输入文本进行编码,转换为模型可接受的数字表示。这可能包括分词、...

    「分布式训练」+ DDP单机多卡并行指南

    本指南将重点讨论DDP,它能有效地利用单机上的多块GPU进行并行计算。 首先,了解分布式训练的基本概念。分布式训练的目标是将训练任务分解到多个计算资源上,每个资源处理一部分工作负载,然后同步结果以保持模型的...

    基于pytorch的单机多卡分布式训练源码

    在PyTorch中,单机多卡分布式训练是一种优化深度学习模型训练效率的方法,它能够充分利用多GPU资源,加速模型的收敛过程。本教程将详细解释如何使用PyTorch实现单机多卡分布式训练,主要参考提供的源码文件`pytorch_...

    tensorflow-example:tensorflow代码示例

    目录结构./├── 3rd 第三方的例子├── cs20 斯坦福tensorflow课程的代码示例├── dist 分布式代码示例├── linreg 线性回归├── mnist mnist多种实现,单机、单机多卡、分布式├── topics 一些专题,从...

    5G多卡聚合测试-深圳高新科技生态园.mp4

    5G多卡聚合测试-深圳高新科技生态园.mp4

    使用NCCL进行多GPU训练(MULTI-GPU TRAINING WITH NCCL)

    使用NCCL进行多GPU深度学习训练,其中涉及多机多卡,单机多卡等技术。 Optimized inter-GPU communication for DL and HPC Optimized for all NVIDIA platforms, most OEMs and Cloud Scales to 100s of GPUs, ...

    Tensorflow深度学习框架中文详解,一个开源的基于python的机器学习框架

    - **分布式计算**:TensorFlow支持多机多卡的分布式训练,显著提升了模型训练的速度和规模。 - **GPU和TPU加速**:利用GPU和TPU硬件加速,大幅度提高了模型训练的速度。 ##### 4. 高度可扩展 - **丰富的API**:...

    Serveur Multicartes IPX800:IPX800多卡服务器-开源

    用PHP开发的家庭自动化服务器,可以控制多个IPX800卡(Gce.electronics)。

    TensorFlow深度学习并发加速训练

    tf.distribute.MirroredStrategy 是一种简洁且高性能的,数据并行的同步式分布式策略,主要支持多个 GPU 在同一台主机上训练。使用这种策略时,我们只需实例化一个 MirroredStrategy 策略: strategy = tf.distribute...

    简单粗暴 TensorFlow 2.0.pdf

    TensorFlow支持分布式训练,包括单机多卡的MirroredStrategy和多机训练的MultiWorkerMirroredStrategy,以及TPU训练。 **模型复用** TensorFlow Hub是一个模型库,提供了预训练模型,可以直接用于特征提取或微调。...

    昀龙Tensorflow框架实战.pdf

    在并行训练方面,Tensorflow支持多机多卡并行训练,主要分为数据并行和模型并行。在数据并行中,所有节点都有模型的完整副本,数据在不同节点间进行切分。同步数据并行是当每个计算节点上传的梯度都到齐后再更新全局...

    llama-factory一个数据微调用例

    "llama-factory"是一个数据微调的工具或平台,主要与LoRa(Long Range)技术相关,这是一项低功耗广域网通信技术,常用于物联网(IoT)应用。在给定的文件列表中,我们可以看到以下几个关键文件: 1. **dataset_info....

    浅谈多卡服务器下隐藏部分 GPU 和 TensorFlow 的显存使用设置

    总的来说,通过巧妙地设置`CUDA_VISIBLE_DEVICES`环境变量和TensorFlow的GPU选项,可以在多卡服务器环境中有效地隐藏和管理GPU资源,同时优化显存使用,以达到最大化效率和协作的目的。合理分配GPU资源不仅能提高...

    Retinanet目标检测算法(简单,明了,易用,全中文注释,单机多卡训练,视频检测)

    目标检测(Object Detection)是计算机视觉领域的一个核心问题,其主要任务是找出图像中所有感兴趣的目标(物体),并确定它们的类别和位置。以下是对目标检测的详细阐述: 一、基本概念 目标检测的任务是解决“在...

    Tensorflow 入门和实战.txt

    1. **张量**:在TensorFlow中,一切数据都以张量的形式表示。张量是多维数组,可以是一维(向量)、二维(矩阵)等。 2. **计算图**:TensorFlow中的计算过程是通过构建一个包含节点(操作)和边(张量)的有向图来...

    Retinanet-Pytorch:Retinanet目标检测算法(简单,明了,易用,全中文注释,单机多卡训练,视频检测)(based on pytorch,Simple, Clear, Mutil GPU)

    本项目单机多卡,通过torch.nn.DataParallel实现,将单机环境统一包装.支持单机单卡,单机多卡,指定gpu训练及测试,但不支持多机多卡和cpu训练和测试. 不限定检测时的设备(cpu,gpu均可). Requirements pytorch op

    与tenorflow第一次接触

    **分布式TensorFlow**:除了单机多卡之外,TensorFlow还支持跨机器的分布式训练。通过配置集群参数,可以在多个机器之间同步训练过程,进一步加速训练速度。 #### 八、结语 《与TensorFlow的第一次接触》这本书...

Global site tag (gtag.js) - Google Analytics