从头开始理解和编码神经网络

参考文章源地址：
https://www.analyticsvidhya.com/blog/2017/05/neural-network-from-scratch-in-python-and-r/

1.神经网络背后的直觉

正向传播：几个输入，通过来自多个隐藏层的多个神经元对其进行处理，并使用输出层返回结果
后向传播：试图将对错误做出更大贡献的神经元的值/权重最小化，这种情况会在返回神经网络的神经元并找出错误所在的时候发生。
为了减少这些迭代次数以最大程度地减少误差，神经网络使用一种称为“梯度下降”的通用算法，该算法有助于快速有效地优化任务。

2.多层感知器及其基础

神经网络的基本构成单位是感知器，感知器可以理解为需要多个输入并产生一个输出的任何事物。

上面是处理一些线性问题。因此，人们想到了将感知器进化为现在所谓的人工神经元。神经元将非线性变换（激活函数）应用于输入和偏置。
什么是激活函数：
激活函数将加权输入的总和（w1 * x1 + w2 * x2 + w3 * x3 + 1 * b）作为参数，并返回神经元的输出。

激活函数主要用于进行非线性变换
多层感知器

上图仅以绿色显示了一个隐藏层，但实际上可以包含多个隐藏层。对于MLP（多层感知器），要记住的另一点是所有层都完全连接。

3.神经网络的训练算法–梯度下降算法

全批量梯度下降算法：使用所有的训练数据点来更新每个权重
随机梯度下降算法：使用一个或多个(样本)，但从不使用整个训练数据来更新一次权重。

4.神经网络方法学涉及的步骤

定义：
wh:隐藏层的权重矩阵
bh:隐藏层的偏差矩阵
wout:输出矩阵的权重矩阵
bout:输出层的偏置矩阵
前向传播：
hidden_layer_input= matrix_dot_product(X,wh) + bh
hiddenlayer_activations = sigmoid(hidden_layer_input)
output_layer_input = matrix_dot_product (hiddenlayer_activations * wout ) + bout
output = sigmoid(output_layer_input)
反向传播：
E = y – output

slope_output_layer = derivatives_sigmoid(output)

slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)

d_output = E * slope_output_layer

Error_at_hidden_layer = matrix_dot_product(d_output, wout.Transpose)，wout.Transpose是隐含层与输出层之间边的权值参数

d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer

wout = wout + matrix_dot_product(hiddenlayer_activations.Transpose, d_output)*learning_rate

wh = wh + matrix_dot_product(X.Transpose,d_hiddenlayer)*learning_rate

bh = bh + sum(d_hiddenlayer, axis=0) * learning_rate

bout = bout + sum(d_output, axis=0)*learning_rate
一个训练周期：一个正向和反向传播迭代。

5.使用Numpy（Python）实施NN

# importing the library
import numpy as np
# creating the input array
X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])
print ('\n Input:')
print(X)
# creating the output array
y=np.array([[1],[1],[0]])
print ('\n Actual Output:')
print(y)
# defining the Sigmoid Function
def sigmoid (x):
return 1/(1 + np.exp(-x))
# derivative of Sigmoid Function
def derivatives_sigmoid(x):
return x * (1 - x)
# initializing the variables
epoch=5000 # number of training iterations
lr=0.1 # learning rate
inputlayer_neurons = X.shape[1] # number of features in data set
hiddenlayer_neurons = 3 # number of hidden layers neurons
output_neurons = 1 # number of neurons at output layer
# initializing weight and bias
wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))
bh=np.random.uniform(size=(1,hiddenlayer_neurons))
wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))
bout=np.random.uniform(size=(1,output_neurons))
# training the model
for i in range(epoch):
#Forward Propogation
hidden_layer_input1=np.dot(X,wh)
hidden_layer_input=hidden_layer_input1 + bh
hiddenlayer_activations = sigmoid(hidden_layer_input)
output_layer_input1=np.dot(hiddenlayer_activations,wout)
output_layer_input= output_layer_input1+ bout
output = sigmoid(output_layer_input)
#Backpropagation
E = y-output
slope_output_layer = derivatives_sigmoid(output)
slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)
d_output = E * slope_output_layer
Error_at_hidden_layer = d_output.dot(wout.T)
d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer
wout += hiddenlayer_activations.T.dot(d_output) *lr
bout += np.sum(d_output, axis=0,keepdims=True) *lr
wh += X.T.dot(d_hiddenlayer) *lr
bh += np.sum(d_hiddenlayer, axis=0,keepdims=True) *lr
print ('\n Output from the model:')
print (output)