AlexNet提高MNIST识别准确率以及最近的学习总结（4.15-4.28）

先后阅读若干AlexNet的各种详解,在AlexNet模块上进行输入和末尾输出的更改.

TensorFlow（1）-AlexNet实现(知乎)

TensorFlow实战之实现AlexNet经典卷积神经网络

规范模型1

规范模型2

【卷积神经网络-进化史】从LeNet到AlexNet

干货|详解CNN五大经典模型:Lenet，Alexnet，Googlenet，VGG，DRL

TF-api(2) tf.nn.lrn (以下1.2.2.3)

AlexNet原理及Tensorflow实现

我看AlexNet

AlexNet网络优点总结：

AlexNet之所以能够成功，深度学习之所以能够重回历史舞台，原因在于：
1.非线性激活函数：ReLU
2.防止过拟合的方法：Dropout，Data augmentation
3.大数据训练：百万级ImageNet图像数据
4.其他：GPU实现，LRN归一化层的使用

近期学习总结:（4.15-4.28）

1.Softmax函数 4.15
2.Logistics Regression推导 4.16
    2.1损失函数:二次代价函数与交叉熵函数;
    2.2梯度下降;
    2.3损失函数的推导
3.激活函数的理解，Sigmoid、ReLu、Tanh、Leaky ReLu，以及正向传播和反向传播 4.17
4.非线性回归的代码实现，以及MNIST数据简单分类的代码练习 4.19
5.对数似然函数的softmax回归的代价函数，超参数的定义以及过拟合 4.21
6.Dropout以及Optimizer的代码实现 4.22
7.CNN的工作方式，（卷积核、Padding、Stride）简单的CNN模型复现 4.23
    7.1个人理解，假设输入是一张图片，CNN就是提取图片的特征，输出为Feature Map，减少计算量同时特征保留。例如输入为39*39*3，输出为7*7*4，减少很多的计算量
    7.2通常一个卷积层: 

input —> conv —> pool —> FC —> output

    7.3池化层;
    7.4超参的选择，基本选取其他人设定好的参数;
    7.5卷积层的优势;
    7.6LeNet-5、AlexNet、VGG-16、ResNet的网络结构原理
8.Tensorboard代码实现，暂时只学习了:4.24

with tensorflow.name_scope() as scope:

    的用法，将学习:

tensorflow.summary.merge_all()

    8.1 ssh远程实现Jupyter Notebook:        

    ssh username@host address -N -L loacalhost:8889:loacalhost:8888

9.CNN提高MNIST的识别准确率代码实现1，参考: 4.25

MNIST wiki

    9.1 下载数据集；
    9.2 tf.argmax();
    9.3 tf.equal();
    9.4 tf.cast();
    9.5 tf.nn.conv2d();
    9.6 一层卷积，两个卷积核的图片推导;
    9.7 卷积各种参数的推导,比如tf.nn.conv2d()内的参数推导，tf.nn.max_pool()内的参数推导
10.CNN提高MNIST的识别准确率代码实现2 4.26
    10.1 数据集
    10.2 权值、偏置、卷积层、池化层函数
    10.3 损失函数、优化器
    10.4 结构:

input —> conv1 -> max_pool1—> conv2 -> max_pool2 —> FC1 —> FC2 —>output

11.手动推算AlexNet网络结构的各种参数 4.28
    11.1 AlexNet的优点，上述已总结
    11.2 初步推导AlexNet网络结构，数据集用的是MNIST数据集

未能搞明白的地方:

1.各种优化器的具体参数推导，比如Adam、Moment等;
2.AlexNet网络中的LRN层，资料显示是归一化层。
3.作用:

    ①使响应比较大的值相对更大，比较小的值相对更小，提高模型的泛化能力。本质上，这个层也是为了防止激活函数的饱和的;
    ②对channel做计算;
    ③2015年 Very Deep Convolutional Networks for Large-Scale Image Recognition.这篇文章提到LRN基本没什么用，反而还增加了计算时间;
4.有可能batch normalization替代了lrn，故对此层没有深入研究，仅了解如下:
    ①平滑输出，输出前后shape不变;
    ②只是一个公式,了解各个参数代表的意义;

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

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

# 每个批次的大小
batch_size = 100
# 总共多少批次
n_batch = mnist.train.num_examples // batch_size

# 初始化权值，偏置，卷积层，池化层,lrn层
def weight_variable(shape):
    initial = tf.truncated_normal(shape,dtype=tf.float32,stddev=1e-1)
    return tf.Variable(initial)

def bias_variable(shape):
    initial = tf.constant(0.0,shape=shape,dtype=tf.float32)
    return tf.Variable(initial)

# 原strides=[1,4,4,1]
def conv2d(x,W):
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')

# 原ksize=[1,3,3,1],strides=[1,2,2,1]
def max_pool_2x2(x):
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='VALID')

# 这儿的参数是抄的，别问我，我也不知道怎么推算出来的，基本上的AlexNet都在用同一个数据
def lrn(x):
    return tf.nn.lrn(x,4,bias=0.001/9.0,beta=0.75)

# 定义placeholder,占位符
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32)

# x --> 4维向量
x_image = tf.reshape(x,[-1,28,28,1])

# 输入是28*28*1，conv1，图片比较小，正宗用的是224*224，我用的是28*28
W_conv1 = weight_variable([5,5,1,32]) 
b_conv1 = bias_variable([32])

h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
h_lrn1 = lrn(h_pool1)
# 只有CPU，没有GPU加速，所以丢了个dropout在每一层
h_drop1 = tf.nn.dropout(h_lrn1,keep_prob)


# 上一层输出是14*14*32，conv2
W_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_drop1,W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
h_lrn2 = lrn(h_pool2)
h_drop2 = tf.nn.dropout(h_lrn2,keep_prob)

# 上一层输出是7*7*64,conv3
W_conv3 = weight_variable([5,5,64,128])
b_conv3 = bias_variable([128])

h_conv3 = tf.nn.relu(conv2d(h_drop2,W_conv3) + b_conv3)
h_drop3 = tf.nn.dropout(h_conv3,keep_prob)

# 上一层的输出是7*7*128，conv4
W_conv4 = weight_variable([5,5,128,128])
b_conv4 = bias_variable([128])

h_conv4 = tf.nn.relu(conv2d(h_drop3,W_conv4) + b_conv4)
h_drop4 = tf.nn.dropout(h_conv4,keep_prob)

# 上一层的输出是7*7*128，conv5
W_conv5 = weight_variable([5,5,128,64])
b_conv5 = bias_variable([64])

h_conv5 = tf.nn.relu(conv2d(h_drop4,W_conv5) + b_conv5)
h_pool5 = tf.nn.max_pool(h_conv5,ksize=[1,1,1,1],strides=[1,1,1,1],padding='VALID')
h_drop5 = tf.nn.dropout(h_pool5,keep_prob)

# 上一层输出为7*7*64，矩阵变为一维
h_drop5_flat = tf.reshape(h_drop5,[-1,7*7*64])

# 上一层的输出是(7*7*64)，FC1
W_fc1 = weight_variable([7*7*64,2048])
b_fc1 = bias_variable([2048])

h_fc1 = tf.nn.relu(tf.matmul(h_drop5_flat,W_fc1) + b_fc1)
h_drop6 = tf.nn.dropout(h_fc1,keep_prob)

# 上一层的输出是（2048）,FC2
W_fc2 = weight_variable([2048,1000])
b_fc2 = bias_variable([1000])

h_fc2 = tf.nn.relu(tf.matmul(h_drop6,W_fc2) + b_fc2)
h_drop7 = tf.nn.dropout(h_fc2,keep_prob)

# 上一层的输出是1000，softmax
W_fc3 = weight_variable([1000,10])
b_fc3 = bias_variable([10])

prediction = tf.nn.softmax(tf.matmul(h_drop7,W_fc3) + b_fc3)

# 现在是时间是2018-4-28，22:59，溜了溜了，剩下的代码片等到明天来补全，初步实现AlexNet网络结构
# 交叉熵

# trian_step

# 结果存放

# 准确率

# 初始化
init = tf.global_variables_initializer()

with tf.Session() as sess:
    pass