实验五 前馈神经网络（2）自动梯度计算 & 优化问题

最新推荐文章于 2024-02-25 18:11:15 发布
最新推荐文章于 2024-02-25 18:11:15 发布
阅读量165 收藏 1
点赞数 1
文章标签： 神经网络 python 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59158839/article/details/127192788
版权

目录

4.3 自动梯度计算

4.3.1 利用预定义算子重新实现前馈神经网络

4.3.2 完善Runner类

4.3.3 模型训练

4.4 优化问题

4.4.1 参数初始化

4.4.2 梯度消失问题

4.4.2.1 模型构建

 4.4.2.2 使用Sigmoid型函数进行训练

4.4.2.3 使用ReLU函数进行模型训练

4.4.3 死亡ReLU问题

4.4.3.1 使用ReLU进行模型训练

4.4.3.2 使用Leaky ReLU进行模型训练

总结

4.3 自动梯度计算

虽然我们能够通过模块化的方式比较好地对神经网络进行组装，但是每个模块的梯度计算过程仍然十分繁琐且容易出错。在深度学习框架中，已经封装了自动梯度计算的功能，我们只需要聚焦模型架构，不再需要耗费精力进行计算梯度。

torch提供了torch.nn.Module类，来方便快速的实现自己的层和模型。模型和层都可以基于torch.nn.Moduler扩充实现，模型只是一种特殊的层。继承了torch.nn.Module类的算子中，可以在内部直接调用其它继承torch.nn.Module类的算子，torch框架会自动识别算子中内嵌的此类算子，并自动计算它们的梯度，并在优化时更新它们的参数。

4.3.1 利用预定义算子重新实现前馈神经网络

使用torch的预定义算子来重新实现二分类任务。主要使用到torch.nn.Module。

1. 使用pytorch的预定义算子来重新实现二分类任务。

import torch.nn as nn
import torch
from torch.nn.init import normal_,constant_
import torch.nn.functional as F

class Model_MLP_L2_V2(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Model_MLP_L2_V2, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        normal_(self.fc1.weight, mean=0., std=1.)
        constant_(self.fc1.bias, val=0.0)
        self.fc2 = nn.Linear(hidden_size, output_size)
        normal_(self.fc2.weight, mean=0., std=1.)
        constant_(self.fc2.bias, val=0.0)
        self.act_fn = torch.sigmoid

    # 前向计算
    def forward(self, inputs):
        z1 = self.fc1(inputs)
        a1 = self.act_fn(z1)
        z2 = self.fc2(a1)
        a2 = self.act_fn(z2)
        return a2

2. 增加一个3个神经元的隐藏层，再次实现二分类。

class Model_MLP_L2_V2(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Model_MLP_L2_V2, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        normal_(self.fc1.weight, mean=0., std=1.)
        constant_(self.fc1.bias, val=0.0)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        normal_(self.fc2.weight, mean=0., std=1.)
        constant_(self.fc2.bias, val=0.0)
        self.act_fn = torch.sigmoid
        self.fc3 = nn.Linear(hidden_size, output_size)
        normal_(self.fc3.weight, mean=0., std=1.)
        constant_(self.fc3.bias, val=0.0)
        self.act_fn = torch.sigmoid

    # 前向计算
    def forward(self, inputs):
        z1 = self.fc1(inputs)
        a1 = self.act_fn(z1)
        z2 = self.fc2(a1)
        a2 = self.act_fn(z2)
        z3 = self.fc3(a2)
        a3 = self.act_fn(z3)
        return a3

4.3.2 完善Runner类

基于上一节实现的 RunnerV2_1 类，本节的 RunnerV2_2 类在训练过程中使用自动梯度计算；模型保存时，使用state_dict方法获取模型参数；模型加载时，使用set_state_dict方法加载模型参数.

class RunnerV2_2(object):
    def __init__(self, model, optimizer, metric, loss_fn, **kwargs):
        self.model = model
        self.optimizer = optimizer
        self.loss_fn = loss_fn
        self.metric = metric

        # 记录训练过程中的评估指标变化情况
        self.train_scores = []
        self.dev_scores = []

        # 记录训练过程中的评价指标变化情况
        self.train_loss = []
        self.dev_loss = []

    def train(self, train_set, dev_set, **kwargs):
        # 将模型切换为训练模式
        self.model.train()

        # 传入训练轮数，如果没有传入值则默认为0
        num_epochs = kwargs.get("num_epochs", 0)
        # 传入log打印频率，如果没有传入值则默认为100
        log_epochs = kwargs.get("log_epochs", 100)
        # 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
        save_path = kwargs.get("save_path", "best_model.pdparams")

        # log打印函数，如果没有传入则默认为"None"
        custom_print_log = kwargs.get("custom_print_log", None)

        # 记录全局最优指标
        best_score = 0
        # 进行num_epochs轮训练
        for epoch in range(num_epochs):
            X, y = train_set
            # 获取模型预测
            logits = self.model(X)
            # 计算交叉熵损失
            trn_loss = self.loss_fn(logits, y)
            self.train_loss.append(trn_loss.item())
            # 计算评估指标
            trn_score = self.metric(logits, y).item()
            self.train_scores.append(trn_score)

            # 自动计算参数梯度
            trn_loss.backward()
            if custom_print_log is not None:
                # 打印每一层的梯度
                custom_print_log(self)

            # 参数更新
            self.optimizer.step()
            # 清空梯度
            self.optimizer.zero_grad()

            dev_score, dev_loss = self.evaluate(dev_set)
            # 如果当前指标为最优指标，保存该模型
            if dev_score > best_score:
                self.save_model(save_path)
                print(f"[Evaluate] best accuracy performence has been updated: {best_score:.5f} --> {dev_score:.5f}")
                best_score = dev_score

            if log_epochs and epoch % log_epochs == 0:
                print(f"[Train] epoch: {epoch}/{num_epochs}, loss: {trn_loss.item()}")

    # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
    @torch.no_grad()
    def evaluate(self, data_set):
        # 将模型切换为评估模式
        self.model.eval()

        X, y = data_set
        # 计算模型输出
        logits = self.model(X)
        # 计算损失函数
        loss = self.loss_fn(logits, y).item()
        self.dev_loss.append(loss)
        # 计算评估指标
        score = self.metric(logits, y).item()
        self.dev_scores.append(score)
        return score, loss

    def predict(self, X):
        # 将模型切换为评估模式
        self.model.eval()
        return self.model(X)

    # 使用'model.state_dict()'获取模型参数，并进行保存
    def save_model(self, saved_path):
        torch.save(self.model.state_dict(), saved_path)

    # 使用'model.set_state_dict'加载模型参数
    def load_model(self, model_path):
        state_dict = torch.load(model_path)
        self.model.set_state_dict(state_dict)

4.3.3 模型训练

实例化RunnerV2类，并传入训练配置，代码实现如下：

1. 使用pytorch的预定义算子来重新实现二分类任务。

# 设置模型
input_size = 2
hidden_size = 5
output_size = 1
model = Model_MLP_L2_V2(input_size=input_size, hidden_size=hidden_size, output_size=output_size)

# 设置损失函数
loss_fn = F.binary_cross_entropy

# 设置优化器
learning_rate = 0.2
optimizer = torch.optim.SGD(model.parameters(), learning_rate)

# 设置评价指标
metric = accuracy

# 其他参数
epoch_num = 1000
saved_path = 'best_model.pdparams'

# 实例化RunnerV2类，并传入训练配置
runner = RunnerV2_2(model, optimizer, metric, loss_fn)
runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=epoch_num, log_epochs=50, save_path="best_model.pdparams")

结果： 

[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.45000
[Train] epoch: 0/1000, loss: 0.8735500574111938
[Evaluate] best accuracy performence has been updated: 0.45000 --> 0.46250
[Evaluate] best accuracy performence has been updated: 0.46250 --> 0.56250
[Evaluate] best accuracy performence has been updated: 0.56250 --> 0.63750
[Evaluate] best accuracy performence has been updated: 0.63750 --> 0.73125
[Evaluate] best accuracy performence has been updated: 0.73125 --> 0.76250
[Evaluate] best accuracy performence has been updated: 0.76250 --> 0.78750
[Train] epoch: 50/1000, loss: 0.4802948832511902
[Evaluate] best accuracy performence has been updated: 0.78750 --> 0.79375
[Evaluate] best accuracy performence has been updated: 0.79375 --> 0.80000
[Evaluate] best accuracy performence has been updated: 0.80000 --> 0.80625
[Evaluate] best accuracy performence has been updated: 0.80625 --> 0.81250
[Evaluate] best accuracy performence has been updated: 0.81250 --> 0.81875
[Train] epoch: 100/1000, loss: 0.41373705863952637
[Evaluate] best accuracy performence has been updated: 0.81875 --> 0.82500
[Evaluate] best accuracy performence has been updated: 0.82500 --> 0.83125
[Train] epoch: 150/1000, loss: 0.378179132938385
[Train] epoch: 200/1000, loss: 0.35704904794692993
[Evaluate] best accuracy performence has been updated: 0.83125 --> 0.83750
[Train] epoch: 250/1000, loss: 0.343575119972229
[Train] epoch: 300/1000, loss: 0.33467379212379456
[Train] epoch: 350/1000, loss: 0.32868289947509766
[Evaluate] best accuracy performence has been updated: 0.83750 --> 0.84375
[Evaluate] best accuracy performence has been updated: 0.84375 --> 0.85000
[Train] epoch: 400/1000, loss: 0.32459431886672974
[Train] epoch: 450/1000, loss: 0.3217635750770569
[Train] epoch: 500/1000, loss: 0.31977084279060364
[Train] epoch: 550/1000, loss: 0.3183404505252838
[Train] epoch: 600/1000, loss: 0.31728997826576233
[Train] epoch: 650/1000, loss: 0.3164980411529541
[Train] epoch: 700/1000, loss: 0.31588321924209595
[Train] epoch: 750/1000, loss: 0.3153904974460602
[Evaluate] best accuracy performence has been updated: 0.85000 --> 0.85625
[Train] epoch: 800/1000, loss: 0.31498241424560547
[Evaluate] best accuracy performence has been updated: 0.85625 --> 0.86250
[Evaluate] best accuracy performence has been updated: 0.86250 --> 0.86875
[Train] epoch: 850/1000, loss: 0.3146332800388336
[Train] epoch: 900/1000, loss: 0.3143254518508911
[Train] epoch: 950/1000, loss: 0.31404656171798706

 将训练过程中训练集与验证集的准确率变化情况进行可视化。

# 可视化观察训练集与验证集的指标变化情况
def plot(runner, fig_name):
    plt.figure(figsize=(10, 5))
    epochs = [i for i in range(len(runner.train_scores))]

    plt.subplot(1, 2, 1)
    plt.plot(epochs, runner.train_loss, color='#e4007f', label="Train loss")
    plt.plot(epochs, runner.dev_loss, color='#f19ec2', linestyle='--', label="Dev loss")
    # 绘制坐标轴和图例
    plt.ylabel("loss", fontsize='large')
    plt.xlabel("epoch", fontsize='large')
    plt.legend(loc='upper right', fontsize='x-large')

    plt.subplot(1, 2, 2)
    plt.plot(epochs, runner.train_scores, color='#e4007f', label="Train accuracy")
    plt.plot(epochs, runner.dev_scores, color='#f19ec2', linestyle='--', label="Dev accuracy")
    # 绘制坐标轴和图例
    plt.ylabel("score", fontsize='large')
    plt.xlabel("epoch", fontsize='large')
    plt.legend(loc='lower right', fontsize='x-large')

    plt.savefig(fig_name)
    plt.show()


plot(runner, 'fw-acc.pdf')

# 模型评价
torch.load("best_model.pdparams")
score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

 

使用测试数据对训练完成后的最优模型进行评价，观察模型在测试集上的准确率以及loss情况。代码如下：

# 模型评价
torch.load("best_model.pdparams")
score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

 从结果来看，模型在测试集上取得了较高的准确率。

2. 增加一个3个神经元的隐藏层，再次实现二分类。

# 设置模型
input_size = 2
hidden_size = 5
add_hidden_size = 3 
output_size = 1
model = Model_MLP_L2_V2(input_size=input_size, hidden_size=hidden_size, output_size=output_size,add_size = add_hidden_size)

# 设置损失函数
loss_fn = F.binary_cross_entropy

# 设置优化器
learning_rate = 0.2
optimizer = torch.optim.SGD(model.parameters(), learning_rate)

# 设置评价指标
metric = accuracy

# 其他参数
epoch_num = 1000
saved_path = 'best_model.pdparams'

# 实例化RunnerV2类，并传入训练配置
runner = RunnerV2_2(model, optimizer, metric, loss_fn)
runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=epoch_num, log_epochs=50, save_path="best_model.pdparams")

结果： 

[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.46875
[Train] epoch: 0/1000, loss: 0.792105495929718
[Evaluate] best accuracy performence has been updated: 0.46875 --> 0.47500
[Evaluate] best accuracy performence has been updated: 0.47500 --> 0.48125
[Evaluate] best accuracy performence has been updated: 0.48125 --> 0.49375
[Evaluate] best accuracy performence has been updated: 0.49375 --> 0.50625
[Evaluate] best accuracy performence has been updated: 0.50625 --> 0.51250
[Evaluate] best accuracy performence has been updated: 0.51250 --> 0.51875
[Evaluate] best accuracy performence has been updated: 0.51875 --> 0.52500
[Evaluate] best accuracy performence has been updated: 0.52500 --> 0.53125
[Evaluate] best accuracy performence has been updated: 0.53125 --> 0.53750
[Evaluate] best accuracy performence has been updated: 0.53750 --> 0.54375
[Evaluate] best accuracy performence has been updated: 0.54375 --> 0.55000
[Evaluate] best accuracy performence has been updated: 0.55000 --> 0.56250
[Train] epoch: 50/1000, loss: 0.6632017493247986
[Evaluate] best accuracy performence has been updated: 0.56250 --> 0.56875
[Evaluate] best accuracy performence has been updated: 0.56875 --> 0.57500
[Evaluate] best accuracy performence has been updated: 0.57500 --> 0.59375
[Evaluate] best accuracy performence has been updated: 0.59375 --> 0.60000
[Evaluate] best accuracy performence has been updated: 0.60000 --> 0.61250
[Evaluate] best accuracy performence has been updated: 0.61250 --> 0.61875
[Evaluate] best accuracy performence has been updated: 0.61875 --> 0.62500
[Evaluate] best accuracy performence has been updated: 0.62500 --> 0.63125
[Evaluate] best accuracy performence has been updated: 0.63125 --> 0.63750
[Evaluate] best accuracy performence has been updated: 0.63750 --> 0.64375
[Evaluate] best accuracy performence has been updated: 0.64375 --> 0.65000
[Evaluate] best accuracy performence has been updated: 0.65000 --> 0.65625
[Train] epoch: 100/1000, loss: 0.612221360206604
[Evaluate] best accuracy performence has been updated: 0.65625 --> 0.66250
[Evaluate] best accuracy performence has been updated: 0.66250 --> 0.66875
[Evaluate] best accuracy performence has been updated: 0.66875 --> 0.67500
[Evaluate] best accuracy performence has been updated: 0.67500 --> 0.68125
[Evaluate] best accuracy performence has been updated: 0.68125 --> 0.68750
[Evaluate] best accuracy performence has been updated: 0.68750 --> 0.69375
[Evaluate] best accuracy performence has been updated: 0.69375 --> 0.70000
[Evaluate] best accuracy performence has been updated: 0.70000 --> 0.70625
[Evaluate] best accuracy performence has been updated: 0.70625 --> 0.71250
[Evaluate] best accuracy performence has been updated: 0.71250 --> 0.72500
[Evaluate] best accuracy performence has been updated: 0.72500 --> 0.73125
[Train] epoch: 150/1000, loss: 0.5504528284072876
[Evaluate] best accuracy performence has been updated: 0.73125 --> 0.73750
[Evaluate] best accuracy performence has been updated: 0.73750 --> 0.74375
[Evaluate] best accuracy performence has been updated: 0.74375 --> 0.75000
[Evaluate] best accuracy performence has been updated: 0.75000 --> 0.75625
[Evaluate] best accuracy performence has been updated: 0.75625 --> 0.76250
[Evaluate] best accuracy performence has been updated: 0.76250 --> 0.76875
[Evaluate] best accuracy performence has been updated: 0.76875 --> 0.77500
[Train] epoch: 200/1000, loss: 0.4901648461818695
[Evaluate] best accuracy performence has been updated: 0.77500 --> 0.78125
[Evaluate] best accuracy performence has been updated: 0.78125 --> 0.78750
[Evaluate] best accuracy performence has been updated: 0.78750 --> 0.79375
[Train] epoch: 250/1000, loss: 0.4414004385471344
[Evaluate] best accuracy performence has been updated: 0.79375 --> 0.80000
[Evaluate] best accuracy performence has been updated: 0.80000 --> 0.80625
[Evaluate] best accuracy performence has been updated: 0.80625 --> 0.81250
[Train] epoch: 300/1000, loss: 0.40371209383010864
[Evaluate] best accuracy performence has been updated: 0.81250 --> 0.81875
[Train] epoch: 350/1000, loss: 0.37464267015457153
[Train] epoch: 400/1000, loss: 0.3527087867259979
[Evaluate] best accuracy performence has been updated: 0.81875 --> 0.82500
[Evaluate] best accuracy performence has been updated: 0.82500 --> 0.83125
[Evaluate] best accuracy performence has been updated: 0.83125 --> 0.83750
[Train] epoch: 450/1000, loss: 0.33678582310676575
[Evaluate] best accuracy performence has been updated: 0.83750 --> 0.84375
[Train] epoch: 500/1000, loss: 0.32561513781547546
[Train] epoch: 550/1000, loss: 0.31791070103645325
[Evaluate] best accuracy performence has been updated: 0.84375 --> 0.85000
[Train] epoch: 600/1000, loss: 0.312591016292572
[Train] epoch: 650/1000, loss: 0.30886030197143555
[Train] epoch: 700/1000, loss: 0.3061731457710266
[Train] epoch: 750/1000, loss: 0.3041686415672302
[Train] epoch: 800/1000, loss: 0.30261164903640747
[Train] epoch: 850/1000, loss: 0.30135002732276917
[Train] epoch: 900/1000, loss: 0.3002856969833374
[Train] epoch: 950/1000, loss: 0.29935526847839355

 通过结果可以发现，增加一个三个隐藏层的神经元后，误差减少，学习率有所提升。

【思考题】

自定义梯度计算和自动梯度计算：

从计算性能、计算结果等多方面比较，谈谈自己的看法。

自定义梯度计算：构建模型有时需要使用自定义的函数，为了不影响模型的反向传播，需要实现自动梯度计算，即把自定义函数嵌入计算图。

自动梯度计算：PyTorch提供的autograd包能够根据输入和前向传播过程自动构建计算图，并执行反向传播。Tensor是这个pytorch的自动求导部分的核心类，如果将其属性.requires_grad=True，它将开始追踪在该tensor上的所有操作，从而实现利用链式法则进行的梯度传播。完成计算后，可以调用.backward()来完成所有梯度计算。此Tensor的梯度将累积到.grad属性中。

对Model_MLP_L2_V2函数分别添加

def back(self, grads):
        grad_input = torch.multiply(self.outputs, (1.0 - self.outputs))
        return torch.multiply((grads, grad_input))
 def back(self):
        loss = -1.0 * (self.labels / self.predicts - (1 - self.labels) / (1 - self.predicts)) / self.num
        self.model.zidingback(loss)

自定义梯度：

自动梯度：

 对比可得自定义梯度计算准确率低但速度快。

4.4 优化问题

4.4.1 参数初始化

实现一个神经网络前，需要先初始化模型参数。

如果对每一层的权重和偏置都用0初始化，那么通过第一遍前向计算，所有隐藏层神经元的激活值都相同；在反向传播时，所有权重的更新也都相同，这样会导致隐藏层神经元没有差异性，出现对称权重现象。

接下来，将模型参数全都初始化为0，看实验结果。这里重新定义了一个类TwoLayerNet_Zeros，两个线性层的参数全都初始化为0。

class Model_MLP_L2_V4(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Model_MLP_L2_V4, self).__init__()
        # 使用'paddle.nn.Linear'定义线性层。
        # 其中in_features为线性层输入维度；out_features为线性层输出维度
        # weight_attr为权重参数属性
        # bias_attr为偏置参数属性

        
        self.fc1 = nn.Linear(input_size, hidden_size)
        constant_(self.fc1.weight, val=0.0)
        constant_(self.fc1.bias, val=0.0)
        self.fc2 = nn.Linear(hidden_size, output_size)
        constant_(self.fc2.weight,val=0.0)
        constant_(self.fc2.bias, val=0.0)
        self.act_fn = torch.sigmoid
        
        # 使用'paddle.nn.functional.sigmoid'定义 Logistic 激活函数
        self.act_fn = torch.sigmoid
        
    # 前向计算
    def forward(self, inputs):
        z1 = self.fc1(inputs)
        a1 = self.act_fn(z1)
        z2 = self.fc2(a1)
        a2 = self.act_fn(z2)
        return a2
def print_weights(runner):
    print('The weights of the Layers：')
    for item in runner.model.named_parameters():
        print(item)

利用Runner类训练模型：

# 设置模型
input_size = 2
hidden_size = 5
output_size = 1
model = Model_MLP_L2_V4(input_size=input_size, hidden_size=hidden_size, output_size=output_size)

# 设置损失函数
loss_fn = F.binary_cross_entropy

# 设置优化器
learning_rate = 0.2 #5e-2
optimizer = torch.optim.SGD(lr=learning_rate, params=model.parameters())

# 设置评价指标
metric = accuracy

# 其他参数
epoch = 2000
saved_path = 'best_model.pdparams'

# 实例化RunnerV2类，并传入训练配置
runner = RunnerV2_2(model, optimizer, metric, loss_fn)

runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=5, log_epochs=50, save_path="best_model.pdparams",custom_print_log=print_weights)

 

 可视化训练和验证集上的主准确率和loss变化：

plot(runner, "fw-zero.pdf")

 从输出结果看，二分类准确率为50%左右，说明模型没有学到任何内容。训练和验证loss几乎没有怎么下降。

为了避免对称权重现象，可以使用高斯分布或均匀分布初始化神经网络的参数。

高斯分布和均匀分布采样的实现和可视化代码如下：

# 使用'paddle.normal'实现高斯分布采样，其中'mean'为高斯分布的均值，'std'为高斯分布的标准差，'shape'为输出形状
gausian_weights = torch.normal(mean=0.0, std=1.0, size=[10000])
# 使用'paddle.uniform'实现在[min,max)范围内的均匀分布采样，其中'shape'为输出形状
uniform_weights = torch.Tensor(10000)
uniform_weights.uniform_(-1,1)
print(uniform_weights)
# 绘制两种参数分布
plt.figure()
plt.subplot(1,2,1)
plt.title('Gausian Distribution')
plt.hist(gausian_weights, bins=200, density=True, color='#f19ec2')
plt.subplot(1,2,2)
plt.title('Uniform Distribution')
plt.hist(uniform_weights, bins=200, density=True, color='#e4007f')
plt.savefig('fw-gausian-uniform.pdf')
plt.show()

4.4.2 梯度消失问题

在神经网络的构建过程中，随着网络层数的增加，理论上网络的拟合能力也应该是越来越好的。但是随着网络变深，参数学习更加困难，容易出现梯度消失问题。

由于Sigmoid型函数的饱和性，饱和区的导数更接近于0，误差经过每一层传递都会不断衰减。当网络层数很深时，梯度就会不停衰减，甚至消失，使得整个网络很难训练，这就是所谓的梯度消失问题。
在深度神经网络中，减轻梯度消失问题的方法有很多种，一种简单有效的方式就是使用导数比较大的激活函数，如：ReLU。

下面通过一个简单的实验观察前馈神经网络的梯度消失现象和改进方法。

4.4.2.1 模型构建

定义一个前馈神经网络，包含4个隐藏层和1个输出层，通过传入的参数指定激活函数。代码实现如下：

# 定义多层前馈神经网络
class Model_MLP_L5(nn.Module):
    def __init__(self, input_size, output_size, act='sigmoid', w_init=torch.normal(mean=torch.tensor(0.0), std=torch.tensor(0.01)), b_init=torch.tensor(1.0)):
        super(Model_MLP_L5, self).__init__()
        self.fc1 = torch.nn.Linear(input_size, 3)
        self.fc2 = torch.nn.Linear(3, 3)
        self.fc3 = torch.nn.Linear(3, 3)
        self.fc4 = torch.nn.Linear(3, 3)
        self.fc5 = torch.nn.Linear(3, output_size)
        # 定义网络使用的激活函数
        if act == 'sigmoid':
            self.act = F.sigmoid
        elif act == 'relu':
            self.act = F.relu
        elif act == 'lrelu':
            self.act = F.leaky_relu
        else:
            raise ValueError("Please enter sigmoid relu or lrelu!")
        # 初始化线性层权重和偏置参数
        self.init_weights(w_init, b_init)

    # 初始化线性层权重和偏置参数
    def init_weights(self, w_init, b_init):
        # 使用'named_sublayers'遍历所有网络层
        for n, m in self.named_parameters():
            # 如果是线性层，则使用指定方式进行参数初始化
            if isinstance(m, nn.Linear):
                w_init(m.weight)
                b_init(m.bias)

    def forward(self, inputs):
        outputs = self.fc1(inputs)
        outputs = self.act(outputs)
        outputs = self.fc2(outputs)
        outputs = self.act(outputs)
        outputs = self.fc3(outputs)
        outputs = self.act(outputs)
        outputs = self.fc4(outputs)
        outputs = self.act(outputs)
        outputs = self.fc5(outputs)
        outputs = F.sigmoid(outputs)
        return outputs

 4.4.2.2 使用Sigmoid型函数进行训练

使用Sigmoid型函数作为激活函数，为了便于观察梯度消失现象，只进行一轮网络优化。代码实现如下：
定义梯度打印函数

def print_grads(runner):
    # 打印每一层的权重的模
    print('The gradient of the Layers：')
    for name,item in runner.model.named_parameters():
        if(len(item.size())==2):
             print(item)
             print(name,torch.norm(input=item,p=2))
             # 学习率大小
lr = 0.01
# 定义网络，激活函数使用sigmoid
model =  Model_MLP_L5(input_size=2, output_size=1, act='sigmoid')
# 定义优化器
optimizer = torch.optim.SGD(lr=lr, params=model.parameters())
# 定义损失函数，使用交叉熵损失函数
loss_fn = F.binary_cross_entropy
# 定义评价指标
metric = accuracy
# 指定梯度打印函数
custom_print_log=print_grads

实例化RunnerV2_2类，并传入训练配置。代码实现如下：

# 实例化Runner类
runner = RunnerV2_2(model, optimizer, metric, loss_fn)

模型训练，打印网络每层梯度值的ℓ2范数。代码实现如下：

# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], 
            num_epochs=1, log_epochs=None, 
            save_path="best_model.pdparams", 
            custom_print_log=custom_print_log)

 观察实验结果可以发现，梯度经过每一个神经层的传递都会不断衰减，最终传递到第一个神经层时，梯度几乎完全消失。 

4.4.2.3 使用ReLU函数进行模型训练

lr = 0.01  # 学习率大小

# 定义网络，激活函数使用relu
model =  Model_MLP_L5(input_size=2, output_size=1, act='relu')

# 定义优化器
optimizer = torch.optim.SGD(lr=lr, params=model.parameters())

# 定义损失函数
# 定义损失函数，这里使用交叉熵损失函数
loss_fn = F.binary_cross_entropy

# 定义评估指标
metric = accuracy

# 实例化Runner
runner = RunnerV2_2(model, optimizer, metric, loss_fn)

# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], 
            num_epochs=1, log_epochs=None, 
            save_path="best_model.pdparams", 
            custom_print_log=custom_print_log)

The gradient of the Layers：
Parameter containing:
tensor([[ 0.4356, -0.1862],
        [-0.1747, -0.5807],
        [ 0.5868,  0.3485]], requires_grad=True)
fc1.weight tensor(1.0286, grad_fn=<NormBackward1>)
Parameter containing:
tensor([[-0.5669,  0.1052, -0.4021],
        [-0.2340,  0.2295,  0.5551],
        [ 0.1985, -0.2634,  0.0469]], requires_grad=True)
fc2.weight tensor(1.0103, grad_fn=<NormBackward1>)
Parameter containing:
tensor([[ 0.1177, -0.4179,  0.3368],
        [-0.3646, -0.3053, -0.0222],
        [-0.5638,  0.2787,  0.3291]], requires_grad=True)
fc3.weight tensor(1.0161, grad_fn=<NormBackward1>)
Parameter containing:
tensor([[ 0.2918, -0.2805, -0.1391],
        [-0.2274,  0.3770, -0.2773],
        [-0.3378, -0.2125,  0.3613]], requires_grad=True)
fc4.weight tensor(0.8624, grad_fn=<NormBackward1>)
Parameter containing:
tensor([[-0.1999,  0.0174, -0.0853]], requires_grad=True)
fc5.weight tensor(0.2180, grad_fn=<NormBackward1>)
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.53125

 图4.4 展示了使用不同激活函数时，网络每层梯度值的ℓ2ℓ2范数情况。从结果可以看到，5层的全连接前馈神经网络使用Sigmoid型函数作为激活函数时，梯度经过每一个神经层的传递都会不断衰减，最终传递到第一个神经层时，梯度几乎完全消失。改为ReLU激活函数后，梯度消失现象得到了缓解，每一层的参数都具有梯度值。

4.4.3 死亡ReLU问题

ReLU激活函数可以一定程度上改善梯度消失问题，但是在某些情况下容易出现死亡ReLU问题，使得网络难以训练。

这是由于当x<0x<0时，ReLU函数的输出恒为0。在训练过程中，如果参数在一次不恰当的更新后，某个ReLU神经元在所有训练数据上都不能被激活（即输出为0），那么这个神经元自身参数的梯度永远都会是0，在以后的训练过程中永远都不能被激活。

一种简单有效的优化方式就是将激活函数更换为Leaky ReLU、ELU等ReLU的变种。

4.4.3.1 使用ReLU进行模型训练

使用第4.4.2节中定义的多层全连接前馈网络进行实验，使用ReLU作为激活函数，观察死亡ReLU现象和优化方法。当神经层的偏置被初始化为一个相对于权重较大的负值时，可以想像，输入经过神经层的处理，最终的输出会为负值，从而导致死亡ReLU现象。

# 定义网络，并使用较大的负值来初始化偏置
model =  Model_MLP_L5(input_size=2, output_size=1, act='relu', b_init=torch.tensor(-8.0))

 实例化RunnerV2类，启动模型训练，打印网络每层梯度值的ℓ2范数。代码实现如下：

# 实例化Runner类
runner = RunnerV2_2(model, optimizer, metric, loss_fn)

# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], 
            num_epochs=1, log_epochs=0, 
            save_path="best_model.pdparams", 
            custom_print_log=custom_print_log)

从输出结果可以发现，使用 ReLU 作为激活函数，当满足条件时，会发生死亡ReLU问题，网络训练过程中 ReLU 神经元的梯度始终为0，参数无法更新。

针对死亡ReLU问题，一种简单有效的优化方式就是将激活函数更换为Leaky ReLU、ELU等ReLU 的变种。接下来，观察将激活函数更换为 Leaky ReLU时的梯度情况。

4.4.3.2 使用Leaky ReLU进行模型训练

将激活函数更换为Leaky ReLU进行模型训练，观察梯度情况。代码实现如下：

# 重新定义网络，使用Leaky ReLU激活函数
model =  Model_MLP_L5(input_size=2, output_size=1, act='lrelu', b_init=torch.tensor(-8.0))
# 实例化Runner类
runner = RunnerV2_2(model, optimizer, metric, loss_fn)
# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], 
            num_epochs=1, log_epochps=None, 
            save_path="best_model.pdparams", 
            custom_print_log=custom_print_log)

 从输出结果可以看到，将激活函数更换为Leaky ReLU后，死亡ReLU问题得到了改善，梯度恢复正常，参数也可以正常更新。但是由于 Leaky ReLU 中，x<0 时的斜率默认只有0.01，所以反向传播时，随着网络层数的加深，梯度值越来越小。如果想要改善这一现象，将 Leaky ReLU 中，x<0 时的斜率调大即可

梯度消失和梯度爆炸产生的原因即解决办法

在反向传播过程中需要对激活函数进行求导，如果导数大于1，那么随着网络层数的增加梯度更新将会朝着指数爆炸的方式增加这就是梯度爆炸。

同样如果导数小于1，那么随着网络层数的增加梯度更新信息会朝着指数衰减的方式减少这就是梯度消失。

因此，梯度消失、爆炸，其根本原因在于反向传播训练法则，属于先天不足。
梯度消失解决方法：

为了解决梯度的问题，采取无监督逐层训练方法，其基本思想是每次训练一层隐节点，训练时将上一层隐节点的输出作为输入，而本层隐节点的输出作为下一层隐节点的输入，此过程是逐层“预训练”；在预训练完成后，再对整个网络进行“微调”。此思想相当于是先寻找局部最优，然后整合起来寻找全局最优
梯度爆炸解决方法：

采用权重正则化。通过对网络权重做正则限制过拟合，仔细看正则项在损失函数的形式：

其中，  是指正则项系数，因此，如果发生梯度爆炸，权值的范数就会变的非常大，通过正则化项，可以部分限制梯度爆炸的发生。但在深度模型中，梯度消失更常见一些。
 

总结

通过本次内容，系统地学习了torch.nn.Module类，以及在前馈神经网络中一定程度地增加隐藏层数目可以减少误差，增加准确率。掌握了自定义梯度计算和自动梯度计算的区别及梯度消失和梯度爆炸产生的原因即解决办法。

参考：

NNDL 实验4（上） - HBU_DAVID - 博客园 (cnblogs.com)

cdd04
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解前馈神经网络：从基础到实践
10-07
前馈神经网络（Feedforward Neural Networks）是深度学习领域最基本且常用的神经网络类型之一。它们被广泛应用于图像分类、自然语言处理、推荐系统等各种领域。本教程将从基础概念出发，深入探讨前馈神经网络的原理...
平滑L0正则化的前馈神经网络批量梯度训练方法
02-24
本文考虑采用平滑L0正则化（BGSL0）的批梯度方法进行训练和修剪前馈神经网络。 我们展示了为什么BGSL0可以产生稀疏的权重，这对于修剪网络。 我们证明了在温和条件下BGSL0的弱收敛和强收敛。 还获得了误差函数在训练...
智能问答模型训练中三种常用的损失函数解读
Focus on AI
05-08 2802
智能问答是NLP领域落地最多的场景，其商业价值较高，能有效解决业务问题，降低人力成本。智能问答分为封闭域问答与开放域问答两种。封闭域的问答是指根据用户的问题，从已有问答库中找出最匹配的答案返回给用户。而开放域问答则是根据用户的问题，由模型根据已学会的知识生成相应的答案返回给用户。由于当前开放域问答存在回答不可控的问题，在工业界落地项目较少。而封闭域问答是NLP领域中落地最多的项目之一。封闭域问答最常见的形式是FAQ问答，即常见问题解答。在NLP中，对FAQ任务的解决方案是，将用户会遇到的常见问题收集起来构建
NNDL 实验五 前馈神经网络（2）自动梯度计算 & 优化问题
vvhvj的博客
10-07 398
在训练过程中，如果参数在一次不恰当的更新后，某个ReLU神经元在所有训练数据上都不能被激活（即输出为0），那么这个神经元自身参数的梯度永远都会是0，在以后的训练过程中永远都不能被激活。继承了paddle.nn.Layer类的算子中，可以在内部直接调用其它继承paddle.nn.Layer类的算子，飞桨框架会自动识别算子中内嵌的paddle.nn.Layer类算子，并自动计算它们的梯度，并在优化时更新它们的参数。当网络层数很深时，梯度就会不停衰减，甚至消失，使得整个网络很难训练，这就是所谓的梯度消失问题。
【深度学习】日常笔记10
努力学习的DS
07-07 1370
常常使⽤L2范数的⼀个原因是它对权重向量的⼤分量施加了巨⼤的惩罚，因为开了平方，那大分量开平方会更大，那么惩罚力度也就越大，这使得学习算法偏向于训练出一个在大量特征上均匀分布权重的模型。而L2正则化通过惩罚大型参数，迫使模型在进行优化时更倾向于选择较小的参数值，从而限制了模型的复杂度，减少了过拟合的风险。),会导致训练模型时出现数值不稳定的情况，因为每个特征的尺度不同，可能会导致某些特征对模型的影响更大，从而影响模型的性能。，而不是计算后的结果。较小的λ值对权重w的约束小，较大的λ值对权重w的约束大。
[MindSpore]ValueError: loss_fn can not be None
weixin_45666880的博客
07-28 173
计算评估指标需要logits和label，在您自定义WithLossCell的情况下，Model不能分辨出哪个输出是logits，哪个是label。因此需要您指定eval_network，并输出用于计算metrics的logits和label。这个应该时说我在定义Model的时候没有加上loss_fn的参数，PrototyAccLoss是我自己定义的一个metrics类。但是我想要自定义一个metric，于是当我改成。如果写成上面的形式，则不会报错。这个应该是图模式才会出现的问题。...
loss 函数 正对数据不平衡
azhang190426的博客
11-14 262
def loss(y_true, y_pred): return - (1 - theta(y_true - margin) * theta(y_pred - margin) - theta(1 - margin - y_true) * theta(1 - margin - y_pred) ) * (y_true * K.log(...
深度学习期末复习资料，绪论，机器学习基础，前馈神经网络，深度模型优化，正则化，卷积神经网络，循环神经网络
10-10
绪论（人工智能到机器学习到深度学习，机器学习三要素，神经网络的三起两落，大模型），机器学习基础（梯度下降算法、数学、线代基础，线性模型，感知机），前馈神经网络（BP），深度模型优化（非凸优化，学习率，...
论文研究-基于反传混沌粒子群训练的前馈神经网络研究.pdf
07-22
为了解决前馈神经网络训练收敛速度慢、易陷入局部极值及对初始权值依赖性强等缺点，提出了一种基于反传的无限折叠迭代混沌粒子群优化（ICMICPSO）算法训练前馈神经网络（FNNs）参数。该方法在充分利用BP算法的误差反...
基于MATLAB多层前馈神经网络的回归预测模型多参数多图调整
04-07
前馈神经网络 一种单向多层的网络结构，信息从输入层开始，逐层向一个方向传递，一直到输出层结束。前馈是指输出入方向是前向，此过程不调整权值。神经元之间不存在跨层连接、同层连接，输入层用于数据的输入，隐含...
TensorFlow入门
qq_45190143的博客
04-20 75
将 optimizer 类设置为 adam，将 loss 设置为您之前定义的 loss_fn 函数，并通过将 metrics 参数设置为 accuracy 来指定要为模型评估的指标。使用 losses.SparseCategoricalCrossentropy 为训练定义损失函数，它会接受 logits 向量和 True 索引，并为每个样本返回一个标量损失。这个未经训练的模型给出的概率接近随机（每个类为 1/10），因此初始损失应该接近 -tf.math.log(1/10) ~= 2.3。
一、常见损失函数的用法
Freeloop_hg的博客
11-30 1756
前言 定义损失函数的常用方法，其中包括多分类交叉熵、均方差、二分类交叉熵的用法。其作用包括：1.衡量模型输出值和标签值的差异；2.评估模型的预测值与真实值不一致程度；3.神经网络中优化的目标函数，损失函数越小，预测值越接近真实值，模型健壮性也越好。 一、L1-loss（MAE）、L2- loss（MSE）、smooth L1- loss、交叉熵损失函数是什么？ 二、使用步骤 1.损失函数方法 代码如下（示例）： #定义损失函数，更新梯度---- loss_fn = torch.nn.CrossEnt
自定义神经网络三之梯度和损失函数激活函数
最新发布
铁柱的博客
02-25 541
本篇博客分别解释了梯度，损失函数，激活函数等相关概念。前期概念准备部分基本结束，接下来我们就尝试自定义一个神经网络，实现训练，推理和生成模型等，也算是对基础概念部分的一个实践。
Python的神经网络梯度优化
昊大侠的博客
07-12 1601
目录前言二级目录三级目录原理举例 前言 以下内容基于 Pytorch 的学习实践总结并参考了 CSDN 及 TouTube 博主的经验。 我们有以下共识 神经网络通过构建计算图实现数据的有序流动，如前向传播（forward）和反向传播（backward），计算图是一种将计算流程化的方法。在计算图中，计算被表示成有向图，其中每个节点就是数据，表示为一个变量（variable），这一变量可以是标量（scalar），向量（vector），矩阵（matrix），张量（tensor）任意形式；前向传播很好理解，节点
NNDL 实验六 卷积神经网络（5）使用预训练resnet18实现CIFAR-10分类
m0_63172447的博客
11-12 657
预训练的简单概括就是使用尽可能多的训练数据，从中提取出尽可能多的共性特征，从而让模型对特定任务的学习负担变轻。预训练方式表现在模型参数上，就是我之前已经拿到一个任务，这个任务和其他任务有很多相同之处，于是提前训练好了所有的模型参数（预训练）。因此我们不再需要从0开始训练所有参数了，但是针对我们目前这个任务，有些参数可能不合适，我们只需要在当前参数的基础上稍加修改（微调）就可以得到比较好的效果，这样学习时间必然会大大减小。
C++/Python机器学习—多层感知机（回归问题）
seek97的博客
03-28 812
二、C++
python损失函数实现_深度学习的损失函数与python实现,之,及
weixin_39884144的博客
12-08 539
import torchimport torch.nn.functional as Fdef run_mse_fun():y_pred = np.array([np.array([0.3, 0.4, 0.3]),np.array([0.1, 0.1, 0.8])])y = np.array([np.array([1., 2., 3.]),np.array([4., 5., 6.])])print(...
Pytorch神经网络常用函数介绍（持续更新……）
Infinity_and_beyond的博客
05-30 2147
在深度学习中，是 PyTorch 中用于定义线性层的类。它用于构建神经网络模型的线性层，将输入数据进行线性变换。bias举个例子，假设我们有一个输入张量x，形状为，我们想将其输入到一个线性层进行变换，输出张量的形状为在上面的代码中，我们创建了一个nn.Linear对象，它将输入特征的大小设置为input_size，输出特征的大小设置为。然后，我们将输入张量x传递给，并获得输出张量output。输出张量的形状为，符合线性层的定义。注意：在使用定义线性层时，PyTorch会自动初始化线性层的权重和偏置项。
Pytorch训练模型损失Loss为Nan或者无穷大（INF）原因
热门推荐
ytusdc的博客
02-12 4万+
常见原因-1 一般来说，出现NaN有以下几种情况： 相信很多人都遇到过训练一个deep model的过程中，loss突然变成了NaN。在这里对这个问题做一个总结： 1.如果在迭代的100轮以内，出现NaN，一般情况下的原因是因为你的学习率过高，需要降低学习率。可以不断降低学习率直至不出现NaN为止，一般来说低于现有学习率1-10倍即可。 2.如果当前的网络是类似于RNN的循环神经网络的话，出现NaN可能是因为梯度爆炸的原因，一个有效的方式是增加“gradient clipping”（梯度截断来解决）
实验六 前馈神经网络
10-19
实验六是关于前馈神经网络的实验，主要包括手动实现和利用torch.nn实现两种方式。在实验中，我们可以通过前馈神经网络来解决回归、二分类、多分类任务，并分析实验结果并绘制训练集和测试集的loss曲线。同时，在神经网络的构建过程中，随着网络层数的增加，理论上网络的拟合能力也应该是越来越好的，但是随着网络变深，参数学习更加困难，容易出现梯度消失问题。因此，在实验中我们需要注意网络的深度和参数的学习情况，以及如何解决梯度消失问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值