python搭建简易神经网络结构

本节使用python环境，在不使用深度学习工具箱情况下搭建一个简单的神经网络结构（非CNN卷积网络）来训练mnist手写体数据库。

网络的结构可以很简单，比如就是([784,200,100,10])，输入维度为784是一个样本大小的28*28，网络包含dropout操作，更多的是理解这种最基础的反向传播机制的实现过程。

完整的项目点击github主页获取

下面看下可运行的包含训练测试的代码：

# -*- coding: utf-8 -*-
"""
@author: chen

"""
import numpy as np
import struct
from datetime import datetime
import matplotlib.pyplot as plt

#读取图像
def read_image(filename):
    binfile = open(filename , 'rb')
    buf = binfile.read()

    index = 0
    magic, numImages , numRows , numColumns = struct.unpack_from('>IIII' , buf , index)
    index += struct.calcsize('>IIII')

    data = np.zeros((numImages,numRows*numColumns))
    for i in range(numImages): 
        im = struct.unpack_from('>784B' ,buf, index)
        index += struct.calcsize('>784B')

        im = np.array(im)
        data[i,:] = im
    return data

#读取图像label
def read_label(filename):
    binfile = open(filename , 'rb')
    buf = binfile.read()

    index = 0
    magic, numLabels = struct.unpack_from('>II' , buf , index)
    index += struct.calcsize('>II')

    data = np.zeros((numLabels,10))
    for i in range(numLabels): 
        label = struct.unpack_from('>B' ,buf, index)[0]

        label = np.array(label)
        data[i,label] = 1

        index += struct.calcsize('>B')
    return data

# 建立与初始化网络参数    
class nn_setup():
    def __init__(self,net,learningRate = 2, epochs = 100, batch = 100, dropoutFraction = 0.05):
        self.net = net
        self.size = net.size
        self.learningRate = learningRate
        self.dropoutFraction = dropoutFraction
        self.epochs = epochs
        self.batch = batch
        # 权值以list的形式保存，方便不同层之间的矩阵参数索引
        self.W = list() 
        self.a = list()
        self.d = list()
        self.dW = list()
        self.dropoutMask = list()
        self.L = 0
        # 初始化网络参数
        for i in range(1,self.size):
            weight = (np.random.rand(self.net[i], self.net[i - 1]+1) - 0.5) * 2 * 4 * np.sqrt(6 / (self.net[i] + self.net[i - 1]))
            self.W.append(weight)

            weight = np.zeros([self.net[i], self.net[i - 1]+1])
            self.dW.append(weight)

        for i in range(self.size):
            if i == self.size-1:
                a_weight = np.zeros([self.batch, self.net[i]])
            else:      
                a_weight = np.zeros([self.batch, self.net[i]+1])
            self.a.append(a_weight)

        if self.dropoutFraction > 0:
            for i in range(self.size):
                if i == self.size-1:
                    dropout_weight = np.zeros([self.batch, self.net[i]])
                else:      
                    dropout_weight = np.zeros([self.batch, self.net[i]+1])
                self.dropoutMask.append(dropout_weight)

        for i in range(self.size):
            if i == self.size-1:
                d_weight = np.zeros([self.batch, self.net[i]])
            else:      
                d_weight = np.zeros([self.batch, self.net[i]+1])
            self.d.append(d_weight) 

        self.e = np.zeros(self.batch,self.net[self.size - 1])


def sigmoid(inputs):
    row,col = inputs.shape
    for i in range(row):
        for j in range(col):
            inputs[i,j] = 1 / (1 + np.exp(- inputs[i,j]))
    return inputs

##----------------------------------------------------------------
if __name__ == '__main__':
    # 数据库文件夹选择
    filename_traindata = 'MNIST_data/train-images.idx3-ubyte'
    filename_trainlabel = 'MNIST_data/train-labels.idx1-ubyte'
    filename_testdata = 'MNIST_data/t10k-images.idx3-ubyte'
    filename_testlabel = 'MNIST_data/t10k-labels.idx1-ubyte'
    train_data = read_image(filename_traindata)/255;
    train_label = read_label(filename_trainlabel)
    test_data = read_image(filename_testdata)/255;
    test_label = read_label(filename_testlabel)
    # 自定义网络结构与网络参数
    net = np.array([784,200,100,10])   
    learningRate = 2 #学习率
    batch = 100 #batch大小
    epochs = 100 #迭代次数
    dropoutFraction = 0.05 #dropout率
    # 初始化网络
    nn = nn_setup(net,learningRate = learningRate,batch = batch,epochs = epochs)

    plot_flag = 0 #是否图像画出中间结果 0-不画 
    Loss = np.array([])
    accuracy_all = np.array([])
    ##----------------------训练----------------------------
    for epochs in range(nn.epochs):
        time_start = datetime.now()  #记录训练开始时间
        num = int(np.floor(train_data.shape[0]/nn.batch))
        for num_batch in range(num) :
            choose = np.random.randint(1,train_data.shape[0],nn.batch) 
            batch_x = train_data[choose,:]
            batch_y = train_label[choose,:]      
    ##--------------------nn前向传播计算各层输出值---------------
            m = batch_x.shape[0]
            nn.a[0] = np.hstack((np.ones([m,1]),batch_x))
            #从前往后依次计算各层输出
            for i in range(1,nn.size-1):
                nn.a[i] = sigmoid(np.dot(nn.a[i-1],nn.W[i-1].T))
                if nn.dropoutFraction > 0:
                    nn.dropoutMask[i] = np.random.rand(nn.a[i].shape[0],nn.a[i].shape[1])
                    nn.dropoutMask[i][nn.dropoutMask[i] > nn.dropoutFraction] = 1
                    nn.dropoutMask[i][nn.dropoutMask[i] <= nn.dropoutFraction] = 0
                    nn.a[i] = nn.a[i] * nn.dropoutMask[i]

                nn.a[i] = np.hstack((np.ones([m,1]),nn.a[i]))
            # 计算最后一层的误差    
            nn.a[nn.size-1] = sigmoid(np.dot(nn.a[nn.size-2],nn.W[nn.size-2].T))
            nn.e = batch_y - nn.a[nn.size-1] #误差计算
            nn.L = 1/2 * np.sum(nn.e * nn.e)/m
            Loss = np.hstack((Loss,nn.L))
    ##---------------------nn反向传播计算各层梯度----------------
            nn.d[nn.size-1] = - nn.e * (nn.a[nn.size-1] * (1 - nn.a[nn.size-1]))
            # 从后往前依次计算反向传播的各层梯度
            for i in range(nn.size-2,0,-1):
                d_act = nn.a[i] * (1 - nn.a[i])
                if i+1 == nn.size-1:
                    nn.d[i] = np.dot(nn.d[i+1],nn.W[i]) * d_act
                else:
                    nn.d[i] = np.dot(nn.d[i+1][:,1:],nn.W[i]) * d_act
                if nn.dropoutFraction > 0:
                    nn.d[i] = nn.d[i] * np.hstack((np.ones([nn.d[i].shape[0],1]),nn.dropoutMask[i]))

            for i in range(nn.size-2):
                if i+1 == nn.size-1:
                    nn.dW[i] = np.dot(nn.d[i + 1].T , nn.a[i]) / nn.d[i + 1].shape[0]
                else:
                    nn.dW[i] = np.dot(nn.d[i + 1][:,1:].T , nn.a[i]) / nn.d[i + 1].shape[0]
    ##-------------------nn计算各层梯度更新-------------------
            for i in range(nn.size-2):
                dW = nn.dW[i]
                dW = nn.learningRate * dW
                nn.W[i] = nn.W[i] - dW           
            # 相关结果输出
            if num_batch % 100 == 0:
                print('epochs = ', epochs,' / ', nn.epochs,
                        '; batch = ',num_batch,' / ',num,
                        '; error_batch = ', nn.L)

        time_end = datetime.now()
        print('time using for this epoch = ', (time_end.minute -time_start.minute)*60 + 
              (time_end.second-time_start.second) + 
            (time_end.microsecond - time_start.microsecond)/1000000, 's')
    ##-------------------计算测试样本的准确率-----------------
        m = test_data.shape[0]
        nn.a[0] = np.hstack((np.ones([m,1]),test_data))
        for i in range(1,nn.size-1):
            nn.a[i] = sigmoid(np.dot(nn.a[i-1],nn.W[i-1].T))
            nn.a[i] = nn.a[i] * (1-nn.dropoutFraction)
            nn.a[i] = np.hstack((np.ones([m,1]),nn.a[i]))

        nn.a[nn.size-1] = sigmoid(np.dot(nn.a[nn.size-2],nn.W[nn.size-2].T))
        res = nn.a[nn.size-1]
        pre_y = np.zeros(res.shape[0])
        y_label = np.zeros(res.shape[0])
        count = 0

        for i in range(res.shape[0]):
            pre_y[i] = np.argmax(res[i,:])
            y_label[i] = np.argmax(test_label[i,:])
            if pre_y[i] == y_label[i]:
                count = count + 1
        accuracy = count/y_label.size
        accuracy_all = np.hstack((accuracy_all,accuracy))
        print('-----------------------------------------\n',
        'test accuracy = ', accuracy, '(',count,'/',y_label.size,')',
        '\n-----------------------------------------\n')
        if plot_flag:
            plt.figure(1)
            plt.plot(Loss)
            plt.title("training batch error")
            plt.figure(2)
            plt.plot(accuracy_all)
            plt.title("testing accuracy in different epochs")
            plt.show()