1.tf.train.batch(image, batch_size=batch_size, num_threads=1) # 获取一个batch的数据
参数说明：image表示输入图片，batch_size表示一个batch的大小，num_threads表示使用几个线程进行执行
import tensorflow as tf import numpy as np def generate_data(): num = 25 label = np.asarray(range(0, num)) image = np.random.random([num, 1, 1, 1]) return label, image def get_batch_data(): labels, images = generate_data() images = tf.cast(images, 'float32') labels = tf.cast(labels, 'int32') input_queue = tf.train.slice_input_producer([images, labels], shuffle=False) image_batch, label_batch = tf.train.batch(input_queue, batch_size=10, num_threads=1, capacity=64) return image_batch, label_batch image_batch, label_batch = get_batch_data() with tf.Session() as sess: coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) i = 0 for i in range(10): image_batch_v, label_batch_v = sess.run([image_batch, label_batch]) print(image_batch_v, label_batch_v) coord.request_stop() coord.join(threads) sess.close()
实例说明
2.tf.image.resize_image_with_crop_or_pad(image, IMAGE_SIZE, IMAGE_SIZE) # 表示对图片进行压缩，即变化维度， 相当于tf.resize(操作)
参数说明：image表示输入图片，IMAGE_SIZE表示变化后的维度
3.tf.train.per_image_standardization(image) 对图片进行标准化操作
参数说明：image表示输入的图片
4.tf.train.string_input_producer(filenames) # 将字符串放入到队列中
参数说明：filename表示输入的字符串集合
5. tf.TFRecordReader() # 构建tfr读取器，使用.read() 对文件进行读取
6. tf.parse_single_example(serialized_exmaple, features={}) 解析example数据字符串
7.tf.train.start_queue_runner(coord=coord， sess=sess) 用来启动线程，进行多线程操作
参数说明：coord表示线程协调器，sess执行函数支持多线程
8.tf.train.Coordinator() 用于建立线程协调器， coord.join(threads) 将多线程放入到线程协调器中
数据说明：使用的数据是Tfrecord数据集，一共3670个数据，每次迭代选取16张图片，输出的结果类别数是5
文中的代码主要是分为两个部分：
第一部分构造flower_input, 读取batch_image, batch_label
第二部分：构造image_tensor_input和label_tensor_input, 输入到构造的flower_inference模型中进行训练，输出结果为softmax概率值，构造loss和train_op，sess.run进行模型的训练操作
第一部分：
第一步：构造flower_input函数，输入为if_random, if_train
第二步：根据是否训练，使用[os.path.join(path_data + ''%i) for i in range(0, 2)] 来获得文件的路径filenames
第三步：使用tf.train.string_input_producer(filenames) , # 输出字符变成一个输入队列中
第四步：将filename_queue输入到read_and_decode(filename_queue) 输出image_object实例化对象，包含image， label， filename等属性
第一步：使用tf.TFRecordReader() 构造reader的读写器
第二步：使用_, serialized_example = reader.read(filenames) 获得存储好的example
第三步：使用tf.parse_single_example(features={}) 获得属性值
第四步：实例化_image_object(), 用于储存image,label, filename，width和height
第五步：使用image_raw = tf.image.decode_jpeg(feature[image/encoded]) # 对图片进行解码操作
第六步：使用tf.image.resize_image_with_crop_or_pad(image_raw) 对图像进行维度的压缩变换
第七步：将其他属性label，filename， height，width，使用image_object.label = features['image/labels'] 进行添加, 返回image_object
第五步：使用image_object.image 获得image， 使用tf.train.per_image_standardization对image进行标准化操作
第六步：使用image_object.label获得label属性
第七步：使用image_object.filename获得filename属性
第八步：判断是否是随机的batch，如果是随机的使用tf.train.shuffle_batch,如果不是随机的batch，使用tf.train.batch([image, label, filename]) 获得随机的batch，返回image_batch, label_batch, filename_batch
第二部分：第一部分，获得了一个batch的数据， 第二部分，建立网络模型
第一步：使用tf.placeholder()构建image_tensor_input, 同时对image_batch_out 进行维度的变化，确认其维度为[BATCH_SIZE, 224, 224, 3]
第二步：使用tf.placeholder()构建label_tensor_input,同时构造label_offset = -tf.ones([batch_size]) ，然后使用tf.add(label_batch_out, label_offset) 将标签值从1变为0。
第三步：构造flower_inference(image_tensor_input)获得logits_batch_out, 对logists_batch 进行维度变化，确认其维度为[BATCH_SIZE, 5]
flower_inference是用于构造卷积的模型，网络的结构是卷积层5层，全连接层4层，输出层为[BATCH_SIZE, 5], 结果使用tf.nn.softmax()
第四步： 使用tf.nn.softmax_entropy_logits(logits=logits_out, labels=tf.one_hots(label_tensor_input, depth=5)) 构造loss损失函数
第五步：使用tf.train.GradientDescentOptimizer().minimize(loss) 构造train_op,降低损失值
第六步：使用with tf.Session() as sess 构造sess执行函数
第七步：使用sess.run, 进行变量的初始化操作
第八步：使用tf.train.Coordinator() 构造coord通道，使用tf.train.start_queue_runners(coord=coord, sess=sess) 构造threads多线程
第九步：进行循环，使用sess.run([image_batch, label_batch]) 获得实际的image_batch 和 label_batch
第十步：使用sess.run([train_op, logits_out, loss]) 进行训练操作
第十一步：coord.request_stop() 将coord进行关闭
第十二步：coord.join(threads) 将多线程添加到通道数，sess.close() 关闭sess
import tensorflow as tf import numpy as np import os data_path = './data/' TRAINING_SET_SIZE = 3670 BATCH_SIZE = 16 IMAGE_SIZE = 224 def create_Weight(shape): return tf.Variable(tf.truncated_normal(shape=shape, stddev=0.05)) def creat_biases(shape): return tf.Variable(tf.constant(0.1, shape=shape)) def conv2d(x, w): return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME') def maxpool(x): return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') def flower_inference(image_tensor_input): # 确认输入的图片的维度为[batchsize, 224, 224, 5] x_image = tf.reshape(image_tensor_input, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) # 创建第一层卷积的w w_conv1 = create_Weight([5, 5, 3, 32]) # 第一层卷积的b b_conv1 = creat_biases([32]) # 进行卷积和激活操作 h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1) + b_conv1) # 进行池化操作 h_pool1 = maxpool(h_conv1) # 第二层卷积的w w_conv2 = create_Weight([5, 5, 32, 64]) # 第二层卷积的b b_conv2 = creat_biases([64]) # 卷积和激活操作 h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2) # 池化操作 h_pool2 = maxpool(h_conv2) # 第三层卷积的w w_conv3 = create_Weight([5, 5, 64, 128]) # 第三层卷积的b b_conv3 = creat_biases([128]) # 卷积和激活操作 h_conv3 = tf.nn.relu(conv2d(h_pool2, w_conv3) + b_conv3) # 池化操作 h_pool3 = maxpool(h_conv3) # 第四层卷积的w w_conv4 = create_Weight([5, 5, 128, 256]) # 第四层卷积的b b_conv4 = creat_biases([256]) # 进行卷积和激活操作 h_conv4 = tf.nn.relu(conv2d(h_pool3, w_conv4) + b_conv4) # 进行池化操作 h_pool4 = maxpool(h_conv4) # 第五层卷积的w w_conv5 = create_Weight([5, 5, 256, 256]) # 第五层卷积的b b_conv5 = creat_biases([256]) # 进行卷积和激活操作 h_conv5 = tf.nn.relu(conv2d(h_pool4, w_conv5) + b_conv5) # 池化操作 h_pool5 = maxpool(h_conv5) # 将卷积后的结果进行维度的变换，以便后续进行全连接操作 fcIn = tf.reshape(h_pool5, [-1, 7*7*256]) # 第一层全连接的w w_fc1 = create_Weight([7*7*256, 2048]) # 第一层全连接的b b_fc1 = creat_biases([2048]) # 点乘和激活操作 h_fc1 = tf.nn.relu(tf.matmul(fcIn, w_fc1) + b_fc1) # dropout操作 h_fc1_dropout = tf.nn.dropout(h_fc1, 1.0) # 第二层全连接的w w_fc2 = create_Weight([2048, 256]) # 第二层全连接的b b_fc2 = creat_biases([256]) # 点乘和激活操作 h_fc2 = tf.nn.relu(tf.matmul(h_fc1_dropout, w_fc2) + b_fc2) # 第三层全连接层 w_fc3 = create_Weight([256, 64]) b_fc3 = creat_biases([64]) h_fc3 = tf.nn.relu(tf.matmul(h_fc2, w_fc3) +b_fc3) # 第四层全连接输出层 w_fc4 = create_Weight([64, 5]) b_fc4 = creat_biases([5]) # 对输出的结果使用softmax获得概率值 y_prob = tf.nn.softmax(tf.matmul(h_fc3, w_fc4) + b_fc4) return y_prob class _image_object: # 构造实例化属性 def __init__(self): # 存放图片，高度，宽度，名字和标签属性 self.image = tf.Variable([], dtype=tf.string) self.height = tf.Variable([], dtype=tf.int64) self.width = tf.Variable([], dtype=tf.int64) self.filename = tf.Variable([], dtype=tf.string) self.label = tf.Variable([], dtype=tf.int32) def read_and_decode(filename_queue): # 构造TFR的读写器 reader = tf.TFRecordReader() # 使用reader.read(filename_queue)读出存入的exmaple数据 _, serialized_exmaple = reader.read(filename_queue) # 使用tf.parse_single_example, 获得数据中属性对应的数据 features = tf.parse_single_example(serialized_exmaple, features={ 'image/encoded':tf.FixedLenFeature([], tf.string), 'image/height': tf.FixedLenFeature([], tf.int64), 'image/width': tf.FixedLenFeature([], tf.int64), 'image/filename': tf.FixedLenFeature([], tf.string), 'image/class/label': tf.FixedLenFeature([], tf.int64) }) # 获得编码的图片数据 image_decode = features['image/encoded'] # 使用tf.image.decode_jpeg 对图片进行解码操作 image_raw = tf.image.decode_jpeg(image_decode, channels=3) # 实例化函数，用于进行数据集合的存储 image_object = _image_object() # 使用tf.image.resize_image_with_crop_or_pad进行维度的变换和压缩，并存储到image.object image_object.image = tf.image.resize_image_with_crop_or_pad(image_raw,IMAGE_SIZE, IMAGE_SIZE) # 将label属性存储到image_object.label中 image_object.label = features['image/class/label'] # 将filename属性存储到image_object.filename中 image_object.filename = features['image/filename'] # 将height属性存储到image_object.height中 image_object.height = features['image/height'] # 将width属性存储到image_object.width中 image_object.width = features['image/width'] # 返回数据集合image_object return image_object # 第一步：创建flower_input，用于进行数据的创建，输入为是否训练和是否获得随机的batch值 def flower_input(if_train=True, if_random=True): # 第二步：如果是进行训练，获得训练集的文件地址 if if_train: filenames = [os.path.join(data_path, 'train-0000%d-of-00002.tfrecord'%i) for i in range(0, 2)] else: filenames = [os.path.join(data_path, 'eval-0000%d-of-00002.tfrecord'%i) for i in range(0, 2)] # 判断文件是否存在，如果不存在返回错误提醒 for f in filenames: if not tf.gfile.Exists(f): raise ValueError('the file is not exits', f) # 第三步：使用tf.train.string_input_producer()将数据输入到队列中 filename_queue = tf.train.string_input_producer(filenames) # 第四步：构造函数获得数据集合 image_object = read_and_decode(filename_queue) # 使用tf.image.per_image_standardization对图片进行标准化 image = tf.image.per_image_standardization(image_object.image) # 获得图片的标签 label = image_object.label # 获得图片的文件名 filename = image_object.filename # 如果是随机获得标签，使用tf.train.shuffle_batch if if_random: min_fraction_of_example_in_queue = 0.4 min_queue_examples = int(min_fraction_of_example_in_queue * TRAINING_SET_SIZE) num_preprocess_threads = 1 image_batch, label_batch, filename_batch = tf.train.shuffle_batch( [image, label, filename], batch_size = BATCH_SIZE, num_threads = num_preprocess_threads, capacity = min_queue_examples + 3 * BATCH_SIZE, min_after_dequeue = min_queue_examples ) # 返回batch的image，label，filename return image_batch, label_batch, filename_batch else: # 如果不是随机获得数据，使用tf.train.batch image_batch, label_batch, filename_batch = tf.train.batch( [image, label, filename], batch_size = BATCH_SIZE, num_threads = 1 ) #返回batch的image，label，filename return image_batch, label_batch, filename_batch def flower_trian(): # 第一部分：使用tf.train.batch获得一个batch的数据 image_batch_out, label_batch_out, filename_batch = flower_input(if_train=True, if_random=False) # 第二部分：构造模型，进行模型的训练，使用sess.run()获得上述的实际数据 # 第一步：使用tf.placeholder初始化输入图像，并对image_batch_out确认维度 image_tensor_input = tf.placeholder(tf.float32, [BATCH_SIZE, 224, 224, 3]) image_batch = tf.reshape(image_batch_out, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) # 第二步：使用tf.placeholder初始化标签值，并构造-1的[batch_size]大小，与标签进行加和，使得标签值变成从0开始 label_tensor_input = tf.placeholder(tf.int64, [BATCH_SIZE]) label_offset = -tf.ones([BATCH_SIZE], dtype=tf.int64, name='label_offset') label_batch = tf.add(label_batch_out, label_offset) # 第三步：构造模型，带入image_tensor_input获得5个类别的概率值，维度为[BATCHSIZE, 5] logits_batch_out = flower_inference(image_tensor_input) logits_batch = tf.reshape(logits_batch_out, [BATCH_SIZE, 5]) # 第四步：使用tf.nn.sotfmax_cross(logist=logits_batch, labels=tf.one_hot() 进行对标签进行one_hot编码 loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=tf.one_hot(label_tensor_input, depth=5), logits=logits_batch)) # 第五步：使用tf.train.Gradient降低损失值loss train_op = tf.train.GradientDescentOptimizer(0.0001).minimize(loss) saver = tf.train.Saver() # 第六步：使用tf.Session() 构造sess执行函数 with tf.Session() as sess: # 第七步：对参数进行初始化操作 sess.run(tf.global_variables_initializer()) # 第八步：使用tf.train.Coordinator构造通道数 coord = tf.train.Coordinator() # 第九步：使用tf.train.start_queue_runners构造sess的多线程threads threads = tf.train.start_queue_runners(coord=coord, sess=sess) for i in range(TRAINING_SET_SIZE * 10): # 第十步：使用sess.run获得实际的batch的label，image image_batch_v, label_batch_v, filename_batch_v = sess.run([image_batch, label_batch, filename_batch]) # 第十一步：进行实际的train_op, loss, logits的执行 _, infer_out, loss_out = sess.run([train_op, logits_batch, loss], feed_dict={image_tensor_input:image_batch_v, label_tensor_input:label_batch_v}) # 打印结果 if (i % 10 == 0): print('infer_out') print(infer_out) print('loss_out') print(loss_out) # 第十一步：关闭线程 coord.request_stop() # 第十二步：将线程进行添加，和关闭sess coord.join(threads) sess.close() flower_trian()
