全连接神经网络 MLP

全连接神经网络–MLP

全连接神经网络,又叫多层感知机,是一种连接方式较为简单的人工神经网络,是前馈神经网络的一种。

MLP的神经网络架构

网络架构为:

全连接神经网络 MLP_第1张图片

通过输入层,隐藏层,输出层三个网络层组成,其中隐藏层可以有多层。

BP传播的原理

梯度下降法

正向传播,对网络层的输出进行传播,反向传播,对输入的梯度进行传播。

输出层:

  • 偏置的梯度
  • 权重的梯度
  • 输入的梯度

中间层:

  • 偏置的梯度
  • 权重的梯度
  • 输入的梯度
网络层 下表 神经元数量
输入层 i l
中间层 j m
输出层 k n

输出层的梯度

相关函数

E = f 1 ( y k ) E=f_1(y_k) E=f1(yk)

y k = f 2 ( u k ) y_k=f_2(u_k) yk=f2(uk)

u k = ∑ q = 1 m ( y q w q k + b k ) u_k=\sum_{q=1}^{m}(y_qw_{qk}+b_k) uk=q=1m(yqwqk+bk)

E:损失值

f 1 f_1 f1:损失函数

y k y_k yk:输出结果

f 2 f_2 f2:激励函数

u k u_k uk:输入与权值乘积与偏置的求和

y j y_j yj: y j y_j yj y q y_q yq中的一个

定义

δ k = ∂ E ∂ u K = ∂ E ∂ y k ∂ y k ∂ u k \delta_k=\frac{∂E}{∂u_K}=\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial u_k} δk=uKE=ykEukyk

∂ E ∂ y k \frac{\partial E}{\partial y_k} ykE损失函数对 y k y_k yk的偏微分

∂ y k ∂ u k \frac{\partial y_k}{\partial u_k} ukyk激励函数对 u k u_k uk的偏微分

输出层权重的梯度

∂ w j k = ∂ E ∂ w j k \partial w_{jk} = \frac{\partial E}{\partial w_{jk}} wjk=wjkE

根据微分连锁公式

∂ E ∂ w j k = ∂ E ∂ y k ∂ y k ∂ u k ∂ u k ∂ w j k \frac{\partial E}{\partial w_{jk}}=\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial u_k}\frac{\partial u_k}{\partial w_{jk}} wjkE=ykEukykwjkuk

∂ u k ∂ w j k = y j \frac{\partial u_k}{\partial w_{jk}}=y_j wjkuk=yj : u k u_k uk w j k w_{jk} wjk的偏微分

∂ w j k = δ k y j \partial w_{jk} =\delta_ky_j wjk=δkyj

输出层偏置的梯度

∂ b k = ∂ E ∂ b k \partial b_k = \frac{\partial E}{\partial b_k} bk=bkE

根据微分连锁公式

∂ E ∂ b k = ∂ E ∂ y k ∂ y k ∂ u k ∂ u k ∂ b k \frac{\partial E}{\partial b_k}=\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial u_k}\frac{\partial u_k}{\partial b_k} bkE=ykEukykbkuk

∂ u k ∂ b k = 1 \frac{\partial u_k}{\partial b_k}=1 bkuk=1 u k u_k uk b k b_k bk的偏微分

∂ b k = δ k \partial b_k =\delta_k bk=δk

输出层的输入梯度

输出层的输入梯度=中间层的输出梯度

∂ y j = ∂ E ∂ y j \partial y_j= \frac{\partial E}{\partial y_j} yj=yjE

根据微分连锁公式

∂ E ∂ y j = ∑ r = 1 n ∂ E ∂ y r ∂ y r ∂ u r ∂ u r ∂ y j \frac{\partial E}{\partial y_j}=\sum_{r=1}^{n}\frac{\partial E}{\partial y_r}\frac{\partial y_r}{\partial u_r}\frac{\partial u_r}{\partial y_j} yjE=r=1nyrEuryryjur

∂ u r ∂ y j = w j r \frac{\partial u_r}{\partial y_j}=w_{jr} yjur=wjr

∂ y j = ∑ r = 1 n δ r w j r \partial y_j=\sum_{r=1}^{n}\delta_rw_{jr} yj=r=1nδrwjr

中间层的梯度

相关函数

y j = f ( u j ) y_j=f(u_j) yj=f(uj)

u j = w i j y i + b j u_j=w_{ij}y_i+b_j uj=wijyi+bj

y j y_j yj为中间层的输出值

f f f为激励函数

u j u_j uj输入值与权重的乘积与偏置的和

中间层权重的梯度

∂ w i j = ∂ E ∂ w i j = ∂ E ∂ u j ∂ u j ∂ w i j = ∂ E ∂ y j ∂ y j ∂ u j ∂ u j ∂ w i j ∂ w_{ij}=\frac{∂ E}{∂ w_{ij}}=\frac{∂ E}{∂ uj}\frac{∂{u_j}}{∂ w_{ij}}=\frac{∂ E}{∂ y_j}\frac{∂ y_j}{∂ u_j}\frac{∂ u_j}{∂ w_{ij}} wij=wijE=ujEwijuj=yjEujyjwijuj

∂ E ∂ y j \frac{∂ E}{∂ y_j} yjE为中间层的输出梯度

∂ y j ∂ u j \frac{∂ y_j}{∂ u_j} ujyj为激励函数的微分

∂ u j ∂ w i j = y i \frac{∂ u_j}{∂ w_{ij}}=y_i wijuj=yi

定义 δ j = ∂ y i ∂ y j ∂ u j \delta_j=∂ y_i\frac{∂ y_j}{∂ u_j} δj=yiujyj ∂ w i j = y i δ j ∂ w_{ij}=yi\delta_j wij=yiδj

中间层偏置的梯度

∂ b j = ∂ E ∂ b j = ∂ E ∂ u j ∂ u j ∂ b j ∂ b_j=\frac{∂ E}{∂ b_j}=\frac{∂ E}{∂ uj}\frac{∂{u_j}}{∂ b_j} bj=bjE=ujEbjuj

∂ u j ∂ b j = 1 \frac{∂{u_j}}{∂ b_j}=1 bjuj=1

b j = δ j b_j=\delta_j bj=δj

若网络层不止三层,即隐藏层不止三层,则 ∂ y i = ∑ q = 1 m ∂ q w i q ∂ y_i=\sum_{q=1}^{m}∂_qw_{iq} yi=q=1mqwiq

梯度计算公式总结

输出层

δ k = ∂ E ∂ u k = ∂ E ∂ y k ∂ y k ∂ u k \delta_k=\frac{\partial E}{\partial u_k}=\frac{\partial E}{\partial y_k}\frac{\partial y_k}{\partial u_k} δk=ukE=ykEukyk

∂ w j k = y j δ k \partial w_{jk} =y_j\delta_k wjk=yjδk

∂ b k = δ k \partial b_k =\delta_k bk=δk

∂ y j = ∑ r = 1 n δ r w j r \partial y_j=\sum_{r=1}^{n}\delta_rw_{jr} yj=r=1nδrwjr

关于 δ k \delta_k δk的求解,在使用不同的损失函数和激励函数组合时不同,其方法也是不同的, δ k \delta_k δk与输出层的神经元数量相同

中间层

δ j = ∂ E ∂ u j = ∂ y i ∂ y j ∂ u j \delta_j=\frac{∂ E}{∂ u_j}=∂ y_i\frac{∂ y_j}{∂ u_j} δj=ujE=yiujyj

∂ w i j = y i δ j ∂ w_{ij}=y_i\delta_j wij=yiδj

∂ b j = δ j ∂ b_j=\delta_j bj=δj

∂ y i = ∑ q = 1 m δ q w i q ∂ y_i=\sum_{q=1}^{m}\delta_qw_{iq} yi=q=1mδqwiq

MLP的建构

import torch
import torch.nn as nn
def self_MLP(nn.module):
  def __init__(self):
    super(self_MLP,self).__init__()
    self.hidden = nn.Sequential(
      nn.Linear(10,128); # 10个输入,第一层隐藏层为10个神经元
      nn.ReLU();         # 激活函数为ReLU()函数 
      nn.Linear(128,64); # 第二个隐藏层为64个神经元
      nn.ReLU();
      nn.Linear(64,32);  # 第三个隐藏层为32个神经元
      nn.ReLU();
    )
  def forward(self,x):
    x = self.hidden(x)
    return x           # 返回x

你可能感兴趣的:(深度学习,python,深度学习)