从零实现深度学习框架 基础框架的构建_从零编写一个深度学习

★★★ 本文源自AlStudio社区精品项目，【点击此处】查看更多精品内容 >>>

---

从零实现深度学习框架

飞桨框架学习(LearnDL)是一个由Mr. Sun发起的活动，主旨在于以简单易懂的方式了解深度学习框架、构造深度学习框架乃至于改写深度学习框架。整体内容包括了入门级的名词解释乃至后续的框架实现工作，推荐新入门深度学习、对神经网络有些困惑、不知道如何给Paddle提PR、不知道如何参加黑客松、觉得平台上的交流充满“黑话”的同学一起参与学习~

本项目受启发于上述活动以及书目用Python实现深度学习框架，通过名词解释+代码的方式简要介绍深度学习/深度学习框架中的一些基础概念和一个简单的实现~

强烈推荐大家看上面那本书，对于新手入门很不错~

什么是深度学习框架

深度学习框架本质可以看作一个库，或者称之为包，或者是一个简单的写满了函数声明的py文件，其核心在于用户（调包侠）可以通过调用其中的函数轻松完成深度学习模型（神经网络）的创建和训练工作。其中，PaddlePaddle就是一个深度学习框架。

更具体来说，如果不使用深度学习框架，用户需要自行编写模型训练中的求导和梯度反馈逻辑；使用了深度学习框架，用户只需要构造模型结构，而不需要去了解这个模型要怎么进行求导和梯度反馈。以一个简单的函数为例：$y=\tan (g\sin (kx\cos (\frac{x^2}{h\ln x})))$，其中$x$是输入变量，$k,g,h$是待拟合的参数，$y$是输出结果。在不使用深度学习框架的时候，我们需要手动设计方案求出$k,g,h$的导数（也称梯度），从而完成参数拟合；使用了深度学习框架后，我们只需要告诉框架有这么一个公式，框架会自动进行梯度计算，给我们省下很多功夫~

如何实现深度学习框架

根据上一章节，实现深度学习框架的方法非常简单：写一个包含了很多好用的函数定义的py文件即可。

我们可以手动的在上述py文件中写$\tan x$、$\tan \tan x$、$\tan \tan \tan x$的导数，但我们没办法通过硬代码（即手动）的方式，把世界上所有的函数的导数都写进来。因此，我们需要一个好用的底层设计，从而保证我们能够通过少量的代码满足框架用户丰富的需求。

为此，我们引入“计算图”的概念。

计算图

计算图是一个深度学习框架的底层设计，但实际上这个词指的就是流程图或者数据图。图中的节点是一个数据单元/运算单元，节点之间的连线指运算关联关系。下图就是一个计算图，描述了输入x1，x2，x3经过一系列计算，得到计算结果，最终和标签y求均方损失（MSE）的过程。

方便起见，我们不妨要求我们的所有运算都是一元或者二元运算，永远不会出现多元运算。即使出现了多元运算，我们也可以通过拆分的方式的变成二元运算的组合。以上图为例，对加法进行拆分可以得到下图

同理，$\tan \tan \tan x$也可以拆分为三个$\tan$的组合。总而言之，我们现在只需要专注于简单的一元运算或者二元运算即可。对多元运算的支持（拆分机制）可以以后再讨论。

以图为例，所有的节点都有至多两个输入和一个输出以及一个特殊的计算流程。比如"+"的运算是相加，"×"的运算是相乘。那么所有的节点都可以属于同一个类，这个类的成员（不妨把函数也称之为成员）包括：

• 父节点：比如x1和w1就是乘的父节点，如果这个节点是根节点，例如x1没有父节点，直接记作None
• 值：每个节点都具有一个值
• 计算：每个节点根据父节点的计算流程

下面简单实现一下~

class Node(object):
    def __init__(self, Papa = None, Mama = None, Value = 0):
        # 通常使用Father表示父节点，这里使用Papa和Mama纯粹因为更有趣一些
        self.Papa = Papa
        self.Mama = Mama
        self.value = Value

    def forward(self):
        self.value = self.value
1
2
3
4
5
6
7
8
9

上述构造了一个基础的节点类，其forward是一个恒等映射，下面分别派生对应的加法节点，乘法节点，和MSE节点

# 加法节点
class AddNode(Node):
    def forward(self):
        if self.Papa != None: self.Papa.forward() # 基础节点的父节点不需要计算，但是非基础节点的父节点需要保证有值
        if self.Mama != None: self.Mama.forward()
        self.value = self.Papa.value + self.Mama.value

# 乘法节点
class MulNode(Node):
    def forward(self):
        if self.Papa != None: self.Papa.forward()
        if self.Mama != None: self.Mama.forward()
        self.value = self.Papa.value * self.Mama.value

# 损失函数节点
class MSENode(Node):
    def forward(self):
        if self.Papa != None: self.Papa.forward()
        if self.Mama != None: self.Mama.forward()
        self.value = (self.Papa.value - self.Mama.value)**2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

只需要对上述几个Node节点进行线性组合，即可完成一次前向计算。

x1 = Node(Value = 1)
x2 = Node(Value = 2)
x3 = Node(Value = 3)
w1 = Node(Value = 1)
w2 = Node(Value = 1)
w3 = Node(Value = 1)
m1 = MulNode(Papa = x1, Mama = w1)
m2 = MulNode(Papa = x2, Mama = w2)
m3 = MulNode(Papa = x3, Mama = w3)
a1 = AddNode(Papa = m1, Mama = m2)
a2 = AddNode(Papa = a1, Mama = m3)
y = Node(Value = 6) # 1+2+3 = 6, 这样MSE的结果为0
result = MSENode(Papa = a2, Mama = y, Value = 20)
print('计算前 result.value = ', result.value)
result.forward()
print('计算后 result.value = ', result.value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

计算前 result.value =  20
计算后 result.value =  0
1
2

可以看到，当对基础内容定义完毕后，用户只需要专注于提供节点和连接关系即可。就像是我们使用Paddle时只需要继承nn.layer后，专注于构造不同的块（Linear，Conv）的连接关系。

梯度反馈

计算图不仅可以用于计算前向过程，还可以用于计算梯度反馈。还是以刚才的内容为例，每个子节点都非常了解自己能够给父节点提供多大的梯度。比如m1相对于x1的梯度是w1，相对于w1的梯度是x1。这个信息对于x1和w1来说是未知的，因此我们要求网络计算后进行 反向传播。

简单来说，子节点还需要增加一些属性：

• 父节点的梯度
• 从子节点收到的梯度

更进一步，当我们收到梯度后，还需要对梯度进行学习，即改变参数，那么我们还需要三个属性：

• 参数指示符：如果为True表明当前的参数是需要随着梯度进行更新的，例如w1的指示符就是True，x1就是False
• 梯度更新函数
• 学习率：梯度只是一个方向，并不能告诉我们应该在这个方向上走多远

结合以上几点，对上述Node类进行改写如下

class Node(object):
    def __init__(self, Papa = None, Mama = None, Value = 0, Flag = 0, lr = 0.01):
        # 通常使用Father表示父节点，这里使用Papa和Mama纯粹因为更有趣一些
        self.Papa = Papa
        self.Mama = Mama
        self.value = Value
        self.Flag = Flag
        self.Papa_grad = 0
        self.Mama_grad = 0
        self.grad = 1
        self.lr = lr

    def updata(self): # 参数更新
        if self.Flag == 1:
            self.value = self.value - self.lr*self.grad

    def forward(self):
        self.value = self.value

    def backward(self):
        self.updata()

# 加法节点
class AddNode(Node):
    def forward(self):
        if self.Papa != None: self.Papa.forward() # 基础节点的父节点不需要计算，但是非基础节点的父节点需要保证有值
        if self.Mama != None: self.Mama.forward()
        self.value = self.Papa.value + self.Mama.value

    def backward(self):
        if self.Papa != None:
            self.Papa.grad = self.grad * 1
            self.Papa.backward()
        if self.Mama != None:
            self.Mama.grad = self.grad * 1
            self.Mama.backward()
        self.updata()


# 乘法节点
class MulNode(Node):
    def forward(self):
        if self.Papa != None: self.Papa.forward()
        if self.Mama != None: self.Mama.forward()
        self.value = self.Papa.value * self.Mama.value

    def backward(self):
        if self.Papa != None:
            self.Papa.grad = self.grad * self.Mama.value
            self.Papa.backward()
        if self.Mama != None:
            self.Mama.grad = self.grad * self.Papa.value
            self.Mama.backward()
        self.updata()

# 损失函数节点
class MSENode(Node):
    def forward(self):
        if self.Papa != None: self.Papa.forward()
        if self.Mama != None: self.Mama.forward()
        self.value = (self.Papa.value - self.Mama.value)**2

    def backward(self):
        if self.Papa != None:
            self.Papa.grad = self.grad * 2 * (self.Papa.value - self.Mama.value) * 1
            self.Papa.backward()
        if self.Mama != None:
            self.Mama.grad = self.grad * 2 * (self.Papa.value - self.Mama.value) * -1
            self.Mama.backward()
        self.updata()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

下面改一下x1的初始值，看看w1会发生什么变化

x1 = Node(Value = 1.1) # 给一点小小的扰动
x2 = Node(Value = 2)
x3 = Node(Value = 3)
w1 = Node(Value = 1, Flag=1)
w2 = Node(Value = 1, Flag=1)
w3 = Node(Value = 1, Flag=1)
m1 = MulNode(Papa = x1, Mama = w1)
m2 = MulNode(Papa = x2, Mama = w2)
m3 = MulNode(Papa = x3, Mama = w3)
a1 = AddNode(Papa = m1, Mama = m2)
a2 = AddNode(Papa = a1, Mama = m3)
y = Node(Value = 6) # 1+2+3 = 6, 这样MSE的结果为0
result = MSENode(Papa = a2, Mama = y, Value = 20)
print('计算前 result.value = ', result.value)
result.forward()
print('计算后 result.value = ', result.value)
result.backward()
print('第一次更新后 w1.value = ', w1.value)
result.forward()
print('第一次更新后 result.value = ', result.value)
result.backward()
print('第二次更新后 w1.value = ', w1.value)
result.forward()
print('第二次更新后 result.value = ', result.value)
result.backward()
print('第三次更新后 w1.value = ', w1.value)
result.forward()
print('第三次更新后 result.value = ', result.value)
result.backward()
print('第四次更新后 w1.value = ', w1.value)
result.forward()
print('第四次更新后 result.value = ', result.value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

计算前 result.value =  20
计算后 result.value =  0.009999999999999929
第一次更新后 w1.value =  0.9978
第一次更新后 result.value =  0.005123696399999996
第二次更新后 w1.value =  0.99622524
第二次更新后 result.value =  0.002625226479937307
第三次更新后 w1.value =  0.995098026792
第三次更新后 result.value =  0.00134508634644392
第四次更新后 w1.value =  0.9942911675777136
第四次更新后 result.value =  0.0006891814070964006
1
2
3
4
5
6
7
8
9
10

可以看到搭建的网络确实能够随着不断迭代贴近目标值~

基于飞桨常规赛的框架实战

飞桨学习赛：吃鸡排名预测挑战赛是一个回归问题比赛，不妨以这个问题为基础，构造一个最为简单的全连接层模型，并且提交赛题~

框架封装

最为简单的封装方式就是构造一个py文件，将上面的类定义放进去就行。用户就可以通过import的方式使用我们提供的接口了。我们不妨给框架起名叫OurDL(Our Deep Learning)，那么只需要建立一个py文件，起名为OurDL.py，再将几个节点类的声明复制粘贴就行。

数据预处理

虽然我们已经有了一个深度学习框架，但是进行深度学习还需要有数据。下面简单展示数据处理的逻辑。

# 提取压缩包
! unzip /home/aistudio/data/data137263/pubg_train.csv.zip
! unzip /home/aistudio/data/data137263/pubg_test.csv.zip
1
2
3

import pandas as pd

# 读取数据
df = pd.read_csv('pubg_train.csv')
# 方便起见，直接丢弃具有Nan信息的行和列
df = df.dropna(axis = 0, how = 'any')
# 提取需要的特征信息
# 部分列属性，比如match_id 和 team_id 对我们这个简单的模型来说没啥用
data = df.iloc[:,2:].values
max_value = data.max(axis = 0)
# 简单归一化
data = data / max_value
print(data.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13

(635716, 14)
1

构造网络

因为数据一共有14个维度，其中一个维度是目标值，所以我们需要构造一个13到1的全连接层。如下构造网络后，我们只需要配置输入数据后调用result.forward()即可完成推理，推理后调用result.backward()即可完成梯度更新。

from OurDL import *

x = [] # 数据输入节点
w = [] # 参数节点
m = [] # 乘法节点
a = [] # 加法节点
for i in range(13):
    x.append(Node())
    w.append(Node(Flag=1))
for i in range(13):
    m.append(MulNode(Papa = x[i], Mama = w[i]))
for i in range(12):
    if i == 0:
        a.append(AddNode(Papa = m[0], Mama = m[1]))
    else:
        a.append(AddNode(Papa = a[i-1], Mama = m[i+1]))
y = Node()
result = MSENode(Papa = a[11], Mama = y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

训练

max_epochs = 1

now_step = 0
for epoch in range(max_epochs):
    for sample in data:
        # 填充输入数据
        for i in range(13):
            x[i].value = sample[i]
        y.value = sample[-1]
        result.forward()
        result.backward()
        now_step = now_step + 1
        print('\rEpoch:{}/{}, Step:{}'.format(epoch,max_epochs,now_step),end="")

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Epoch:0/1, Step:635716
1

训练后可以简单查看一下模型学习到的参数内容

for i in range(13):
    print('第{}个参数的系数w{}是{}'.format(i,i,w[i].value))
1
2

第0个参数的系数w0是0.49341314151790766
第1个参数的系数w1是0.05316682466660218
第2个参数的系数w2是-0.18646504530370703
第3个参数的系数w3是0.9929170515580459
第4个参数的系数w4是-3.58987972356301
第5个参数的系数w5是-0.7891178302503383
第6个参数的系数w6是-1.0691692309220726
第7个参数的系数w7是-0.898262690288156
第8个参数的系数w8是0.0004192227134026445
第9个参数的系数w9是-0.0009873152783230444
第10个参数的系数w10是0.005132983009114543
第11个参数的系数w11是0.0018281459458755276
第12个参数的系数w12是0.009944236048885842
1
2
3
4
5
6
7
8
9
10
11
12
13

预测

# 读取数据
df = pd.read_csv('pubg_test.csv')
test_data = df.iloc[:,2:].values
# 测试集数据没有最后一维，所以要取max_value的前13维度进行归一化
test_data = test_data / max_value[:-1]
# 由于测试集数据即使有缺失值也不能删除了，所以需要使用训练集数据的均值对缺失值进行填充
mean_value = data.mean(axis = 0)
1
2
3
4
5
6
7

# 预测

import numpy as np
predict_result = [] # 保存预测信息
for i in range(len(test_data)):
    sample = test_data[i]
    # 替换缺失值
    for j in range(len(sample)):
        if np.isnan(sample[j]):
            sample[j] = mean_value[j]
    # 填充输入数据
    for i in range(13):
        x[i].value = sample[i]
    y.value = sample[-1]
    # 需要注意，result节点只是用于求损失，真正的结果输出其实在a[12]节点
    # 这里既可以运行result也可以运行a[12]节点，只要最后从a[12]节点取数据即可
    a[-1].forward()
    # 记录结果，并且去归一化
    out = int(a[-1].value * max_value[-1])
    if out<=0: out = 1
    if out>=max_value[-1]: out = max_value[-1]
    predict_result.append(out)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 打包提交
predict_df = pd.DataFrame(predict_result, columns = ['team_placement'])
predict_df.to_csv('submission.csv',index = None)
! zip submission.zip submission.csv
1
2
3
4

updating: submission.csv (deflated 75%)
1

最后…当我准备好一切准备提交的时候发现…似乎这个比赛已经结束了，所以没办法提交了哈哈哈哈

不过还有一些其他的比赛还可以提交，等这个框架扩充一个用于分类损失的节点后就可以参加分类任务的比赛了~

结语

本项目从0开始，逐渐形成了一个简单的神经网络框架~

这个框架显然不能应对较为复杂的网络结构，但希望可以作为新手入门的指引，让大家对框架和计算图有更为清楚的认知~

请点击此处查看本环境基本用法.

Please click here for more detailed instructions.