devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

tensorflow的GPU加速计算_tensorflow gpu

作者：从前慢现在也慢 | 2024-03-01 05:20:32

赞

踩

tensorflow gpu

参考    tensorflow的GPU加速计算 - 云+社区 - 腾讯云

一、概述

tensorflow程序可以通过tf.device函数来指定运行每一个操作的设备，这个设备可以是本地的CPU或者GPU，也可以是某一台远程的服务器。tensorflow会给每一个可用的设备一个名称，tf.device函数可以通过设备的名称来指定执行运算的设备，比如CPU在tensorflow中的名称为/cpu:0。在默认情况下，即使机器有多CPU，tensorflow也不会区分它们，所有CPU都使用/cpu:0作为名称。而一台机器上不同为/gpu:0，第二个GPU名称为/gpu:1，以此类推。

tensorflow提供了一个快捷的方式来查看运行每一个运算的设备。在生成会话时，可以通过设置log_device_placement参数来打印运行每一个运算的设备。以下程序展示了如何使用log_device_placement这个参数。

  1. import tensorflow as tf
  2.  
  3. a = tf.constant([1.0, 2.0, 3.0], shape=[3], name='a')
  4. b = tf.constant([1.0, 2.0, 3.0], shape=[3], name='b')
  5. c = a + b 
  6.  
  7. # 通过log_device_placement参数来输出运行每一个运算的设备。
  8. sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
  9. print sess.run(c)
  10.  
  11. '''
  12. 在没有GPU的机器上运行以上代码可以得到类似以下的输出。
  13. Device mapping: no known devices.
  16. add: (Add): /job:localhost/replacement/replica:0/task:0/cpu:0
  17. b: (Add): /job:localhost/replacement/replica:0/task:0/cpu:0
  18. a: (Add): /job:localhost/replacement/replica:0/task:0/cpu:0
  19. [2. 4. 6.]
  20. '''

在以上代码中，tensorflow程序会生成会话时加入了参数log_device_placement=True，所以程序会将运行每一个操作的设备输出到屏幕。于是除了可以看到最后的计算结果，还可以看到类似"add: (Add): /job:localhost/replacement/replica:0/task:0/cpu:0
"这样的输出。这些输出显示了执行每一个运算的设备。比如加法操作add是通过CPU来运行的，因为它的设备名称中包含了/cpu:0。

在配置好GPU环境的tensorflow中，如果操作没有明确地指定运行设备，那么tensorflow会优先选择GPU。比如将以上代码在亚马逊(Amazon Web Services, AWS)的g2.8xlarge实例上运行时，会得到类似以下的运行结果。

  1. Device mapping:
  2. /job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: GRID K520, pci bus
  3. id： 0000：00：03.0
  4. /job:localhost/replica:0/task:0/gpu:0 -> device: 1, name: GRID K520, pci bus
  5. id： 0000：00：04.0
  6. /job:localhost/replica:0/task:0/gpu:0 -> device: 2, name: GRID K520, pci bus
  7. id： 0000：00：05.0
  8. /job:localhost/replica:0/task:0/gpu:0 -> device: 3, name: GRID K520, pci bus
  9. id： 0000：00：06.0
  10.  
  11. add: (Add): /job:localhost/replace:0/task:0/gpu:0
  12. a: (Const): /job:localhost/replace:0/task:0/gpu:0
  13. b: (Const): /job:localhost/replace:0/task:0/gpu:0
  14. [ 2. 4. 6. ]

从以上输出可以看出在配置好GPU环境的tensorflow中，tensorflow会自动优先将运算放置在GPU上。不过，尽管g2.8xlarge示例中有4个GPU，在默认情况下，tensorflow只会将运算优先放到/gpu:0上。于是可以看见在以上程序中，所有的运算都被放在了/gpu:0上。如果需要将某些运算放到不同的GPU或者CPU上，就需要通过tf.device来手工指定。以下程序给出了一个通过tf.device手工指定运行设备的样例。

  1. import tensorflow as tf
  2.  
  3. # 通过tf.device将运算指定到特定的设备上。
  4. with tf.device('/cpu:0'):
  5.    a = tf.constant([1.0 2.0 3.0], shape=[3], name='a')
  6.    b = tf.constant([1.0 2.0 3.0], shape=[3], name='b') 
  7.  
  8. with tf.device('/gpu:1')
  9.    c = a + b
  10.  
  11. sess = tf.Session(config=tf.ConfigProto(log_device_palcement+=True))  
  12. print sess.run(c)
  13.  
  14. '''
  15. 在AWS g2.8xlarge实例上的运行上述代码可以得到以下结果:
  16. Device mapping:
  17. /job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: GRID K520, pci bus
  18. id： 0000：00：03.0
  19. /job:localhost/replica:0/task:0/gpu:0 -> device: 1, name: GRID K520, pci bus
  20. id： 0000：00：04.0
  21. /job:localhost/replica:0/task:0/gpu:0 -> device: 2, name: GRID K520, pci bus
  22. id： 0000：00：05.0
  23. /job:localhost/replica:0/task:0/gpu:0 -> device: 3, name: GRID K520, pci bus
  24. id： 0000：00：06.0
  26. add: (Add): /job:localhost/replace:0/task:0/gpu:1
  27. a: (Const): /job:localhost/replace:0/task:0/gpu:0
  28. b: (Const): /job:localhost/replace:0/task:0/gpu:0
  29. [2. 4. 6.]

在以上代码中可以看到生成常量a和b的操作被加载到了CPU上，而加法操作被放到了第二个GPU上"/gpu:1"上。在tensorflow中，不是所有的操作都可以被放在GPU上，如果强行将无法放在GPU上的操作指定到GPU上，那么程序将会报错。以下代码给出了一个报错的样例。

  1. import tensorflow as tf
  2.  
  3. # 在CPU上运行tf.Variable
  4. a_cpu = tf.Variable(0, name="a_gpu")
  5.  
  6. with tf.device('/gpu:0'):
  7.    # 将tf.Variable强制放在GPU上。
  8.    a_gpu = tf.Variable(0, name="a_gpu")
  9.  
  10. sess = tf.Session(config=tf.ConfigProto(log_device_palcement=True))
  11. sess.run(tf.initialize_all_variables())
  12.  
  13.  
  14. '''
  15. 运行以上程序将会报出以下错误：
  16. tensorflow.python.framework.errors.InvalidArgumentError: Cannot assign a
  17. device to node 'a_gpu': Could not satisfy explicit device specification
  18. '/device:GPU:0' because no supported kernel for GPU device is available.
  19. Colocation Debug Info:
  20. Colocation group had the following types and devices:
  21. Identity:CPU
  22. Assign:CPU
  23. Variable:CPU
  24. [[Node: a_gpu = Variable[container="", dtype=DT_INT32, shape=[],shared_name="", _device="/device:GPU:0"]()]]
  25. '''

不同版本的tensorflow对GPU的支持不一样，如果程序中全部使用强制指定设备的方式会降低程序的可移植性。在tesnorflow的kernel中定义了哪些操作可以泡在GPU上。比如可以在variable_ops.cc程序中找到以下定义。

  1. # define REGISTER_GPU_KERNELS(type)
  2.     REGISTER_KERNEL_BUILDER(
  3.       Name("Variable").Device(DEVICE_GPU).TypeConstraint<type>("dtype"),
  4.       VariableOp);
  5.   ...
  6. TF_CALL_GPU_NUMBER_TYPES(REGISTER_GPU_KERNELS);

在这段定义中可以看到GPU只在部分数据类型上支持tf.Variable操作。如果在tensorflow代码库中搜索调用这段代码的宏TF_CALL_NUMBER_TYPES，可以发现在GPU上，tf.Variable操作只支持实数型(float16, float32和double)的参数。而在报错的样例代码中给定参数是整数型的，所以不支持在GPU上运行。为避免这个问题，tensorflow在声称会话时可以指定allow_soft_placement参数。当allow_soft_placement参数设置为True时，如果运算无法由GPU执行，那么tensorflow参数设置为True时，如果运算无法由GPU执行，那么tensorflow会自动将它放到CPU上执行。以下代码给出了一个使用allow_soft_placement参数的样例。

  1. import tensorflow as tf 
  2.  
  3. a_cpu = tf.Variable(9, name="a_cpu")
  4. with tf.device('/gpu:0'):
  5.    a_gpu = tf.Variable(0, name="a_gpu")
  6.  
  7.  
  8. # 通过allow_soft_placement参数自动将无法在GPU上的操作放回CPU上。
  9. sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))
  10. sess.run(tf.initializ_all_variables())
  11.  
  12.  
  13. '''
  14. 运行上面这段程序可以得到以下结果：
  15. Device mapping:
  16. /job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: GRID K520, pci bus
  17. id： 0000：00：03.0
  18. /job:localhost/replica:0/task:0/gpu:0 -> device: 1, name: GRID K520, pci bus
  19. id： 0000：00：04.0
  20. /job:localhost/replica:0/task:0/gpu:0 -> device: 2, name: GRID K520, pci bus
  21. id： 0000：00：05.0
  22. /job:localhost/replica:0/task:0/gpu:0 -> device: 3, name: GRID K520, pci bus
  23. id： 0000：00：06.0
  25. a_gpu: /job:localhost/replaca:0/task:0/gpu:1
  26. a_gpu/read: /job:localhost/replaca:0/task:0/gpu:0
  27. a_gpu/Assign: /job:localhost/replaca:0/task:0/gpu:0
  28. init/NoOp_1:  /job:localhost/replaca:0/task:0/gpu:0
  29. a_gpu: /job:localhost/replaca:0/task:0/gpu:1
  30. a_gpu/read: /job:localhost/replaca:0/task:0/gpu:0
  31. a_gpu/Assign: /job:localhost/replaca:0/task:0/gpu:0
  32. init/NoOp:  /job:localhost/replaca:0/task:0/gpu:0
  33. init:  /job:localhost/replaca:0/task:0/gpu:0
  34. a_gpu/initial_value: /job:localhost/replaca:0/task:0/gpu:0
  35. a_gpu/initial_value: /job:localhost/replaca:0/task:0/gpu:0
  36. 从输出的日志中可以看到再生成变量a_gpu时，无法放到GPU上的运算被自动调整到了CPU上(比如a_gpu和a_gpu/read)，而可以被GPU执行的命令(比如a_gpu/initial_value)依旧由GPU执行。
  37. '''

虽然GPU可以加速tensorflow的计算，但一般来说不会把所有的操作全部放在GPU上，一个比较好的实践是将计算密集型的运算放在GPU上，而把其他操作放到CPU上。GPU是机器中相对独立的资源，将计算放入或者转出GPU都需要额外的时间。而且GPU需要将计算时用到的数据从内存复制到GPU设备上，这也需要额外的时间。tensorflow可以自动完成这些操作而不需要用户特别处理，但为了提高程序运行的速度，用户也需要尽量将相关的运算放在同一个设备上。

tensorflow默认会占用设备的所有GPU以及每个GPU的所有程序。如果在一个tensorflow程序中只需要使用GPU，可以通过设置CUDA_VISIBLE_DEVICES环境变量来控制。以下样例介绍了如何在运行是设置这个环境变量。

  1. # 只使用第二块GPU(GPU编号从0开始)。在demo_code.py中，机器上的第二块GPU的
  2. # 名称变成/gpu:0，不过在运行时所有/gpu:0的运算将被放在第二块GPU上。
  3. CUDA_VISIBLE_DEVICES=1 python demo_code.py
  4. # 只使用第一块和第二块GPU。
  5. CUDA_VISIBLE_DEVICES=0, 1 python demo_code.py

tensorflow也支持在程序中设置环境变量，以下代码展示了如何在程序中设置这些环境变量。

  1. import os
  2.  
  3. # 只使用第三块GPU。
  4. os.environ["CUDA_VISIBLE_DEVICES"] = "2"

虽然tensorflow默认会一次性占用一个GPU所有显存，但是tensorflow也支持动态分配GPU的显存，使得一块GPU上可以同时运行多个任务。下面给出了tensorflow动态分配显存的方法。

  1. config = tf.ConfigProto()
  2.  
  3. # 让tensorflow按需分配显存。
  4. config.gpu_options.allow_growth = True
  5.  
  6.  
  7. # 或者直接按照固定的比例分配。以下代码会占用所有可使用GPU的40%显存。
  8. # config.gpu_options.per_process_gpu_memeory_fraction = 0.4
  9. session = tf.Session(config=config, ...)

二、深度学习的多GPU并行训练模式

tensorflow可以很容易地利用单个GPU加速深度学习模型的训练过程，但是利用更多的GPU或者机器，需要了解如何并行化地训练深度学习模型。常用的并行化深度学习模型训练方式有两种，同步模式和异步模式。

深度学习模型的训练是一个迭代的过程。在每一轮迭代中，前向传播算法会根据当前参数的取值计算出在一小部分训练数据上的预测值，然后反向传播算法再根据损失函数计算参数的梯度并更新参数。在并行化地训练深度学习模型时，不同设备(GPU或CPU)可以在不同训练数据上运行这个迭代过程，而不同并行模式的区别在于不同的参数更新方式。

下图展示了异步训练模式。在每一轮迭代时，不同设备会读取参数最新的取值，但因为当前参数的取值和随机获取的一小部分训练数据，不同设备各自运行反向传播的过程并独立更新参数。可以简单地认为异步模式就是单机模式复制了多份，每一份使用不同的训练数据进行训练。在异步模式下，不同设备之间是完全独立的。

                  

然而使用异步模式训练的深处学习模型有可能无法达到较优的结果。下图给出了一个具体的样例来说明异步模式的问题。其中黑色曲线展示了模型的损失函数，黑色小球表示了在t0时刻参数所对应的损失函数的大小。假设两个设备d0和d1在时间t0同时读取了参数的取值，那么设备d0和d1计算出来的梯度都会将小黑球向左移动。假设在时间t1设备d0已将完成了反向传播的计算并更新了参数，修改后的参数处于下图中小灰球的位置。然而这时的设备d1并不知道参数已经被更新了，所以在时间t2时，设备d1会继续将小球向左移动，使得小球的位置达到下图中白球的位置。

                                

           

为了避免更新不同步的问题，可以使用同步模式。在同步模式下，所有的设备同时读取参数的取值，并且当反向传播算法完成之后同步更新参数的取值。单个设备不会单独对参数进行更新，而会等待所有设备都完成反向传播之后再统一更新参数。上图展示了同步模式的训练过程，在每一轮迭代时，不同设备首先统一读取当前参数的取值，并随机获取一小部分数据。然后在不同设备上运行反向传播过程得到在各自训练数据上参数的梯度。注意虽然所有设备使用的参数是一致的 ，但是因为训练数据不同，所以得到参数的梯度就可能不一样。当所有设备完成反向传播的计算之后，需要计算出不同设备上参数梯度的平均值，最后再根据平均值对参数进行更新。

同步模式解决了异步模式中存在的参数更新问题，然而同步模式的效率却低于异步模式。在同步模式下，每一轮迭代都需要设备统一开始、统一结束。如果设备的运行速度不一致，那么每一轮训练都需要等待最慢的设备结束才能开始、统一结束。如果设备的运行速度不一致，那么每一轮训练都需要等待最慢的设备结束才能开始更新参数，于是很多时间将被花在等待上。虽然理论上异步模式存在缺陷，但因为训练深度学习模型时使用的随机梯度下降本身就是梯度下降的一个近似解法，而且即使是梯度下降也无法保证达到全局最优解，所以在实际应用中，在相同的时间内，使用异步模式训练的模型不一定比同步模式差。所以两种训练模式在实践中都有非常广泛的应用。

下面给出具体的tensorflow代码，在一台机器的多个GPU上并行训练深度学习模型。因为一般来说一台机器上的多个GPU性能相似，所以在这种设置下会更多地采用同步训练深度学习模型。下面给出了具体代码，在多GPU上训练深度学习模型解决MNIST问题。使用mnist_inference.py程序来完成神经网络的前向传播过程。以下代码给出了新的神经网络训练程序mnist_multi_gpu_train.py。

  1. # coding=utf-8
  2. from datetime import datetime 
  3. import os
  4. import time
  5.  
  6. import tensorflow as tf
  7. import mnist_inference
  8.  
  9. # 定义训练神经网络时需要的参数。
  10. BATCH_SIZE = 100
  11. LEARNING_RATE_BASE = 0.001
  12. LEARNING_RATE_DECAY = 0.99
  13. REGULARAZTION_RATE = 0.0001
  14. TRAINING_STEPS = 1000
  15. MOVING_AVERAGE_DECAY = 0.99
  16. N_GPU = 2
  17.  
  18. # 定义日志和模型输出的路径。
  19. MODEL_SAVE_PATH = "logs_and_models/"
  20. MODEL_NAME = "model.ckpt"
  21.  
  22.  
  23. # 定义数据存储的路径。因为需要为不同的GPU提供不同的训练数据，所以通过placeholder
  24. # 的方式就需要动手准备多分数据。为了方便训练数据的获取过程，可采用Dataset的方式从
  25. # TFRecord中读取数据。于是在这里提供的数据文件路径为MNIST训练数据转化为TFRecord
  26. # 格式之后的路径。
  27. DATA_PATH = "otput.tfrecord"
  28.  
  29. # 定义输入队列得到训练数据
  30. def get_input():
  31.    dataset = tf.contrib.data.TFRecordDataset([DATA_PATH])
  32.    
  33.    # 定义数据解析格式。
  34.    def parser(record): 
  35.        features = tf.place_single_example(
  36.            record,             
  37.            features={
  38.                'image_raw': tf.FixedLenFeature([], tf.string),
  39.                'pixels': tf.FixedLenFeature([], tf.int64),
  40.                'label': tf.FixedLenFeature([], tf.int64),
  41.            })
  42.        # 解析图片和标签信息
  43.        decoded_image = tf.decoded_raw(features['image_raw'], tf.unit8)
  44.        reshaped_image = tf.reshape(decoded_image, [784])
  45.        retyped_image = tf.cast(reshaped_image, tf.float32)
  46.        label = tf.cast(feature['label'], tf.init32)
  47.  
  48.        return retyped_image, label
  49.    
  50.   # 定义输入队列。
  51.   dataset = dataset.map(parser)
  52.   dataset = dataset.shuffle(buffer_size=10000)
  53.   dataset = dataset.repeat(10)
  54.   dataset = dataset.batch(BATCH_SIZE)
  55.   iterator = dataset.make_one_shot_iterator()
  56.   
  57.   feature, labels = iterator.get_next()
  58.   return feature, labels
  59.  
  60. # 定义损失函数。对于给定的训练数据、正则化损失计算规则和命名空间，计算在这个命名空间
  61. # 下的总损失。之所以需要给定命名空间是因为不同的GPU上计算得出的正则化损失都会加入名为
  62. # loss的集合，如果不通过命名空间就会将不同GPU上的正则化损失都加进来。
  63. def get_loss(x, y_, regularizer, scope, reuse_variables=None):
  64.    with tf.variable_scope(tf.get_variable_scope(),
  65.                          reuse=reuse_variables):
  66.       y = mnist_inference.inference(x, regularizer)
  67.    # 计算交叉熵损失。
  68.    cross_entropy = tf.reduce_mean(
  69.       tf.nn.sparse_softmax_cross_entropy_with_logits(                           
  70.           logits=y, labels=y_))
  71.    # 计算当前GPU上计算得到的正则化损失。
  72.    regularization_loss = tf.add(tf.get_collection('losses', scope))
  73.    # 计算最终的总损失。
  74.    loss = cross_entropy + regularization_liss
  75.    return loss
  76.  
  77. # 计算每一个变量梯度的平均值。
  78. def average_gradients(tower_grads):
  79.    average_grads = []
  80.    
  81.    # 枚举所有的变量和变量在不同GPU上计算得出的梯度。
  82.    for grad_and_vars in zip(*tower_grads):
  83.       # 计算所有GPU上的梯度平均值。
  84.       grads = []
  85.       for g, _ in grad_and_vars:
  86.          expend_g = tf.expend_dims(g, 0)
  87.          grads.append(extend_g)
  88.       grad = tf.concat(grads, 0)
  89.       grad = tf.reduce_mean(grad, 0)
  90.       
  91.       v = grad_and_vars[0][1]
  92.       grad_and_var = (grad, v)
  93.       # 将变量和它的平均梯度对应起来。
  94.       average_grads.append(grad_and_var)
  95.    # 返回所有变量的平均梯度，这个将被用于变量的更新
  96.    return average_grade
  97.       
  98. # 主训练过程。
  99. def main(argv=None):
  100.    # 将简单的运算放在CPU上，只有神经网络的训练过程放在GPU上。
  101.    with tf.Graph().as_default(), tf.device('/cpu:0'):
  102.       # 定义基本的训练过程
  103.       x, y_ = get_input()
  104.       regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
  105.  
  106.       global_step = tf.get_variable(
  107.          'global_step', [], initializer=tf.constant_initializer(0),
  108.          trainable=False)
  109.       learning_rate = tf.train.exponential_decay(
  110.          LEARNING_RATE_BASE, global_step,
  111.          60000 / BATCH_SIZE, LEARNING_RATE_DECAY)
  112.       
  113.       opt = tf.train.GradientDescentOptimizer(learning_rate)
  114.       
  115.       tower_grads = []
  116.       reuse_variables = False
  117.       # 将神经网络的优化过程跑在不同的GPU上。
  118.       for i in range(N_GPU):
  119.          # 将优化过程指定在一个GPU上。
  120.              with tf.device('/gpu:%d' % i):
  121.                 with tf.name_scope('GPU_%d' % i) as scopes:
  122.                    cur_loss = get_loss(
  123.                    x, y_, regularizer, scope, reuse_variables)
  124.                 # 在第一次声明变量以后，将控制变量重用的参数设置为True。这样可以计算
  125.                 # 让不同的GPU更新同一组参数。
  126.                 reuse_variables = True
  127.                 grads = opt.compute_gradients(cut_Loss)
  128.                 tower_grads.append(grads)
  129.       # 计算变量的平均梯度
  130.       grads = average_gradients(tower_grads)
  131.       for grad, var in grads:
  132.          if grad is not None:
  133.            tf.summary.histogram('gradients_on_averages/%s' % var.op.name, grad)
  134.       
  135.       # 使用平均梯度更新参数
  136.       apply_gradients_op = opt.apply_gradients(
  137.           grads, global_step=global_step)
  138.       for var in tf.trainable_variables():
  139.           tf.summary.histogram(var.op.name, var)
  140.       
  141.       # 计算变量的滑动平均值。
  142.       variable_averages = tf.train.ExponentialMOvingAverage(
  143.           MOVING_AVERAGE_DECAY, global_step)
  144.       variables_to_average = (
  145.          tf.trainable_variables() + tf.moving_average_variables())
  146.       varaibles_averages_op = variable_averages.apply(
  147.          variables_to_average)
  148.       
  149.       # 每一轮迭代需要更新变量的取值并更新变量的滑动平均值。
  150.       train_op = tf.group(apply_gradient_op, variables_averages_op)
  151.       
  152.       saver = tf.train.Saver()
  153.       summmary_op = tf.summary.merge_all()
  154.       init = tf.global_variable_initializer()
  155.       with tf.Session(config=tf.ConfigProto(
  156.                      allow_soft_placement=True,
  157.                      log_device_placement=True)) as sess:
  158.          # 初始化所有变量并启动队列。
  159.          init.run()
  160.          summary_writer = tf.summary.FileWriter(
  161.              MODEL_SAVE_PATH, sess.graph)
  162.          
  163.          for step in range(TRAINING_STEPS):
  164.          # 执行神经网络训练操作，并记录训练操作的运行时间。
  165.          start_time = time.time()
  166.          _, loss_value = sess.run([train_op, cur_loss])
  167.          duration = time.time() - start_time
  168.          
  169.          # 每隔一段时间输出当前的训练进度，并统计训练速度。
  170.          if step != 0 and step % 10 == 0:
  171.             # 计算使用过的训练数据个数。因为在每一次运行训练操作时，每一个GPU
  172.             # 都会使用一个batch的训练数据，所以总共用到的训练数据个数为
  173.             # batch大小 X GPU个数。
  174.             num_example_per_step = BATCH_SIZE * N_GPU
  175.             
  176.             # num_examples_per_step为本次迭代使用到的训练数据个数，
  177.             # duration为运行当前训练过程中使用的时间，于是每秒可以处理的训
  178.             # 练数据个数为num_examples_per_step / duration。
  179.             examples_per_sec = num_examples_per_step / duration
  180.             
  181.             # duration为运行当前训练过程使用的时间，因为在每一个训练过程中，
  182.             # 每一个GPU都会使用一个batch的训练数据，所以在单个batch上的训练数据
  183.             # 所需要的时间为duration / GPU个数。
  184.             sec_per_batch = duration / N_GPU
  185.             
  186.             # 输出训练信息。
  187.             format_str = ('%s: step %d, loss = %.2f(
  188.                  %.1f examples/sec; %.3f sec/batch)')
  189.             print (format_str % (datetime.now(), step, loss_value,
  190.                                  examples_per_sec, sec_per_batch))
  191.             
  192.             # 通过tensorflow可视化训练过程。
  193.             summary = sess.run(summary_op)
  194.             summary_writer.add_summary(summary, step)
  195.          
  196.          # 每隔一段时间保存当前的模型。
  197.          if step % 1000 == 0 or (step + 1) == TRAINING_STEPS:
  198.             checkpoint_path = os.path.join(
  199.                MODEL_SAVE_PATH, MODEL_NAME)
  200.             saver.save(sess, checkpoint_path, global_step=step)
  201.  
  202. if __name__ == '__main__':
  203.     tf.app.run()
  204.  
  205. '''
  206. 在AWS的g2.8xlarge实例上运行上面这段代码可以得到类似下面的结果：
  207. step 10, loss = 71.90 (15292.3 examples/sec; 0.007 sec/batch)
  208. step 20, loss = 37.97 (18758.3 examples/sec; 0.005 sec/batch)
  209. step 30, loss = 9.54  (16313.3 examples/sec; 0.006 sec/batch)
  210. step 40, loss = 11.84 (14199.0 examples/sec; 0.007 sec/batch)
  211. '''
  212. step 980, loss = 0.66 (15034.7 examples/sec; 0.007 sec/batch)
  213. step 990, loss = 1.56 (16134.1 examples/sec; 0.006 sec/batch)
  214. '''

三、分布式tensorflow

 1.分布式tensorflow原理

以下代码创建了一个最简单的tensorflow集群：

  1. import tensorflow as tf
  2.  
  3. c = tf.constant("Hello, distuributed Tensorflow!")
  4. # 创建一个本地tensorflow集群
  5. server = tf.train.Server.create_local_server()
  6. # 在集群上创建一个会话。
  7. sess = tf.Session(server.target)
  8. # 输出Hello, distributed Tensorflow!
  9. print sess.run(c)

在以上代码中，首先通过tf.train.Server.create_local_server函数在本地创建了一个只有一台机器的tensorflow集群。然后在该集群上生成了一个会话，并通过生成的会话将运算运行在创建的tensorflow集群上。虽然这只是一个单机集群，但它大致反映了tensorflow集群的工作流程。tensorflow集群通过一系列任务(tasks)来执行tesnorflow计算图中的运算。一般来说，不同任务跑在不同机器上。最主要的例外是使用GPU时，不同任务可以使用同一台机器上的不同GPU。tensorflow集群中的任务也会被聚合成工作(jobs)，每个工作包含一个或者多个任务。比如在训练深度学习模型时，一台运行反向传播的机器是一个任务，而所有运行反向传播机器的集合是一种工作。

以上样例代码是只有一个任务的集群。当一个tensorflow集群有多个任务时，需要使用tf.train.ClusterSpec来指定运行每一个任务的机器。比如以下代码展示了在本地运行有两个任务的tensorflow集群。第一个任务的代码如下：

  1. import tensorflow as tf
  2. c = tf.constant("Hello from server!")
  3.  
  4. # 生成一个有两个任务的集群，一个任务跑在本地2222端口，另外一个跑在本地2223端口。
  5. cluster = tf.train.ClusterSpec(
  6.    {"local": ["localhost:2222", "localhost:2223"]})
  7.  
  8. # 通过上面生成的集群配置生成Server，并通过job_name和task_index指定当前所启动
  9. # 的任务。因为该任务是第一个任务，所以task_index为0。
  10. server = tf.train.Server(cluster, job_name="local", task_index=0)
  11.  
  12. # 通过server.target生成会话来使用Tensorflow集群中的资源。通过设置
  13. # log_device_placement可以看到执行每一个操作的任务。
  14. sess = tf.Session(
  15.        server.target, config=tf.ConfigProto(log_device_placement=True))
  16. print sess.run(c)
  17. server.join()

下面给出了第二个任务的代码：

  1. import tensorflow as tf
  2. c = tf.constant("Hello from server2!")
  3.  
  4. # 和第一个程序一样的集群配置。集群中的每一个任务需要采样相同的配置。
  5. cluster = tf.train.ClusterSpec(
  6.    {"local":["localhost:2222", "localhost:2223"]})
  7. # 指定task_index为1，所以这个程序将在localhost:2223启动服务。
  8. server = tf.train.Server(cluster, job_Name="local", task_index=1)
  9. # 剩下的代码都和第一个任务的代码一致。
  10. ...

启动第一个任务后，可以得到类似下面的输出：

  1. tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:215]   Initialize
  2. GrpcChannelCache for job local -> {0 -> localhost:2222, 1 -> localhost:2223}
  3. tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:316]   Started
  4. serve with target: grpc://localhost:2222
  5. tensorflow/core/distributed_runtime/master.cc:209] CreateSession still
  6. waiting for response from worker: /job:local/replica:0/task:1
  7. tensorflow/core/distributed_runtime/master.cc:209] CreateSession still
  8. waiting for response from worker: /job:local/replica:0/task:1
  9. tensorflow/core/distributed_runtime/master_session.cc:998] Start master
  10. session 67a422339d0b7833 with config: log_device_Placement: true
  11. Const: (Const): /job:local/replica:0/task:0/cpu:0
  12. tensorflow/core/common_runtime/simple_place.cc:872]
  13. (Const) /job:local/replica:0/task:0/cpu:0
  14. Hello from server1!

从第一个任务输出中可以看到，当只启动第一个任务时，程序会停下来等待第二个任务启动，而且持续输出CreateSession still waiting for response from worker: /job:local/replica:0/task:0/task:1。当第二个任务启动后，可以看到从第一个任务中会输出Hello from server1!的结果。第二个任务的输出如下：

  1. tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:215]   Initialize
  2. GrpcChannelCache for job local -> {0 -> localhost:2222, 1 -> localhost:2223}
  3. tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:316]   Started
  4. serve with target: grpc://localhost:2223
  5. tensorflow/core/distributed_runtime/master_session.cc:998] Start master
  6. session 67a422339d0b7833 with config: log_device_Placement: true
  7. Const: (Const): /job:local/replica:0/task:0/cpu:0
  8. tensorflow/core/common_runtime/simple_place.cc:872]
  9. (Const) /job:local/replica:0/task:0/cpu:0
  10. Hello from server2!

值得注意的是第二个任务中定义的计算定义也被放在了设备/job:local/replica:0/task:0/cpu:0上。也就是说这个计算将由第一个任务来执行。从上面这个样例可以看到，通过tf.train.Server.target生成的会话可以统一管理整个tensorflow集群中的资源。

和使用多GPU类似，tensorflow支持通过tf.device来指定操作运行在哪个任务上。比如将第二个任务重定义计算的语句改为以下代码，就可以看到这个计算被调度到/job:local/replica:0/task:1/cpu:0上面。

  1. with tf.device("/job:local/task:1")
  2. c = tf.constant("Hello from server2!")

在以上样例中只定义了一个工作"local"。但一般在训练深度学习模型时，会定义两个工作。一个专门负责存储、获取以及更新变量的取值，这个工作所包含的任务统称为参数服务器(parameter server, ps)。另外一个工作负责运行反向传播算法来获取参数梯度，这个工作包含的任务统称为计算服务器(worker)。下面给出了一个比较常见的用于训练深度学习模型的tensorflow集群配置方法。

  1. tf.train.clusterSpec({
  2.    "worker": [
  3.       "tf-worker0:2222", 
  4.       "tf-worker1:2222",
  5.       "tf-worker2:2222"
  6.    ],
  7.    "ps": [
  8.       "tf-ps0:2222",
  9.       "tf-ps1:2222"
  10.    ]})

使用分布式tensorflow训练神经学习模型一般有两种方式。一种方式叫做计算图内分布式(in-graph replication)。使用这种分布式训练方式时，所有的任务都会使用一个tensorflow计算图中的变量(也就是深度学习中的参数)，而只是将计算部分发布到不同的计算服务器上。多GPU样例程序将计算复制了多份，每一份放到一个GPU上进行计算。但不同的GPU使用的参数都是在一个tensorflow计算图中的。因为参数都是存在同一个计算图中，所以同步更新参数比较容易控制。因为计算图内分布式需要有一个中心节点来生成这个计算图并分配计算任务，所以当数据量太大时，这个中心节点容易造成性能瓶颈。

另一种分布式tensorflow训练深度学习模型的方法叫计算图之间分布式(between-graph replication)。使用这种分布式方式时，在每一个计算服务器上都会创建一个独立的tensorflow计算图，但不同计算图中的相同参数需要一种固定的方式放到同一个参数服务器上。tensorflow提供了tf.train.replica_device_setter函数来帮助完成这一个过程。因为每个计算服务器的tensorflow计算图是独立的，所以这种方式的并行度要更高。但在计算图之间分布式下进行参数的同步更新比较困难。为了解决这个问题，tensorflow提供了tf.train.SyncReplicasOptimizer函数来帮助实现参数的同步更新。这让计算图之间分布式方式更加广泛地应用。

2.分布式tensorflow模型训练

下面将给出两个样例程序分别实现使用计算图之间分布式(Between-graph replication)完成分布式深度学习模型训练的一步更新和同步更新。第一部分将给出使用计算图之间分布式实现异步更新的tensorflow程序。这一部分也会给出具体的命令行将该程序分布式的运行在一个参数服务器和两个计算服务器上，并通过tensorflow可视化在第一个服务器上的tensorflow计算图。第二部分将给出计算图之间分布式实现同步参数更新的tesnorflow程序。同步参数更新的代码大部分和异步更新相似，所以这一部分中将重点介绍他们之间的不同之处。

异步模式样例程序

以下代码实现可异步模式的分布式神经网络的训练过程。

  1. # coding=utf-8
  2. import time
  3. import tensorflow as tf
  4. from tensorflow.example.tutorials.mnist import input_data
  5.  
  6. import mnist_inference
  7.  
  8.  
  9. # 配置神经网络的参数
  10. BATCH_SIZE = 100
  11. LEARNING_RATE_BASE = 0.01
  12. LEARNING_RATE_DECAY = 0.99
  13. REGULARAZTION_RATE = 0.0001
  14. TRAINING_STEPS = 20000
  15. MOVING_AVERAGE_DECAY = 0.99
  16.  
  17. # 模型保存的路径。
  18. MODEL_SAVE_PATH = "logs/log_async"
  19. # MNIST数据路径。
  20. DATA_PATH = "path/to/mnist/data"
  21.  
  22.  
  23. # 通过flags指定运行的参数。
  24. # 但这不是一种可扩展的方式。这里将使用运行程序时给出的参数来配置在不同
  25. # 任务中运行的程序。
  26. FLAGS = tf.app.flags.FLAGS
  27. # 指定当前运行的是参数服务器还是计算服务器。参数服务器只负责Tensorflow中变量的维护
  28. # 和管理，计算服务器负责每一轮迭代时运行反向传播过程。
  29. tf.app.flags.DEFINE_string('job_name', 'worker', ' "ps" or "worker"')
  30. # 指定集群中的参数服务器地址。
  31. tf.app.flags.DEFINE_string(
  32.     'ps_hosts', 'tf-ps0:2222,tf-ps1:1111',
  33.     'Comma-separated list of hostname:port for the parameter server '
  34.     'joba. e.g. "tf-ps0:2222, tf-ps1:1111" ')
  35.  
  36. # 指定集群中的计算服务器地址。
  37. tf.app.flags.DEFINE_string(
  38.     'worker_hosts', 'tf-worker0:2222, tf-worker1:1111',
  39.     'Comma-separated list of homename:port for the worker jobs. '
  40.     'e.g. "tf-worked0:2222, tf-worker1:1111" ')
  41.  
  42.  
  43. # 指定当前程序的任务ID。tensorflow会根据参数服务器/计算服务器列表中的端口号
  44. # 来启动服务器。注意参数服务器和计算服务器的编号都是从0开始的。
  45. tf.app.flags.DEFINE_integer(
  46. 'task_id', 0, 'Task ID of the worker/replica running the training.')
  47.  
  48. # 定义tensorflow的计算图，并返回每一轮迭代时需要运行的操作。
  49. def build_model(x, y_, is_chief):
  50.    regularizer = tf.contrib.layer.l2_regularizer(REGULARAZTION_RATE)
  51.    y = mnist_inference.inference(x, regularizer)
  52.    global_step = tf.contrib.framework.get_or_create_global_step()
  53.  
  54.    # 计算损失函数并定义反向传播过程。
  55.    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
  56.        logits = y, labels = tf.argmax(y_, 1))
  57.    cross_entropy_mean = tf.reduce_mean(cross_entropy)
  58.    loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
  59.    learning_rate = tf.train.exponential_decay(
  60.        LEARNING_RATE_BASE,
  61.        global_step,
  62.        60000 / BATCH_SIZE,
  63.        LEARNING_RATE_DECAY)
  64.    train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, 
  65.       global_step = global_step)
  66.    # 定义每一轮迭代需要运行的操作。
  67.    if is_chief:
  68.       # 计算变量的滑动平均值。
  69.       variable_average = tf.train.ExponentialMovingAverage(
  70.          MOVING_AVERGAE_DECAY, global_step)
  71.       variables_average_op = variable_average.apply(
  72.          tf.trainable_variables())
  73.       with tf.control_dependencies([variable_average_op, train_op]):
  74.          train_op = tf.no_op()
  75.    return global_step, loss, train_op
  76.  
  77. def main(argv = None):
  78.     # 解析flags并通过tf.train.ClusterSpec配置tensorflow集群。
  79.     ps_hosts = FLAGS.ps_hosts.split(',')
  80.     worker_hosts = FLAGS.worker_hosts.split(',')
  81.     cluster = tf.train.ClusterSpec(
  82.         {"ps": ps_hosts, "worker": worker_hosts})
  83.     # 通过tf.train.ClusterSpec以及当前任务共创建tf.train.Server。
  84.     server = tf.train.Server(cluster,
  85.                              job_name=FLAGS.job_name,
  86.                              task_index=FLAGS.task_id)
  87.     # 参数服务器只需要管理tensorflow中的变量，不需要执行训练的过程。server.join()
  88.     # 会一致停在这条语句上。
  89.     if FLAGS.job_name == 'ps':
  90.        with tf.device("/cpu:0"):
  91.           server.join()
  92.     
  93.     # 定义计算服务器需要运行的操作。
  94.     is_chief = (FLAGS.task_id == 0)
  95.     mnist = input_data.read_data_sets(DATA_PATH, one_hot=True)
  96.     
  97.     
  98.     # 通过tf.train.replica_device_setter函数来指定执行每一个运算的设备。
  99.     # tf.train.replica_device_setter函数会自动将所有的参数分配到参数服务器上，将
  100.     # 计算分配到当前的计算服务器上。
  101.     device_setter = tf.train.replica_device_setter(
  102.        worker_device="/job:worker/task:%d" % FLAGS.task_id,
  103.        cluster=cluster)
  104.  
  105.     with tf.device(device_setter):
  106.        # 定义输入并得到每一轮迭代需要运行的操作。
  107.        x = tf.placeholder(
  108.            tf.float32, [None, mnist_inference.INPUT_NODE],
  109.            name='x-input')
  110.        y_ = tf.placeholder(
  111.             tf.float32, [None, mnist_inference.OUTPUT_NODE],
  112.             name='y-input')
  113.        global_config = tf.ConfigProto(allow_soft_placement=True,
  114.                                      log_device_placement=False)
  115.        
  116.        # 通过tf.train.MonitoredTrainingSession管理训练深度学习模型的通用功能。
  117.        with tf.train.MonitoredTrainingSession(
  118.                master=server.target,
  119.                is_chief=is_chief,
  120.                checkpoint_dir=MODEL_SAVE_PATH,
  121.                hooks=hooks,
  122.                save_checkpoint_secs=60,
  123.                config=sess_config) as mon_sess:
  124.            print "session started."
  125.            step = 0
  126.            start_time = time.time()
  127.            
  128.            # 执行迭代过程。在迭代过程中tf.train.MonitoredTrainingSession会帮助
  129.            # 完成初始化。从checkpoint中加载训练过程的模型。输出日志并保存模型，所以
  130.            # 以下程序中不需要在调用这些过程。tf.train.StopAtStepHook会帮助判断
  131.            # 是否需要退出。
  132.            while not mon_sess.should_stop():
  133.                xs, ys = mnist.train.next_batch(BATCH_SIZE)
  134.                _, loss_value, global_step_value = mon_sess.run(
  135.                   [train_op, loss, global_step], feed_dict = {x:xs, y_: ys})
  136.                
  137.                # 每隔一段时间输出训练信息。不同的计算服务器都会更新全局的训练轮数，
  138.                # 所以这里使用global_step_value得到训练中使用过的batch的总数。
  139.                if step > 0 and step % 100 == 0:
  140.                   duration = time.time() - start_time
  141.                   sec_per_batch = duration / global_step_value
  142.                   format_str = "After %d training steps " +\
  143.                                "(%d global steps), loss on training " +\
  144.                                "batch is %g. (% .3f sec/batch)"
  145.                   print format_str % (step, global_step_value, loss_value,
  146.                                      sec_per_batch)
  147.                step += 1
  148.  
  149. if __name__ == "__main__":
  150.    tf.app.run()

假设上面代码的文件名为dist_mnist_saync.py，那么要启动一个拥有一个参数服务器、两个计算服务器的集群，需要先在运行参数服务器的机器上启动以下命令：

  1. python dist_tf_main_async.py  \
  2. --job_name='ps' \
  3. --task_id = 0 \
  4. --ps_hosts='tf-ps0:2222' \ 
  5. --worker_hosts='tf-worker0:2222,tf-worker1:2222'

然后在运行第一个服务器的机器上启动以下命令：

  1. python dist_tf_main_async.py  \
  2. --job_name='worker' \
  3. --task_id = 0 \
  4. --ps_hosts='tf-ps0:2222' \ 
  5. --worker_hosts='tf-worker0:2222,tf-worker1:2222'

最后在运行第二个计算服务器的机器上启动以下命令：

  1. python dist_tf_main_async.py  \
  2. --job_name= 'worker' \
  3. --task_id = 1 \
  4. --ps_hosts= 'tf-ps0:2222' \ 
  5. --worker_hosts= 'tf-worker0:2222,tf-worker1:2222'

最后在运行第二个计算服务器的机器上启动以下命令：

  1. python dist_tf_main_async.py  \
  2. --job_name='worker' \
  3. --task_id = 1 \
  4. --ps_hosts='tf-ps0:2222' \ 
  5. --worker_hosts='tf-worker0:2222,tf-worker1:2222'

在启动第一个计算服务器之后，这个计算服务器就会尝试连接其他的服务器(包括计算服务器和参数服务器)。如果其他服务器还没有启动，则被启动的计算服务器会提示等待连接其它服务器。以下代码展示了一个预警信息。

  1. tensorflow/core/distributed_runtime/master.cc:209] CreateSession still
  2. waiting for response from worker: /job:worker/replica:0/task:1

不过这不影响tensorflow集群的启动。当tensorflow集群中所有服务器都被启动之后，每一个计算服务器将不再预警。在tensorflow集群完全启动之后，训练过程将被执行。在计算服务器训练神经网络的过程中，第一个计算服务器会输出类似下面的信息。

  1. After 100 training steps (100 global steps), loss on training batch is 0.302718.
  2. (0.039 sec/batch)
  3. After 200 training steps (200 global steps), loss on training batch is 0.269476.
  4. (0.037 sec/batch)
  5. After 300 training steps (300 global steps), loss on training batch is 0.286755.
  6. (0.037 sec/batch)
  7. After 400 training steps (463 global steps), loss on training batch is 0.349983.
  8. (0.033 sec/batch)
  9. After 500 training steps (666 global steps), loss on training batch is 0.229955.
  10. (0.029 sec/batch)
  11. After 600 training steps (873 global steps), loss on training batch is 0.245588.
  12. (0.027 sec/batch)

第二个服务器会输出类似下面的信息。

  1. After 100 training steps (537 global steps), loss on training batch is 0.223165.
  2. (0.007 sec/batch)
  3. After 200 training steps (732 global steps), loss on training batch is 0.186126.
  4. (0.010 sec/batch)
  5. After 300 training steps (925 global steps), loss on training batch is 0.228191.
  6. (0.012 sec/batch)

从输出信息中可以看到，在第二个计算服务器启动之前，第一个计算服务器已经运行了很多轮迭代了。在异步模式下，即使有计算服务器没有正常工作，参数更新的过程仍可继续，而且全局的迭代轮数是所有计算服务器迭代轮数的和。

同步模式样例程序

该代码实现了同步模式的分布式神经网络训练过程。

  1. # coding = utf-8
  2. import time
  3. import tensorflow as tf
  4. from tensorflow.example.tutorials.mnist import input_data
  5.  
  6. import mnist_inference
  7.  
  8. # 配置神经网络的参数。
  9. BATCH_SIZE = 100
  10. LEARNING_RATE_BASE = 0.01
  11. LEARNING_RATE_DECAY = 0.99
  12. REGULARAZTION_RATE - 0.0001
  13. TRAINING_STEPS = 20000
  14. MOVING_AVERAGE_DECAY = 0.99
  15.  
  16. MODEL_SAVE_PATH = "logs/log_sync"
  17. DATA_PATH = "/path/to/mnist/data"
  18.  
  19.  
  20. # 和异步模式类似的设置false。
  21. FLAGS = tf.app.flags.FLAGS
  22.  
  23. tf.app.flags.DEFINE_string('job_name', 'worker', ' "ps" or "worker" ')
  24. tf.app.flags.DEFINE_string(
  25.    'ps_hosts', ' tf-ps0:2222,tf-ps1:1111',
  26.    'Comma-separated list of hostname:port for the parameter server '
  27.    'jobs. e.g. "tf-ps0:2222,tf-ps1:1111" ')
  28.  
  29. tf.app.flags.DEFINE_string(
  30.    'ps_hosts', ' tf-ps0:2222,tf-ps1:1111',
  31.    'Comma-separated list of hostname:port for the worker jobs. '
  32.    'e.g. "tf-worker0:2222,tf-worker1:1111" ')
  33. tf.app.flags.DEFINE_integer(
  34.    'task_id', 0, 'Task ID of the worker/replica running the training.')
  35.  
  36. # 和异步模式类似的定义tensorflow的计算图。唯一的区别在于使用
  37. # tf.train.SyncReplicasOptimizer函数处理同步更新。
  38. def build_model(x, y_, n_worker, is_chief)
  39.     regularizer = tf.contrib.layers.l2_regularizer(REGULARAZATION_RATE)
  40.     y = mnist_inference.inference(x, regularizer)
  41.     global_step = tf.contrib.framework.get_or_create_global_step()
  42.     
  43.     cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
  44.         logits=y, labels=tf.argmax(y_, 1))
  45.     cross_entropy_mean = tf.reduce_mean(cross_enropy)
  46.     loss = cross_entropy_mean + tf.add_n(tf.get_collection('lossses'))
  47.     learning_rate = tf.train.exponential_decay(
  48.        LEARNING_RATE_BASE,
  49.        global_step,
  50.        60000 / BATCH_SIZE,
  51.        LEARNING_RATE_DECAY)
  52.     
  53.     # 通过tf.train.SyncReplicaOptimizer函数实现同步更新。
  54.     opt = tf.train.SyncReplicasOptimizer(
  55.        tf.train.GradientDescentOptimizer(learning_rate),
  56.        replica_to_aggregate=n_workers,
  57.        total_num_replicas = n_workers)
  58.     sync_replicas_hook = opot.make_session_run_hook(is_chief)
  59.     train_op = opt.minimize(loss, global_step=global_step)
  60.     
  61.     if is_chief:
  62.        variable_average = tf.train.ExponentialMovingAverage(
  63.           MOVING_AVERAGE_DECAY, global_step)
  64.        variable_average_op = variable_average.apply(
  65.           tf.trainable_variables())
  66.        with tf.control_dependencies([variables_average_op, train_op]):
  67.           train_op = tf.no_op()
  68.     
  69.     return global_step, loss, train_op, sync_replicas_hook
  70.  
  71. def main(argv=None):
  72.    # 创建tensorflow集群。
  73.    ps_hosts = FLAGS.ps_hosts.split(',')
  74.    worker_hosts = FLAGS.worker_hosts.split(',')
  75.    n_workers = len(worker_hosts)
  76.    cluster = tf.train.ClusterSpec(
  77.       {"ps": ps_hosts, "worker": worker_hosts})
  78.    
  79.    server = tf.train.Server(cluster,
  80.                             job_name=FLAGS.job_name,
  81.                             task_index=FALGS.task_id)
  82.    
  83.    if FLAGS.job_name == 'ps':
  84.       with tf.device("/cpu:0"):
  85.          server.join()
  86.    is_chief = (FLAGS.task_id == 0)
  87.    mnist = input_data.read_data_sets(DATA_PATH, one_hot=True)
  88.    
  89.    device_setter = tf.train.replica_device_setter(
  90.       worker_device="/job:worker/task:%d" % FLAGS.task_id
  91.       cluster=cluster)
  92.    
  93.    with tf.device(device_setter):
  94.       x = tf.placeholder(
  95.           tf.float32, [None_inference.INPUT_NODE],
  96.           name='x-input')
  97.       y_ = tf.placeholder(
  98.            tf.float32, [None, mnist_inference.INPUT_NODE],
  99.            name = 'y-input')
  100.       global_step, loss, train_op, sync_replica_hook = build_model(
  101.            x, y_, n_workers, is_chief)
  102.       
  103.       # 把处理同步更新的hook也加进来。
  104.       hooks=[sync_replicas_hook,
  105.              tf.train.StopAtStepHook(last_step=TRAINING_STEPS)]
  106.       sess_config = tf.ConfigProto(allow_soft_placement=True,
  107.                                    log_device_placement=False)
  108.  
  109.       # 训练过程和异步一致。
  110.       with tf.train.MonitoredTrainingSession(
  111.             master=server.target,
  112.             is_chief=is_chief,
  113.             checkpoint_dir=MODEL_SAVE_PATH,
  114.             hooks=hopoks,
  115.             save_checkpoint_secs=60,
  116.             config=sess_config) as mon_sess:
  117.         print "session started."
  118.         step = 0
  119.         start_time = time.time()
  120.         
  121.         while not mon_sess.should_stop():
  122.            xs, ys = mnist.train.next_batch(BATCH_SIZE)
  123.            _, loss_value, global_step_value = mon_sess.run(
  124.               [train_op, loss, global_step], feed_dict={x: xs, y_: ys})
  125.            
  126.            if step > 0 and step % 100 == 0:
  127.               duration = time.time() - start_time
  128.               sec_per_batch = duration / global_step_value
  129.               fromat_str = "After %d training steps(%d global " +\
  130.                            "steps), loss on training " +\
  131.                            " batch is %g. (%.3f sec/batch)"
  132.           
  133.            print format_str % (step, global_step_values, loss_values,
  134.                                sec_per_batch)
  135.         step += 1
  136.  
  137. if __name__ == "__main__"
  138.    tf.app.run()

和异步模式类似，在不同机器上运行以上代码就可以启动tensorflow集群。在第一个计算服务器上，可以看到与下面类似的输出。

  1. After 100 training steps (49 global steps), loss on training batch is 1.60499.
  2. (0.049 sec/batch)
  3. After 200 training steps (99 global steps), loss on training batch is 1.10667.
  4. (0.040 sec/batch)
  5. After 300 training steps (149 global steps), loss on training batch is 0.968059.
  6. (0.036 sec/batch)
  7. After 400 training steps (230 global steps), loss on training batch is 0.833886.
  8. (0.035 sec/batch)
  9. After 500 training steps (330 global steps), loss on training batch is 0.846468.
  10. (0.032 sec/batch)

第二个计算服务器的输出如下：

  1. After 100 training steps (268 global steps), loss on training batch is 0.810314.
  2. (0.035 sec/batch)
  3. After 200 training steps (368 global steps), loss on training batch is 0.602304.
  4. (0.032 sec/batch)
  5. After 300 training steps (468 global steps), loss on training batch is 0.72167.
  6. (0.031 sec/batch)
  7. After 400 training steps (568 global steps), loss on training batch is 0.529358.
  8. (0.030 sec/batch)
  9. After 500 training steps (668 global steps), loss on training batch is 0.626258.
  10. (0.030 sec/batch)

和异步模式不同。在同步模式下，global_step差不多是两个计算器local_step的平均值。比如在第二个计算服务器还没有开始之前，global_step是第一个服务器local_step的一半。这是因为同步模式要求收集replicas_to_aggragate是第一个服务器local_step的一半。这是因为同步模式要求收集replicas_to_aggregate份梯度才会开始更新(注意这里tensorflow不要求每一份梯度来自不同的计算服务器)。同步模式不仅仅是一次使用多份梯度。tf.train.SyncReplicasOptimizer的实现同时也保证了不会出现陈旧变量的问题。tf.train.SyncReplicasOptimizer函数会记录每一份梯度是不是由最新的变量值计算得到的，如果不是，那么这一份梯度将会被丢弃。

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号