MINIST深度學習識別：python全連接神經網絡和pytorch LeNet CNN網絡訓練實現及比較（一）

版權聲明：本文為博主原創文章，歡迎轉載，並請注明出處。聯系方式：[e-mail]

全連接神經網絡是深度學習的基礎，理解它就可以掌握深度學習的核心概念：前向傳播、反向誤差傳遞、權重、學習率等。這里先用python創建模型，用minist作為數據集進行訓練。

定義3層神經網絡：輸入層節點28*28（對應minist圖片像素數）、隱藏層節點300、輸出層節點10（對應0-9個數字）。

網絡的激活函數采用sigmoid，網絡權重的初始化采用正態分布。

完整代碼如下：

# -*- coding:utf-8 -*-

u"""全連接神經網絡訓練學習MINIST"""

__author__ = 'zhengbiqing [e-mail]'


import numpy
import scipy.special
import scipy.misc
from PIL import Image
import matplotlib.pyplot
import pylab
import datetime
from random import shuffle


#是否訓練網絡
LEARN = True

#是否保存網絡
SAVE_PARA = False

#網絡節點數
INPUT = 784
HIDDEN = 300
OUTPUT = 10

#學習率和訓練次數
LR = 0.05
EPOCH = 10

#訓練數據集文件
TRAIN_FILE = 'mnist_train.csv'
TEST_FILE = 'mnist_test.csv'

#網絡保存文件名
WEIGHT_IH = "minist_fc_wih.npy"
WEIGHT_HO = "minist_fc_who.npy"


#神經網絡定義
class NeuralNetwork:
    def __init__(self, inport_nodes, hidden_nodes, output_nodes, learnning_rate):
        #神經網絡輸入層、隱藏層、輸出層節點數
        self.inodes = inport_nodes
        self.hnodes = hidden_nodes
        self.onodes = output_nodes

        #神經網絡訓練學習率
        self.learnning_rate = learnning_rate

        #用均值為0，標准方差為連接數的-0.5次方的正態分布初始化權重
        #權重矩陣行列分別為hidden * input、 output * hidden，和ih、ho相反
        self.wih = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
        self.who = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))

        #sigmoid函數為激活函數
        self.active_fun = lambda x: scipy.special.expit(x)        

    #設置神經網絡權重，在加載已訓練的權重時調用
    def set_weight(self, wih, who):
        self.wih = wih
        self.who = who

    #前向傳播，根據輸入得到輸出
    def get_outputs(self, input_list):
        # 把list轉換為N * 1的矩陣，ndmin=2二維，T轉制
        inputs = numpy.array(input_list, ndmin=2).T

        # 隱藏層輸入 = W dot X，矩陣乘法
        hidden_inputs = numpy.dot(self.wih, inputs)
        hidden_outputs = self.active_fun(hidden_inputs)

        final_inputs = numpy.dot(self.who, hidden_outputs)
        final_outputs = self.active_fun(final_inputs)

        return inputs, hidden_outputs, final_outputs

    #網絡訓練，誤差計算，誤差反向分配更新網絡權重
    def train(self, input_list, target_list):
        inputs, hidden_outputs, final_outputs = self.get_outputs(input_list)

        targets = numpy.array(target_list, ndmin=2).T

        #誤差計算
        output_errors = targets - final_outputs
        hidden_errors = numpy.dot(self.who.T, output_errors)

        #連接權重更新
        self.who += numpy.dot(self.learnning_rate * output_errors * final_outputs * (1 - final_outputs), hidden_outputs.T)
        self.wih += numpy.dot(self.learnning_rate * hidden_errors * hidden_outputs * (1 - hidden_outputs), inputs.T)
        

#圖像像素值變換
def vals2input(vals):
    #[0,255]的圖像像素值轉換為i[0.01,1]，以便sigmoid函數作非線性變換
    return (numpy.asfarray(vals) / 255.0 * 0.99) + 0.01


'''
訓練網絡
train：是否訓練網絡，如果不訓練則直接加載已訓練得到的網絡權重
epoch：訓練次數
save：是否保存訓練結果，即網絡權重
'''
def net_train(train, epochs, save):
    if train:
        with open(TRAIN_FILE, 'r') as train_file:
            train_list = train_file.readlines()

        for epoch in range(epochs):
            #打亂訓練數據
            shuffle(train_list)

            for data in train_list:
                all_vals = data.split(',')
                #圖像數據為0～255，轉換到0.01～1區間，以便激活函數更有效
                inputs = vals2input(all_vals[1:])

                #標簽，正確的為0.99，其他為0.01
                targets = numpy.zeros(OUTPUT) + 0.01
                targets[int(all_vals[0])] = 0.99

                net.train(inputs, targets)

            #每個epoch結束后用測試集檢查識別准確度
            net_test(epoch)
            print('')

        if save:
            #保存連接權重
            numpy.save(WEIGHT_IH, net.wih)
            numpy.save(WEIGHT_HO, net.who)
    else:
        #不訓練直接加載已保存的權重
        wih = numpy.load(WEIGHT_IH)
        who = numpy.load(WEIGHT_HO)
        net.set_weight(wih, who)


'''
用測試集檢查准確率
'''
def net_test(epoch):
    with open(TEST_FILE, 'r') as test_file:
        test_list = test_file.readlines()

    ok = 0
    errlist = [0] * 10

    for data in test_list:
        all_vals = data.split(',')
        inputs = vals2input(all_vals[1:])
        _, _, net_out = net.get_outputs(inputs)

        max = numpy.argmax(net_out)
        if max == int(all_vals[0]):
            ok += 1
        else:
            # 識別錯誤統計，每個數字識別錯誤計數
            # print('target:', all_vals[0], 'net_out:', max)
            errlist[int(all_vals[0])] += 1

    print('EPOCH: {epoch} score: {score}'.format(epoch=epoch, score = ok / len(test_list) * 100))
    print('error list: ', errlist, ' total: ', sum(errlist))


#變換圖片的尺寸，保存變換后的圖片
def resize_img(filein, fileout, width, height, type):
    img = Image.open(filein)
    out = img.resize((width, height), Image.ANTIALIAS)
    out.save(fileout, type)


#用訓練得到的網絡識別一個圖片文件
def img_test(img_file):
    file_name_list = img_file.split('.')
    file_name, file_type = file_name_list[0], file_name_list[1]
    out_file = file_name + 'out' + '.' + file_type
    resize_img(img_file, out_file, 28, 28, file_type)

    img_array = scipy.misc.imread(out_file, flatten=True)
    img_data = 255.0 - img_array.reshape(784)
    img_data = (img_data / 255.0 * 0.99) + 0.01

    _, _, net_out = net.get_outputs(img_data)
    max = numpy.argmax(net_out)
    print('pic recognized as: ', max)


#顯示數據集某個索引對應的圖片
def img_show(train, index):
    file = TRAIN_FILE if train else TEST_FILE
    with open(file, 'r') as test_file:
        test_list = test_file.readlines()

    all_values = test_list[index].split(',')
    print('number is: ', all_values[0])

    image_array = numpy.asfarray(all_values[1:]).reshape((28, 28))
    matplotlib.pyplot.imshow(image_array, cmap='Greys', interpolation='None')
    pylab.show()


start_time = datetime.datetime.now()

net = NeuralNetwork(INPUT, HIDDEN, OUTPUT, LR)
net_train(LEARN, EPOCH, SAVE_PARA)

if not LEARN:
    net_test(0)
else:
    print('MINIST FC Train:', INPUT, HIDDEN, OUTPUT, 'LR:', LR, 'EPOCH:', EPOCH)
    print('train spend time: ', datetime.datetime.now() - start_time)

#用畫圖軟件創建圖片文件，由得到的網絡進行識別
# img_test('t9.png')

#顯示minist中的某個圖片
# img_show(True, 1)

784-300-10簡單的全連接神經網絡訓練結果准確率基本在97.7%左右，運行結果如下：

EPOCH: 0 score: 95.96000000000001
error list:  [13, 21, 31, 28, 51, 61, 33, 66, 44, 56]  total:  404

EPOCH: 1 score: 96.77
error list:  [15, 19, 27, 63, 37, 37, 21, 40, 18, 46]  total:  323

EPOCH: 2 score: 97.25
error list:  [9, 17, 26, 26, 24, 56, 21, 41, 22, 33]  total:  275

EPOCH: 3 score: 97.82
error list:  [9, 16, 21, 18, 20, 18, 22, 21, 31, 42]  total:  218

EPOCH: 4 score: 97.54
error list:  [12, 23, 17, 25, 15, 34, 19, 25, 22, 54]  total:  246

EPOCH: 5 score: 97.78999999999999
error list:  [10, 16, 20, 23, 21, 32, 18, 31, 26, 24]  total:  221

EPOCH: 6 score: 97.6
error list:  [9, 13, 26, 34, 27, 26, 20, 28, 22, 35]  total:  240

EPOCH: 7 score: 97.74000000000001
error list:  [12, 8, 26, 29, 27, 26, 25, 20, 27, 26]  total:  226

EPOCH: 8 score: 97.77
error list:  [7, 10, 27, 16, 29, 28, 23, 29, 26, 28]  total:  223

EPOCH: 9 score: 97.99
error list:  [11, 10, 32, 17, 18, 24, 14, 22, 21, 32]  total:  201

MINIST FC Train: 784 300 10 LR: 0.05 EPOCH: 10
train spend time:  0:05:54.137925

Process finished with exit code 0