前言

前几天一个朋友跟我说想要用python自己从头到尾写一个神经网络，并向我推荐了一本书 塔里克的《python神经网络编程》，主要分为三部分，分别是基础理论介绍，python 编程，基础数学知识和树莓派上使用。

基础理论

前向传播

理论部分其实就是分为前向传播和反向传播部分，对于前向传播部分其实很简单。假设我有三层网络，分别是输入层、隐藏层、输出层，每层有三个节点。前向传播就是输入层和权重相乘得到隐藏层的输出，然后使用激活函数激活（这里使用的是sigmoid）,同理得到输出层的输出。

比如隐藏层第一个输出就是hidden1 = w11 *i1 + w21*i2 + w31*i3,在这里w的第一下标表示的就是节点，第二个表示第几层。使用矩阵的话可以写成。这里使用的是两个节点表示

所以权重矩阵的行数是层数，列数是节点数。所以公式可以表示X = W*I

反向传播

反向传播的目的就是为了更新权重

我们通过网络输出结果与实际结果做差可以得到e1和e2，但是对于这个误差如何进行分割呢，这里就继续用到了权重，在这里w11更新后的权重就是w11 / (w11+w21) *e1 ,同理可以求出其他三个更新后的权重。 使用矩阵进行如下表示：

在这里分母就是归一化分子，可以去掉。
这个权重矩阵与前面对比，我们发现他是前向传播的矩阵的转置。

梯度下降法

梯度下降法目的是为了求解最小值

使用矩阵形式表示：

python 编程

import numpy
import scipy.special
import matplotlib.pyplot as plt


class neuralNetwork:
    def __init__(self,inputnodes,hiddennodes,outputnodes,learningrate):
        self.inodes=inputnodes
        self.hnodes=hiddennodes
        self.onodes=outputnodes
        self.lr=learningrate
        #配置权重文件
        # self.wih=(numpy.random.rand(self.hnodes,self.inodes)-0.5)
        # self.who=(numpy.random.rand(self.onodes,self.hnodes)-0.5)
        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))

        #sigmod激活函数
        self.activation_function = lambda x: scipy.special.expit(x)
        pass

    def train(self,inputs_list,targets_list):
        inputs = numpy.array(inputs_list,ndmin=2).T
        targets=numpy.array(targets_list,ndmin=2).T

        hidden_inputs = numpy.dot(self.wih, inputs)
        hidden_outputs = self.activation_function(hidden_inputs)

        final_inputs = numpy.dot(self.who, hidden_outputs)
        findal_outputs = self.activation_function(final_inputs)

        output_errors=targets-findal_outputs
        hidden_errors=numpy.dot(self.who.T,output_errors)

        self.who +=self.lr*numpy.dot((output_errors*findal_outputs*(1.0-findal_outputs)),
                                      numpy.transpose(hidden_outputs))
        self.wih+=self.lr*numpy.dot((hidden_errors*hidden_outputs*(1.0-hidden_outputs)),numpy.transpose(inputs))

        pass

    def query(self,inputs_list):
        inputs=numpy.array(inputs_list,ndmin=2).T

        hidden_inputs = numpy.dot(self.wih,inputs)
        hidden_outputs=self.activation_function(hidden_inputs)

        final_inputs = numpy.dot(self.who,hidden_outputs)
        findal_outputs=self.activation_function(final_inputs)

        return findal_outputs




input_nodes=784
hidden_nodes=100
outpt_nodes=10
learning_rate=0.1
epochs =7

n=neuralNetwork(input_nodes,hidden_nodes,outpt_nodes,learning_rate)


data_file=open("minist_dataset/mnist_train.csv",'r')
data_list=data_file.readlines()
data_file.close()

for e in range(epochs):
    for record in data_list:
        all_values=record.split(',')

        inputs=(numpy.asfarray(all_values[1:])/ 255.0 * 0.99)+0.01

        targets=numpy.zeros(outpt_nodes)+0.01
        targets[int(all_values[0])]=0.99

        n.train(inputs,targets)


#测试
scorecard=[]

test_data_file=open("minist_dataset/mnist_test.csv",'r')
test_data_list=test_data_file.readlines()
test_data_file.close()

for record in test_data_list:
    all_values=record.split(',')

    correct_label = int(all_values[0])
    print(correct_label,"correct_label")

    inputs=(numpy.asfarray(all_values[1:])/ 255.0 * 0.99)+0.01

    outputs=n.query(inputs)

    label=numpy.argmax(outputs)
    print(label,"network's answer")

    if(label==correct_label):
        scorecard.append(1)
    else:
        scorecard.append(0)

#计算得分
scorecard_array=numpy.asarray(scorecard)
print("performance= ",scorecard_array.sum()/scorecard_array.size)