1. 配套使用: tf.train.Examples将数据转换为二进制，提升IO效率和方便管理
对于int类型 ： tf.train.Examples(features=tf.train.Features(feature=tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))))
对于bytes类型： tf.train.Examples(features=tf.train.Features(feature=tf.train.Feature(int64_list=tf.train.BytesList(value=[value]))))
2. tf.image.decode_jpeg(image, channel=3) # 将图片进行解码操作，通道数是3
参数说明：image表示图片，channel表示通道数
3. tf.image.encode_jpeg(image, format='rgb', quality=100) # 将解码后的图片，转码成jpeg
参数说明：image表示图片，format表示rgb的类型，quality表示图片的质量
4. tf.train.Coordinator() # 构建多线程通道，使用coord.join(threads)将线程列表添加
5.t = threading.Thread(target=, args=) # 建立单线程
参数说明：target表示对应的函数，args表示传入的参数
6. tf.python_io.TFRecordWriter(output_path) 构造TFR的写入器writer，使用writer.write将打包的参数写入
参数说明：output_path表示保存TFR文件的路径
7.np.linspace(0, len(3), 3) # 表示将数据进行切分，
参数说明：0表示第一个数，len(3)表示第二个数，3表示切分成3个数，
8. sys.stdout.flush() 进行数据的刷新
数据说明：在flower文件中，存在5个文件，每个文件的文件名分别对应的是标签名，在flower_label.txt保存的5个标签名
代码说明：这个采用了多线程的方式，即如果要生成n个shards，有2个thread, 那么每个thread就处理n/2个shards的生成
参数说明：使用tf.app.flags.DEFINE_string 进行参数的设置，使用FLAGS = tf.app.flags.FLAGS将参数并入FLAGS中
代码主要分为第一部分和第二部分，使用tf.app.run()执行代码，定义model()，在model中分为两部分
第一部分：用于进行文件名的读取filenames，标签的制作labels，以及存入标签名texts
第二部分：建立多个线程，在每个线程中，调用函数，建立TFR的写入writer，循环一个线程的shards数，将标准化后的example进行写入，关闭writer
第一部分：
第一步：构建find_image_files, 传入参数为文件名，标签名
第二步：使用[l.strip() for l in TF.gfile.FastGFile(f).readlines()] 来获得标签值
第三步： 循环标签值，使用os.path.join(‘%s/%s/*’%())标签值和文件路径进行拼接，获得每一个文件夹的名字
第四步： 使用tf.gfile.Glob(文件名) 获得文件名中所有的图片名称，如果报错，打印文件名,continue
第五步：定义filenames, labels, texts = []
第六步：使用.extend() 将图片列表添加到filenames, 使用[label_index] * len(matchfile)制作标签，以及[text] * len(matchfile) 制作标签名，使用.extend() 进行添加
第七步： 构造shuffed_index = np.arange(len(filenames))， 使用random.shuffle(shuffed_index) 获得混乱的标签索引值
第八步：使用filenames = [filename[i] for i in shuffed_index] 构造打乱的filenams，labels，和texts， 返回结果
第二部分：将生成的filenams，labels和texts， train_shards传入到process_image_files函数
第一步：使用assert len(filenames) == len(labels)，即filenams的大小是否和labeles以及texts的大小相同
第二步：使用np.linspace(0, len(filenames), train_shards+1) 根据train_shards大小进行切分，
第三步：循环切分的列表，将两个之间的索引值添加到ranges中， ranges.append([split_index[i], split_index[i+1]]), 使用sys.stdout.flush() 刷新操作
第四步：实例化coder = ImageCode()
第一步：构造png转jpg的初始化函数，使用tf.placeholder初始化，使用tf,image.decode_png()解码png，使用tf.image.encode_jpeg()编码jpeg
第二步：构造jpg的解码的初始化函数, 使用tf.placeholder初始化，使用tf.image.decode_jpeg()解码jpg
第三步：构造函数png_to_jpeg(self, image_data), sess.run(self._png_to_jpg, feed_dict={self.png_image:image_data})，进行实际转换
第四步：构造函数decode_jpeg(self, image_data):, sess.run(self._decode_jpg) 进行实际转换
第五步：使用coord = tf.train.Coordinator() 建立线程的通道
第六步：循环num_thread, 建立args参数，使用threading.Thread(target=_precess_image_files_batch， args) 构建单线程，使用t.start()启动单线程，threads.append(t), 然后再将coord.join(threads)构建出了多线程
函数target = _precess_image_files_batch 说明：主要是用于构建Tfrecord数据集
第一步：将train_shards / num_threads相除，获得每个线程所需要建立的shards的个数
第二步：使用np.linspace(range[thread_index][0], range[thread_index][1],num_shards_per_batch + 1) # 获得每一个shards的数据索引
第三步：使用ranges[thread_index][1] - ranges[thread_index][0] 获得当前线程所执行的样本数
第四步：循环num_shard_per_batch,即每个线程所需要建立的shards个数
第五步：使用shard = thread_index * num_per_batch + s，获得当前的shards的索引
第六步：使用name，shard， trian_shard建立当前的路径
第七步：使用os.path.join() 将文件路径与当前路径进行拼接，获得保存路径
第八步：使用writer = tf.python_io.TFRecordWriter(output_path) 构造一个TFR写入的writer函数
第九步：循环每一个shards的数据索引值
第十步：使用_image_process获得图片的image_buff， 如果是png格式使用coder转换为jpg格式
第十一步：使用tf.train.Example(features=tf.train.Features(feature={
})) # 将参数进行打包，返回example
第十二步：writer.write(example.SerializeToString()) 将数据写入到writer中
第十三步：如果执行1000次，打印当前时间，第几个线程，第几张图片， 该线程的图片数，使用sys.stdout.flush() 刷新
第十四步：一个shards结束后，writer.close() ,打印，并进行刷新
第十五步：整个循环结束后，打印，并刷新
from __future__ import absolute_import from __future__ import division from __future__ import print_function from datetime import datetime import os import random import sys import threading import numpy as np import tensorflow as tf tf.app.flags.DEFINE_string('train_directory', './flower_photos/', 'Training data directory') tf.app.flags.DEFINE_string('validation_directory', './flower_photos', 'Validation data directory') tf.app.flags.DEFINE_string('output_directory', './data/', 'Output data directory') tf.app.flags.DEFINE_integer('train_shards', 2, 'Number of shards in training TFRecord files.') tf.app.flags.DEFINE_integer('validation_shards', 0, 'Number of shards in validation TFRecord files.') tf.app.flags.DEFINE_integer('num_threads', 2, 'Number of thread to preprocess the images') tf.app.flags.DEFINE_string('labels_file', './flower_label.txt', 'labels file') FLAGS = tf.app.flags.FLAGS def _int64_feature(value): if not isinstance(value, list): value = [value] # 将数据转换为int的列表类型 return tf.train.Feature(int64_list=tf.train.Int64List(value=value)) def _bytes_feature(value): # 将数据转换为bytes的列表类型 return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def _convert_to_example(filename, image_buff, label, text, height, width): colorspace= 'RGB' channels = 3 image_format = 'JPEG' # 使用tf.train.Example和tf.train.Features构造打包数据 example = tf.train.Example(features=tf.train.Features(feature={ 'image/height': _int64_feature(height), 'image/width': _int64_feature(width), 'image/colorspace': _bytes_feature(tf.compat.as_bytes(colorspace)), 'image/channels': _int64_feature(channels), 'image/class/label': _int64_feature(label), 'image/class/text': _bytes_feature(tf.compat.as_bytes(text)), 'image/format': _bytes_feature(tf.compat.as_bytes(image_format)), 'image/filename': _bytes_feature(tf.compat.as_bytes(os.path.basename(filename))), 'image/encoded': _bytes_feature(tf.compat.as_bytes(image_buff)) })) return example def is_png(filename): return '.png' in filename def _process_image(filename, coder): # 打开文件夹，使用bytes数据类型 with tf.gfile.FastGFile(filename, 'rb') as f: # 进行数据的读取 image_data = f.read() # 如果数据是png的格式的话就转换为jpeg类型 if is_png(filename): image_data = coder.png_to_jpeg(image_data) # 将iamge_data进行解码 image = coder.decode_jpeg(image_data) # 判断图片的维度是否是3 assert len(image.shape) == 3 # 图片的高度 height = image.shape[0] # 图片的宽度 width = image.shape[1] return image_data, height, width def _process_image_files_batch(coder, thread_index, ranges, name, filenames, texts, labels, train_shards): # 获得线程数 num_threads = len(ranges) # 保证线程和train_shards可以整除 assert not train_shards % num_threads # 每个线程所需要执行的shards数 num_shards_per_batch = int(train_shards / num_threads) # 根据每个线程的shars数，获得每个线程切分后的数据索引值 shard_ranges = np.linspace(ranges[thread_index][0], ranges[thread_index][1], num_shards_per_batch + 1) # 获得线程的样本数目 num_files_in_thread = ranges[thread_index][1] - ranges[thread_index][0] # 用于图片的统计 counter = 0 # 循环线程 for s in range(num_shards_per_batch): # 获得当前是第几个shards shard = thread_index * num_shards_per_batch + s # 构造TFR的路径 output_filename = '%s-%.5d-of-%.5d.tfrecord'%(name, shard, train_shards) # 拼接获得最终的路径 output_file = os.path.join(FLAGS.output_directory, output_filename) # 输入路径，构造TFR的读入器 writer = tf.python_io.TFRecordWriter(output_file) # shard_counter = 0 # 获得数据索引值的列表 file_in_shard = np.arange(shard_ranges[s], shard_ranges[s+1]).astype('int') # 循环列表 for i in file_in_shard: # 获得文件名 filename = filenames[i] # 获得标签值 label = labels[i] # 获得标签名 text = texts[i] # 使用tf.gfile.FastGFile(filename, 'rb'): 打开文件 image_buff, height, width = _process_image(filename, coder) # 将各个参数进行打包 example = _convert_to_example(filename, image_buff, label, text, height, width) # 将一张图片打包好的参数写入到writer里面 writer.write(example.SerializeToString()) shard_counter += 1 counter += 1 # 如果读取了1000张图片，打印并进行刷新操作 if not counter % 1000: print('%s [thread %d]:Processed %d of %d images in thread batch.'%( datetime.now(), thread_index, counter, num_files_in_thread )) sys.stdout.flush() # 循环了一个shards就关闭writer，打印和刷新操作 writer.close() print('%s [thread %d]:Processed %d of %d images in thread batch.' % ( datetime.now(), thread_index, counter, num_files_in_thread )) sys.stdout.flush() # 循环结束，打印和刷新操作 print('%s [thread %d]:Processed %d of %d images in thread batch.' % ( datetime.now(), thread_index, counter, num_files_in_thread )) sys.stdout.flush() class ImageCoder(object): def __init__(self): # 构造sess函数 self._sess = tf.Session() # 初始化png的输入数据 self.png_img = tf.placeholder(dtype=tf.string) # 将png进行解码操作，使用tf.image.decode_png image = tf.image.decode_png(self.png_img, channels=3) # 对解码的图片，使用tf.image.encode_jpeg进行加码操作，format表示rgb, quality表示图片的质量 self._png_to_jpeg = tf.image.encode_jpeg(image, format='rgb', quality=100) # 初始化输入jpeg_image的图片 self.jpeg_image = tf.placeholder(dtype=tf.string) # 使用tf.image.decode_jpeg对图片进行解码操作 self._decode_jpeg = tf.image.decode_jpeg(self.jpeg_image, channels=3) def png_to_jpeg(self, image_data): # 输入数据，获得实际的png_to_jpeg的转换 return self._sess.run(self._png_to_jpeg, feed_dict={self.png_img:image_data}) def decode_jpeg(self, image_data): # 输入数据,进行实际的decode_jpeg的解码操作 image = self._sess.run(self._decode_jpeg, feed_dict={self.jpeg_image:image_data}) return image def _process_image_files(name, filenames, labels, texts, train_shards): # 第一步：确认维度是否相等 assert len(filenames) == len(texts) assert len(filenames) == len(labels) # 第二步：使用np.linspace()将len(filenames)根据train_shards的个数进行切片，获得每一份的索引值 ranges = [] split_index = np.linspace(0, len(filenames), train_shards+1) # 第三步：根据索引值，构造range列表，即每一个列表，对于前后的索引值 for i in range(len(split_index) - 1): ranges.append([split_index[i], split_index[i+1]]) # 刷新操作 print('Launching %d threads for spacings: %s'%(FLAGS.num_threads, ranges)) sys.stdout.flush() # 第四步：实例化ImageCoder() 进行png_to_jpeg，或者对jpeg进行解码操作 coder = ImageCoder() # 第五步：使用tf.train.Coordinator获得线程的通道 coord = tf.train.Coordinator() # 构造线程的列表 threads = [] # 第六步：循环线程的个数，构造多线程 for thread_index in range(len(ranges)): # 构造线程参数，coder表示解码器，thread_index当前是第几个线程，ranges表示线程的范围，name表示名字，filenames表示文件的图片名 args = (coder, thread_index, ranges, name, filenames, texts, labels, train_shards) # 构建线程 t = threading.Thread(target=_process_image_files_batch, args=args) # 开始线程 t.start() # 线程添加到线程列表中 threads.append(t) # 将线程添加到通道中 coord.join(threads) def _find_image_files(data_path, labels_file): # 使用tf.gfile.FastGFile读取标签文件，获得标签的列表 upload_labels = [l.strip() for l in tf.gfile.FastGFile(labels_file).readlines()] # 第一种类别的标签值 label_index = 1 # 文件图片的名字列表 filenames = [] # 标签列表 labels = [] # 图片标签名列表 texts = [] # 循环标签文本 for text in upload_labels: # 构造相对路径 jpeg_path_join = '%s/%s/*' % (data_path, text) try: # 使用tf.gfile.Glob遍历相对路径下所有的图片，获得图片的路径 matchfile = tf.gfile.Glob(jpeg_path_join) except: print(jpeg_path_join) continue # 将获得的路径列表添加到filenames中 filenames.extend(matchfile) # 产生[1] * len(filenams)的标签，并添加到标签列表中 labels.extend([label_index] * len(matchfile)) # 产生[test] * len(filenames)的标签名，并添加到标签名列表中 texts.extend([text] * len(matchfile)) # 标签值加1，作为下一个类比的标签值 label_index += 1 # 获得len(filenames)的索引值 shuffled_index = np.arange(len(filenames)) # 将索引值进行打乱 random.seed(1234) random.shuffle(shuffled_index) # 根据打乱的索引值重新构造filenames，labels，和texts filenames = [filenames[i] for i in shuffled_index] labels = [labels[i] for i in shuffled_index] texts = [texts[i] for i in shuffled_index] # 返回filenames，labels和texts return filenames, labels, texts def _process_dataset(name, data_path, train_shards, labels_file): # 第一部分：找出文件名，构造标签列表以及文件名列表，并使用random.shuffle获得乱序的索引 filenames, labels, texts = _find_image_files(data_path, labels_file) # 第二部分：将文件图片的名字，标签值，标签名，以及生产shards个数传入，用于生成tfrecord _process_image_files(name, filenames, labels, texts, train_shards) def main(unused_argv): # 确认train_shards是够能被线程整除 assert not FLAGS.train_shards % FLAGS.num_threads, ('在训练过程中线程的数目应该与文件的数目相对应') assert not FLAGS.validation_shards % FLAGS.num_threads, ('在验证集制作中线程的数目应该与文件的数目相对应') # 构建process_dataset执行函数，传入的参数有name, 训练数据文件路径，训练集的num，以及标签的文件名 _process_dataset('train', FLAGS.train_directory, FLAGS.train_shards, FLAGS.labels_file) if __name__ == '__main__': tf.app.run()
