Task 3 使用TensorFlow

1. 了解linear regression, logistic regression 和 softmax

1.1 了解Linear Regression

对于一个被研究的物体,它有多个属性(x1, x2, ... xn)和一个值y。线性回归假设y与(x1, x2, ... xn)有线性关系,也就是我们可以把y表示成关于(x1, x2, ... xn)的函数

其中(θ, θ1, θ2, ...)都是常数。线性回归就是要找到最合适的(θ, θ1, θ2, ...)使得这个函数离真实分布的偏差尽量小,尽量"贴切"真实的分布,让损失最小化。

于是这就引出两个问题:

  1. 怎么定义这个与真实分布的偏差?
  2. 如何去靠近这个真实分布?

这两个问题的答案就是

  1. 选择合适的损失函数, 此处使用距离方差。
  2. 选择合适的优化策略, 有最小二乘法和梯度下降。

1.1.1 距离方差

距离方差的定义是:

即对每一组数据求真实值与预测值的差的平方,再把这些平方求和。 为什么损失函数要用平方距离

1.1.2 优化策略:最小二乘法

本来的表达式y = WX + b,为便于研究,接下来我们试图把转换为y = WX(或y = XW,总之要去掉b这个"小尾巴")的形式。

  1. 我们把W与b吸收为一个新的向量
  1. 把X转为
  1. 这样就可以表达y = XW了

那么最合适的W可以表达为

令上式得0可得

如果(X^T)X满秩,则有逆,就可以求出W*。

但它的缺点在于,现实任务中(X^T)X往往不是满秩,就需要正则化(regularization)来使其有逆,也就是为这个矩阵的加一个偏差。但即使是很小的偏差,有时候都会导致预测结果的较大变化。所以,梯度下降的策略更稳定可行。

1.1.3 优化策略:梯度下降

这篇文章比较好地解释了梯度下降的机制。

  1. 首先,损失函数是距离差的平方,如上文所说。

此处的1/2m是为了后面计算方便

  1. 接下来要对每个变量求偏导 对于一个样本的误差(随机梯度下降用到它):

对于所有m个样本的误差(批量梯度下降用到它):

  1. 更新θj时,用它的偏导数乘以步长,就是对应θj的变化程度了。 设偏导数在该点的值为∂,则θj = θj - α∂,其中∂用上一步的式子求得。于是θj可以更新为: 对于一个样本点(随机梯度下降用到它):

对于多个样本点(批量梯度下降用到它):

  1. 批量梯度下降的计算量过大,每次都要计算所有m组数据。 我们引入随机梯度下降:每次只计算一组样本,每一次迭代不一定要用所有样本,可以只取其中m个。公式如下:
  1. 我们让他迭代一定次数,比如1500次,只要次数足够多,迭代停止时应该是达到最优的。另外可以设一个变量,监控theta,theta变化小于某一个很小的数的时候停止迭代。

1.1.4 两种优化策略的比较

参考:机器学习知识体系 - 线性回归

比较

1.1.5 编程实现

import tensorflow as tf
import numpy as np

# 随机生成一批训练数据
# y = 2 * x + 10
# np.random.randn标准正态分布
train_X = np.linspace(-1, 1, 100)
train_Y = 5 * train_X + np.random.randn(*train_X.shape) * 0.33 + 10 # *的作用是解包

# 构建计算模型
W = tf.Variable(tf.random_normal([1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

X = tf.placeholder(tf.float32, shape=[None]) # 只有一维,第一维长度随意
Y = tf.placeholder(tf.float32) # 默认一维


# 构建计算模型
hypothesis = X * W + b
cost = tf.reduce_mean(tf.square(hypothesis - Y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
train = optimizer.minimize(cost) # 反向传播


sess = tf.Session()
sess.run(tf.global_variables_initializer())

# 迭代2000次
for step in range(2001):
    cost_val, W_val, b_val, _ = sess.run([cost, W, b, train], feed_dict={X: train_X, Y: train_Y})
    if step % 40 == 0:
        print(step, cost_val, W_val, b_val)

1.1.6 运行结果

如图,当运行到2000次时,两个参数已经约等于5和10,误差仅有0.119

1.2 了解Logistic Regression

这篇文章解释的比较好 Logistic Regression(逻辑回归)原理及公式推导

我们知道,线性回归的公式如下:

而对于Logistic Regression来说,其思想也是基于线性回归(Logistic Regression属于广义线性回归模型)。其公式如下:

其中,

被称作sigmoid函数,我们可以看到,Logistic Regression算法是将线性函数的结果映射到了sigmoid函数中。 图形如下:

我们把函数的值视为物体属于某一类别的概率,当hθ(x)>0.5,我们把它分到A类,当hθ(x)<0.5,我们把它分到B类。

1.2.1 极大似然估计求损失函数

(该推论在博客中也有详细解释) 首先我们知道概率的表示为

那么m个样本的概率分布为

取对数似然函数:

最大似然估计就是要求得使 l(θ) 取最大值时的 θ ,这里可以使用梯度上升法求解。我们稍微变换一下:

因为乘了一个负的系数−1/m,然后就可以使用梯度下降算法进行参数求解了。 于是损失函数与梯度下降的函数都如下所示

1.2.2 编程实现

import tensorflow as tf
import numpy as np

# 生成随机数据
# x为(-10, -10), (-10, -9) 到 (4, 4)
# 分界为 3 * x1 + 4 * x2 + 5 = 0
x_data = []
y_data = []
for i1 in range(15):
  for i2 in range(15):
    x1 = i1 - 10
    x2 = i2 - 10
    x_data.append([x1, x2])
    y = int(3 * x1 + 4 * x2 + 5 > 0)
    y_data.append([y])

# 构建变量与占位符
X = tf.placeholder(tf.float32, shape=[None, 2])
Y = tf.placeholder(tf.float32, shape=[None, 1])

W = tf.Variable(tf.random_normal([2, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

# 构建模型
hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
train = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost)
predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))

with tf.Session() as sess:
   sess.run(tf.global_variables_initializer())

   #迭代训练
   for step in range(10001):
       cost_val, _ = sess.run([cost, train], feed_dict={X: x_data, Y: y_data})
       if step % 200 == 0:
           print(step, cost_val)

   # 预测参数与准确率
   h, c, a = sess.run([hypothesis, predicted, accuracy],
                      feed_dict={X: x_data, Y: y_data})
   print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)

1.2.3 运行结果

1.2.4 关于计算过程出现nan问题

最初是打算在(-100, -100) 到 (100, 100)上生成一万组x的数据,结果出现了

查阅了 Tensorflow 实现稠密输入数据的逻辑回归二分类,文中提到

注意如果设置的batch_size 比较大 而learning rate也比较大 可能会出现nan, 可以通过减小batch_size 或者调小learning rate来避免

原来是一批处理的数据量太大了,改成15 * 15组数据后,仍然有

根据上文,我推测是学习率0.1太大了,于是改成了0.01

当数据量适中,且学习率足够小,代码可以顺利运行

1.3 了解softmax回归

softmax适用于多分类问题,比如有3个分类,就为它们分别计算一个值,并把它们通过

映射区间为(0, 1)且和为1的值上,可以视为某种"概率",但不是真正的概率。它的意义在于相互比较,得到最可能的类别。 其损失函数是交叉熵(cross entropy loss),表示了信息的混乱程度。 运算公式为cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))

1.3.1 编程实现

因为MINST中的数字识别问题就是一个多分类问题,我们以MINST作为数据源进行编程。

import tensorflow as tf  
import numpy as np  
import tensorflow.examples.tutorials.mnist.input_data as input_data  
  
# 读取MNIST数据集
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)  
#trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels  
  
# 一副图像有784个像素
X = tf.placeholder(tf.float32, [None, 784])
Y = tf.placeholder(tf.float32, [None, 10]) # 正确分类

W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

# 构建计算图
y = tf.nn.softmax(tf.matmul(X, W) + b) # 预测分类
cross_entropy = -tf.reduce_sum(Y * tf.log(y))  
optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)  
  
with tf.Session() as sess:   
    sess.run(tf.global_variables_initializer())

    # 每次迭代读取128张图,迭代1000轮
    for i in range(1000):  
        batch_x, batch_y = mnist.train.next_batch(128)  
        sess.run(optimizer, feed_dict={X: batch_x, Y: batch_y})  
  
    # 计算准确率
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(Y, 1))  
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))  
    print(sess.run(accuracy, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))

1.3.2 执行结果

2.用简单CNN解决MNIST数字识别问题

2.1 理解CNN

卷积神经网络CNN原理以及TensorFlow实现 形象地描述了CNN的大致流程

另外这篇文章也很好:https://blog.csdn.net/u013082989/article/details/53673602

2.1.1 理解卷积层

在接收到图片数据方阵时,我们用卷积层对其“特征”进行提取,生成一个新的数据方阵。 接收的图片数据方阵一般是两种形式,有一个或三个Channel:

  1. 标准的数码相机有红、绿、蓝三个通道(Channels),每一种颜色的像素值在0-255之间,构成三个堆叠的二维矩阵,大小为width * height * 3
  2. 灰度图像则只有一个通道,可以用一个二维矩阵来表示。大小为width * heigh

2.1.1.1 卷积操作

  1. 下图是channel为1时,3x3的卷积核(又称过滤器,filter)在5x5的图像上做的一次卷积操作,就是矩阵做点乘之后的和。

i个隐含单元的输入就是:

,其中

就时与过滤器filter过滤到的图片局部区域。 上图中,filter为[[1,0,1], [0,1,1], [0,0,1]],b为0,上图的点乘结果为4,再加上0的偏置,得到结果为4.

  1. 当channel为3时,则对应的filter过滤器也是三维的。下图是只有一个过滤器,channel为3的情况。

2.1.1.1 一个卷积核且channel为3的情形 则卷积操作是

  1. 让每一个channel上的该图片区域 与 filter中对应的矩阵作点乘
  2. 把三个点乘的结果加起来
  3. 加上偏置:

上图的具体操作是: 与w0[:,:,0]卷积:0x(-1)+0x0+0x1 + 0x1+0x0+1x(-1) + 1x0+1x(-1)+2x0=-2 与w0[:,:,1]卷积:2x1+1x(-1)+1x1=2 与w0[:,:,2]卷积:1x(-1)+1x(-1)=-2 最终结果:-2+2+(-2)+1=-1 (1为偏置)

2.1.1.2 经过ReLU神经元激活

一次卷积操作得到的值还要经过ReLU神经元进行激活,于是g(-1) = 0就是卷积层对矩阵这个位置上处理的最终结果。

一次完整的传播过程如下图所示。我们取第一块区域为例,卷积操作得到 1 * 2(点乘结果) + 1(偏置) = 3,然后经过ReLU函数,得到最终结果为3。

卷积层前向传播样例图

2.1.1.3 其它

  • 滑动的步长-stride 上面(2.1.1.2)那张图片从左到右,每次滑动的时候移动了两格,stride为2。但是其实它一次滑动多格,这就是步长。
  • 卷积的边界处理-padding 原本的图片是3 * 3的,而过滤器是 2 * 2,这样卷积操作出来的图片就缩小为2 * 2了,比原来的图片要小了。

所以要考虑这个边界的问题。卷积的边界处理有两种方式: 一、丢掉边界,也就是就按右边那个缩小的矩阵来。 二、使用全0填充,就如下图所示

一般来说,卷积操作的意义不在于压缩图片,所以我们倾向于用全0填充

2.1.1.4 多个卷积核的情形

从上文中的图"2.1.1.1 一个卷积核且channel为3的情形"我们可以知道,不管channel是几,一个卷积核都会对图片处理得到一份二维的数据。那么如果有多个卷积核,就会得到多份二维的数据。如下图,就是一副图片经过三个卷积核得到了三组二维的数据。

但有时文章会把这三个卷积核认为是一个整体,称为一个具有深度的卷积核。所以上文一共用到了三个卷积核,我们也可以称为用到了一个深度为3的卷积核

卷积核的示意图

2.1.1.5 总结

有了上文,我们再次回顾整个卷积层处理的过程 首先将图片分割成如下图的重叠的独立小块;下图中,这张照片被分割成了77张大小相同的小图片。

然后,对每一块图片,我们用一个卷积层来处理。下图中的卷积层的深度为5,有就是有5个卷积核。 每个卷积核与图片进行卷积操作并经过ReLU激活后,得到一个值。

将所有的独立小块分别进行卷积激活操作后,再将每一个输出的特征数组按照第一步时77个独立小块的相对位置做排布,就得到一个新数组。

这就是一个完整的卷积层所做的事情了

2.1.2 理解池化层

池化就是对卷积层处理后得到的信息进行压缩,有最大池化(max pooling)和平均池化(average pooling)。前者就是在一个范围内找最大值,后者就是在范围内算平均值。实践发现最大池化的表现更好,现在一般都采用max pooling。 下图是3 * 3 * 2的矩阵经过最大池化的过程示意图。可以得知在上一层的卷积层的过滤器的深度为2。

下图是224 * 224 * 64的矩阵经过最大池化的过程示意图。可以得知在上一层的卷积层的过滤器的深度为64。

2.1.3 理解全连接层

将多次卷积和池化后的图像展开进行全连接,如下图所示。 之所以要放在卷积和池化之后,是因为全连接层的每个神经元都与所有输入相关联,如果不对图片进行“压缩”,其中的神经元的连接数量是巨大的。通过对图片多次卷积和池化后,最后留下的矩阵大小已大大缩小,且保留了原图片的特征,于是就可以使用全连接层处理了。 在分类问题中的最后一层,要使用softmax函数进行归一化处理。

2.2 用CNN编程解决MNIST数字识别问题

2.2.1 代码

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

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)     #下载并加载mnist数据
x = tf.placeholder(tf.float32, [None, 784])                        #输入的数据占位符
y_actual = tf.placeholder(tf.float32, shape=[None, 10])            #输入的标签占位符

#定义一个函数,用于初始化所有的权值 W
def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

#定义一个函数,用于初始化所有的偏置项 b
def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)
  
#定义一个函数,用于构建卷积层
def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

#定义一个函数,用于构建池化层
def max_pool(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')

#构建网络
x_image = tf.reshape(x, [-1,28,28,1])         # 转换输入数据shape,以便于用于网络中
W_conv1 = weight_variable([5, 5, 1, 32])      # 深度为32的随机权重矩阵
b_conv1 = bias_variable([32]) # 初始偏差为全1的偏差向量
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)     #第一个卷积层
h_pool1 = max_pool(h_conv1)                                  #第一个池化层

W_conv2 = weight_variable([5, 5, 32, 64])     # 通道为32,深度为64的随机权重矩阵
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)      #第二个卷积层
h_pool2 = max_pool(h_conv2)                                   #第二个池化层

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])              #reshape成向量

"""
  有的代码还会在此添加一个全连接层和dropout层
"""

W_fc2 = weight_variable([7*7*64, 10]) #softmax层
b_fc2 = bias_variable([10])
y_predict=tf.nn.softmax(tf.matmul(h_pool2_flat, W_fc2) + b_fc2)   

cross_entropy = -tf.reduce_sum(y_actual*tf.log(y_predict))     #交叉熵
train_step = tf.train.GradientDescentOptimizer(1e-4).minimize(cross_entropy)    #梯度下降法
correct_prediction = tf.equal(tf.argmax(y_predict,1), tf.argmax(y_actual,1))    
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))                 #精确度计算
sess=tf.InteractiveSession()                          
sess.run(tf.global_variables_initializer())
for i in range(20000):
  batch = mnist.train.next_batch(50)
  if i%100 == 0:                  #训练100次,验证一次
    train_acc = accuracy.eval(feed_dict={x:batch[0], y_actual: batch[1]})
    print('step',i,'training accuracy',train_acc)
  train_step.run(feed_dict={x: batch[0], y_actual: batch[1]})

test_acc=accuracy.eval(feed_dict={x: mnist.test.images, y_actual: mnist.test.labels})
print("test accuracy",test_acc)

2.2.2 运行结果

到学习后期已经基本稳定在95%左右

3 用LeNet-5解决MNIST数字识别问题

3.1 理解LeNet-5

LeNet-5模型一共有7层,下图展示了LeNet-5模型的架构:

其实就是由两次(卷积->池化)交替,后跟上三个全连接层。LeNet5的具体参数也在图中有所体现,比如C1接收32 * 32的图片,输出28 * 28的矩阵,且卷积核种类为6。

3.2 代码实现

这份代码参考了网上别人的代码。尽管认真思考过,我还是不确定这个是否算作LeNet-5。因为这份代码的构建格式与《tensorflow实战google深度学习框架》第六章所提到的LeNet-5格式基本相似。我觉得是符合LeNet-5的架构的,因为两次卷积->池化后确实有两个全连接层,代码应该只是把第六层和输出层合并了。

代码:

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


"""
训练3000次时已能接近1.000正确率
"""
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)  
  
def conv2d(x, W):  
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')  
  
def max_pool_2x2(x):  
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  
  
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)  
  
sess = tf.InteractiveSession()  


# 第一层卷积核池化层
x_image = tf.reshape(x, [-1, 28, 28, 1])  
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)  
  
# 第二层卷积核池化层
W_conv2 = weight_variable([5, 5, 32, 64])  
b_conv2 = bias_variable([64])  
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)  
h_pool2 = max_pool_2x2(h_conv2)  

# Now image size is reduced to 7*7  
W_fc1 = weight_variable([7 * 7 * 64, 1024])  
b_fc1 = bias_variable([1024])  
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层
keep_prob = tf.placeholder("float")  
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)  
  
# full connect层与输出层
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_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)  
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))  
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))  
sess.run(tf.global_variables_initializer())  
  
for i in range(20000):  
  batch = mnist.train.next_batch(50)  
  if i%100 == 0:  
    train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})  
    print("step %d, training accuracy %.3f"%(i, train_accuracy))
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})  
  
print("Training finished")
  
test_acc = accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})
print("test accuracy %.3f" % test_acc)

3.3 运行结果

表现比较好,很容易就到95+%了。

4. 疑惑与感想

  1. 优化器的封装程度太高,比如梯度下降函数,只提供一个learning_rate参数就可以调用了。自己不确定函数的效率和具体执行策略。
  2. 在试图构建LeNet-5时遇到了许多困难,在网上也一直找不到完全满意的样例
  3. 在理解概念上花费了很多时间,自己的实操能力还有待提高。
  4. 这周感觉比较赶,因为上周的代码需要修改,而我的代码的改动量比较大,主要逻辑基本相当于重写。所以在LeNet-5的实现上不太顺利。

5.参考

实验代码

LeNet-5

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券