TensorFlowによるネットワークトレーニング、検証、テスト

本稿ではtensorflowの使用に関する方法をまとめます.
0、ネットワーク入力の定義
1、tensorflowをどのように利用して既存のネットワークがresnetに入った上で自分のネットワーク構造を構築するか
2、自分のネットワーク層を追加する方法
3、既存のモジュールがresnet全接続層に入る前の部分のパラメータをどのようにインポートするか
4、ネットワーク損失の定義
5、最適化演算子の定義及び減衰最適化演算子
6、予測ネットワーク出力
7、ネットワークモデルを保存する
8、カスタム生成トレーニングbatch
9、トレーニングネットワーク
10、tensorboardによる可視化訓練過程
 
0、ネットワーク入力の定義

    inputs = tf.placeholder(tf.float32, [None, 224, 224, 3], name='inputs')
    labels = tf.placeholder(tf.int32, [None], name='lables')
    is_training = tf.placeholder(tf.bool, name='is_training')

ここでinputsは入力データ、labelsは対応するlabel、is_を表すtrainingは主にdropおよびbatchnorm層のような訓練試験段階を区別するために用いられる.
1、tensorflowをどのように利用して既存のネットワークがresnetに入った上で自分のネットワーク構造を構築するか

    with slim.arg_scope(nets.resnet_v1.resnet_arg_scope()):
        if config.TRAIN.net_layer == '50':
            logits, endpoints = nets.resnet_v1.resnet_v1_50(inputs, num_classes=None, is_training=is_training)
        if config.TRAIN.net_layer == '101':
            logits, endpoints = nets.resnet_v1.resnet_v1_101(inputs, num_classes=None, is_training=is_training)
        if config.TRAIN.net_layer == '152':
            logits, endpoints = nets.resnet_v1.resnet_v1_152(inputs, num_classes=None, is_training=is_training)

resnetを例にとると、logitsはbottleneckの特徴を表し、num_classesはNoneに設定してbottleneckフィーチャーを取得します.
2、自分のネットワーク層を追加する方法

    with tf.variable_scope('Logits'):
        logits = tf.squeeze(logits, axis=[1,2])
        logits = slim.dropout(logits, keep_prob=0.5, scope='scope')
        logits = slim.fully_connected(logits, num_outputs=config.DATASET.num_classes, activation_fn=None, scope='fc')

ここにscopeがあります.後で、主にresnetの既存のパラメータを区別するために使用され、squeezeは1*1*512の特徴をベクトルに伸ばすために使用され、dropout層と全接続層を追加することがわかります.
3、既存のモジュールがresnet全接続層に入る前の部分のパラメータをどのようにインポートするか

    checkpoint_exclude_scopes = 'Logits'
    exclusions = None
    if checkpoint_exclude_scopes:
        exclusions = [scope.strip() for scope in checkpoint_exclude_scopes.split(',')]
    variables_to_restore = []
    for var in slim.get_model_variables():
        excluded = False
        for exclusion in exclusions:
            if var.op.name.startswith(exclusion):
                excluded = True
        if not excluded:
            variables_to_restore.append(var)

logits scopeの下の変数は考慮しないで、他のパラメータrestoreは回復します.
4、ネットワーク損失の定義

loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits))

5、最適化演算子の定義及び減衰最適化演算子

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.0001)
train_step = optimizer.minimize(loss)

    batch = config.TRAIN.batch_size
    sample_size = len(os.listdir(config.DATASET.image_root))
    global_step = tf.Variable(0)
    learning_rate = tf.train.exponential_decay(1e-4, global_step,
                                               decay_steps=4 * sample_size / batch, decay_rate=0.98,
                                               staircase=True)
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

上は通常定義最適化演算子、下は減衰最適化演算子を表します.ここで、batchは各batchサンプル数、sample_を表すsizeすなわちサンプル数global_Stepは現在のiteration,sample_を取得するために使用されます.size/batchすなわちepochごとに含まれるiterationの数であり、減衰を計算するとdecay_Stepは1回の学習率を下げる.learning_rate_current = learning_rate_start * dacay_rate ** (global_step/decay_steps).
6、予測ネットワーク出力

    logits = tf.nn.softmax(logits, name='logits')
    classes = tf.argmax(logits, axis=1, name='classes')
    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.cast(classes, tf.int32), labels), tf.float32))

7、ネットワークモデルを保存する

    init = tf.global_variables_initializer()
    saver_restore = tf.train.Saver(var_list=variables_to_restore)
    saver = tf.train.Saver(tf.global_variables())

8、カスタム生成トレーニングbatch

images, truths, valid_imgs, valid_trus = get_batch()

def get_label(xml_path):
	tree = ET.parse(xml_path)
	objs = tree.findall('object')

	objs = [obj for obj in objs if 'b' in obj.find('name').text] # select all pointer pannels
	if not len(objs) == 1:
		return [[], []]
	obj = objs[0] # suppose there is only one pannel, otherwise use center selection
	label = str(float(obj.find('name').text.split('b')[-1]))
	return [label]

def get_list():
	image_list = []
	label_list = []
	for file in os.listdir(config.DATASET.image_root):
		image_label = get_label(os.path.join(config.DATASET.label_root,file.split('.jpg')[0]+'.xml'))
		if len(image_label) > 1:
			continue
		else:
			image_label = image_label[0]
		if image_label in config.DATASET.range_dict.keys():
			label_list.append(config.DATASET.range_dict[image_label])
		else:
			label_list.append(len(config.DATASET.range_dict))
		image_list.append(os.path.join(config.DATASET.image_root,file))
	valid_num = int(len(image_list)*config.DATASET.valid_ratio)
	train_list = image_list[valid_num:]
	valid_list = image_list[:valid_num]
	train_label = label_list[valid_num:]
	valid_label = label_list[:valid_num]
	return train_list, train_label, valid_list, valid_label

def process_batch(input_quene):

	label = input_quene[1]
	image = tf.read_file(input_quene[0])
	image = tf.image.decode_jpeg(image, channels=3)
	image = tf.image.resize_image_with_crop_or_pad(image, config.DATASET.width, config.DATASET.height)
	image = tf.image.per_image_standardization(image)

	image_batch, label_batch = tf.train.batch([image, label], batch_size=config.TRAIN.batch_size,
											  capacity=config.TRAIN.capacity, num_threads=config.TRAIN.num_threads)
	label_batch = tf.reshape(label_batch, [config.TRAIN.batch_size])
	image_batch = tf.cast(image_batch, tf.float32)

	return image_batch, label_batch


def get_batch():
	train_image_list, train_label_list, valid_image_list, valid_label_list = get_list()

	input_quene = tf.train.slice_input_producer([train_image_list, train_label_list])
	trian_image_batch, trian_label_batch = process_batch(input_quene)

	valid_quene = tf.train.slice_input_producer([valid_image_list, valid_label_list])
	valid_image_batch, valid_label_batch = process_batch(valid_quene)

	return trian_image_batch, trian_label_batch, valid_image_batch, valid_label_batch

9、トレーニングネットワーク

    with tf.Session(config=tfConfig) as sess:

        sess.run(init)
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)

        # =============================Import Pretrained Parameter=========================== #
        saver_restore.restore(sess, config.TRAIN.model_path)

        # ================================TensorBoard Related================================ #
        tf.summary.image('inputs',inputs)
        tf.summary.scalar('loss',loss)
        tf.summary.scalar('accuracy',accuracy)
        tf.summary.scalar('learning rate', learning_rate)
        merged_summary_op = tf.summary.merge_all()
        if os.path.exists(os.path.join(config.TRAIN.log_path, 'train')):
            shutil.rmtree(os.path.join(config.TRAIN.log_path, 'train'))
        if os.path.exists(os.path.join(config.TRAIN.log_path, 'valid')):
            shutil.rmtree(os.path.join(config.TRAIN.log_path, 'valid'))
        train_writer = tf.summary.FileWriter(os.path.join(config.TRAIN.log_path, 'train'), sess.graph)
        valid_writer = tf.summary.FileWriter(os.path.join(config.TRAIN.log_path, 'valid'))

        for i in range(config.TRAIN.num_iterations):

            images_, truths_ = sess.run([images, truths])
            valid_imgs_, valid_trus_ = sess.run([valid_imgs, valid_trus])

            summary_str, _, loss_, acc_ = sess.run([merged_summary_op, train_step, loss, accuracy], \
                                      feed_dict={inputs: images_, labels: truths_, is_training: True})
            valid_str, vloss, vacc = sess.run([merged_summary_op, loss, accuracy], \
                                      feed_dict={inputs: valid_imgs_, labels: valid_trus_, is_training: False})

            print('Step: {}, Loss: {:.4f}, Accuracy: {:.4f}, Valid Loss: {:.4f}, Valid Accuracy: {:.4f}'.format(i+1, loss_, acc_, vloss, vacc))

            # if (i+1) % 1000 == 0:
            #     saver.save(sess, config.TRAIN.save_path)
            #     print('save mode to {}'.format(config.TRAIN.save_path))

            # summary_str = sess.run(merged_summary_op)
            train_writer.add_summary(summary_str, i)
            valid_writer.add_summary(valid_str, i)


        coord.request_stop()
        coord.join(threads)

10、tensorboardによる可視化訓練過程

        tf.summary.image('inputs',inputs)
        tf.summary.scalar('loss',loss)
        tf.summary.scalar('accuracy',accuracy)
        tf.summary.scalar('learning rate', learning_rate)
        merged_summary_op = tf.summary.merge_all()
        if os.path.exists(os.path.join(config.TRAIN.log_path, 'train')):
            shutil.rmtree(os.path.join(config.TRAIN.log_path, 'train'))
        if os.path.exists(os.path.join(config.TRAIN.log_path, 'valid')):
            shutil.rmtree(os.path.join(config.TRAIN.log_path, 'valid'))
        train_writer = tf.summary.FileWriter(os.path.join(config.TRAIN.log_path, 'train'), sess.graph)
        valid_writer = tf.summary.FileWriter(os.path.join(config.TRAIN.log_path, 'valid'))