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

时间：2022-08-18 05:21:17

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)

相关文章