神经网络之小试牛刀
本文主要介绍本学期入门深度学习的一点学习进展，顺便整理一下我的思路。
首先介绍一下我的学习思路，这里先引用一下知乎某答主的学习路线，觉得很有参考价值：
CS229《吴恩达的机器学习》作为ML的入门,然后CS231《李飞飞的计算机视觉》走CNN路线;CS224《Chris Manning的用深度学习来做自然语言处理》走RNN路线。期间选定方向,比如我选的是char-level的text classification,我就从Kim 2014的EMNLP看起 一直到ZHANG NIPS2015的和他同组的CNNxRNN 最后到facebook的29层CNN…期间搭配各种blog和延伸的论文,但是主线任务就是这几个.现在基本能把thesis写出来了…大概这么一个学习的过程…仅供参考
可以看出，上边的答主走的是『用深度学习来做自然语言处理』路线。因为深度学习必须依附于实际应用，而且我觉得与机器人结合应该是不错的方向，所以硕士期间准备学习深度学习计算机视觉方向和视觉slam两大块。
1.概念
神经网络是一门重要的机器学习技术。它是目前最为火热的研究方向深度学习的基础。学习神经网络不仅可以让你掌握一门强大的机器学习方法，同时也可以更好地帮助你理解深度学习技术。
了解神经网络之前，首先需要了解一部分机器学习的知识。从广义上来说，机器学习是一种能够赋予机器学习的能力以此让它完成直接编程无法完成的功能的方法。但从实践的意义上来说，机器学习是一种通过利用数据，训练出模型，然后使用模型预测的一种方法。
2.代码
看了很多机器学习的东西，还是云山雾绕，这不禁令我想起一句话『Talk is cheap, show me the code』。所以有时候看了大段的书本，学了不少教程，不如亲自跑一下代码。以下是我刚学的tensoflow的教程中的第一个代码：MNIST。
1.MNIST简介：
MNIST是一个入门级的计算机视觉数据集，它包含各种手写数字图片：
它也包含每一张图片对应的标签，告诉我们这个是数字几。比如，上面这四张图片的标签分别是5，0，4，1。在此教程中，我们将训练一个机器学习模型用于预测图片里面的数字。我们的目的不是要设计一个世界一流的复杂模型 – 尽管我们会在之后给你源代码去实现一流的预测模型 – 而是要介绍下如何使用TensorFlow。所以，我们这里会从一个很简单的数学模型开始，它叫做Softmax Regression。
2.tensorflow的安装
首先，tensorflow的安装需要说明一下，tensorflow在linux下的安装推荐使用anacoda环境安装，然后使用jupyter notebook编辑。需要注意的是使用jupyter notebook之前要source activate tensorflow 。还有就是在tensorflow环境中可能缺少各种包，但是你安装的时候提示已经安装，那就把已经安装的卸载掉，然后在tensorflow环境下重新安装。
3.仅含有Softmax Regression的全连接神经网络
下面代码分为两部分，首先是仅含有Softmax Regression的全连接神经网络训练过程：
#导入Minst数据集
import input_data #导入名为‘input_data.py‘的input_data函数，这个函数是下载到本地并将数据存在命名为MNST的文件夹中
mnist = input_data.read_data_sets("MNST_data",one_hot=True)
#导入tensorflow库
import tensorflow as tf
#定义输入变量，把28*28的图片变成一维数组（丢失结构信息）
x = tf.placeholder("float",[None,784])
#定义权重矩阵，把28*28=784的一维输入，变成0-9这10个数字的输出
w = tf.Variable(tf.zeros([784,10]))
#偏置
b = tf.Variable(tf.zeros([10]))
#核心运算，其实就是softmax（x*w+b）
y = tf.nn.softmax(tf.matmul(x,w) + b)
#这个是训练集的正确结果
y_ = tf.placeholder("float",[None,10])
#交叉熵，作为损失函数
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
#梯度下降算法，最小化交叉熵
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
#初始化，在run之前必须进行的
init = tf.global_variables_initializer()
#创建session以便运算
sess = tf.Session()
sess.run(init)
#迭代1000次
for i in range(1000):
#获取训练数据集的图片输入和正确表示数字
batch_xs, batch_ys = mnist.train.next_batch(100)
#运行刚才建立的梯度下降算法，x赋值为图片输入，y_赋值为正确的表示数字
sess.run(train_step,feed_dict = {x:batch_xs, y_: batch_ys})
#tf.argmax获取最大值的索引。比较运算后的结果和本身结果是否相同。
#这步的结果应该是[1,1,1,1,1,1,1,1,0,1...........1,1,0,1]这种形式。
#1代表正确，0代表错误
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
#tf.cast先将数据转换成float，防止求平均不准确。
#tf.reduce_mean由于只有一个参数，就是上面那个数组的平均值。
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
#输出
print "test accuracy %g"%sess.run(accuracy,feed_dict={x:mnist.test.images,y_: mnist.test.labels}) 输出结果：
Extracting MNST_data/train-images-idx3-ubyte.gz
Extracting MNST_data/train-labels-idx1-ubyte.gz
Extracting MNST_data/t10k-images-idx3-ubyte.gz
Extracting MNST_data/t10k-labels-idx1-ubyte.gz
test accuracy 0.91581.怎样理解权值和Softmax
可以看出，“MNIST机器学习入门”里面，没有用卷积神经网络，而是用了一个全连接神经网络+Softmax输出层。
MNIST的一幅图片是28*28，因此一共有784个像素值，在第一个例子里面，我们就直接就考虑用这784个数字得出正确的数字结果。最简单的考虑，我们要对这个784个数字进行加权求和，然后加点偏置，然后衡量一下得出的结果，看到底和哪个数字最像。那么这个加权加偏移的结构就是全连接神经网，而这个衡量结果的过程就是Softmax。实际的运算是将784个像素输入加权，并且用不同的权值加权10次（因为有0-9一共10个数字），得到10个不同的结果，最后使用Softmax进行结果的输出。
因此，最终得到的10个输出都会有一个概率值，这个概率值处于0-1之间，而且10个输出相加等于1。将整个神经网络表示成一个表达式，就是：
2.怎样计算正确率
为了衡量目前神经网络中的权值和偏移是否合理，我们可以定义交叉熵。交叉熵的公式是：
如果神经网络的性能好，那么交叉熵就会越小，最终接近于0. 在这个例子的训练中，使用的是随机梯度下降法结合反向传播进行参数训练。
#交叉熵，作为损失函数
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
#梯度下降算法，最小化交叉熵
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)从结果中可以看出测试的准确率有0.9158，下边使用多层卷积神经网络与其做一个对比。
4.拥有多层卷积网络的softmax回归模型
# -*- coding: utf-8 -*-
import tensorflow as tf
#导入input_data用于自动下载和安装MNIST数据集
import input_data
mnist = input_data.read_data_sets("MNST_data",one_hot=True)
#创建一个交互式Session
sess = tf.InteractiveSession()
#创建两个占位符，x为输入网络的图像，y_为输入网络的图像类别(0-9)这九个数字
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])
#权重初始化函数
def weight_variable(shape):
#输出服从截尾正态分布的随机值
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#偏置初始化函数
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#创建卷积op
#x 是一个4维张量，shape为[batch,height,width,channels]
#卷积核移动步长为1。填充类型为SAME,可以不丢弃任何像素点
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding="SAME")
#创建池化op
#采用最大池化，也就是取窗口中的最大值作为结果
#x 是一个4维张量，shape为[batch,height,width,channels]
#ksize表示pool窗口大小为2x2,也就是高2，宽2
#strides，表示在height和width维度上的步长都为2
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1],
strides=[1,2,2,1], padding="SAME")
#第1层，卷积层
#初始化W为[5,5,1,32]的张量，表示卷积核大小为5*5，第一层网络的输入和输出神经元个数分别为1和32
W_conv1 = weight_variable([5,5,1,32])
#初始化b为[32],即输出大小
b_conv1 = bias_variable([32])
#把输入x(二维张量,shape为[batch, 784])变成4d的x_image，x_image的shape应该是[batch,28,28,1]
#-1表示自动推测这个维度的size
x_image = tf.reshape(x, [-1,28,28,1])
#把x_image和权重进行卷积，加上偏置项，然后应用ReLU**函数，最后进行max_pooling
#h_pool1的输出即为第一层网络输出，shape为[batch,14,14,1]
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
#第2层，卷积层
#卷积核大小依然是5*5，这层的输入和输出神经元个数为32和64
W_conv2 = weight_variable([5,5,32,64])
b_conv2 = weight_variable([64])
#h_pool2即为第二层网络输出，shape为[batch,7,7,1]
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
#第3层, 全连接层
#这层是拥有1024个神经元的全连接层
#W的第1维size为7*7*64，7*7是h_pool2输出的size，64是第2层输出神经元个数
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
#计算前需要把第2层的输出reshape成[batch, 7*7*64]的张量
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#Dropout层
#为了减少过拟合，在输出层前加入dropout
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#输出层
#最后，添加一个softmax层
#可以理解为另一个全连接层，只不过输出时使用softmax将网络输出值转换成了概率
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#预测值和真实值之间的交叉墒
cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
#train op, 使用ADAM优化器来做梯度下降。学习率为0.0001
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#评估模型，tf.argmax能给出某个tensor对象在某一维上数据最大值的索引。
#因为标签是由0,1组成了one-hot vector，返回的索引就是数值为1的位置
correct_predict = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
#计算正确预测项的比例，因为tf.equal返回的是布尔值，
#使用tf.cast把布尔值转换成浮点数，然后用tf.reduce_mean求平均值
accuracy = tf.reduce_mean(tf.cast(correct_predict, "float"))
#初始化变量
sess.run(tf.global_variables_initializer())
#开始训练模型，循环20000次，每次随机从训练集中抓取50幅图像
for i in range(20000):
batch = mnist.train.next_batch(50)
if i%100 == 0:
#每100次输出一次日志
train_accuracy = accuracy.eval(feed_dict={
x:batch[0], y_:batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (i, train_accuracy)
train_step.run(feed_dict={x:batch[0], y_:batch[1], keep_prob:0.5})
print "test accuracy %g" % accuracy.eval(feed_dict={
x:mnist.test.images, y_:mnist.test.labels, keep_prob:1.0})训练结果：
Extracting MNST_data/train-images-idx3-ubyte.gz
Extracting MNST_data/train-labels-idx1-ubyte.gz
Extracting MNST_data/t10k-images-idx3-ubyte.gz
Extracting MNST_data/t10k-labels-idx1-ubyte.gz
step 0, training accuracy 0.12
step 100, training accuracy 0.84
step 200, training accuracy 0.92
step 300, training accuracy 0.92
......
step 19700, training accuracy 1
step 19800, training accuracy 1
step 19900, training accuracy 1
test accuracy 0.991 涉及到卷积神经网络，说实话，还没大看懂，这里仅从代码方面分析：
首先是第一层卷积，然后使用ReLu（Rectified Linear Unit 修正线性函数）『这个应该和Sigmoid函数作用一样』，然后池化『理解为降采样』，TensorFlow经过若干的卷积和池化后接的是Softmax。
所以，在TensorFlow这个例子里面，它采用的模式是SAME，经过第一次卷积，使用了32种卷积核，计算出32张28*28的特征图，经过一次2*2大小的MAX Pooling，减为14*14，然后再经过第二次卷积，计算出64张14*14的特征图（每个图都用了两个卷积核），再经过一次MAX Pooling，得到7*7的图，将这个图输入到有7*7*64个输入，1024个输出的全连接神经网络，然后再加一个SoftMax层，就得到最后的10个概率值。
Dropout是为了解决大规模深度学习的两个缺点：费时，过拟合而发明的一种方法。Dropout就是在不同的训练过程中随机扔掉一部分神经元。
从结果可以看出，利用卷积神经网络的测试准确率有0.991，可以得出结论，好的网络的重要性。
学到这儿的时候，可以看出来，光看代码是不行的，要回头看论文，blog等,来了解卷积神经网络到底是怎么一回事儿，为什么教程要用到ReLu，pooling，Dropout…
待续
参考：
上一篇： 一些名词