邏輯迴歸-圖片識別-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毛刺嚴重，這也在另一個角度詮釋了兩個算法的優勢劣勢。

如何優化尾部這麼大的波動呢？那就要開始構建神經網絡了，這樣纔可以合理提高預測的準確度，下一節淺層神經網絡。