逻辑回归-图片识别-TF实现-数据可视化【人工智能学习】

今天学习了一下逻辑回归，并且实现了对手写图片图集MNIST 的学习
读者可以根据代码做少聊修改便可以完成一个简单的数字识别器

逻辑回归

什么事逻辑回归？
逻辑回归和线性回归都是一种拟合方式，都是监督学习中的方式。
线性回归是给一个结果，我们来预测她的结果是什么，我们举的例子是房价
逻辑回归则不是，它是对于事物判断的可能性，即概率，我们举个例子：判断这个图片是不是一组手写数字

而监督学习会给我们一大堆已经标号的数据，【图A-是】【图B-不是】等等…我们通过机器学习可以让他判断这个是不是我们想要的图片（非卷积）

那么对于逻辑回归，它的样本公式和线性的不同：
看得出来，随着z的不断变大，g的值趋近0
也因为这种特性，它的损失函数不再是MSE（方差），而是Cross Entropy（交叉熵），对于交叉熵的概念可以参考交叉熵解释。
这个在tf当中就是一句话：【softmax_cross_entropy_with_logits】

在逻辑回归模型中，我们最大化似然函数和最小化损失函数实际上是等价的，因此他的代价函数
其中L(w)是似然函数：
其中p（x）代表发生概率

那么对他使用梯度向下的方法 该怎么办呢？

梯度向下算法

还是老样子，其实我们求导之后选择变化最大的方向去优化即可
梯度下降是通过 J(w) 对 w 的一阶导数来找下降方向，并且以迭代的方式来更新参数，更新方式为，其中 k 为迭代次数:

当然，在代码里我们tf也有库的封装去训练他，下面我们开始代码实现

代码实现

思路：首先我们还是老样子，获取数据集，点击这里进行下载：

train-images-idx3-ubyte.gz: training set images (9912422 bytes)
train-labels-idx1-ubyte.gz: training set labels (28881 bytes)
t10k-images-idx3-ubyte.gz: test set images (1648877 bytes)
t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes)

引用这个训练集的方法，我放在和py文件同样目录下：

MNIST = input_data.read_data_sets("./", one_hot=True)

然后就要开始构建这个学习的函数了，由于这次我们使用了数据集，我们需要使用分批的形式来训练，这样可以快速达成训练目标，当然也要训练25次，这样提高模型精度
最后再使用测试集来完成测试，并绘制整个loss的波动图

learning_rate = 0.01 #设置学习速率
batch_size = 128 #批次数量
n_epochs = 25 #训练次数
#下面是初始化，一个分类器的W、b是784维向量，10个分类器就是784*10的矩阵
X = tf.placeholder(tf.float32, [batch_size, 784])
Y = tf.placeholder(tf.float32, [batch_size, 10])
w = tf.Variable(tf.random_normal(shape=[784,10], stddev=0.01), name="weights")
b = tf.Variable(tf.zeros([1, 10]), name="bias")

构建模型，很熟悉的模型，和线性回归类似即可，原因是通过训练集的训练，参数会变成合理的形式（向量化）

logits = tf.matmul(X, w) + b

之后构建交叉熵的损失函数，再加上一个优化器，不多说了，和线性回归一样的：

entropy = tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits)
loss = tf.reduce_mean(entropy)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)

开始学习：

init = tf.global_variables_initializer()#初始化

with tf.Session() as sess:
    sess.run(init)
    n_batches = int(MNIST.train.num_examples/batch_size)#一批数量
    for i in range(n_epochs):
        for j in range(n_batches):
            X_batch, Y_batch = MNIST.train.next_batch(batch_size)#去出这一批的训练集
            loss_ = sess.run([optimizer, loss], feed_dict={ X: X_batch, Y: Y_batch})#去除的训练集丢进去训练
            print("Loss of epochs[{0}] batch[{1}]: {2}".format(i, j, loss_))

然后加入测试集的代码，测试的原理是预测结果记录下来，再和标准答案比对，算出正确率即可：

with tf.Session() as sess:
    sess.run(init)
    
    n_batches = int(MNIST.test.num_examples/batch_size)
    total_correct_preds = 0
    for i in range(n_batches):
        X_batch, Y_batch = MNIST.test.next_batch(batch_size)
        preds = tf.nn.softmax(tf.matmul(X_batch, w) + b) #算预测结果
        correct_preds = tf.equal(tf.argmax(preds, 1), tf.argmax(Y_batch, 1)) #判断预测结果和标准结果
        accuracy = tf.reduce_sum(tf.cast(correct_preds, tf.float32))#先转化判断的字符类型，再降维求和，这样就得到了一大堆压缩后的判断结果
        total_correct_preds += sess.run(accuracy) #之前都是公式，必须要run才有用，然后记录数量

    print("Accuracy {0}".format(total_correct_preds/MNIST.test.num_examples))#判断正确率并输出

这样我们就得到了一个合格的模型，并且争取率一半都会到90%以上！
可是我们现在还需要把她的loss值输出出来，看看它收敛效果怎么样，以便之后改进数值调整
使用matplotlib.pyplot库来完成数据的可视化即可：

import matplotlib.pyplot as plt
cost_accum = []
...
with tf.Session() as sess:
    sess.run(init)

    n_batches = int(MNIST.train.num_examples/batch_size)
    for i in range(n_epochs):
        for j in range(n_batches):
            X_batch, Y_batch = MNIST.train.next_batch(batch_size)
            loss_ = sess.run([optimizer, loss], feed_dict={ X: X_batch, Y: Y_batch})
            print("Loss of epochs[{0}] batch[{1}]: {2}".format(i, j, loss_))
            cost_accum.append(loss_)#记录结果
...
#绘制图形
plt.plot(range(len(cost_accum)), cost_accum, 'r')
plt.title('Logic Regression Cost Curve')
plt.xlabel('epoch*batch')
plt.ylabel('loss')
plt.show()

最后完整代码如下：

#-*- coding:utf-8 -*-
import time
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

MNIST = input_data.read_data_sets("./", one_hot=True)
cost_accum = []

learning_rate = 0.01
batch_size = 128
n_epochs = 25

X = tf.placeholder(tf.float32, [batch_size, 784])
Y = tf.placeholder(tf.float32, [batch_size, 10])

w = tf.Variable(tf.random_normal(shape=[784,10], stddev=0.01), name="weights")
b = tf.Variable(tf.zeros([1, 10]), name="bias")

logits = tf.matmul(X, w) + b

entropy = tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits)
loss = tf.reduce_mean(entropy)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)

init = tf.global_variables_initializer()

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

    n_batches = int(MNIST.train.num_examples/batch_size)
    for i in range(n_epochs):
        for j in range(n_batches):
            X_batch, Y_batch = MNIST.train.next_batch(batch_size)
            loss_ = sess.run([optimizer, loss], feed_dict={ X: X_batch, Y: Y_batch})
            print("Loss of epochs[{0}] batch[{1}]: {2}".format(i, j, loss_))
            cost_accum.append(loss_)


    n_batches = int(MNIST.test.num_examples/batch_size)
    total_correct_preds = 0
    for i in range(n_batches):
        X_batch, Y_batch = MNIST.test.next_batch(batch_size)
        preds = tf.nn.softmax(tf.matmul(X_batch, w) + b) #算预测结果
        correct_preds = tf.equal(tf.argmax(preds, 1), tf.argmax(Y_batch, 1)) #判断预测结果和标准结果
        accuracy = tf.reduce_sum(tf.cast(correct_preds, tf.float32))#先转化判断的字符类型，再降维求和，这样就得到了一大堆压缩后的判断结果
        total_correct_preds += sess.run(accuracy) #之前都是公式，必须要run才有用，然后记录数量

    print("Accuracy {0}".format(total_correct_preds/MNIST.test.num_examples))#判断正确率并输出

plt.plot(range(len(cost_accum)), cost_accum, 'r')
plt.title('Logic Regression Cost Curve')
plt.xlabel('epoch*batch')
plt.ylabel('loss')
print('show')
plt.show()

顺利的话，你将得到这样的结果：


可以看出模型在前期快速收敛，而在后期的loss一直在波动，但是误差值不超过0.7，整个函数完成收敛。
此外我们将优化器变成【AdamOptimizer】可以得到结果如下：


可以明显看出，收敛速度变快了，但是还是有部分loss毛刺严重，这也在另一个角度诠释了两个算法的优势劣势。

如何优化尾部这么大的波动呢？那就要开始构建神经网络了，这样才可以合理提高预测的准确度，下一节浅层神经网络。