一个可扩展的深度学习框架的Python实现（仿keras接口）

一个可扩展的深度学习框架的Python实现（仿keras接口）

动机

keras是一种非常优秀的深度学习框架，其具有较好的易用性，可扩展性。keras的接口设计非常优雅，使用起来非常方便。在这里，我将仿照keras的接口，设计出可扩展的多层感知机模型，并在多维奇偶校验数据上进行测试。

本文实现的mlp的可扩展性在于：可以灵活指定神经网络的层数，每层神经元的个数，每层神经元的激活函数，以及指定神经网络的损失函数

本文将尽量使用numpy的矩阵运算用于训练网络，公式的推导过程可以参考此篇博客，细节上可能有所不同。

本文将只实现批量梯度下降用于训练网络，对于规模较大的数据集可扩展性不强；本文只实现了固定步长的学习率算法，将来可能会拓展到动态学习率算法；本文只实现了二分类问题的平方损失函数，对于多分类问题，用户可以自定义损失函数；

# -*- coding: utf-8 -*-
import numpy as np
from matplotlib import pyplot as plt

测试数据生成

此函数将生成n维二进制数据及其奇偶校验码

输入：

n_dim:需要生成的二进制数据的维度

输出：

X_train:n维二进制数据
y_train：以上二进制数据的奇偶校验码

#2维测试数据
#X_train=np.array([[0,0],[0,1],[1,0],[1,1]])
#y_train=np.array([0,1,1,0])
#生成用于奇偶校验的训练数据
def generate_data(n_dim):
    X_train=[]
    y_train=[]
    for i in range(2**n_dim):
        v=[0]*n_dim
        x=i
        for j in range(n_dim-1,-1,-1):
            v[j]=x%2
            x//=2
        X_train.append(v)
        y_train.append(sum(v)%2)
    return np.array(X_train),np.array(y_train)     

测试

X_train,y_train=generate_data(n_dim=3)
print(X_train)
print(y_train)

[[0 0 0]
 [0 0 1]
 [0 1 0]
 [0 1 1]
 [1 0 0]
 [1 0 1]
 [1 1 0]
 [1 1 1]]
[0 1 1 0 1 0 0 1]

感知机模型实现

class MLP:
    def __init__(self):
        #使用列表保存所有的感知机层
        self.layer=[]
        #设置优化器
        self.optimizator=None
        #用于保存每一次迭代过程中的损失，最后可以用来对损失变化情况绘图
        self.loss=[]
        #设置损失函数
        self.loss_func=None
        #设置损失函数的梯度函数
        self.loss_grad=None
    
    #可以用于给mlp加一个层
    def add(self,layer):
        self.layer.append(layer)
    
    #编译模型结构，初始化模型参数
    def compile(self,loss='squared_loss',optimizator=None,epsilon=4):
        #指定模型的优化方式，本文没有实现
        self.optimizator=optimizator
        #指定模型的损失函数
        self.loss_func=loss_function[loss]
        #设置损失函数的梯度函数
        self.loss_grad=gradient_function[loss]
        for i in range(len(self.layer)):
            #初始化参数矩阵
            if i==0:
                row=self.layer[i].input_shape[0]
            else:
                row=self.layer[i-1].size
            column=self.layer[i].size
            #将参数设置为[-epsilon, epsilon]区间上均匀分布的随机数
            self.layer[i].weight=np.random.rand(row,column)*2*epsilon-epsilon
            self.layer[i].bias=np.random.rand(1,column)*2*epsilon-epsilon
    
    #对模型进行拟合训练
    def fit(self,X,y,epochs=10000,lr=0.01):
        epoch=0
        y=y.reshape((-1,1))
        while epoch < epochs:
            #前向传播计算每层的输出
            self.__forward__(X,y)
            #将此次迭代的损失保存下来
            self.loss.append(self.loss_func(model.layer[-1].output,y))
            #反向传播计算每层参数的变化量
            self.__backward__(X,y,lr)
            #更新参数
            for i in range(len(self.layer)):
                self.layer[i].weight+=self.layer[i].weight_change
                self.layer[i].bias+=self.layer[i].bias_change
            epoch+=1
    
    #预测样本类别
    def predict(self,X_test):
        self.__forward__(X_test)
        y_pred=self.layer[-1].output
        y_pred[np.less(y_pred,0.5)]=0
        y_pred[np.greater_equal(y_pred,0.5)]=1
        return y_pred.astype('int').ravel()
    
    #评估在测试集上的分类是否正确
    def evaluate(self,X_test,y_test):
        y_pred=self.predict(X_test)
        return np.logical_not(np.logical_xor(y_pred,y_test.astype('bool')))
    
    #评估在测试上进行分类的正确率
    def evaluate_accuracy(self,X_test,y_test):
        is_correct=self.evaluate(X_test,y_test)
        return np.sum(is_correct)/is_correct.shape[0]
        
    #可视化模型训练过程中的损失变化
    def print_loss(self):
        plt.plot(self.loss)
        plt.ylim(ymin=0)
        plt.xlabel('epoch')
        plt.ylabel('loss')
        plt.title('loss per epoch')
        plt.show()
    
    #前向传播过程
    def __forward__(self,X,y=None):
        for i in range(len(self.layer)):
            #获取每一层的输入数据
            if i==0:
                input_data=X
            else:
                input_data=self.layer[i-1].output
            #更新每一层的输出
            self.layer[i].net=np.dot(input_data,self.layer[i].weight)+self.layer[i].bias
            self.layer[i].output=self.layer[i].activation(self.layer[i].net)
    
    #反向传播过程
    def __backward__(self,X,y,lr):
        for i in range(len(self.layer)-1,-1,-1):
            if i==len(self.layer)-1:
                temp=-1*self.loss_grad(y,self.layer[i].output)
            else: 
                temp=np.dot(self.layer[i+1].sensitivity,np.transpose(self.layer[i+1].weight))      
            #计算每一层的敏感度，权重变化
            self.layer[i].sensitivity=self.layer[i].gradient(self.layer[i].net)*temp
            self.layer[i].weight_change=(lr)*np.dot(np.transpose(self.layer[i-1].output),self.layer[i].sensitivity)
            self.layer[i].bias_change=(lr)*np.sum(self.layer[i].sensitivity,axis=0).reshape((1,-1))
            

感知机层类

class Layer:
    def __init__(self,size,activation='sigmoid',input_shape=None):
        #本层感知机的数量
        self.size=size
        #本层感知机的激活方式
        self.activation=activation_function[activation]
        #本层感知机的激活函数的求导函数
        self.gradient=gradient_function[activation]
        #mlp的输入维度，只对第一层的感知机有效。注意在这个模型中并没有定义输入层。
        self.input_shape=input_shape
        #此层感知机的输入
        self.input=None
        #此层感知机的权重矩阵
        self.weight=None
        #权重变更
        self.weight_change=None
        #偏置变更
        self.bias_change=None
        #此层感知机的偏置矩阵
        self.bias=None
        #记录神经元激活前的状态
        self.net=None
        #此层感知机的输出矩阵
        self.output=None
        #此层感知机的敏感度矩阵，误差逆传播的时候会用到
        self.sensitivity=None

定义需要用到的损失函数和激活函数，定义其梯度函数

def squared_loss(y,y_pred):
    return 0.5*np.sum(np.square(y-y_pred))

def squared_loss_gd(y,y_pred):
    return y_pred-y

def sigmoid(x):
    return 1/(1+np.exp(-1*x))
 
def sigmoid_gd(x):
    return sigmoid(x)*(1-sigmoid(x)) 

def relu(x):
    y=x
    y[np.less(y,0)]=0
    return y

def relu_gd(x):
    g=x
    g[np.less(x,0)]=0
    g[np.equal(x,0)]=0.5
    g[np.greater(x,0)]=1
    return g

def softmax():
    pass

def softmax_gd():
    pass

#使用字典保存函数，可以实现使用字符串查阅所需函数
loss_function={'squared_loss':squared_loss}
activation_function={'sigmoid':sigmoid,'softmax':softmax,'relu':relu}
gradient_function={'squared_loss':squared_loss_gd,'sigmoid':sigmoid_gd,'softmax':softmax_gd,'relu':relu_gd}

测试

#指定奇偶校验数据的维度
dim=5
#生成训练数据
X_train,y_train=generate_data(n_dim=dim)
#设置模型参数
model=MLP()
model.add(Layer(20,'sigmoid',input_shape=(dim,)))
model.add(Layer(10,'sigmoid'))
model.add(Layer(5,'sigmoid'))
model.add(Layer(1,'sigmoid'))
model.compile(loss='squared_loss')
model.fit(X_train,y_train,epochs=20000,lr=0.01)
#输出测试结果
print('-'*100)
print('accuracy:')
print(model.evaluate_accuracy(X_train,y_train))
model.print_loss()

----------------------------------------------------------------------------------------------
accuracy:
1.0