#coding:utf-8

import tensorflow as tf

import os

def read_and_decode(filename):

    #根据文件名生成一个队列

    filename_queue = tf.train.string_input_producer([filename])

    reader = tf.TFRecordReader()

    _, serialized_example = reader.read(filename_queue)   #返回文件名和文件

    features = tf.parse_single_example(serialized_example,

                                       features={

                                           'label': tf.FixedLenFeature([], tf.int64),

                                           'img_raw' : tf.FixedLenFeature([], tf.string),

                                       })

    img = tf.decode_raw(features['img_raw'], tf.uint8)

    img = tf.reshape(img, [227, 227, 3])

    img = (tf.cast(img, tf.float32) * (1. / 255) - 0.5)*2

    label = tf.cast(features['label'], tf.int32)

    print img,label

    return img, label

def get_batch(image, label, batch_size,crop_size):

    #数据扩充变换

    distorted_image = tf.random_crop(image, [crop_size, crop_size, 3])#随机裁剪

    distorted_image = tf.image.random_flip_up_down(distorted_image)#上下随机翻转

    distorted_image = tf.image.random_brightness(distorted_image,max_delta=63)#亮度变化

    distorted_image = tf.image.random_contrast(distorted_image,lower=0.2, upper=1.8)#对比度变化  

    #生成batch

    #shuffle_batch的参数：capacity用于定义shuttle的范围，如果是对整个训练数据集，获取batch，那么capacity就应该够大

    #保证数据打的足够乱

    images, label_batch = tf.train.shuffle_batch([distorted_image, label],batch_size=batch_size,

                                                 num_threads=1,capacity=2000,min_after_dequeue=1000) 

    return images, label_batch

class network(object): 

    def lenet(self,images,keep_prob):

        '''

        根据tensorflow中的conv2d函数，我们先定义几个基本符号

        输入矩阵 W×W，这里只考虑输入宽高相等的情况，如果不相等，推导方法一样，不多解释。

        filter矩阵 F×F，卷积核

        stride值 S，步长

        输出宽高为 new_height、new_width

        在Tensorflow中对padding定义了两种取值：VALID、SAME。下面分别就这两种定义进行解释说明。

        VALID

        new_height = new_width = (W – F + 1) / S  #结果向上取整

        SAME

        new_height = new_width = W / S    #结果向上取整

        '''

        images = tf.reshape(images,shape=[-1,32,32,3])

        #images = (tf.cast(images,tf.float32)/255.0-0.5)*2

        #第一层，卷积层 32,32,3--->5,5,3,6--->28,28,6

        #卷积核大小为5*5 输入层深度为3即三通道图像 卷积核深度为6即卷积核的个数

        conv1_weights = tf.get_variable("conv1_weights",[5,5,3,6],initializer = tf.truncated_normal_initializer(stddev=0.1))

        conv1_biases = tf.get_variable("conv1_biases",[6],initializer = tf.constant_initializer(0.0))

        #移动步长为1 不使用全0填充

        conv1 = tf.nn.conv2d(images,conv1_weights,strides=[1,1,1,1],padding='VALID')

        #激活函数Relu去线性化

        relu1 = tf.nn.relu(tf.nn.bias_add(conv1,conv1_biases))

        #第二层 最大池化层  28,28,6--->1,2,2,1--->14,14,6

        #池化层过滤器大小为2*2 移动步长为2 使用全0填充

        pool1 = tf.nn.max_pool(relu1, ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

        #第三层 卷积层   14,14,6--->5,5,6,16--->10,10,16

        #卷积核大小为5*5 当前层深度为6 卷积核的深度为16

        conv2_weights = tf.get_variable("conv_weights",[5,5,6,16],initializer = tf.truncated_normal_initializer(stddev=0.1))

        conv2_biases = tf.get_variable("conv2_biases",[16],initializer = tf.constant_initializer(0.0))

        conv2 = tf.nn.conv2d(pool1,conv2_weights,strides=[1,1,1,1],padding='VALID') #移动步长为1 不使用全0填充

        relu2 = tf.nn.relu(tf.nn.bias_add(conv2,conv2_biases))

        #第四层 最大池化层 10,10,16--->1,2,2,1--->5,5,16

        #池化层过滤器大小为2*2 移动步长为2 使用全0填充

        pool2 = tf.nn.max_pool(relu2,ksize = [1,2,2,1],strides=[1,2,2,1],padding='SAME')

        #第五层 全连接层

        fc1_weights = tf.get_variable("fc1_weights",[5*5*16,1024],initializer = tf.truncated_normal_initializer(stddev=0.1))

        fc1_biases = tf.get_variable("fc1_biases",[1024],initializer = tf.constant_initializer(0.1)) #[1,1024]

        pool2_vector = tf.reshape(pool2,[-1,5*5*16]) #特征向量扁平化 原始的每一张图变成了一行9×9*64列的向量

        fc1 = tf.nn.relu(tf.matmul(pool2_vector,fc1_weights)+fc1_biases)

        #为了减少过拟合 加入dropout层

        fc1_dropout = tf.nn.dropout(fc1,keep_prob)

        #第六层 全连接层

        #神经元节点数为1024  分类节点2

        fc2_weights = tf.get_variable("fc2_weights",[1024,2],initializer=tf.truncated_normal_initializer(stddev=0.1))

        fc2_biases = tf.get_variable("fc2_biases",[2],initializer = tf.constant_initializer(0.1))

        fc2 = tf.matmul(fc1_dropout,fc2_weights) + fc2_biases

        return fc2

    def lenet_loss(self,fc2,y_):

        #第七层 输出层

        #softmax

        y_conv = tf.nn.softmax(fc2)

        labels=tf.one_hot(y_,2)

        #定义交叉熵损失函数

        #cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv),reduction_indices=[1]))

        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = y_conv, labels =labels))

        self.cost = loss

        return self.cost

    def lenet_optimer(self,loss):

        train_optimizer = tf.train.GradientDescentOptimizer(lr).minimize(loss)

        return train_optimizer

def train():

    image,label=read_and_decode("./train.tfrecords")

    batch_image,batch_label=get_batch(image,label,batch_size=30,crop_size=32)

   #建立网络,训练所用

    x = tf.placeholder("float",shape=[None,32,32,3],name='x-input')

    y_ = tf.placeholder("int32",shape=[None])

    keep_prob = tf.placeholder(tf.float32)

    net=network()

    #inf=net.buildnet(batch_image)

    inf = net.lenet(x,keep_prob)

    loss=net.lenet_loss(inf,y_)  #计算loss

    opti=net.optimer(loss)  #梯度下降

    correct_prediction = tf.equal(tf.cast(tf.argmax(inf,1),tf.int32),batch_label)

    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

    init=tf.global_variables_initializer()

    with tf.Session() as session:

        with tf.device("/gpu:0"):

            session.run(init)

            coord = tf.train.Coordinator()

            threads = tf.train.start_queue_runners(coord=coord)

            max_iter=10000

            iter=0

            if os.path.exists(os.path.join("model",'model.ckpt')) is True:

                tf.train.Saver(max_to_keep=None).restore(session, os.path.join("model",'model.ckpt'))

            while iter<max_iter:

                #loss_np,_,label_np,image_np,inf_np=session.run([loss,opti,batch_image,batch_label,inf])

                b_batch_image,b_batch_label = session.run([batch_image,batch_label])

                loss_np,_=session.run([loss,opti],feed_dict={x:b_batch_image,y_:b_batch_label,keep_prob:0.6})

                if iter%50==0:

                    print 'trainloss:',loss_np

                if iter%500==0:

                    #accuracy_np = session.run([accuracy])

                    accuracy_np = session.run([accuracy],feed_dict={x:b_batch_image,y_:b_batch_label,keep_prob:1.0})

                    print 'xxxxxxxxxxxxxxxxxxxxxx',accuracy_np

                iter+=1

            coord.request_stop()#queue需要关闭，否则报错

            coord.join(threads)

if __name__ == '__main__':

    train()