1、激活函数导数
1.1 Sigmoid函数导数
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, losses
import numpy as np # 导入 numpy
def sigmoid(x): # sigmoid 函数
return 1 / (1 + np.exp(-x))
def derivative(x): # sigmoid 导数的计算
return sigmoid(x)*(1-sigmoid(x))
x = tf.constant([1,2,3,4,5,6,7,8])
a = sigmoid(x)
b = derivative(x)
print(x,a,b)
ReLU 函数 函数 导数:
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, losses
import numpy as np # 导入 numpy
def derivative(x): # ReLU 函数的导数
d = np.array(x, copy=True) # 用于保存梯度的张量
d[x < 0] = 0 # 元素为负的导数为 0
d[x >= 0] = 1 # 元素为正的元素导数为 1
return d
LeakyReLU函数导数:
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, losses
import numpy as np # 导入 numpy
# 其中 p 为 LeakyReLU 的负半段斜率
def derivative(x, p):
dx = np.ones_like(x) # 创建梯度张量
dx[x < 0] = p # 元素为负的导数为 p
return dx
Tanh函数梯度:
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, losses
import numpy as np # 导入 numpy
def sigmoid(x): # sigmoid 函数实现
return 1 / (1 + np.exp(-x))
def tanh(x): # tanh 函数实现
return 2*sigmoid(2*x) - 1
def derivative(x): # tanh 导数实现
return 1-tanh(x)**2
2、损失函数梯度:包括均方差函数梯度和交叉熵损失函数梯度
3、全连接层梯度
3.1 单个神经元梯度
3.2 全连接层 全连接层梯度:
4、链式法则
import tensorflow as tf
# 构建待优化变量
x = tf.constant(1.)
w1 = tf.constant(2.)
b1 = tf.constant(1.)
w2 = tf.constant(2.)
b2 = tf.constant(1.)
# 构建梯度记录器
with tf.GradientTape(persistent=True) as tape:
# 非 tf.Variable 类型的张量需要人为设置记录梯度信息
tape.watch([w1, b1, w2, b2])
# 构建 2 层线性网络
y1 = x * w1 + b1
y2 = y1 * w2 + b2
# 独立求解出各个偏导数
dy2_dy1 = tape.gradient(y2, [y1])[0]
dy1_dw1 = tape.gradient(y1, [w1])[0]
dy2_dw1 = tape.gradient(y2, [w1])[0]
# 验证链式法则
print(dy2_dy1 * dy1_dw1)
print(dy2_dw1)
5、反向传播算法
每层的偏导数的计算公式如下:
输出层:
6、实例:
6.1 第一个实战:采用 TensorFlow 提供的自动求导来优化Himmelblau 函数的极小值;
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import pyplot as plt
import tensorflow as tf
def himmelblau(x):
# himmelblau函数实现
return (x[0] ** 2 + x[1] - 11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2
x = np.arange(-6, 6, 0.1)
y = np.arange(-6, 6, 0.1)
print('x,y range:', x.shape, y.shape)
# 生成x-y平面采样网格点,方便可视化
X, Y = np.meshgrid(x, y)
print('X,Y maps:', X.shape, Y.shape)
Z = himmelblau([X, Y]) # 计算网格点上的函数值
# 绘制himmelblau函数曲面
fig = plt.figure('himmelblau')
ax = fig.gca(projection='3d')
ax.plot_surface(X, Y, Z)
ax.view_init(60, -30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()
# 参数的初始化值对优化的影响不容忽视,可以通过尝试不同的初始化值,
# 检验函数优化的极小值情况
# [1., 0.], [-4, 0.], [4, 0.]
# x = tf.constant([4., 0.])
# x = tf.constant([1., 0.])
# x = tf.constant([-4., 0.])
x = tf.constant([-2., 2.])
for step in range(200):# 循环优化
with tf.GradientTape() as tape: #梯度跟踪
tape.watch([x]) # 记录梯度
y = himmelblau(x) # 前向传播
# 反向传播
grads = tape.gradient(y, [x])[0]
# 更新参数,0.01为学习率
x -= 0.01*grads
# 打印优化的极小值
if step % 20 == 19:
print ('step {}: x = {}, f(x) = {}'
.format(step, x.numpy(), y.numpy()))
第二个实战是基于 Numpy 实现反向传播算法,并完成多层神经网络的二分类任务训练。
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
#%matplotlib inline
N_SAMPLES=2000
TEST_SIZE=0.3
X,y=make_moons(n_samples=N_SAMPLES,noise=0.2,random_state=100)
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=TEST_SIZE,random_state=42)
print(X.shape,y.shape)
def make_plot(X,y,plot_name,file_name=None,XX=None,YY=None,preds=None,dark=False):
if(dark):
plt.style.use('dark_background')
else:
sns.set_style("whitegrid")
plt.figure(figsize=(16,12))
axes=plt.gca()
axes.set(xlabel="$x_1$",ylabel="$x_2$")
plt.title(plot_name,fontsize=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=cm.Spectral)
plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5],
cmap="Greys", vmin=0, vmax=.6)
# 绘制散点图,根据标签区分颜色
plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral,
edgecolors='none')
# plt.savefig('dataset.svg')
plt.show()
# 调用make_plot 函数绘制数据的分布,其中X 为2D 坐标,y 为标签
make_plot(X, y, "Classification Dataset Visualization ")
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)
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 变量,用于计算梯度
# 实现网络层的前向传播如下:
def activate(self, x):
# 前向传播
r = np.dot(x, self.weights) + self.bias # X@W+b
# 通过激活函数,得到全连接层的输出o
self.last_activation = self._apply_activation(r)
return self.last_activation
# 其中self._apply_activation 实现了不同的激活函数的前向计算过程:
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):
self._layers = [] # 网络层对象列表
def add_layer(self, layer):
# 追加网络层
self._layers.append(layer)
# 网络的前向传播只需要循环调用个网络层对象的前向计算函数即可:
def feed_forward(self, X):
# 前向传播
for layer in self._layers:
# 依次通过各个网络层
X = layer.activate(X)
return X
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]: # 对于输出层
layer.error = y - output # 计算2 分类任务的均方差的导数
# 关键步骤:计算最后一层的delta,参考输出层的梯度公式
layer.delta = layer.error * layer.apply_activation_derivative(output)
else: # 如果是隐藏层
next_layer = self._layers[i + 1] # 得到下一层对象
layer.error = np.dot(next_layer.weights, next_layer.delta)
# 关键步骤:计算隐藏层的delta,参考隐藏层的梯度公式
layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
for i in range(len(self._layers)):
layer = self._layers[i]
# o_i 为上一网络层的输出
o_i = np.atleast_2d(X if i == 0 else self._layers[i - 1].last_activation)
# 梯度下降算法,delta 是公式中的负数,故这里用加号
layer.weights += layer.delta * o_i.T * learning_rate
def predict(self,x):
output = self.feed_forward(x)
return np.argmax(output,axis=-1)
def accuracy(self,pre,y):
return (np.sum(pre==y)*1.0)/len(pre)
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))
y_onehot[np.arange(y_train.shape[0]), y_train] = 1
mses = []
accs=[]
for i in range(max_epochs): # 训练1000 个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)
print('Epoch: #%s, MSE: %f' % (i, float(mse)))
# 统计并打印准确率
acc=(self.accuracy(self.predict(X_test), y_test.flatten()) * 100)
accs.append(acc)
print('Accuracy: %.2f%%' % acc)
return mses,accs
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
sigmoid_mses,sigmoid_accs = nn.train(X_train,X_test,y_train,y_test,0.001,500)
plt.rcParams['figure.dpi'] = 300 #分辨率
plt.figure()
plt.xlabel('Epoch')
plt.title("sigmoid_mses")
plt.ylabel('MSE')
plt.plot(sigmoid_mses, label='Test')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
plt.figure()
plt.xlabel('Epoch')
plt.title("sigmoid_accs")
plt.ylabel('ACCS')
plt.plot(sigmoid_accs, label='Test')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
nn = NeuralNetwork() # 实例化网络类
nn.add_layer(Layer(2, 25, 'relu')) # 隐藏层1, 2=>25
nn.add_layer(Layer(25, 50, 'relu')) # 隐藏层2, 25=>50
nn.add_layer(Layer(50, 25, 'relu')) # 隐藏层3, 50=>25
nn.add_layer(Layer(25, 2, 'sigmoid')) # 输出层, 25=>2
relu_mses,relu_accs = nn.train(X_train,X_test,y_train,y_test,0.001,500)
plt.figure()
plt.xlabel('Epoch')
plt.title("relu_mses")
plt.ylabel('MSES')
plt.plot(relu_mses, label='Test')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
plt.figure()
plt.xlabel('Epoch')
plt.title("relu_accs")
plt.ylabel('ACCS')
plt.plot(relu_accs, label='Test')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
nn = NeuralNetwork() # 实例化网络类
nn.add_layer(Layer(2, 25, 'tanh')) # 隐藏层1, 2=>25
nn.add_layer(Layer(25, 50, 'tanh')) # 隐藏层2, 25=>50
nn.add_layer(Layer(50, 25, 'tanh')) # 隐藏层3, 50=>25
nn.add_layer(Layer(25, 2, 'tanh')) # 输出层, 25=>2
tanh_mses,tanh_accs = nn.train(X_train,X_test,y_train,y_test,0.001,500)
plt.figure()
plt.xlabel('Epoch')
plt.title("tanh_mses")
plt.ylabel('MSES')
plt.plot(tanh_mses, label='Test')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
plt.figure()
plt.xlabel('Epoch')
plt.title("tanh_accs")
plt.ylabel('ACCS')
plt.plot(tanh_accs, label='Test')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
plt.figure(figsize=(8,6))
plt.xlabel('Epoch')
plt.title("sigmoid vs relu vs tanh")
plt.ylabel('MSES')
plt.plot(sigmoid_mses, label='sigmoid_mses')
plt.plot(relu_mses, label='relu_mses')
plt.plot(tanh_mses, label='tanh_mses')
plt.legend()
# plt.savefig('auto.svg')
plt.show()
plt.figure()
plt.xlabel('Epoch')
plt.title("sigmoid vs relu vs tanh")
plt.ylabel('ACCS')
plt.plot(sigmoid_accs, label='sigmoid_accs')
plt.plot(relu_accs, label='relu_accs')
plt.plot(tanh_accs, label='tanh_accs')
plt.legend()
# plt.savefig('auto.svg')
plt.show()