• 图像分类数据组织方式


    一.npy输入数据格式

    数据文件夹组织形式

    ——————————flower
    ————————rose
    ——————图片
    ————————菊花
    ——————图片

    图像数据编码
    data_encoder.py
    import glob
    import os.path
    import numpy as np
    import tensorflow as tf
    from tensorflow.python.platform import gfile
    
    # 原始输入数据的目录,这个目录下有5个子目录,每个子目录底下保存这属于该
    # 类别的所有图片。
    INPUT_DATA = r'E:X18301096flower_photos'
    # 输出文件地址。我们将整理后的图片数据通过numpy的格式保存。
    OUTPUT_FILE = r'E:X18301096flower_photos/flower_processed_data.npy'
    
    # 测试数据和验证数据比例。
    VALIDATION_PERCENTAGE = 10
    TEST_PERCENTAGE = 10
    
    
    # 读取数据并将数据分割成训练数据、验证数据和测试数据。
    def create_image_lists(sess, testing_percentage, validation_percentage):
        sub_dirs = [x[0] for x in os.walk(INPUT_DATA)]
        is_root_dir = True
    
        # 初始化各个数据集。
        training_images = []
        training_labels = []
        testing_images = []
        testing_labels = []
        validation_images = []
        validation_labels = []
        current_label = 0
    
        # 读取所有的子目录。
        for sub_dir in sub_dirs:
            if is_root_dir:
                is_root_dir = False
                continue
    
            # 获取一个子目录中所有的图片文件。
            extensions = ['jpg', 'jpeg', 'JPG', 'JPEG']
            file_list = []
            dir_name = os.path.basename(sub_dir)
            for extension in extensions:
                file_glob = os.path.join(INPUT_DATA, dir_name, '*.' + extension)
                file_list.extend(glob.glob(file_glob))
            if not file_list: continue
            print("processing:", dir_name)
    
            i = 0
            # 处理图片数据。
            for file_name in file_list:
                i += 1
                # 读取并解析图片,将图片转化为299*299以方便inception-v3模型来处理。
                image_raw_data = gfile.FastGFile(file_name, 'rb').read()
                image = tf.image.decode_jpeg(image_raw_data)
                if image.dtype != tf.float32:
                    image = tf.image.convert_image_dtype(image, dtype=tf.float32)
                image = tf.image.resize_images(image, [299, 299])
                image_value = sess.run(image)
    
                # 随机划分数据聚。
                chance = np.random.randint(100)
                if chance < validation_percentage:
                    validation_images.append(image_value)
                    validation_labels.append(current_label)
                elif chance < (testing_percentage + validation_percentage):
                    testing_images.append(image_value)
                    testing_labels.append(current_label)
                else:
                    training_images.append(image_value)
                    training_labels.append(current_label)
                if i % 200 == 0:
                    print(i, "images processed.")
            current_label += 1
    
        # 将训练数据随机打乱以获得更好的训练效果。
        state = np.random.get_state()
        np.random.shuffle(training_images)
        np.random.set_state(state)
        np.random.shuffle(training_labels)
    
        return np.asarray([training_images, training_labels,
                           validation_images, validation_labels,
                           testing_images, testing_labels])
    
    #数据处理主函数
    def main():
        with tf.Session() as sess:
            processed_data = create_image_lists(sess, TEST_PERCENTAGE, VALIDATION_PERCENTAGE)
            # 通过numpy格式保存处理后的数据。
            np.save(OUTPUT_FILE, processed_data)
    
    if __name__ == '__main__':
        main()

    图像数据解码

    data_load.py

    import glob
    import os.path
    import numpy as np
    import tensorflow as tf
    from tensorflow.python.platform import gfile
    
    INPUT_DATA = ''
    
    def main():
        processed_data = np.load(INPUT_DATA)
        training_images = processed_data[0]
        training_labels = processed_data[1]
        validation_images = processed_data[2]
        validation_labels = processed_data[3]
        testing_images = processed_data[4]
        testing_labels = processed_data[5]
    
        print(len(training_images),len(validation_images),len(testing_images))
        print(len(training_images[0]),len(training_images[0][0]))
        print(training_labels)
        print(validation_labels)
        print(testing_labels)
    
    if __name__ =="__main__":
        main()

    二.TFRecord输入数据格式

    将数据写成TFRecord格式

    TFRecord_write.py

    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    import numpy as np
    
    #生成整数型的属性
    def _int64_feature(value):
        return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
    
    #生成字符串型的属性
    def _bytes_feature(value):
        return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
    # 将数据转化为tf.train.Example格式。
    def make_example(image,label,pixels):
        # 将图像转化成一个字符串
        image_raw = image.tostring()
        # 将一个样例转化为Example protocol Buffer,并将所有信息写入这个数据结构
        example = tf.train.Example(features=tf.train.Feature(feature={
            'pixels': _int64_feature(pixels),
            'label': _int64_feature(np.argmax(labels[index])),
            'image_raw': _bytes_feature(image_raw)
        }))
        return example
    
    
    #读取mnist训练数据
    mnist = input_data.read_data_sets(
        r"E:MNIST_dataMNIST_data",dtype=tf.uint8,one_hot=True
    )
    images = mnist.train.images
    #训练数据所对应的正确答案,可以作为一个属性保存在TFRECORD中
    labels = mnist.train.labels
    #训练数据的图像分辨率,这可以作为Example中的一个属性
    pixels = images.shape[1]
    num_examples = mnist.train.num_examples
    
    #输出TFRecord文件的地址
    filename = r"E:X18301096data_processingTFRecordoutput.tfrecords"
    #创建一个writer 来写TFRecord文件
    with tf.python_io.TFRecordWriter(filename) as writer:
        for index in range(num_examples):
            example = make_example(images[index],labels[index],pixels)
            #将一个Example写入TFRecord文件
            writer.write(example.SerializeToString())
    print("TFRecord训练数据已保存。")
    
    #读取mnist测试数据
    images_test = mnist.test.images
    labels_test = mnist.test.labels
    pixels_test = images_test.shape[1]
    num_examples_test = mnist.test.num_examples
    #输出包含测试数据的TFRecord文件
    with tf.python_io.TFRecordWriter("output_test.tfrecords") as writer:
        for index in range(num_examples_test):
            example = make_example(images_test[index],labels[index],pixels_test)
            writer.write(example.SerializeToString())
    print("TFRecord测试数据已保存!")

    读取TFRecord数据格式

    import tensorflow as tf
    #读取文件。
    reader= tf.TFRecordReader()
    #创建一个队列来维护输入文件列表 filename_queue
    = tf.train.string_input_producer(["output.tfrecords"])
    #从文件中读出一个样例 _,serialized_example
    = reader.read(filename_queue) #解析读取的样例 features = tf.parse_single_example( serialized_example, features={ 'image_raw':tf.FixedLenFeature([],tf.string), 'pixels':tf.FixedLenFeature([],tf.int64), 'label':tf.FixedLenFeature([],tf.int64) }) #tf.decode_raw可以将字符串解析成图像对应的像素数组 images = tf.decode_raw(features['image_raw'],tf.uint8) labels = tf.cast(features['label'],tf.int32) pixels = tf.cast(features['pixels'],tf.int32) with tf.Session() as sess: #启动多线程处理输入数据 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess,coord=coord) for i in range(10): image,label,pixel = sess.run([images,labels,pixels])

    三.tf.dataset

    在数据集框架中,每个数据集代表一个数据来源;数据可能来自一个张量,一个TFRecord文件,一个文本文件。

     数据集的基本使用方法

    基本步骤:

    1.定义数据集的构造方法

    2.定义遍历器

    one_shot_iterator

    initializable_iterator

    3.使用get_next()方法从遍历器中读取数据张量,作为计算图其它部分的输入

    import tensorflow as tf
    import tempfile
    
    #从数组创建数据集
    input_data = [1,2,3,4,5,8]
    
    dataset = tf.data.Dataset.from_tensor_slices(input_data)
    
    #定义迭代器,用于遍历数据集
    iterator = dataset.make_one_shot_iterator()
    
    #get_next()返回代表一个输入数据的张量
    x = iterator.get_next()
    y = x * x
    
    with tf.Session() as sess:
        for i in range(len(input_data)):
            print(y.eval())
    
    
    #读取文本文件里的数据
    #创建文本文件作为本例的输入
    with open("./test1.txt","w") as file:
        file.write("File1,line1.
    ")
        file.write("File1,line2.
    ")
    
    with open("./test2.txt","w") as file:
        file.write("File2,line1.
    ")
        file.write("File2,line2.
    ")
    #从文本文件创建数据集。可提供多个文件
    input_files= ["./test1.txt","./test2.txt"]
    dataset = tf.data.TextLineDataset(input_files)
    
    #定义迭代器
    iterator = dataset.make_one_shot_iterator()
    
    #get_next()返回一个字符串类型的张量,代表文件中的一行
    x = iterator.get_next()
    with tf.Session() as sess:
        for i in range(4):
            print(x.eval())
    
    # 解析TFRecord文件里的数据
    def parser(record):
        features = tf.parse_single_example(
            record,
            features={
                'image_raw':tf.FixedLenFeature([],tf.string),
                'pixels':tf.FixedLenFeature([],tf.int64),
                'label':tf.FixedLenFeature([],tf.int64)
            }
        )
        decode_images = tf.decode_raw(features['image_raw'],tf.uint8)
        retyped_images = tf.cast(decode_images,tf.float32)
        images = tf.reshape(retyped_images,[784])
        labels = tf.cast(features['label'],tf.int32)
        return images,labels
    #从TFRecord文件创建数据集。这里可以提供多个文件
    input_files = ["../output.tfrecords"]
    dataset = tf.data.TFRecordDataset(input_files)
    
    #map()函数表示对数据集中的每一条数据进行调用解析方法
    dataset = dataset.map(parser)
    #定义遍历数据集的迭代器
    iterator = dataset.make_one_shot_iterator()
    
    #读取数据,可用于进一步计算
    image,label = iterator.get_next()
    
    with tf.Session() as sess:
        for i in range(10):
            x,y = sess.run([image,label])
            print(y)
    
    #使用initializable_iterator来动态初始化数据集
    # 从TFRecord文件创建数据集,具体文件路径是一个placeholder,稍后再提供具体路径。
    input_files = tf.placeholder(tf.string)
    dataset = tf.data.TFRecordDataset(input_files)
    dataset = dataset.map(parser)
    
    # 定义遍历dataset的initializable_iterator。
    iterator = dataset.make_initializable_iterator()
    image, label = iterator.get_next()
    
    with tf.Session() as sess:
        # 首先初始化iterator,并给出input_files的值。
        sess.run(iterator.initializer,
                 feed_dict={input_files: ["../output.tfrecords"]})
        # 遍历所有数据一个epoch。当遍历结束时,程序会抛出OutOfRangeError。
        while True:
            try:
                x, y = sess.run([image, label])
            except tf.errors.OutOfRangeError:
                break

    数据集的高层操作

    import tensorflow as tf
    
    #列举输入文件
    # 输入数据使用本章第一节(1. TFRecord样例程序.ipynb)生成的训练和测试数据。
    train_files = tf.train.match_filenames_once("../output.tfrecords")
    test_files = tf.train.match_filenames_once("../output_test.tfrecords")
    
    #定义解析TFRecord文件的parser方法
    # 解析一个TFRecord的方法。
    def parser(record):
        features = tf.parse_single_example(
            record,
            features={
                'image_raw':tf.FixedLenFeature([],tf.string),
                'pixels':tf.FixedLenFeature([],tf.int64),
                'label':tf.FixedLenFeature([],tf.int64)
            })
        decoded_images = tf.decode_raw(features['image_raw'],tf.uint8)
        retyped_images = tf.cast(decoded_images, tf.float32)
        images = tf.reshape(retyped_images, [784])
        labels = tf.cast(features['label'],tf.int32)
        #pixels = tf.cast(features['pixels'],tf.int32)
        return images, labels
    
    #定义训练数据集
    image_size = 299          # 定义神经网络输入层图片的大小。
    batch_size = 100          # 定义组合数据batch的大小。
    shuffle_buffer = 10000   # 定义随机打乱数据时buffer的大小。
    
    # 定义读取训练数据的数据集。
    dataset = tf.data.TFRecordDataset(train_files)
    dataset = dataset.map(parser)
    
    # 对数据进行shuffle和batching操作。这里省略了对图像做随机调整的预处理步骤。随机打乱顺序,将数据组合成batch
    dataset = dataset.shuffle(shuffle_buffer).batch(batch_size)
    
    # 重复NUM_EPOCHS个epoch。
    NUM_EPOCHS = 10
    #将数据集重复N份 dataset = dataset.repeat(NUM_EPOCHS) # 定义数据集迭代器。 iterator = dataset.make_initializable_iterator() image_batch, label_batch = iterator.get_next() # 定义神经网络结构和优化过程 # 定义神经网络的结构以及优化过程。这里与7.3. 4小节相同。 def inference(input_tensor, weights1, biases1, weights2, biases2): layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1) return tf.matmul(layer1, weights2) + biases2 INPUT_NODE = 784 OUTPUT_NODE = 10 LAYER1_NODE = 500 REGULARAZTION_RATE = 0.0001 TRAINING_STEPS = 5000 weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1)) biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE])) weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1)) biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE])) y = inference(image_batch, weights1, biases1, weights2, biases2) # 计算交叉熵及其平均值 cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=label_batch) cross_entropy_mean = tf.reduce_mean(cross_entropy) # 损失函数的计算 regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE) regularaztion = regularizer(weights1) + regularizer(weights2) loss = cross_entropy_mean + regularaztion # 优化损失函数 train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss) #定义测试用数据集 # 定义测试用的Dataset。 test_dataset = tf.data.TFRecordDataset(test_files) test_dataset = test_dataset.map(parser) test_dataset = test_dataset.batch(batch_size) # 定义测试数据上的迭代器。 test_iterator = test_dataset.make_initializable_iterator() test_image_batch, test_label_batch = test_iterator.get_next() # 定义测试数据上的预测结果。 test_logit = inference(test_image_batch, weights1, biases1, weights2, biases2) predictions = tf.argmax(test_logit, axis=-1, output_type=tf.int32) # 声明会话并运行神经网络的优化过程。 with tf.Session() as sess: # 初始化变量。 sess.run((tf.global_variables_initializer(), tf.local_variables_initializer())) # 初始化训练数据的迭代器。 sess.run(iterator.initializer) # 循环进行训练,直到数据集完成输入、抛出OutOfRangeError错误。 while True: try: sess.run(train_step) except tf.errors.OutOfRangeError: break test_results = [] test_labels = [] # 初始化测试数据的迭代器。 sess.run(test_iterator.initializer) # 获取预测结果。 while True: try: pred, label = sess.run([predictions, test_label_batch]) print(pred.shape) test_results.extend(pred) test_labels.extend(label) except tf.errors.OutOfRangeError: break # 计算准确率 correct = [float(y == y_) for (y, y_) in zip(test_results, test_labels)] accuracy = sum(correct) / len(correct) print("Test accuracy is:", accuracy)

    四.多线程输入数据处理框架

    import tensorflow as tf
    
    #创建文件列表,通过文件列表创建输入文件队列,读取文件为本章第一节创建的文件
    files = tf.train.match_filenames_once("./output.tfrecords")
    filename_queue = tf.train.string_input_producer(files, shuffle=False)
    
    # 解析TFRecord文件里的数据
    # 读取文件。
    
    reader = tf.TFRecordReader()
    _,serialized_example = reader.read(filename_queue)
    
    # 解析读取的样例。
    features = tf.parse_single_example(
        serialized_example,
        features={
            'image_raw':tf.FixedLenFeature([],tf.string),
            'pixels':tf.FixedLenFeature([],tf.int64),
            'label':tf.FixedLenFeature([],tf.int64)
        })
    #从原始图像数据解析出像素矩阵,并根据图像尺寸还原图像
    decoded_images = tf.decode_raw(features['image_raw'],tf.uint8)
    retyped_images = tf.cast(decoded_images, tf.float32)
    labels = tf.cast(features['label'],tf.int32)
    #pixels = tf.cast(features['pixels'],tf.int32)
    images = tf.reshape(retyped_images, [784])
    
    #将文件以100个为一组打包。
    min_after_dequeue = 10000
    batch_size = 100
    capacity = min_after_dequeue + 3 * batch_size
    
    image_batch, label_batch = tf.train.shuffle_batch([images, labels],
                                                        batch_size=batch_size,
                                                        capacity=capacity,
                                                        min_after_dequeue=min_after_dequeue)
    
    #训练模型
    def inference(input_tensor, weights1, biases1, weights2, biases2):
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
        return tf.matmul(layer1, weights2) + biases2
    
    
    # 模型相关的参数
    INPUT_NODE = 784
    OUTPUT_NODE = 10
    LAYER1_NODE = 500
    REGULARAZTION_RATE = 0.0001
    TRAINING_STEPS = 5000
    
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))
    
    weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))
    
    y = inference(image_batch, weights1, biases1, weights2, biases2)
    
    # 计算交叉熵及其平均值
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=label_batch)
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    
    # 损失函数的计算
    regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    regularaztion = regularizer(weights1) + regularizer(weights2)
    loss = cross_entropy_mean + regularaztion
    
    # 优化损失函数
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
    
    # 初始化会话,并开始训练过程。
    with tf.Session() as sess:
        # tf.global_variables_initializer().run()
        sess.run((tf.global_variables_initializer(),
                  tf.local_variables_initializer()))
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        # 循环的训练神经网络。
        for i in range(TRAINING_STEPS):
            if i % 1000 == 0:
                print("After %d training step(s), loss is %g " % (i, sess.run(loss)))
    
            sess.run(train_step)
        coord.request_stop()
        coord.join(threads)
  • 相关阅读:
    Kaka's Matrix Travels
    Cable TV Network
    LightOJ 1137
    SPOJ AMR11E Distinct Primes 基础数论
    HDU 5533Dancing Stars on Me 基础几何
    POJ 1014 / HDU 1059 Dividing 多重背包+二进制分解
    vijos 1180 选课 树形DP
    vijos 1313 金明的预算方案 树形DP
    LightOJ 1062
    vijos 1464 积木游戏 DP
  • 原文地址:https://www.cnblogs.com/qqw-1995/p/11240808.html
Copyright © 2020-2023  润新知