读《Python神经网络编程》

一、神经网络前向传播公式推导

这样设计的原因：第一是这种一致的完全连接形式事实上可以相对容易地编码成计算机指令，第二是神经网络的学习过程将会弱化这些实际上不需要的连接（也就是这些连接的权重将趋近于0），因此对于解决特定任 务所需最小数量的连接冗余几个连接，也无伤大雅。

这意味着，随着神经网络学习过程的进行，神经网络通过调整优化网络内部的链接权重改进输出，一些权重可能会变为零或接近于零。零或几乎为零的权重意味着这些链接对网络的贡献为零，因为没有传递信号。零权重意味着信号乘以零，结果得到零，因此这个链接实际上是被断开了。

 表示从第一层节点1到第二程节点1的权重，其他也类似。

x=（第一个节点的输出*链接权重）+（第二个节点的输出*链接权重）

x=（1.0 * 0.9）+（0.5*0.3）x=0.9+0.15 x=1.05

我们不希望看到：不使用权重调节信号，只进行一个非常简单的信号 相加1.0+0.5。权重是神经网络进行学习的内容，这些权重持续进行优化，得到越来越好的结果。

因此，现在，我们已经得到了x =1.05，这是第二层第一个节点的组合 调节输入。最终，我们可以使用激活函数y=1/（1+e^-x）计算该节点的 输出。你可以使用计算器来进行这个计算。答案为y=1/（1 +0.3499）=1 /1.3499。因此，输出y=0.7408。

三、当有许多节点和层次时，计算量将会非常大，因此可以用矩证来计算

因此我们可以用下式来表示：X=W*I

此处，W是权重矩阵，I是输入矩阵，X是组合调节后的信号，即输入到第二层的结果矩阵。

但是，我们不需要写出长长的一串数字或大量的文字。我们可以简单地写为W •I ，不管I有2个元素还是有200个元素。

激活函数最后一层的输出：O=sigmoid(X) 斜体的O代表矩阵，这个矩阵包含了来自神经网络的最后一层中的所有输出。

四、第一 层为输入层，最后一层为输出层，中间层我们称之为隐藏层。

隐藏矩阵与输入层的权重写为  ,跟输出层权重为 

 

二、神经网络反向传播公式推导

在我的知乎文章上，下面是链接

https://zhuanlan.zhihu.com/p/54055777

 

 

 

三、神经网络前反向传播代码实例

构建神经网络的基本代码：

#neural network class definition
import scipy.special
import numpy

class neuralNetwork:

      # initialise the neural network
      def __init__(self,inputnodes,hiddennodes,outputnodes,learningrate):
            #set number of nodes in each input,hidden,output,lawer,
            self.inodes=inputnodes;
            self.hnodes=hiddennodes;
            self.onodes=outputnodes;

            #w11,w21,w12,w22 etc 权重矩阵设置，正态分布
            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))
            #learning rate
            self.lr = learningrate
           #activation function is the sigmoid function
            self.activation_function = lambda x: scipy.special.expit(x)


            pass

      #train the neural network
      def train(self,inputs_lists,targets_list):
            #转换输入输出列表到二维数组
            inputs=numpy.array(inputs_lists,ndmin=2).T
            targets=numpy.array(tasgets_lists,ndmin=2).T
            #计算到隐藏层的信号
            hidden_inputs=numpy.dot(self.wih,inputs)
            #j计算到隐藏层的信号
            hidden_outputs=self.activation_function(hidden_inputs)
            #计算到输出层的信号
            final_inputs=numpy.dot(self.who,hidden_outputs)
            final_outputs=self.activation_function(final_inputs)  #与query()几乎一模一样

            output_errors=targets-final_outputs
            #输出误差转化为隐藏层误差
            hidden_errors=numpy.dot(self.who.T,output_errors)
            #更新隐藏层和输出层之间的权责
            self.who+=self.lr*numpy.dot((output_errors*final_outputs*(1.0-final_outputs)),numpy.transpose(hidden_outputs))
            #更新隐藏层到输入层之间的权责
            self.wih+=self.lr*numpy.dot((hidden_errors*hidden_outputs*(1.0-hidden_outputs)),numpy.transpose(inputs))


            pass
      #query the nnetwork
      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)
            final_outputs=self.activation_function(final_inputs)
            return final_outputs;

            pass



#number of input,output,hidden nodes
input_nodes=3;
hidden_nodes=3;
output_nodes=3;

#learning rate is 3.0
learning_rate=3.0

#creat instance of netural network
n=neuralNetwork(input_nodes,hidden_nodes,output_nodes,learning_rate)