今天學習了一下邏輯回歸，并且實作了對手寫圖檔圖集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檔案同樣目錄下：
然後就要開始建構這個學習的函數了，由于這次我們使用了資料集，我們需要使用分批的形式來訓練，這樣可以快速達成訓練目标，當然也要訓練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毛刺嚴重，這也在另一個角度诠釋了兩個算法的優勢劣勢。
如何優化尾部這麼大的波動呢？那就要開始建構神經網絡了，這樣才可以合理提高預測的準确度，下一節淺層神經網絡。