哈嘍，大家好。
今天給大家分享一個非常牛逼的開源項目，用Numpy?開發(fā)了一個深度學(xué)習(xí)框架，語法與 Pytorch 基本一致。
今天以一個簡單的卷積神經(jīng)網(wǎng)絡(luò)為例，分析神經(jīng)網(wǎng)絡(luò)訓(xùn)練過程中，涉及的前向傳播、反向傳播、參數(shù)優(yōu)化等核心步驟的源碼。
使用的數(shù)據(jù)集和代碼已經(jīng)打包好，文末有獲取方式。
1. 準備工作
先準備好數(shù)據(jù)和代碼。
1.1 搭建網(wǎng)絡(luò)
首先，下載框架源碼，地址：https://github.com/duma-repo/PyDyNet
git clone https://github.com/duma-repo/PyDyNet.git
搭建LeNet卷積神經(jīng)網(wǎng)絡(luò)，訓(xùn)練三分類模型。
在PyDyNet目錄直接創(chuàng)建代碼文件即可。
from pydynet import nn
class LeNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 6, kernel_size=5, padding=2)
self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
self.avg_pool = nn.AvgPool2d(kernel_size=2, stride=2, padding=0)
self.sigmoid = nn.Sigmoid()
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 3)
def forward(self, x):
x = self.conv1(x)
x = self.sigmoid(x)
x = self.avg_pool(x)
x = self.conv2(x)
x = self.sigmoid(x)
x = self.avg_pool(x)
x = x.reshape(x.shape[0], -1)
x = self.fc1(x)
x = self.sigmoid(x)
x = self.fc2(x)
x = self.sigmoid(x)
x = self.fc3(x)
return x
可以看到，網(wǎng)絡(luò)的定義與Pytorch語法完全一樣。
我提供的源代碼里，提供了 summary 函數(shù)可以打印網(wǎng)絡(luò)結(jié)構(gòu)。
1.2 準備數(shù)據(jù)
訓(xùn)練數(shù)據(jù)使用Fanshion-MNIST數(shù)據(jù)集，它包含10個類別的圖片，每個類別 6k 張。
為了加快訓(xùn)練，我只抽取了前3個類別，共1.8w張訓(xùn)練圖片，做一個三分類模型。
1.3 模型訓(xùn)練
import pydynet
from pydynet import nn
from pydynet import optim
lr, num_epochs = 0.9, 10
optimizer = optim.SGD(net.parameters(),
lr=lr)
loss = nn.CrossEntropyLoss()
for epoch in range(num_epochs):
net.train()
for i, (X, y) in enumerate(train_iter):
optimizer.zero_grad()
y_hat = net(X)
l = loss(y_hat, y)
l.backward()
optimizer.step()
with pydynet.no_grad():
metric.add(l.numpy() * X.shape[0],
accuracy(y_hat, y),
X.shape[0])
訓(xùn)練代碼也跟Pytorch一樣。
下面重點要做的就是深入模型訓(xùn)練的源碼，來學(xué)習(xí)模型訓(xùn)練的原理。
2. train、no_grad和eval
模型開始訓(xùn)練前，會調(diào)用net.train。
def train(self, mode: bool = True):
set_grad_enabled(mode)
self.set_module_state(mode)
可以看到，它會將grad?(梯度)設(shè)置成True?，之后創(chuàng)建的Tensor?是可以帶梯度的。Tensor帶上梯度后，便會將其放入計算圖中，等待求導(dǎo)計算梯度。
而下面的with no_grad(): 代碼
class no_grad:
def __enter__(self) -> None:
self.prev = is_grad_enable()
set_grad_enabled(False)
會將grad?(梯度)設(shè)置成False?，這樣之后創(chuàng)建的Tensor不會放到計算圖中，自然也不需要計算梯度，可以加快推理。
我們經(jīng)常在Pytorch?中看到net.eval()的用法，我們也順便看一下它的源碼。
def eval(self):
return self.train(False)
可以看到，它直接調(diào)用train(False)?來關(guān)閉梯度，效果與no_grad()類似。
所以，一般在訓(xùn)練前調(diào)用train?打開梯度。訓(xùn)練后，調(diào)用eval關(guān)閉梯度，方便快速推理。
3. 前向傳播
前向傳播除了計算類別概率外，最最重要的一件事是按照前傳順序，將網(wǎng)絡(luò)中的 tensor? 組織成計算圖，目的是為了反向傳播時計算每個tensor的梯度。
tensor在神經(jīng)網(wǎng)絡(luò)中，不止用來存儲數(shù)據(jù)，還用計算梯度、存儲梯度。
以第一層卷積操作為例，來查看如何生成計算圖。
def conv2d(x: tensor.Tensor,
kernel: tensor.Tensor,
padding: int = 0,
stride: int = 1):
'''二維卷積函數(shù)
'''
N, _, _, _ = x.shape
out_channels, _, kernel_size, _ = kernel.shape
pad_x = __pad2d(x, padding)
col = __im2col2d(pad_x, kernel_size, stride)
out_h, out_w = col.shape[-2:]
col = col.transpose(0, 4, 5, 1, 2, 3).reshape(N * out_h * out_w, -1)
col_filter = kernel.reshape(out_channels, -1).T
out = col @ col_filter
return out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)
x?是輸入的圖片，不需要記錄梯度。kernel是卷積核的權(quán)重，需要計算梯度。
所以，pad_x = __pad2d(x, padding)? 生成的新的tensor也是不帶梯度的，因此也不需要加入計算圖中。
而kernel.reshape(out_channels, -1)?產(chǎn)生的tensor則是需要計算梯度，也需要加入計算圖中。
下面看看加入的過程：
def reshape(self, *new_shape):
return reshape(self, new_shape)
class reshape(UnaryOperator):
'''
張量形狀變換算子，在Tensor中進行重載
Parameters
----------
new_shape : tuple
變換后的形狀，用法同NumPy
'''
def __init__(self, x: Tensor, new_shape: tuple) -> None:
self.new_shape = new_shape
super().__init__(x)
def forward(self, x: Tensor)
return x.data.reshape(self.new_shape)
def grad_fn(self, x: Tensor, grad: np.ndarray)
return grad.reshape(x.shape)
reshape?函數(shù)會返回一個reshape?類對象，reshape?類繼承了UnaryOperator?類，并在__init__函數(shù)中，調(diào)用了父類初始化函數(shù)。
class UnaryOperator(Tensor):
def __init__(self, x: Tensor) -> None:
if not isinstance(x, Tensor):
x = Tensor(x)
self.device = x.device
super().__init__(
data=self.forward(x),
device=x.device,
# 這里 requires_grad 為 True
requires_grad=is_grad_enable() and x.requires_grad,
)
UnaryOperator?類繼承了Tensor?類，所以reshape?對象也是一個tensor。
在UnaryOperator的__init__?函數(shù)中，調(diào)用Tensor?的初始化函數(shù)，并且傳入的requires_grad?參數(shù)是True，代表需要計算梯度。
requires_grad?的計算代碼為is_grad_enable() and x.requires_grad，is_grad_enable()?已經(jīng)被train?設(shè)置為True?，而x?是卷積核，它的requires_grad?也是True。
class Tensor:
def __init__(
self,
data: Any,
dtype=None,
device: Union[Device, int, str, None] = None,
requires_grad: bool = False,
) -> None:
if self.requires_grad:
# 不需要求梯度的節(jié)點不出現(xiàn)在動態(tài)計算圖中
Graph.add_node(self)
最終在Tensor?類的初始化方法中，調(diào)用Graph.add_node(self)?將當前tensor加入到計算圖中。
同理，下面使用requires_grad=True的tensor?常見出來的新tensor都會放到計算圖中。
經(jīng)過一次卷積操作，計算圖中會增加 6 個節(jié)點。
4. 反向傳播
一次前向傳播完成后，從計算圖中最后一個節(jié)點開始，從后往前進行反向傳播。
l = loss(y_hat, y)
l.backward()
經(jīng)過前向網(wǎng)絡(luò)一層層傳播，最終傳到了損失張量l。
以l?為起點，從前向后傳播，就可計算計算圖中每個節(jié)點的梯度。
backward的核心代碼如下：
def backward(self, retain_graph: bool = False):
for node in Graph.node_list[y_id::-1]:
grad = node.grad
for last in [l for l in node.last if l.requires_grad]:
add_grad = node.grad_fn(last, grad)
last.grad += add_grad
Graph.node_list[y_id::-1]將計算圖倒序排。
node?是前向傳播時放入計算圖?中的每個tensor。
node.last? 是生成當前tensor的直接父節(jié)點。
調(diào)用node.grad_fn計算梯度，并反向傳給它的父節(jié)點。
grad_fn?其實就是Tensor的求導(dǎo)公式，如：
class pow(BinaryOperator):
'''
冪運算算子，在Tensor類中進行重載
See also
--------
add : 加法算子
'''
def grad_fn(self, node: Tensor, grad: np.ndarray)
if node is self.last[0]:
return (self.data * self.last[1].data / node.data) * grad
return?后的代碼其實就是冪函數(shù)求導(dǎo)公式。
假設(shè)y=x^2，x?的導(dǎo)數(shù)為2x。
5. 更新參數(shù)
反向傳播計算梯度后，便可以調(diào)用優(yōu)化器，更新模型參數(shù)。
l.backward()
optimizer.step()
本次訓(xùn)練我們用梯度下降SGD算法優(yōu)化參數(shù)，更新過程如下：
def step(self):
for i in range(len(self.params)):
grad = self.params[i].grad + self.weight_decay * self.params[i].data
self.v[i] *= self.momentum
self.v[i] += self.lr * grad
self.params[i].data -= self.v[i]
if self.nesterov:
self.params[i].data -= self.lr * grad
self.params?是整個網(wǎng)絡(luò)的權(quán)重，初始化SGD時傳進去的。
step?函數(shù)最核心的兩行代碼，self.v[i] += self.lr * grad? 和 self.params[i].data -= self.v[i]?，用當前參數(shù) - 學(xué)習(xí)速率 * 梯度?更新當前參數(shù)。
這是機器學(xué)習(xí)的基礎(chǔ)內(nèi)容了，我們應(yīng)該很熟悉了。
一次模型訓(xùn)練的完整過程大致就串完了，大家可以設(shè)置打印語句，或者通過DEBUG的方式跟蹤每一行代碼的執(zhí)行過程，這樣可以更了解模型的訓(xùn)練過程。
