import tensorflow as tf

import numpy as np

from tensorflow.examples.tutorials.mnist import input_data

# 第一步数据导入

mnist = input_data.read_data_sets('/data', one_hot=True)

#卷积层的构造

def conv_layer(input, inputS, outputS, name):

    # 在name的范围内进行操作

    with tf.variable_scope(name):

        # 构造w的初始化矩阵，tf.Variable()维度为[5, 5, inputS, outputS]

        w = tf.Variable(tf.truncated_normal([5, 5, inputS, outputS], stddev=0.05), name='w')

        # 构造b的初始化矩阵，维度为[outputS]

        b = tf.Variable(tf.constant(0.1, shape=[outputS]), name='b')

        # 使用tf.nn.conv2d进行卷积操作

        conv = tf.nn.conv2d(input, w, strides=[1, 1, 1, 1], padding='SAME')

        # 使用tf.nn.relu进行激活操作

        act = tf.nn.relu(conv)

        # 使用tf.summary.histogram() 做参数分布直方图

        tf.summary.histogram('weights', w)

        tf.summary.histogram('biases', b)

        tf.summary.histogram('activations', act)

        # 进行池化操作，返回结果

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

def fc_layer(input, inputS, outputS, name):

    with tf.variable_scope(name):

        w = tf.Variable(tf.truncated_normal([inputS, outputS], stddev=0.05), name='w')

        b = tf.Variable(tf.constant(0.1, shape=[outputS]), name='b')

        fc = tf.matmul(input, w) + b

        act = tf.nn.relu(fc)

        tf.summary.histogram('weights', w)

        tf.summary.histogram('biases', b)

        tf.summary.histogram('activations', act)

        return act

# 将输入use_two_conv和use_two_fc转换为字符串, 并将转换后的字符串和learning_rate进行组合

def make_hparam_string(learning_rate, use_two_conv, use_two_fc):

    conv_param = 'conv=2' if use_two_conv else 'conv=1'

    fc_param = 'fc=2' if use_two_fc else 'fc=1'

    return 'lr_%.0E,%s,%s'%(learning_rate, conv_param, fc_param)

# 构造mnist_model层

def mnist_model(learning_rate, use_two_conv, use_two_fc, hparam):

    # 使用tf.reset_default_graph() 进行graph的清除和重置操作

    tf.reset_default_graph()

    # 使用tf.Session() 构造执行函数sess

    sess = tf.Session()

    # 使用tf.placeholder() 构造初始化输入

    x = tf.placeholder(tf.float32, [None, 784], name='x')

    # 将x进行维度的变化以便进行后续的卷积操作

    x_images = tf.reshape(x, [-1, 28, 28, 1])

    # 在tf.summary.image在tensorboard画出前3副图

    tf.summary.image('input', x_images, 3)

    # 使用tf.placeholder()构造y的初始化输入

    y = tf.placeholder(tf.float32, [None, 10], name='labels')

    # 如果使用两个卷积层

    if use_two_conv:

        # 构造第一层卷积，输入为x，1为channel，32为输出的num_filter, name表示名字

        conv_1 = conv_layer(x_images, 1, 32, name='conv_1')

        # 构造第二层卷积，输入为conv_1, 32为channel, 64为输出的num_filter， name表示名字

        conv_out = conv_layer(conv_1, 32, 64, name='conv_2')

    else:

        # 构造第一层卷积层，输入为x_images, 1为channel， 64为输出w的num_filter通道数,name表示名字

        conv_1 = conv_layer(x_images, 1, 64, name='conv')

        # 直接进行池化操作，降低矩阵的维度，为了与二次卷积的维度相同

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

    # 对池化的矩阵进行维度的变化，维度转换为[-1, 7*7*64]

    fcIn = tf.reshape(conv_out, [-1, 7*7*64])

    # 使用二层全连接层

    if use_two_fc:

        # 进行第一层全连接层，w的维度是7*7*64, 1024, name表示名字

        fc_1 = fc_layer(fcIn, 7*7*64, 1024, name='fc_1')

        # 进行第二层全连接层，w的维度是1024， 10, name表示名字

        logits = fc_layer(fc_1, 1024, 10, name='fc_2')

    else:

        # 只进行第一层全连接层，w的维度是7*7*64， 10， name表示名字

        logits = fc_layer(fcIn, 7*7*64, 10, name='fc')

    # 将获得的得分计算损失值，tf.reduce_mean(tf.nn.softmax_cross_entrop)进行交叉熵损失值计算

    with tf.variable_scope('loss'):

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

        # 构造损失值的折线图

        tf.summary.scalar('loss', loss)

    # 使用tf.train.AdamOptimizer进行损失值的降低

    train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss)

    # 计算准确率

    with tf.variable_scope('accuracy'):

        # 使用tf.equal() 计算correct_pred

        correct_pred = tf.equal(tf.argmax(logits, axis=1), tf.argmax(y, 1))

        # 使用tf.reduce_mean() 计算准确率

        accuracy = tf.reduce_mean(tf.cast(correct_pred, 'float'))

        # 在tensorboard画出准确率的折线图

        tf.summary.scalar('accuracy', accuracy)

    # 对参数进行初始化操作

    sess.run(tf.global_variables_initializer())

    # 将所有的summary在tensorboard进行画图

    ssum = tf.summary.merge_all()

    # 构造tensorboard的路径

    tensorboard_dir = './tensorboard/test3/'

    # 构造summary的写入

    writer = tf.summary.FileWriter(tensorboard_dir + hparam)

    # 将graph进行添加

    writer.add_graph(sess.graph)

    # 进行循环迭代

    for i in range(2001):

        # 获得数据

        batch = mnist.train.next_batch(100)

        # 每迭代5次，执行ssum, 将summary进行添加

        if i % 5 == 0:

            [s, accur] = sess.run([ssum, accuracy], feed_dict={x:batch[0], y:batch[1]})

            # 将summary进行添加

            writer.add_summary(s, i)

        # 进行模型的优化操作

        sess.run(train_op, feed_dict={x:batch[0], y:batch[1]})

# 第二步：构建main()函数, 循环学习率，循环use_two_conv以及use_two_fc

def main():

    for learning_rate in [1E-4]:

        for use_two_conv in [True]:

            for use_two_fc in [True]:

                # 第三步：构建basename,将学习率和use_two_conv和use_two_fc组合成字符串

                hparam = make_hparam_string(learning_rate, use_two_conv, use_two_fc)

                # 第四步:构建网络模型，将学习率，是否使用两个卷积层，是否使用两个全连接层，以及文件的basename传入

                mnist_model(learning_rate, use_two_conv, use_two_fc, hparam)

# 第五步：执行函数

if __name__ == '__main__':

    main()

    for learning_rate in [1E-4,1E-3,1E-2]:

    # Include "False" as a value to try different model architectures

        for use_two_fc in [True,False]:

            for use_two_conv in [True,False]:

                for iter_num in [1000,2000,5000]: