【Pytorch】浅层神经网络的几种简单实现

一、说明

本文给出了pytorch对浅层神经网络的几种简单实现，下面各例实现均相互独立，但按照目录组织有一定循序渐进之意。
注：例中的神经网络并无实际含义（训练集随机生成），仅以学习记录为主要目的。（当然你可以称之为随机数生成器hhh…）

二、借助基本API进行实现

import torch

# 定义训练集数量与各层维数
N = 64
DEG_in = 1000
DEG_hidden = 100
DEG_out = 10

# 激活函数选用ReLU
ReLU = torch.nn.ReLU()

# 建立训练数据
x = torch.randn(DEG_in, N)
y = torch.randn(DEG_out, N)

# 设定权重初值
w2 = torch.randn(DEG_hidden, DEG_in)
w3 = torch.randn(DEG_out, DEG_hidden)

# 设定学习率
learning_rate = 5e-5

# 梯度下降法迭代500次
for i in range(500):
    # 向前传播
    z2 = torch.mm(w2, x)
    a2 = ReLU(z2)
    z3 = torch.mm(w3, a2) # out
    
    # 计算损失/代价
    cost = 0.5 * ((y - z3).pow(2).sum().item())
    print('['+str(i)+']', 'cost: '+str(cost))
    
    # 反向传播
    grad_actfunc_z3 = torch.ones_like(z3) # 输出层等价于选用y=x作为激活函数
    delta3 = torch.mul(- (y - z3), grad_actfunc_z3)
    grad_cost_w3 = torch.mm(delta3, a2.t())
    
    grad_actfunc_z2 = z2.clone()
    grad_actfunc_z2[grad_actfunc_z2 > 0] = 1
    grad_actfunc_z2[grad_actfunc_z2 <= 0] = 0
    delta2 = torch.mul(torch.mm(w3.t(), delta3), grad_actfunc_z2)
    grad_cost_w2 = torch.mm(delta2, x.t())
    
    # 优化/更新权重
    w2 -= learning_rate / N * grad_cost_w2
    w3 -= learning_rate / N * grad_cost_w3

三、利用自动求导机制（Autograd）省去手动梯度计算

import torch

# 定义训练集数量与各层维数
N = 64
DEG_in = 1000
DEG_hidden = 100
DEG_out = 10

# 激活函数选用ReLU
ReLU = torch.nn.ReLU()

# 建立训练数据
x = torch.randn(DEG_in, N)
y = torch.randn(DEG_out, N)

# 设定权重初值（对需要跟踪求导的tensor设置requires_grad=True）
w2 = torch.randn(DEG_hidden, DEG_in, requires_grad=True)
w3 = torch.randn(DEG_out, DEG_hidden, requires_grad=True)

# 设定学习率
learning_rate = 5e-5

# 梯度下降法迭代500次
for i in range(500):
    # 向前传播
    z2 = torch.mm(w2, x)
    a2 = ReLU(z2)
    z3 = torch.mm(w3, a2) # out
    
    # 计算损失/代价
    cost = 0.5 * ((y - z3).pow(2).sum())
    print('['+str(i)+']', 'cost: '+str(cost.item()))
    
    # 反向传播（自动求导的结果将保存在grad属性中）
    cost.backward()
    
    # 优化权重时就不必再跟踪计算w2和w3的导数/梯度
    with torch.no_grad():
        # 优化/更新权重
        w2 -= learning_rate / N * w2.grad
        w3 -= learning_rate / N * w3.grad
        # # 进入下一轮迭代前将被跟踪的tensor的grad属性置零（若不手动清零则会累加每轮自动求导的结果）
        w2.grad.zero_()
        w3.grad.zero_()

四、引入nn.Sequential简化模型定义

import torch

# 定义训练集数量与各层维数
N = 64
DEG_in = 1000
DEG_hidden = 100
DEG_out = 10

# 建立训练数据（与前两个实现不同的是，此处将输入定义为行向量以满足model.forward()的传参）
x = torch.randn(N, DEG_in)
y = torch.randn(N, DEG_out)

# 定义神经网络模型
model = torch.nn.Sequential(
    torch.nn.Linear(DEG_in, DEG_hidden), # 第一个参数指定前一层的维数，第二个参数指定后一层的维数
    torch.nn.ReLU(),
    torch.nn.Linear(DEG_hidden, DEG_out)
)

# 选择代价函数
cost_func = torch.nn.MSELoss(reduction='sum')

# 设定学习率
learning_rate = 2e-3

# 梯度下降法迭代500次
for i in range(500):
    # 向前传播
    out = model(x) # 即model.forward(x)
    
    # 计算损失/代价
    cost = cost_func(y, out)
    print('['+str(i)+']', 'cost: '+str(cost.item()))
    
    # 反向传播
    cost.backward()
    
    # 优化权重时就不必再跟踪计算w2和w3的导数/梯度
    with torch.no_grad():
        # 优化/更新权重（通过model.parameters()获取）
        for param in model.parameters():
            param -= learning_rate / N * param.grad
        # 进入下一轮迭代前将被跟踪的tensor的grad属性置零
        model.zero_grad()

五、选用optim中的优化器来优化梯度下降

import torch

# 定义训练集数量与各层维数
N = 64
DEG_in = 1000
DEG_hidden = 100
DEG_out = 10

# 建立训练数据
x = torch.randn(N, DEG_in)
y = torch.randn(N, DEG_out)

# 定义神经网络模型
model = torch.nn.Sequential(
    torch.nn.Linear(DEG_in, DEG_hidden),
    torch.nn.ReLU(),
    torch.nn.Linear(DEG_hidden, DEG_out)
)

# 选择代价函数
cost_func = torch.nn.MSELoss(reduction='sum')

# 设定学习率
learning_rate = 5e-5

# 选择优化器（须传入模型参数与学习率）
optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)

# 梯度下降法迭代500次
for i in range(500):
    # 向前传播
    out = model(x) # 即model.forward(x)
    
    # 计算损失/代价
    cost = cost_func(y, out)
    print('['+str(i)+']', 'cost: '+str(cost.item()))
    
    # 反向传播
    cost.backward()
    
    # 梯度下降（全权交给优化器来优化实现）
    optimizer.step()
    # 进入下一轮迭代前将被跟踪的tensor的grad属性置零
    optimizer.zero_grad()