1.数据读取 tfrecord
-
调用 tf.train.slice_input_producer，从 本地文件里抽取tensor，准备放入Filename Queue（文件名队列）中;
- 调用 tf.train.batch，从文件名队列中提取tensor，使用单个或多个线程，准备放入文件队列;
- 调用 tf.train.Coordinator() 来创建一个线程协调器，用来管理之后在Session中启动的所有线程;
- 调用tf.train.start_queue_runners, 启动入队线程，由多个或单个线程，按照设定规则，把文件读入Filename Queue中。函数返回线程ID的列表，一般情况下，系统有多少个核，就会启动多少个入队线程（入队具体使用多少个线程在tf.train.batch中定义）;
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
if is_train:
while not coord.should_stop():
i +=1
if i < 2000:
lrn_rate = 0.01
elif i < 4000:
_lrn_rate = 0.001
else:
_lrn_rate = 0.0001
kp = 0.5
sess.run(train_step,feed_dict={lr:lrn_rate,keep_prob:kp})
2. 通过placeholder
train_files = []
train_file_path = "train_filename.txt"
with open(train_file_path) as file:
for line in file.readlines():
root_name = line.split('.')[0]
train_files.append(root_name)
total_train_images = train_files
total_train_length = len(total_train_images)
start = total_train_index
end = total_train_index + batch_size
for i in range(start, end):
if i == total_train_length:
np.random.shuffle(total_train_images)
train_epoch +=1
idx = i % total_train_length
image_name = total_train_images[idx]
image_path = os.path.join(origin_data_folder, image_name+'.jpg')
ground_truth_path = os.path.join(ground_truth_folder, image_name+'.mat')
image_paths.append((image_path, ground_truth_path))
for i in range(num_epochs):
data, labels = load_batch(batch_size=batch_size, path_func=get_images_labels)
global_step = lesion_net.train_step(batch_data=data, batch_labels=labels)
def train_step(self, batch_data, batch_labels):
feed_dict = {
self.data: batch_data,
self.ground_truth: batch_labels
}
_, loss, global_loss, global_step, summaries = \
self.sess.run([self.train_op, self.mse, self.global_loss,
self.global_step, self.train_summaries_merge], feed_dict=feed_dict)
with tf.name_scope('Data'):
self.data = tf.placeholder(shape=[None, 1024, 1024, 3], dtype=tf.float32)
self.ground_truth = tf.placeholder(shape=[None, 1024, 1024, 1], dtype=tf.float32)
3. loss and summary
with tf.name_scope('LesionTrain'):
self.mse = tf.reduce_mean(tf.square(lesion_map - self.ground_truth))
regularization_losses = tf.losses.get_regularization_losses('Lesion')
self.regularization_losses = tf.get_collection(key=tf.GraphKeys.REGULARIZATION_LOSSES, scope='Lesion')
print(self.regularization_losses)
self.global_loss = tf.add_n([self.mse] + self.regularization_losses, 'global_loss')
# only trainable variables
self.train_vars = tf.get_collection(key=tf.GraphKeys.TRAINABLE_VARIABLES, scope='Lesion')
# for train_var in self.train_vars:
# print(train_var)
self.global_step = tf.Variable(0, trainable=False)
# 31,000 - 49,500
learning_rate = 0.0001
optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate)
self.train_op = optimizer.minimize(var_list=self.train_vars,
loss=self.mse, global_step=self.global_step)
# add summaries
tf.summary.scalar('learning_rate', learning_rate)
tf.summary.scalar('mse', self.mse)
tf.summary.scalar('loss', self.global_loss)
# merge all summaries and write to file
self.train_summaries_merge = tf.summary.merge_all()
self.summary_writer = tf.summary.FileWriter('Summaries', graph=self.sess.graph)
4. if pretrained_model:
print('Restoring pretrained model: %s' % pretrained_model)
saver.restore(sess, pretrained_model)
5. new_layer_names = ['InceptionResnetV1/Bottleneck/','InceptionResnetV1/tf_add']
newlayer_need_update=[]
oldlayer_need_restore = []
# Create a saver
for var in tf.trainable_variables:
if any( elem in var.name for elem in new_layer_names):
newlayer_need_update.append(var)
else:
oldlayer_need_restore.append(var)
loader = tf.train.Saver(var_list =oldlayer_need_restore)
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
6. Model
print('Model directory: %s' % model_exp)
meta_file, ckpt_file = get_model_filenames(model_exp)
print('Metagraph file: %s' % meta_file)
print('Checkpoint file: %s' % ckpt_file)
saver = tf.train.import_meta_graph(os.path.join(model_exp, meta_file), input_map=input_map)
saver.restore(session, os.path.join(model_exp, ckpt_file))
7. variable
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
variable_arrary = [var for var in tf.global_variables()]
variablevalues = sess.run(variable_arrary)
variable_names = [v.name for v in tf.global_variables()]
for k, m in zip(variable_names,variablevalues):
print("Variable: ", k)
print("Shape: ", m.shape)
print()
8. statistics
print('Saving statistics')
with h5py.File(stat_file_name, 'w') as f:
for key, value in stat.iteritems():
f.create_dataset(key, data=value)
API
9.tf.nn
# def conv2d(name, l_input, w, b): # return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(l_input, w, strides=[1, 1, 1, 1], padding='SAME'),b), name=name) # # # 最大下采样操作 # def max_pool(name, l_input, k): # return tf.nn.max_pool(l_input, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME', name=name) # # # 归一化操作 # def norm(name, l_input, lsize=4): # return tf.nn.lrn(l_input, lsize, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name=name) #
# weights = {
# 'wc1': tf.Variable(tf.random_normal([3, 3, 3, 64])),
# 'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128])),
# 'wc3': tf.Variable(tf.random_normal([3, 3, 128, 256])),
# 'wd1': tf.Variable(tf.random_normal([4*4*256, 1024])),
# 'wd2': tf.Variable(tf.random_normal([1024, 1024])),
# 'out': tf.Variable(tf.random_normal([1024, 2]))
# }
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
def print_activations(t):
print(t.op.name, ' ', t.get_shape().as_list())
def conv_op(input_op, name, kh, kw, n_out, dh, dw):
input_op = tf.convert_to_tensor(input_op)
n_in = input_op.get_shape()[-1].value
with tf.name_scope(name) as scope:
kernel = tf.get_variable(scope + "w",
shape=[kh, kw, n_in, n_out],
dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer_conv2d())
conv = tf.nn.conv2d(input_op, kernel, (1, dh, dw, 1), padding='SAME')
bias_init_val = tf.constant(0.0, shape=[n_out], dtype=tf.float32)
biases = tf.Variable(bias_init_val, trainable=True, name='b')
z = tf.nn.bias_add(conv, biases)
activation = tf.nn.relu(z, name=scope)
return activation
def _conv(self, name, x, filter_size, in_filters, out_filters, strides):
"""Convolution."""
with tf.variable_scope(name):
n = filter_size * filter_size * out_filters
kernel = tf.get_variable(
'DW', [filter_size, filter_size, in_filters, out_filters],
tf.float32, initializer=tf.random_normal_initializer(
stddev=np.sqrt(2.0/n)))
return tf.nn.conv2d(x, kernel, strides, padding='SAME')
def _relu(self, x, leakiness=0.0):
"""Relu, with optional leaky support."""
return tf.where(tf.less(x, 0.0), leakiness * x, x, name='leaky_relu')
def _fully_connected(self, x, out_dim):
"""FullyConnected layer for final output."""
x = tf.reshape(x, [self.hps.batch_size, -1])
w = tf.get_variable(
'DW', [x.get_shape()[1], out_dim],
initializer=tf.uniform_unit_scaling_initializer(factor=1.0))
b = tf.get_variable('biases', [out_dim],
initializer=tf.constant_initializer())
return tf.nn.xw_plus_b(x, w, b)
def _batch_norm(self, name, x):
"""Batch normalization."""
with tf.variable_scope(name):
params_shape = [x.get_shape()[-1]]
beta = tf.get_variable(
'beta', params_shape, tf.float32,
initializer=tf.constant_initializer(0.0, tf.float32))
gamma = tf.get_variable(
'gamma', params_shape, tf.float32,
initializer=tf.constant_initializer(1.0, tf.float32))
if self.mode == 'train':
mean, variance = tf.nn.moments(x, [0, 1, 2], name='moments')
moving_mean = tf.get_variable(
'moving_mean', params_shape, tf.float32,
initializer=tf.constant_initializer(0.0, tf.float32),
trainable=False)
moving_variance = tf.get_variable(
'moving_variance', params_shape, tf.float32,
initializer=tf.constant_initializer(1.0, tf.float32),
trainable=False)
self._extra_train_ops.append(moving_averages.assign_moving_average(
moving_mean, mean, 0.9))
self._extra_train_ops.append(moving_averages.assign_moving_average(
moving_variance, variance, 0.9))
else:
mean = tf.get_variable(
'moving_mean', params_shape, tf.float32,
initializer=tf.constant_initializer(0.0, tf.float32),
trainable=False)
variance = tf.get_variable(
'moving_variance', params_shape, tf.float32,
initializer=tf.constant_initializer(1.0, tf.float32),
trainable=False)
tf.summary.histogram(mean.op.name, mean)
tf.summary.histogram(variance.op.name, variance)
# epsilon used to be 1e-5. Maybe 0.001 solves NaN problem in deeper net.
y = tf.nn.batch_normalization(
x, mean, variance, beta, gamma, 0.001)
y.set_shape(x.get_shape())
return y
slim API
# 149 x 149 x 32
net = slim.conv2d(inputs, 32, 3, stride=2, padding='VALID',
scope='Conv2d_1a_3x3')
end_points['Conv2d_1a_3x3'] = net
# 147 x 147 x 32
net = slim.conv2d(net, 32, 3, padding='VALID',
scope='Conv2d_2a_3x3')
end_points['Conv2d_2a_3x3'] = net
# 147 x 147 x 64
net = slim.conv2d(net, 64, 3, scope='Conv2d_2b_3x3')
end_points['Conv2d_2b_3x3'] = net
# 73 x 73 x 64
net = slim.max_pool2d(net, 3, stride=2, padding='VALID',
scope='MaxPool_3a_3x3')
end_points['MaxPool_3a_3x3'] = net
# 73 x 73 x 80
net = slim.conv2d(net, 80, 1, padding='VALID',
scope='Conv2d_3b_1x1')
end_points['Conv2d_3b_1x1'] = net
# 71 x 71 x 192
net = slim.conv2d(net, 192, 3, padding='VALID',
scope='Conv2d_4a_3x3')
end_points['Conv2d_4a_3x3'] = net
# 35 x 35 x 256
net = slim.conv2d(net, 256, 3, stride=2, padding='VALID',
scope='Conv2d_4b_3x3')
end_points['Conv2d_4b_3x3'] = net
def reduction_a(net, k, l, m, n):
with tf.variable_scope('Branch_0'):
tower_conv = slim.conv2d(net, n, 3, stride=2, padding='VALID',
scope='Conv2d_1a_3x3')
with tf.variable_scope('Branch_1'):
tower_conv1_0 = slim.conv2d(net, k, 1, scope='Conv2d_0a_1x1')
tower_conv1_1 = slim.conv2d(tower_conv1_0, l, 3,
scope='Conv2d_0b_3x3')
tower_conv1_2 = slim.conv2d(tower_conv1_1, m, 3,
stride=2, padding='VALID',
scope='Conv2d_1a_3x3')
with tf.variable_scope('Branch_2'):
tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID',
scope='MaxPool_1a_3x3')
net = tf.concat([tower_conv, tower_conv1_2, tower_pool], 3)
return net
with tf.variable_scope('Logits'):
end_points['PrePool'] = net
#pylint: disable=no-member
# 1*1*1792
net = slim.avg_pool2d(net, net.get_shape()[1:3], padding='VALID',
scope='AvgPool_1a_8x8')
#1792
net = slim.flatten(net)
net = slim.dropout(net, dropout_keep_prob, is_training=is_training,
scope='Dropout')
end_points['PreLogitsFlatten'] = net
#512
net = slim.fully_connected(net, bottleneck_layer_size, activation_fn=None,
scope='Bottleneck', reuse=False)