手动实现反向传播算法
#!/usr/bin/env python# encoding: utf-8"""@author: HuRuiFeng@file: 7.9-backward-prop.py@time: 2020/2/24 17:32@desc: 7.9 反向传播算法实战的代码"""import matplotlib.pyplot as pltimport numpy as npimport seaborn as
·
#!/usr/bin/env python
# encoding: utf-8
"""
@author: HuRuiFeng
@file: 7.9-backward-prop.py
@time: 2020/2/24 17:32
@desc: 7.9 反向传播算法实战的代码
"""
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
plt.rcParams['font.size'] = 16
plt.rcParams['font.family'] = ['STKaiti']
plt.rcParams['axes.unicode_minus'] = False
def load_dataset():
# 采样点数
N_SAMPLES = 2000
# 测试数量比率
TEST_SIZE = 0.3
# 利用工具函数直接生成数据集
X, y = make_moons(n_samples=N_SAMPLES, noise=0.2, random_state=100)
'''
n_samples为生成样本的个数，noise为引入高斯噪音的随机变量
random_state为对应生成的随机因子
'''
# 将 2000 个点按着 7:3 分割为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=42)
return X, y, X_train, X_test, y_train, y_test
def make_plot(X, y, plot_name, XX=None, YY=None, preds=None, dark=False):
# 绘制数据集的分布， X 为 2D 坐标， y 为数据点的标签
if (dark):
plt.style.use('dark_background')
else:
sns.set_style("whitegrid")
plt.figure(figsize=(16, 12))
#表示figure的大小为宽，长(单位为inch)
axes = plt.gca()
#获取对应的子图
axes.set(xlabel="$x_1$", ylabel="$x_2$")
plt.title(plot_name, fontsize=30)
#plot_name为调入函数的参数，对应的字体大小为30
plt.subplots_adjust(left=0.20)
#图片中子图的左侧
plt.subplots_adjust(right=0.80)
#图片中子图的右侧
if XX is not None and YY is not None and preds is not None:
plt.contourf(XX, YY, preds.reshape(XX.shape), 25, alpha=1, cmap=plt.cm.Spectral)
plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5], cmap="Greys", vmin=0, vmax=.6)
# 绘制散点图，根据标签区分颜色
#plt.contourf会绘制轮廓线，contour会绘制轮廓
'''
coutour([X,Y],Z,[levels],**kwargs)
X,Y:类似数组，Z:类似数组，level:int或类似数组，**kwargs其他参数
'''
plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral, edgecolors='r')
'''
x,y:形如shape(n,)数组，s:标量,形如shape(n,)数组，c：色彩或颜色序列
cmap:Colormap可选，默认:None,norm
'''
plt.savefig('数据集分布.svg')
plt.close()
class Layer:
# 全连接网络层
def __init__(self, n_input, n_neurons, activation=None, weights=None,
bias=None):
"""
:param int n_input: 输入节点数
:param int n_neurons: 输出节点数
:param str activation: 激活函数类型
:param weights: 权值张量，默认类内部生成
:param bias: 偏置，默认类内部生成
"""
# 通过正态分布初始化网络权值，初始化非常重要，不合适的初始化将导致网络不收敛
self.weights = weights if weights is not None else np.random.randn(n_input, n_neurons) * np.sqrt(1 / n_neurons)
#randn函数返回一个或一组样本，具有正态分布，括号里面为表格的每个维度
self.bias = bias if bias is not None else np.random.rand(n_neurons) * 0.1
self.activation = activation # 激活函数类型，如’sigmoid’
self.last_activation = None # 激活函数的输出值o
self.error = None # 用于计算当前层的delta 变量的中间变量
self.delta = None # 记录当前层的delta 变量，用于计算梯度
# 网络层的前向传播函数实现如下，其中last_activation 变量用于保存当前层的输出值：
def activate(self, x):
# 前向传播函数
r = np.dot(x, self.weights) + self.bias # X@W+b
# 通过激活函数，得到全连接层的输出o
self.last_activation = self._apply_activation(r)
#!!!在通过每一层的时候都要求出该层的last_activiation
return self.last_activation
# 上述代码中的self._apply_activation 函数实现了不同类型的激活函数的前向计算过程，
# 尽管此处我们只使用Sigmoid 激活函数一种。代码如下：
def _apply_activation(self, r):
# 计算激活函数的输出
if self.activation is None:
return r # 无激活函数，直接返回
# ReLU 激活函数
elif self.activation == 'relu':
return np.maximum(r, 0)
# tanh 激活函数
elif self.activation == 'tanh':
return np.tanh(r)
# sigmoid 激活函数
elif self.activation == 'sigmoid':
return 1 / (1 + np.exp(-r))
return r
# 针对于不同类型的激活函数，它们的导数计算实现如下：
def apply_activation_derivative(self, r):
# 计算激活函数的导数
# 无激活函数，导数为1
if self.activation is None:
return np.ones_like(r)
# ReLU 函数的导数实现
elif self.activation == 'relu':
grad = np.array(r, copy=True)
grad[r > 0] = 1.
grad[r <= 0] = 0.
return grad
# tanh 函数的导数实现
elif self.activation == 'tanh':
return 1 - r ** 2
# Sigmoid 函数的导数实现
elif self.activation == 'sigmoid':
return r * (1 - r)
return r
# 神经网络模型
class NeuralNetwork:
def __init__(self):
print('__init__')
self._layers = [] # 网络层对象列表
def add_layer(self, layer):
# 追加网络层
print('add_layer')
self._layers.append(layer)
# 网络的前向传播只需要循环调各个网络层对象的前向计算函数即可，代码如下：
# 前向传播
def feed_forward(self, X):
print('feed_forward')
for layer in self._layers:
# 依次通过各个网络层
'''
因为self._layers里面压入的为Layer类，所以layer调用的
就是前面的Layer类!!!
'''
print('layer = ***')
print(layer)
X = layer.activate(X)
print('X = ***')
print(X)
return X
def backpropagation(self, X, y, learning_rate):
# 反向传播算法实现
# 前向计算，得到输出值
print('backpropagation')
output = self.feed_forward(X)
print('output')
print(output)
'''
output = [0.892 0.484]这一数组为前向传播传播到最后的结果
总的概括：为输出的时候layer.delta=(y-out)
*layer.apply_activation_derivative(output)
为中间层的时候layer.delta=np.dot(next_layer.weights,
next_layer.delta)*layer.apply_activation_derivative(layer.
last_activation)
'''
for i in reversed(range(len(self._layers))): # 反向循环
#!!!注意这里的数组为反向循环数组，第一次先访问输出层，然后依次向前
#最后一次访问最开始的层数
print('i = %d!!!'%i)
layer = self._layers[i] # 得到当前层对象
# 如果是输出层
if layer == self._layers[-1]: # 对于输出层
'''
最后一层输出的时候使用的公式为(y-out)*layer.apply_activation_derivative(output)
输出层对应的公式为(ok-tk)*ok*(1-ok)
layer.apply_activation_derivative(output) = ok*(1-ok)
'''
print('output layer')
print('y = ***')
print(y)
print('output = ***')
print(output)
layer.error = y - output # 计算2 分类任务的均方差的导数
# 关键步骤：计算最后一层的delta，参考输出层的梯度公式
print('layer error = ***')
print(layer.error)
print('layer.apply_activation = ***')
print(layer.apply_activation_derivative(output))
#layer.apply_activation_derivative(output)求取该函数相应的导数
layer.delta = layer.error * layer.apply_activation_derivative(output)
print('layer.delta = ***')
print(layer.delta)
#layer.delta为误差与导数之间的乘积
else: # 如果是隐藏层
'''
隐藏层输出的时候为np.dot(next_layer.weights,next_layer.delta)*layer.apply_activation_derivative(layer.last_activation)
对应的公式为oj*(1-oj)*oi,layer.apply_activation_derivation=oj*(1-oj)
此时使用的公式为oj*(1-oj)*deltak*wjk
'''
print('hidden layer')
next_layer = self._layers[i + 1] # 得到下一层对象
print('next_layer = ***')
print(next_layer)
print('next_layer.weight = ***')
print(next_layer.weights)
#得到下一层随机生成的正态分布矩阵
print('next_layer.delta = ***')
print(next_layer.delta)
'''
next_layer.weight为一个初始化的正态分布产生的随机数数组
由于是逆序遍历，next_layer.delta会在之前的分布中求得，使用公式
layer.delta = np.dot(next_layer.weights,next_layer.delta)*layer.apply_activation_derivative(layer.last_activation)
求得当前层对应的layer.delta的值
'''
layer.error = np.dot(next_layer.weights, next_layer.delta)
# 关键步骤：计算隐藏层的delta，参考隐藏层的梯度公式，np.dot为向量点积或矩阵相乘
print('layer.error = ***')
print(layer.error)
layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
'''
完整地写出关系式就是layer.delta=np.dot(next_layer.weights,next_layer.delta)
*layer.apply_activation_derivative(layer.last_activation)
'''
print('layer.delta = ***')
print(layer.delta)
#apply_activation_derivative为求激活函数导数的过程
print('finish')
# 循环更新权值
print('!!!finish!!!')
for i in range(len(self._layers)):
print('i = %d'%i)
layer = self._layers[i]
# o_i 为上一网络层的输出
o_i = X if i == 0 else self._layers[i - 1].last_activation
print('o_i = ***')
print(o_i)
o_i = np.atleast_2d(X if i == 0 else self._layers[i - 1].last_activation)
#之前再求每一层的时候，已经求出每一层所对应的last_activation的值
print('o_i1 = ***')
print(o_i)
'''
np.atleast_2d将输入的数组转化为至少两维
比如np.atleast_2d(1,[1,2],[[1,2]])
转化为相应的数组[array([[1]]),array([[1,2]]),array([[1,2]])]
'''
# 梯度下降算法，delta 是公式中的负数，故这里用加号
layer.weights += layer.delta * o_i.T * learning_rate
print('layer.weights = ***')
print(layer.weights)
'''
在每个参数偏导数明确的情况下，带入梯度下降公式即可
'''
def train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs):
# 网络训练函数
# one-hot 编码
y_onehot = np.zeros((y_train.shape[0], 2))
'''
[[0 0]
[0 0]
[0 0]
...]
'''
y_onehot[np.arange(y_train.shape[0]), y_train] = 1
#y_train.shape[0]的值为1400，y_train的对应值为对应的标签值
'''
[[1 0]
[1 0]
[0 1]
...
[0 1]
[1 0]
'''
# 将One-hot 编码后的真实标签与网络的输出计算均方误差，并调用反向传播函数更新网络参数，循环迭代训练集1000 遍即可
mses = []
accuracys = []
for i in range(max_epochs + 1): # 训练100 个epoch
for j in range(len(X_train)): # 一次训练一个样本
self.backpropagation(X_train[j], y_onehot[j], learning_rate)
if i % 10 == 0:
# 打印出MSE Loss
mse = np.mean(np.square(y_onehot - self.feed_forward(X_train)))
mses.append(mse)
accuracy = self.accuracy(self.predict(X_test), y_test.flatten())
accuracys.append(accuracy)
print('Epoch: #%s, MSE: %f' % (i, float(mse)))
# 统计并打印准确率
print('Accuracy: %.2f%%' % (accuracy * 100))
return mses, accuracys
def predict(self, X):
print('predict')
return self.feed_forward(X)
def accuracy(self, X, y):
print('accuracy')
return np.sum(np.equal(np.argmax(X, axis=1), y)) / y.shape[0]
def main():
X, y, X_train, X_test, y_train, y_test = load_dataset()
# 调用 make_plot 函数绘制数据的分布，其中 X 为 2D 坐标， y 为标签
make_plot(X, y, "Classification Dataset Visualization ")
plt.show()
print('begin NeuralNetwork')
nn = NeuralNetwork() # 实例化网络类
nn.add_layer(Layer(2, 25, 'sigmoid')) # 隐藏层 1, 2=>25
nn.add_layer(Layer(25, 50, 'sigmoid')) # 隐藏层 2, 25=>50
nn.add_layer(Layer(50, 25, 'sigmoid')) # 隐藏层 3, 50=>25
nn.add_layer(Layer(25, 2, 'sigmoid')) # 输出层, 25=>2
mses, accuracys = nn.train(X_train, X_test, y_train, y_test, 0.01, 100)
x = [i for i in range(0, 101, 10)]
# 绘制MES曲线
plt.title("MES Loss")
plt.plot(x, mses[:11], color='blue')
plt.xlabel('Epoch')
plt.ylabel('MSE')
plt.savefig('训练误差曲线.svg')
plt.close()
print('MSE = ***')
print(mses[:11])
# 绘制Accuracy曲线
plt.title("Accuracy")
plt.plot(x, accuracys[:11], color='blue')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.savefig('网络测试准确率.svg')
plt.close()
if __name__ == '__main__':
main()
这里在Layer的类中activate计算wx+b并通过激活函数之后的结果，
apply_activatioin计算激活函数的输出，apply_activation_derivative
计算激活函数的导数，也就是说Layer类中的activate可以计算出一
层的结果。
而在NeuralNetwork类之中，add_layer每一次将Layer类放置进去，
用于手动模拟具体的每一个神经网络层，feed_forward计算前向传播
经过所有网络层之后最后对应的结果，backpropagation计算反向传
播最后的结果，这里面重点看下反向传播函数的具体实现：
def backpropagation(self, X, y, learning_rate):
# 反向传播算法实现
# 前向计算，得到输出值
output = self.feed_forward(X)
for i in reversed(range(len(self._layers))): # 反向循环
#!!!注意这里的数组为反向循环数组，第一次先访问输出层，然后依次向前
#最后一次访问最开始的层数
layer = self._layers[i] # 得到当前层对象
# 如果是输出层
if layer == self._layers[-1]: # 对于输出层
'''
最后一层输出的时候使用的公式为(y-out)*layer.apply_activation_derivative(output)
输出层对应的公式为(ok-tk)*ok*(1-ok)
layer.apply_activation_derivative(output) = ok*(1-ok)
'''
layer.error = y - output # 计算2 分类任务的均方差的导数
# 关键步骤：计算最后一层的delta，参考输出层的梯度公式
#layer.apply_activation_derivative(output)求取该函数相应的导数
layer.delta = layer.error * layer.apply_activation_derivative(output)
#layer.delta为误差与导数之间的乘积
else: # 如果是隐藏层
'''
隐藏层输出的时候为np.dot(next_layer.weights,next_layer.delta)*layer.apply_activation_derivative(layer.last_activation)
对应的公式为oj*(1-oj)*oi,layer.apply_activation_derivation=oj*(1-oj)
此时使用的公式为oj*(1-oj)*deltak*wjk
'''
next_layer = self._layers[i + 1] # 得到下一层对象
#得到下一层随机生成的正态分布矩阵
'''
next_layer.weight为一个初始化的正态分布产生的随机数数组
由于是逆序遍历，next_layer.delta会在之前的分布中求得，使用公式
layer.delta = np.dot(next_layer.weights,next_layer.delta)*layer.apply_activation_derivative(layer.last_activation)
求得当前层对应的layer.delta的值
'''
layer.error = np.dot(next_layer.weights, next_layer.delta)
# 关键步骤：计算隐藏层的delta，参考隐藏层的梯度公式，np.dot为向量点积或矩阵相乘
layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
'''
完整地写出关系式就是layer.delta=np.dot(next_layer.weights,next_layer.delta)
*layer.apply_activation_derivative(layer.last_activation)
'''
#apply_activation_derivative为求激活函数导数的过程
# 循环更新权值
for i in range(len(self._layers)):
layer = self._layers[i]
# o_i 为上一网络层的输出
o_i = X if i == 0 else self._layers[i - 1].last_activation
o_i = np.atleast_2d(X if i == 0 else self._layers[i - 1].last_activation)
#之前再求每一层的时候，已经求出每一层所对应的last_activation的值
'''
np.atleast_2d将输入的数组转化为至少两维
比如np.atleast_2d(1,[1,2],[[1,2]])
转化为相应的数组[array([[1]]),array([[1,2]]),array([[1,2]])]
'''
# 梯度下降算法，delta 是公式中的负数，故这里用加号
layer.weights += layer.delta * o_i.T * learning_rate
'''
在每个参数偏导数明确的情况下，带入梯度下降公式即可
'''
这里面首先要判断是否为最后一层，因为输出层的反向传播公式与中间隐藏层对应的反向传播公式有所不同，如果是的话，调用公式
layer.error = y - output # 计算2 分类任务的均方差的导数
# 关键步骤：计算最后一层的delta，参考输出层的梯度公式
#layer.apply_activation_derivative(output)求取该函数相应的导数
layer.delta = layer.error * layer.apply_activation_derivative(output)
这其中layer.apply_activation_derivative(out)的结果为ok*(1-ok)，根据反向传播输出层的对应公式
隐藏层对应的代码如下：
layer.error = np.dot(next_layer.weights, next_layer.delta)
# 关键步骤：计算隐藏层的delta，参考隐藏层的梯度公式，np.dot为向量点积或矩阵相乘
layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
这里的apply_activation_derivative(layer.last_activation)=oj*(1-oj)
next_layer.weights=oi,由隐藏层的公式
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
1
0- 0
已为社区贡献4条内容
所有评论(0)