使用多块GPU进行训练 1.slim.arg_scope(对于同等类型使用相同操作) 2.tf.name_scope(定义名字的范围) 3.tf.get_variable_scope().reuse_variable(参数的复用) 4.tf.py_func(构造函数)

1. slim.arg_scope(函数, 传参) # 对于同类的函数操作，都传入相同的参数

from tensorflow.contrib import slim as slim
import tensorflow as tf

@slim.add_arg_scope # 进行修饰操作
def fun1(a=0, b=0):
    return a + b

with slim.arg_scope([fun1], a=2):

    x = fun1(b=2)
    print(x)
# 4 

2. tf.name_scope('tower') 对范围内的操作都添加上该操作名

import tensorflow as tf

with tf.name_scope('tower'):
    op = tf.constant(1)
print(op.name)

with tf.name_scope('tower_1'):
    op = tf.constant(1)
print(op.name)
# tower/Const:0
# tower_1/Const:0

3. tf.get_variable_scope.reuse_variable()  对于相同的操作传入使用同一个网络结构，不需要再创建新值

import tensorflow as tf
import vgg


inputs_1 = tf.random_normal([10, 224, 224, 3])
input_2 = tf.random_normal([10, 224, 224, 3])

with tf.variable_scope('vgg_16'):
    net, end_points = vgg.vgg_16(inputs_1, 100, False)
    tf.get_variable_scope().reuse_variables() # 对上述的参数进行重复使用，相当于是reuse=True
    net_, end_points_ = vgg.vgg_16(input_2, 100, False)

with tf.Session() as sess:
     print('no error')

4. tf.py_func(func, [x], [tf.int32]) 与lamda配套使用，相当于是将参数传入到func中

参数说明：func表示定义的函数, [x] 表示传入的参数，[tf.int32]表示返回的类型

import numpy as np
import tensorflow as tf

def func(x):
    return x+20


softmax_idx = np.arange(10)
softmax_idx = map(lambda x:tf.py_func(func, [x], [tf.int32]), softmax_idx)
sess = tf.Session()
for softmax_ides in softmax_idx:
    print(sess.run(softmax_ides))

使用多块GPU进行训练，主要是通过tf.device('/gpu' + str(i)) 来实现的,通过对参数

tf.variable_scope(tf.get_variable_scope) as var_scope：定义参数范围

reuse = False if i== 0 else True 来定义参数是否重复使用，对于第一次创建网络,reuse=False,后续的网络使用reuse=True，表示不需要重新构建网络

这里同样使用tf.get_variable_scope().reuse_variable()来进行参数的复用 

第一步：

      第一步:使用tf.data.Dataset.range() 来构造数据队列

      第二步：使用softmax_data.map(lamda x:tf.pyfunc( _parse_function, [x], [tf.string, tf.int32])) # 将数据集进行传入

      第三步：使用softmax_data.map(tensor_from_slice) # 将数据转换为slice格式进行输出

      第四步：softmax_data.batch(single_size_batch*args.num_gpus) # 创建一个batch的数据集

      第五步：softmax_data.make_initializable_iterator() # 构造迭代器

      第六步： softmax_data_element = softmax_iterator.get_next_batch() 获得一个batch的数据

      第七步：softmax_data_element[0].set_shape() 进行维度的设置

      第八步：使用tf.spilt(softmax_data_element[0], args.num_gpus) 将数据进行切分，构造出batch_image_list 和 batch_label_list 

第二步：

       第一步：循环 args.gpu_num 

       第二步：使用with tf.device('/gpu' + str(i)) # 将训练放在gpu上

       第三步：使用with tf.name_scope('tower_' + str(i))  # 定义名字的变量防止冲突

      第四步：with slim.arg_scope([slim.mode_variable, slim.variable], '/cpu0')   # 将变量放在CPU上进行训练

      第五步：使用tf.variable_scope(tf.get_variable_scope) as var_scope 定义变量的范围

      第六步： 使用tf.get_variable_scope().reuse_scope() 进行变量的复用 

第三步：

     第一步： 将添加到tower_loss的loss求出均值

     第二步：求取梯度，建立训练train_op 

import tensorflow as tf
from tensorflow import data as tf_data
import random
import numpy as np
from tensorflow.contrib import slim as slim




def _sample_people_softmax(x):
    global softmax_ind
    if softmax_ind >= dataset_size:
        softmax_ind = 0
        random.shuffle(indices)
    true_num_batch = min(single_batch_size*args.num_gpus, dataset_size - softmax_ind)

    sample_paths = image_list[softmax_ind:softmax_ind + true_num_batch]
    sample_labels = label_list[softmax_ind:softmax_ind+true_num_batch]

    softmax_ind += true_num_batch

    return np.array(sample_paths), np.array(sample_labels, dtype=np.int32)

def _parse_function(filename, label):
    file_content = tf.read_file(filename)
    image = tf.image.decode_image(file_content)
    print(image.shape)

    if args.random_crop:
        print('use random crop')
        image = tf.random_crop(image, [args.image_size, args.image_size, 3])
    else:
        print('Not use random crop')
        image = tf.image.resize(image, [args.image_height, args.image_width, 3])
    if args.random_flip:
        image = tf.image.random_flip_left_right(image)

    image.set_shape((args.image_height, args.image_width, 3))

    if debug:
        image = tf.cast(image, tf.float32)

    else:
        image = tf.cast(image, tf.float32)
        image = tf.subtract(image, 127.5)
        image = tf.div(image, 128)

    return image, label


learning_rate = 0.01
opt = tf.train.AdamOptimizer(learning_rate)

def _from_tensor_slices(tensor_x, tensor_y):
    return tf_data.Dataset.from_tensor_slices((tensor_x, tensor_y))

with tf.device('/cpu:0'):

    softmax_data = tf_data.Dataset.range(args.epoch_size*args.max_nrof_epochs*100)
    softmax_data = softmax_data.map(lambda x: tf.py_func(_sample_people_softmax, [x], [tf.string, tf.float32]))
    softmax_data = softmax_data.flat_map(_from_tensor_slices)
    softmax_data = softmax_data.map(_parse_function)
    softmax_data = softmax_data.batch(args.num_gpus*single_batch_size)
    softmax_iterator = softmax_data.make_initializable_iterator()
    softmax_data_element = softmax_iterator.get_next()
    softmax_data_element[0].set_shape((args.num_gpus*single_batch_size, args.image_height, args.image_width, 3))
    sotfmax_data_element[1].set_shape((args.num_gpus*single_batch_size))
    batch_image_split = tf.split(softmax_data_element[0], args.num_gpus)
    batch_label_split = tf.split(softmax_data_element[1], args.num_gpus)


tower_loss = []
for i in range(args.num_gpus):
    with tf.device('/gpu:' + str(i)):
        with tf.name_scope('tower_' + str(i)) as scope: # 对参数进行命名防止出现变量冲突
            with slim.arg_scope([slim.model_variable, slim.variable], device='/cpu:0'): # 将变量和全局变量放在cpu上
                with tf.variable_scope(tf.get_variable_scope()) as var_scope: # 设置参数变量的范围
                    reuse = False if i==0 else True
                    '''
                    
                    '''
                    tower_loss.append(loss) # 将loss添加到tower_loss里面
                tf.get_variable_scope().reuse_variables()  # 将参数变量进行重复的使用，相当于是reuse = True

tower_loss = tf.reduce_mean(loss) # 求得损失值
# 进行损失值的train_op更新的构造
grads = opt.compute_gradients(tower_loss, tf.trainable_variables(), colocate_gradients_with_ops=True)
grad_opt = opt.apply_gradients(grads) # 计算梯度
update_op = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_op):
    train_op = tf.group(grad_opt)
sess = tf.Session()
sess.run(softmax_iterator.initializer)