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()

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()