# 神经网络方法的可视化步骤

• 注意：
• 对于良好的可视化图像，我有2或3个位置的十进制小数位。
• 黄色填充的细胞代表当前活动细胞
• 橙色单元格表示用于填充当前单元格值的输入
• 步骤1：读取输入和输出

Step 1

• 步骤2：用随机值初始化权重和偏差（有初始化权重和偏差的方法，但是现在用随机值初始化）

Step 2

• 步骤3：计算隐层输入：

hidden_layer_input= matrix_dot_product(X,wh) + bh

Step 3

• 步骤4：对隐藏的线性输入进行非线性变换

hiddenlayer_activations = sigmoid(hidden_layer_input)

Step 4

• 步骤5：在输出层执行隐层激活的线性和非线性变换

output_layer_input = matrix_dot_product (hiddenlayer_activations * wout ) + bout

output = sigmoid(output_layer_input)

Step 5

• 步骤6：计算输出层的误差（E）梯度

E = y-output

Step 6

• 步骤7：计算输出和隐藏层的斜率

Slope_output_layer= derivatives_sigmoid(output)

Slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)

py26-10.png

• 步骤8：计算输出层的增量

d_output = E * slope_output_layer*lr

py26-11.png

• 步骤9：计算隐藏层的误差

Error_at_hidden_layer = matrix_dot_product(d_output, wout.Transpose)

py26-12.png

• 步骤10：计算隐藏层的增量

d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer

py26-13.png

• 步骤11：更新输出和隐藏层的权重

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

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

py26-14.png

• 步骤12：更新输出和隐藏层的偏置量

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

bout = bout + sum(d_output, axis=0)*learning_rate

py26-15.png

# 使用Numpy（Python）实现NN

import numpy as np
#Input array
X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])
#Output
y=np.array([[1],[1],[0]])
#Sigmoid Function
def sigmoid (x):
return 1/(1 + np.exp(-x))
#Derivative of Sigmoid Function
def derivatives_sigmoid(x):
return x * (1 - x)
#Variable initialization
epoch=5000 #Setting training iterations
lr=0.1 #Setting 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
#weight and bias initialization
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))
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("output of Forward Propogation:\n{}".format(output))
print("wout,bout of Backpropagation:\n{},\n{}".format(wout,bout))

output of Forward Propogation:
[[ 0.98497471]
[ 0.96956956]
[ 0.0416628 ]]
wout,bout of Backpropagation:
[[ 3.34342103]
[-1.97924327]
[ 3.90636787]],
[[-1.71231223]]

# 在R中实现NN

# input matrix
X=matrix(c(1,0,1,0,1,0,1,1,0,1,0,1),nrow = 3, ncol=4,byrow = TRUE)
# output matrix
Y=matrix(c(1,1,0),byrow=FALSE)
#sigmoid function
sigmoid<-function(x){
1/(1+exp(-x))
}
# derivative of sigmoid function
derivatives_sigmoid<-function(x){
x*(1-x)
}
# variable initialization
epoch=5000
lr=0.1
inputlayer_neurons=ncol(X)
hiddenlayer_neurons=3
output_neurons=1
#weight and bias initialization
wh=matrix( rnorm(inputlayer_neurons*hiddenlayer_neurons,mean=0,sd=1), inputlayer_neurons, hiddenlayer_neurons)
bias_in=runif(hiddenlayer_neurons)
bias_in_temp=rep(bias_in, nrow(X))
bh=matrix(bias_in_temp, nrow = nrow(X), byrow = FALSE)
wout=matrix( rnorm(hiddenlayer_neurons*output_neurons,mean=0,sd=1), hiddenlayer_neurons, output_neurons)
bias_out=runif(output_neurons)
bias_out_temp=rep(bias_out,nrow(X))
bout=matrix(bias_out_temp,nrow = nrow(X),byrow = FALSE)
# forward propagation
for(i in 1:epoch){
hidden_layer_input1= X%*%wh
hidden_layer_input=hidden_layer_input1+bh
hidden_layer_activations=sigmoid(hidden_layer_input)
output_layer_input1=hidden_layer_activations%*%wout
output_layer_input=output_layer_input1+bout
output= sigmoid(output_layer_input)
# Back Propagation
E=Y-output
slope_output_layer=derivatives_sigmoid(output)
slope_hidden_layer=derivatives_sigmoid(hidden_layer_activations)
d_output=E*slope_output_layer
Error_at_hidden_layer=d_output%*%t(wout)
d_hiddenlayer=Error_at_hidden_layer*slope_hidden_layer
wout= wout + (t(hidden_layer_activations)%*%d_output)*lr
bout= bout+rowSums(d_output)*lr
wh = wh +(t(X)%*%d_hiddenlayer)*lr
bh = bh + rowSums(d_hiddenlayer)*lr
}
output

# [可选]反向传播算法的数学理解

Y =σ（u'）=σ（Whh），即Y是u'的函数，u'是Wh和h的函数。

∂E/∂Wh = (∂E/∂Y).( ∂Y/∂u’).( ∂u’/∂Wh), ……..(1)

We know E is of the form E=(Y-t)2/2.

So, (∂E/∂Y)= (Y-t)

(∂Y/∂u’)=Y(1-Y)

∂E/∂Wh = (Y-t). Y(1-Y).h

∂E/∂Wi =(∂ E/∂ h). (∂h/∂u).( ∂u/∂Wi)

∂E/∂Wi =[(∂E/∂Y).( ∂Y/∂u’).( ∂u’/∂h)]. (∂h/∂u).( ∂u/∂Wi)……………(2)

∂u’/∂h = ∂(Whh)/ ∂h = Wh

∂h/∂u = ∂( σ(u)/ ∂u= σ(u)(1- σ(u))

(∂Y/∂u)=h(1-h)

∂E/∂Wi = [(Y-t). Y(1-Y).Wh].h(1-h).X

Wh = Wh + η . ∂E/∂Wh

Wi = Wi + η . ∂E/∂Wi

hiddenlayer_activations= H

E = Y-t

Slope_output_layer = Y（1-Y）

lr =η

slope_hidden_layer = h（1-h）

wout = Wh

# 结束语

1. 计算机视觉
2. 言语
3. 自然语言处理

（转载请注明来源）

|
2天前
|

Python 与机器学习：开启智能时代的大门
【2月更文挑战第6天】在当今数字化时代，Python作为一种高度灵活且功能强大的编程语言，与机器学习技术的结合为我们带来了前所未有的智能化解决方案。本文将介绍Python在机器学习领域的应用，并探讨其如何开启智能时代的大门。
10 0
|
2天前
|

Python中网络请求超时的原因及解决方案
Python中网络请求超时的原因及解决方案
14 3
|
4天前
|

|
6天前
|

Python中的机器学习入门：从数据预处理到模型评估
Python中的机器学习入门：从数据预处理到模型评估
8 0
|
6天前
|

5 0
|
6天前
|

Python的网络编程
Python的网络编程
8 2
|
7天前
|

|
8天前
|

Python 与机器学习：构建高效数据处理流程

11 2
|
20天前
|

GEE机器学习——混淆矩阵Classifier.confusionMatrix()和errorMatrix()和exlain()的用法（js和python代码）
GEE机器学习——混淆矩阵Classifier.confusionMatrix()和errorMatrix()和exlain()的用法（js和python代码）
14 0
|
1天前
|

Python编程中的迭代器与生成器
【2月更文挑战第7天】在Python编程中，迭代器和生成器是两个重要的概念，它们提供了一种高效的方法来处理数据集合。本文将深入探讨迭代器和生成器的定义、用法以及在实际项目中的应用，帮助读者更好地理解和运用这两个功能强大的工具。
11 0

• 机器翻译
• 工业大脑

更多

更多

更多