# 通过tf.get_variable的方式创建滤波器的权重变量和偏置项变量。上面介绍了卷积层
# 的参数个数之和滤波器的尺寸、深度以及当前层节点矩阵的深度有关，所以这里声明的参数变
# 量是一个四维矩阵，前面两个维度代表了滤波器的尺寸，第三个维度表示当前层的深度，第四
# 个维度表示滤波器的深度。

filter_weight = tf.get_variable(
   'weights', [5, 5, 3, 16],             
   initializer = tf.truncated_normal_initializer(stddev=0.1))

# 和卷积层的权重类似，当前层矩阵上不同位置的偏置项也是共享的，所以总共有下一层深度个不
# 同的偏置项。
biases = tf.get_variable(
         ''biases', [16], initializer=tf.constant_initializer(0.1))


# tf.nn.conv2d提供了一个非常方便的函数来实现卷积层前向传播的算法。这个函数的第一个输入为
# 当前层的节点矩阵。注意这个矩阵是一个四维矩阵，后面三个维度对应一个节点矩阵，第一
# 维对应一个输入batch。比如在输入层，input[0,:,:,:]表示第一张图片，input[1,:,:,:]
# 表示第二张图片，以此类推。tf.nn.conv2第二个参数提供了卷积层的权重，第三个参数为不同
# 维度上的步长。虽然第三个参数提供的是一个长度为4的数组，但是第一维和最后一维的数字
# 要求一定是1.这是因为卷积层的步长只对矩阵的长和宽有效。最后一个参数是填充(padding)
# 的方法，tensorflow中提供SAME或是VALID两种选择。其中SAME表示添加全0填充，'VALID'表示
# 不添加。

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


# tf.nn.bisa_add提供了一个方便的函数给每一个节点加上偏置项。注意这里不能直接使用加
# 法，因为矩阵上不同位置上的节点都需要加上同样的偏置项。虽然下一层神经网络的大小为2*2
# 但是偏置项只有一个数(因为深度为1)，而2*2矩阵中的每一个值都需要加上这个偏置项。
bias = tf.nn.bias_add(conv, biases)
# 将计算结果通过ReLU激活函数完成去线性化。
activated_conv = tf.nn.relu(bias)

# tf.nn.max_pool实现了最大池化层的前向传播算法，它的参数和tf.nn,conv2d函数类似。
# ksize提供了滤波器的尺寸，strides提供了步长信息，padding提供了是否使用全0填充。
pool = tf.nn.max_pool(actived_conv, ksize=[1, 3, 3, 1],
                     strides=[1, 2, 2, 1], padding='SAME')

# 调整输入数据placeholder的格式，输入为一个四维矩阵。
x = tf.placeholder(tf.float32,
            BTACH_SIZE,                      # 第一维表示一个batch中样例的个数。
            mnsit_inference.IMAGE_SIZE,      # 第二维和第三维表示图片的尺寸。     
            mnist_inference.IMAGE_SIZE,      
            mnist_inference.NUM_CHANNELS]    # 第四维表示图片的深度，对于RBG格
                                             # 式的图片，深度为3。
            
       name='x-input')
...


# 类似将输入的训练数据格式调整为一个四维矩阵，并将这个调整后的数据传入sess.run过程。
reshaped_xs = np.(xs,  (BATCH_SIZE,
                        mnist_inference.IMAGE_SIZE,
                        mnist_inference.IMAGE_SIZE,
                        mnist_inference.NUM_CHANNELS))

# -*- coding: utf-8 -*-

import tensorflow as tf


# 配置神经网络的参数。
INPUT_NODE = 784
OUTPUT_NODE = 10

IMAGE_SIZE = 28
NUM_CHANNELS = 1
NUM_LABELS = 10


# 第一层卷积层的尺寸和深度。
CONV1_DEEP = 32
CONV1_SIZE = 5
# 第二层卷积层的尺寸和深度。
CONV2_DEEP = 64
CONV2_SZIE = 5
# 全连接层的节点个数。
FC_SIZE = 512

# 定义卷积神经网络的前向传播过程。这里添加了一个新的参数train，用于区分训练过程和测试
# 过程。在这个程序中将其用到dropout方法，dropout可以进一步提升模型可靠性并防止过拟合，
# dropout过程只在训练时使用。
def inference(input_tensor, train, regularizer):
    # 声明第一层卷积层的变量并实现前向传播过程。
    # 通过使用不同的命名空间来隔离不同层的变量，这可以让每一层中的变量名只需要
    # 考虑在当前层的作用，而不需要担心命名的问题。和标准LeNet-5模型不大一样，这里
    # 定义的卷积层输入为28*28*1的原始MNIST图片像素，因为卷积层中使用了全0填充，
    # 所以输出为28*28*32的矩阵。
    with tf.variable_scope('layer1-conv1'):
       conv1_weights = tf.get_variable(
          "weights",  [CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_DEEP],
          initializer=tf.trancated_normal_initializer(stddev=0.1)      
       conv1_biases = tf.get_variable(
          "biases", [CONV1_DEEP], initializer=tf.constant_initializer(0.0))
       # 使用变长为5，深度为32的滤波器，滤波器移动的步长为1，且使用全0填充。
       conv1 = tf.nn.conv2d(
           input_tensor, conv1_weights, strides=[1, 1, 1, 1], pedding='SAME')
       relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))
# 实现第二层池化层的前向传播过程。这里选用最大池化，池化层滤波器的边长为2，
# 使用全0填充且移动步长为2.这一层的输入是上一层的输出，也就是28*28*32的
# 矩阵。输出为14*14*32的矩阵。
with tf.name_scope('layer2-pool1'):
   pool1 = tf.nn.max_pool(
       relu1, kszie=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')


# 声明第三层卷积层的变量并实现前向传播过程。这一层的输入为14*14*32的矩阵。
# 输出为14*14*64的矩阵。
with tf.variable_scope('layer3-conv2'):
   conv2_weights = tf.get_variable(
       "weight", [CONV2_SIZE, CONV2_SZIE, CONV1_DEEP, CONV2_DEEP],  
       initializer=tf.truncated_normal_initializer(stddev=0.1))
   conv2_baises = tf.get_variable(
       "bias", [CONV2_DEEP],
       initializer=tf.constant_initializer(0.0))
   
   # 使用边长为5，深度为64的滤波器，滤波器移动的步长为1，且使用全0填充。
   conv2 = tf.nn.conv2d(
      pool1, conv2_weights, strides=[1, 1, 1, 1], padding='SAME')
   relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))
# 实现第四层池化层的前向传播过程。这一层和第二层的结构是一样的。这一层的输入为
# 14*14*64的矩阵，输出为7*7*54的矩阵。
with tf.name_scope('layer4-pool2'):
   pool2 = tf.nn.max_pool(
       relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME' )
# 将第四层池化层的输出幻化为第五层的输入格式。第四层的输出为7*7*64的矩阵，然而
# 然而第五层全连接层需要的输入格式为向量，所以在这里需要将这个7*7*64的矩阵拉直成
# 一个向量。pool2.get_shape函数可以得到第四层输出矩阵的维度而不需要手工计算。注意
# 因为每一层神经网络的输入输出都为一个batch的矩阵，所以这里得到的维度也包含了一个
# batch中数据的个数。
pool_shape = pool2.get_shape().as_list()

# 计算将矩阵拉直成向量之后的长度。这个长度就是矩阵长度及深度的乘积。注意这里
# pool_shape[0]为一个batch中的数据。
nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]

# 通过tf.reshape函数将第四层的输出变成一个batch的向量。
reshape = tf.reshape(pool2, [pool_shape[0], nodes])

# 声明第五层全连接层的变量并实现前向传播过程。这一层的输入时拉直之后的一组向量，
# 向量长度为3136，输出是一组长度为512的向量。这一层和之前介绍的基本一致，唯一的区别
# 就是引入了droopout的概念。dropout在训练时会随机将部分节点的
# 输出改为0。dropout可以避免过拟合问题，从而得到在测试数据上的效果更好。
# dropout一般只在全连接层而不是卷积层或者池化层使用。
with tf.variable_scope('layer5-fc1'):
    fc1_weights = tf.get_variable(
        'weight', [nodes, FC_SIZE],
        initializer = tf.truncated_normal_initializer(stddev=0.1))
    # 只有全连接层的权重需要加入正则化。
    if regularizer != None
       tf.add_to_collection('losses', regularizer(fc1_weights))
    fc1_biases = tf.get_variable("bias", [FC_SIZE], 
                 initializer=tf.constant_initializer(0.1))
    fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_weights) + fc1_biases)
    if train: fc1 = tf.nn.dropout(fc1, 0.5)

# 声明第六层全连接层的变量并实现前向传播过程。这一层的输入为一组长度为512的向量，
# 输出为一组长度为10的向量。这一层的输出通过SOftmax之后就得到了最后的分类结果。
with tf.variable_scope('layer6-fc2'):
    fc2_weights = tf.get_variable(
       "weight", [FC_SIZE, NUM_LABELS],
       initializer = tf.truncated_normal_initializer(stddev=0.1)
    if regularizer != None
       tf.add_to_collection('losses', regularizer(fc2_weights))
    fc2_biases = tf.get_variable(
       "bias",[NUM_LABELS],
       initializer=tf.constant_initializer(0.1))
    logit = tf.matmul(fc1, fc2_weights) + fc2_biases

# 返回第六层的输出。
return logit

~/mnist$ python mnist_train.py
Extracting /tmp/data/train-images-idx3-ubyte.gz
Extracting /tmp/data/train-images-idx1-ubyte.gz
Extracting /tmp/data/t10k-images-idx3-ubyte.gz
Extracting /tmp/data/t10k-images-idx1-ubyte.gz
After 1 training step(s), loss on training betch is 6.45373.
After 1001 training step(s), loss on training betch is 0.824825.
After 2001 training step(s), loss on training betch is 0.646993.
After 3001 training step(s), loss on training betch is 0.75997.
After 4001 training step(s), loss on training betch is 0.68468.
After 5001 training step(s), loss on training betch is 0.630368.

# 直接使用tensorflow原始API实现卷积层。

with tf.variable_scope(scope_name):
     weights = tf.get_variable("weight", ...)
     biases = tf.get_variable("biases", ...)
     conv = tf.nn.conv2d(...)
     relu = tf.nn.relu(tf.nn.bias_add(conv, biases))


# 使用tensorflow-slim实现卷积层。通过tensorflow-slim可以在一行中实现一个卷积层
# 的前向传播算法。slim.conv2d函数的有3个参数是必填的。第一个参数为输入节点矩阵，
# 第二参数是当前卷积层滤波器的深度，第三个参数是滤波器的尺寸。可选的参数有滤波器
# 移动的步长，是否使用全0填充，激活函数的选择以及变量的命名空间等。
net = slim.conv2d(input, 32, [3, 3])

# 加载slim库。
slim = tf.contrib.slim

# slim.arg_scope函数可以用于设置默认参数值。slim.arg_scope函数的第一个参数是
# 一个参数列表，在这个列表中的函数将使用默认的参数取值。比如通过下面的定义，调用
# slim.conv2d(net, 320, [1, 1])函数时会自动加上stride=1和padding='SAME'的参
# 数。如果在函数调用时指定了stride，那么这里设置的默认值就不会再使用。通过这种方式
# 可以进一步减少冗余的代码。
with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                   stride=1, padding='VALID')
    ...
    # 此处省略了Inception-v3模型中其他的网络结构而直接实现最后面的
    # Inception结构。假设输入图像讲过之前的神经网络前向传播的结果保存在变量net。
    # 中。
    net = 上一层的输出节点矩阵
    # 为一个Inception模块声明一个统一的变量命名空间。
    with tf.variable_scope('Branch_0'):
       branch_1 = slim.conv2d(net, 320, [1,1], scope='Conv2d_0a_1x1')
       # tf.concat函数可以将多个矩阵拼接起来。tf.concat函数的第一个参数指定
       # 了拼接的维度，这里给出了“3“代表了矩阵是在深度这个维度上进行拼接。
       branch_1 = tf.concat(3,[
           slim.conv2d(branch_1, 384, [1,3], scope='Conv2d_0b_1x3')
           slim.conv2d(branch_1, 384, [3,1], scope='Conv2d_0c_3x1')])
       
       # Inception模块中第三条路径。此计算路径也是一个Inception结构。
       with tf.varibale_scope('Branch_2'):
           branch_2 = slim.conv2d(
              net, 448, [1,1], scope='Conv2d_0a_3x3')
           branch_2 = slim.conv2d(
              branch_2, 384, [3,3], scope='Conv2d_0b_3x3'
           branch_2 = tf.concat(3, [ 
               slim.conv2d(branch_2, 384, [1, 3], scope='Conv2d_0c_1x3'),
               slim.conv2d(branch_2, 384, [3, 1], scope='Conv2d_0d_3x1')])
           
           # Inception模块中的第四条路径。
           with tf.variable_scope('Branch_3'):
              branch_3 = slim.avg_pool2d(
                 net, [3,3], scope='AvgPool_0a_3x3')
              branch_3 = slim.con2d(
                 branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
           
           # 当前Inception模块的最后输出是由上面4个计算结果拼接得到的。
           net = tf.concat(3, [branch_0, branch_1, branch_2, branch_3])