如何使用numpy实现一个全连接神经网络？（上）
gfanqi 人气:0全连接神经网络的概念我就不介绍了，对这个不是很了解的朋友，可以移步其他博主的关于神经网络的文章，这里只介绍我使用基本工具实现全连接神经网络的方法。
所用工具：
numpy == 1.16.4
matplotlib 最新版
我的思路是定义一个layer类，在这个类里边构建传播的前向传播的逻辑，以及反向传播的逻辑，然后在构建一个model类，在model类里边，将layer类中的对象拼接，就可以得到我们想要的模型。
在Layers类的传播中，在Dense层中，我是按照公式output = X*w+b，来计算输出。X 是 （m，n）的矩阵，表示有m行数据，每一个数据是n维的向量。w是一个（n,1）的矩阵，是我们要优化的参数。b是一个（m,1)的矩阵，是偏置。在Activation层中，我是按照公式 output = f激活(X) 来计算输出的。f激活是激活函数，是逐元素函数。将Dense层与Activation层叠加，就能实现output = f激活(X*w+b)的效果，如果多次交替叠加，就相当于在计算output = f激活( f激活(f激活(X*w+b)*w+b)*w+b)，这里只演示了三层，实际上这个就是全连接神经网络的基本数学表达式。
构建这个模型的难点在于梯度的计算以及反向传播逻辑。中间层的每一层的输出对输入以及偏置求导，都是一个矩阵对另一个矩阵的求导。而矩阵的求导不同于高数中所学的导数，链式法则也有一些不同。关于这部分内容可参考：矩阵求导术(上)，矩阵求导术(下)，这里不再讲述。笔者正是在参考了这两篇文章的前提下实现这个过程的。
导入工具包：
import numpy as np import matplotlib.pyplot as plt
定义Layer类中的Dense类中类：（这里可以把layers类单独拿出来作为一个父类，其余的层可以继承layers，然后钉子自己的反向传播逻辑，可以减少重复代码，这里为了方便展示，没有那么做）
class Layers:
class Dense:
'''
全连接层
'''
def __init__(self, output_category):
'''
接收并初始化一个输出维度，用于确定这一层w的维度，以及用于梯度计算
:param output_category:
'''
self.output_category = output_category
def __call__(self, Input):
'''
使用魔法方法，实例化对象后，随机的方式初始化w参数，
实例化输入数据，计算本层前向传播方式
:param Input:
:return:
'''
w_shape = (Input.shape[1], self.output_category)
b_shape = (Input.shape[0], self.output_category)
self.w = np.mat(np.random.random(size=w_shape))
self.b = np.mat(np.random.random(size=b_shape))
self.Input = Input
result = self.Input * self.w +self.b
self.result = result
return result
def backpropagation(self, w_grad_from_next_layer=None, learning_rate=None, use_bias=False):
'''
反向传播算法的数学描述，公式参考
https://zhuanlan.zhihu.com/p/24863977
公式 Y = X * w +b ，
dY = dX * w + X * dw + db
= I * dX * w + X * dw * I + I * db * I (I是单位矩阵,
公式里每个I都不一样维度，具体是多少要参考它与谁相乘）
vec(dY) = np.kron(w,I)*vec(dX) + np.kron(I,w)*vec(dw) + np.kron(I,I)*vec(db)
:param w_grad_from_next_layer:从下一层传过来的梯度
:param learning_rate:学习率
:return:
'''
mid_w_grad = np.mat(np.kron(np.eye(self.output_category), self.Input))
self.w_grad = w_grad_from_next_layer * mid_w_grad
mid_x_grad = np.kron(self.w.T, np.eye(self.Input.shape[0]))
self.x_grad = w_grad_from_next_layer * mid_x_grad
if use_bias == True:
mid_b_grad = np.kron(np.eye(self.output_category), np.eye(self.Input.shape[0]))
self.b_grad = w_grad_from_next_layer * mid_b_grad
if learning_rate is not None:
self.w = self.w - learning_rate * self.w_grad.T
if use_bias == True:
self.b = self.b - learning_rate * self.b_grad
return self.x_grad
定义Layers 中的Activation类：（这里初始化的时候必须传入一个激活函数，这个激活函数应该是一个类，应该有一个call方法来定义它的前向逻辑，应该有一个grad方法来计算梯度）
class Layers:
class Activation:
'''
激活层
'''
def __init__(self, activate_func):
'''
传入激活方程类
:param output_category:
'''
self.activate_func = activate_func
def __call__(self, Input):
'''
使用魔法方法，实例化对象后，随机的方式初始化w参数，
实例化输入数据，计算本层前向传播方式
:param Input:
:return:
'''
self.Input = Input
self.activate_func_obj = self.activate_func(self.Input)
result = self.activate_func_obj.call()
self.result = result
return result
def backpropagation(self, w_grad_from_next_layer=None, learning_rate=None, ):
'''
反向传播算法的数学描述，公式参考
https://zhuanlan.zhihu.com/p/24863977
公式 Y = f(X) (f是逐元素函数)
dY = df(X)
= f'(X) ⊙ dX (⊙表示出逐元素相乘，也就是通缩意义上的对应位置相乘）
所以
vec(dY) = np.diagflat(f'(X))* vec(dX)
:param w_grad_from_next_layer:从下一层传过来的梯度
:param learning_rate:学习率
:return:
'''
mid_x_grad = self.activate_func_obj.grad()
self.x_grad = w_grad_from_next_layer * mid_x_grad
return self.x_grad
定义了Activation后，但这个方程需要传入一个激活函数类，现在我们顺从定义一个函数类，用来给激活层提供激活函数类。这个类有两个功能，一是定义正向传播方法，一种是定义梯度计算。
class Funcs:
'''
方程
'''
class Relu:
'''
Relu函数
'''
def __init__(self,Input):
self.Input = Input
pass
def call(self):
'''
计算结果，并返回
:return:
'''
result = np.multiply((self.Input>0),self.Input)
return result
def grad(self):
'''
梯度计算
:return:
'''
mid_grad = (self.Input>0)*1.0 #乘1 讲bollen类型转化为float类型
result = np.diagflat(mid_grad)
return result
类似的，我们可以定义更多的种类的激活函数，比如selu，sigmoid等等。到目前为止，如果我们可以定义一个常用的损失函数，那么我们就具备了搭建简单的神经网络的基本要求了。这里我们的定义一个平方差损失函数。
class Funcs:
'''
方程
'''
class SqureLossError:
'''
平方误差类
'''
def __init__(self,y,pred):
self.y=y
self.pred = pred
def call(self):
'''
计算损失，并返回
:return:
'''
result = np.linalg.norm(self.y-self.pred)
return result
def grad(self):
'''
梯度计算
:return:
'''
result = np.mat(2*(self.pred-self.y).T)
return result
到这里，我们已经具备了搭建神经网络的基本板块了，我们可以用这些基本模块来搭建一个简单的神经网络模型。下一章，我会继续详述一下这个过程。
加载全部内容