pytorch10:正则化(weight_decay、dropout、Batch Normalization)

在这里插入图片描述

目录

  • 一、正则化regularization
    • 1.概念
    • 2.过拟合
    • 3.减小方差策略
    • 4 正则化--权值衰减
  • 二、正则化-dropout
    • 2.1 dropout概念
    • 2.2 数据尺度变化
    • 2.3 nn.Dropout
    • 2.4 两种模式
  • 三、Batch Normalization
    • 3.1 ICS现象(Internal Covariate Shift,内部协变量偏移)
    • 3.2 BN原理
    • 3.3 BN的优点
    • 3.4 数据尺度实验
    • 3.5 实际模型训练
    • 3.6 _BatchNorm
      • 3.6.1 相关参数分析
      • 3.6.2 1d、2d、3d特征区别
      • 3.6.3 1d代码实现
      • 3.6.4 2d代码实现

往期回顾

pytorch01:概念、张量操作、线性回归与逻辑回归
pytorch02:数据读取DataLoader与Dataset、数据预处理transform
pytorch03:transforms常见数据增强操作
pytorch04:网络模型创建
pytorch05:卷积、池化、激活
pytorch06:权重初始化
pytorch07:损失函数与优化器
pytorch08:学习率调整策略
pytorch09:可视化工具-TensorBoard,实现卷积核和特征图可视化


一、正则化regularization

1.概念

正则化:减小方差的策略
什么叫误差?误差可分解为:偏差,方差与噪声之和。即误差 = 偏差 + 方差 + 噪声之和;
偏差度量了学习算法的期望预测与真实结果的偏离程度,即刻画了学习算法本身的拟合能力
方差度量了同样大小的训练集的变动所导致的学习性能的变化,即刻画了数据扰动所造成的影响
噪声则表达了在当前任务上任何学习算法所能达到的期望泛化误差的下界

通过下面这幅图来理解上面三个差值概念
这幅图是训练过程中,在训练集和验证集上面的损失曲线,红色的是在验证集上面的损失,橙色是在训练集上面的损失,我们在训练过程中希望损失越小越好;
偏差:我们训练集的损失大小,通常不考虑噪声的情况,也就是训练集与真实值之间的误差称为偏差;
方差:训练集与验证集之间的一个差异;
总结:我们的regularization就是为了解决方差过大的问题。
在这里插入图片描述

2.过拟合

下面这幅图训练的模型可以完整的拟合每一个训练集,但是无法拟合测试集,也就是我们说的过拟合现象,此时方差最大,regularization就是用来降低方差解决过拟合问题。
在这里插入图片描述

3.减小方差策略

在之前的博客文章讲过目标函数的公式,它是由代价函数和一个正则项组成,代价函数表示的是模型的输出与我们真实值之间的一个差异。而这个正则项则是为了约束我们模型的复杂度,让模型不那么复杂,常见的正则项有L1和L2
在这里插入图片描述

L1函数和L2函数分别表示下面的正方形和圆形,也就是正则项,彩色的圆盘表代表着cost,那么如何控制obj的值最小?先观察第一幅图片,当正方形的顶点和圆弧相交在w2轴的时候,obj最小;第二幅图,当两个圆相交,此时的点使得obj的值为最小。
在这里插入图片描述

4 正则化–权值衰减

L2 Regularization = weight decay(权值衰减)
我们习惯性把L2 Regularization正则项当作权值衰减,那么为什么要称L2为权值衰减呢,看一下下面公式;
下面是加上L2正则项之后求w梯度公式,直接看最后一步化简公式,我们通常取(0<λ<1),所以w*(1-λ)该项是减小的,所以我们称L2正则项是权值衰减;
在这里插入图片描述
代码实现:
训练两个模型,带weight decay和不带weight decay的模型训练结果,权重衰减一般都放在优化器函数里面;

import torch  # 导入PyTorch库
import torch.nn as nn  # 导入PyTorch神经网络模块
import matplotlib.pyplot as plt  # 导入matplotlib用于绘图
import sys, os  # 导入系统和操作系统模块
hello_pytorch_DIR = os.path.abspath(os.path.dirname(__file__)+os.path.sep+".."+os.path.sep+"..")  # 获取项目路径
sys.path.append(hello_pytorch_DIR)  # 将项目路径添加到系统路径中

from tools.common_tools import set_seed  # 导入自定义的公共函数
from torch.utils.tensorboard import SummaryWriter  # 导入PyTorch的TensorBoard可视化模块

set_seed(1)  # 设置随机种子
n_hidden = 200  # 隐藏层神经元个数
max_iter = 2000  # 最大迭代次数
disp_interval = 500  # 显示间隔
lr_init = 0.01  # 初始学习率


# ============================ step 1/5 数据 ============================
def gen_data(num_data=10, x_range=(-1, 1)):  # 生成模拟数据函数

    w = 1.5  # 斜率
    train_x = torch.linspace(*x_range, num_data).unsqueeze_(1)  # 生成训练数据x
    train_y = w*train_x + torch.normal(0, 0.5, size=train_x.size())  # 生成训练数据y
    test_x = torch.linspace(*x_range, num_data).unsqueeze_(1)  # 生成测试数据x
    test_y = w*test_x + torch.normal(0, 0.3, size=test_x.size())  # 生成测试数据y

    return train_x, train_y, test_x, test_y  # 返回训练数据和测试数据


train_x, train_y, test_x, test_y = gen_data(x_range=(-1, 1))  # 调用gen_data函数生成训练和测试数据


# ============================ step 2/5 模型 ============================
class MLP(nn.Module):  # 定义多层感知器模型类
    def __init__(self, neural_num):  # 初始化函数
        super(MLP, self).__init__()
        self.linears = nn.Sequential(  # 多层感知器结构
            nn.Linear(1, neural_num),  # 全连接层
            nn.ReLU(inplace=True),  # ReLU激活函数
            nn.Linear(neural_num, neural_num),  # 全连接层
            nn.ReLU(inplace=True),  # ReLU激活函数
            nn.Linear(neural_num, neural_num),  # 全连接层
            nn.ReLU(inplace=True),  # ReLU激活函数
            nn.Linear(neural_num, 1),  # 全连接层
        )

    def forward(self, x):  # 前向传播
        return self.linears(x)  # 返回模型输出


net_normal = MLP(neural_num=n_hidden)  # 创建无权重衰减的多层感知器模型
net_weight_decay = MLP(neural_num=n_hidden)  # 创建有权重衰减的多层感知器模型

# ============================ step 3/5 优化器 ============================
optim_normal = torch.optim.SGD(net_normal.parameters(), lr=lr_init, momentum=0.9)  # 创建无权重衰减的优化器
optim_wdecay = torch.optim.SGD(net_weight_decay.parameters(), lr=lr_init, momentum=0.9, weight_decay=1e-2)  # 创建有权重衰减的优化器


# ============================ step 4/5 损失函数 ============================
loss_func = torch.nn.MSELoss()  # 定义均方误差损失函数

# ============================ step 5/5 迭代训练 ============================

writer = SummaryWriter(comment='_test_tensorboard', filename_suffix="12345678")  # 创建TensorBoard可视化对象
for epoch in range(max_iter):  # 迭代训练循环

    # forward
    pred_normal, pred_wdecay = net_normal(train_x), net_weight_decay(train_x)  # 分别计算无权重衰减和有权重衰减模型的预测值
    loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)  # 计算两种模型的损失值

    optim_normal.zero_grad()  # 清空无权重衰减优化器梯度
    optim_wdecay.zero_grad()  # 清空有权重衰减优化器梯度

    loss_normal.backward()  # 反向传播计算无权重衰减模型梯度
    loss_wdecay.backward()  # 反向传播计算有权重衰减模型梯度

    optim_normal.step()  # 更新无权重衰减模型参数
    optim_wdecay.step()  # 更新有权重衰减模型参数

    if (epoch+1) % disp_interval == 0:  # 每间隔disp_interval次迭代进行可视化和绘图

        # ==============================tensorboard可视化====================================
        for name, layer in net_normal.named_parameters():  # 添加无权重衰减模型梯度和参数直方图
            writer.add_histogram(name + '_grad_normal', layer.grad, epoch)
            writer.add_histogram(name + '_data_normal', layer, epoch)

        for name, layer in net_weight_decay.named_parameters():  # 添加有权重衰减模型梯度和参数直方图
            writer.add_histogram(name + '_grad_weight_decay', layer.grad, epoch)
            writer.add_histogram(name + '_data_weight_decay', layer, epoch)

        test_pred_normal, test_pred_wdecay = net_normal(test_x), net_weight_decay(test_x)  # 获取测试数据的预测值

        # ================================plt绘图==============================================
        plt.scatter(train_x.data.numpy(), train_y.data.numpy(), c='blue', s=50, alpha=0.3, label='train')  # 绘制训练数据散点图
        plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='red', s=50, alpha=0.3, label='test')  # 绘制测试数据散点图
        plt.plot(test_x.data.numpy(), test_pred_normal.data.numpy(), 'r-', lw=3, label='no weight decay')  # 绘制无权重衰减模型预测曲线
        plt.plot(test_x.data.numpy(), test_pred_wdecay.data.numpy(), 'b--', lw=3, label='weight decay')  # 绘制有权重衰减模型预测曲线
        plt.text(-0.25, -1.5, 'no weight decay loss={:.6f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})  # 显示无权重衰减模型损失值
        plt.text(-0.25, -2, 'weight decay loss={:.6f}'.format(loss_wdecay.item()), fontdict={'size': 15, 'color': 'red'})  # 显示有权重衰减模型损失值

        plt.ylim((-2.5, 2.5))  # 设置y轴范围
        plt.legend(loc='upper left')  # 设置图例位置
        plt.title("Epoch: {}".format(epoch+1))  # 设置图标题
        plt.show()  # 展示图
        plt.close()  # 关闭图

plt绘制结果:
在训练到第2000轮的时候,无权值衰减的红色曲线虽然在训练集上表现非常好Loss为0,但是产生了严重的过拟合,在测试集上面表现非常差,此时的方差最大,
在这里插入图片描述
tensorboard展示:
不带有权值衰减方法的网络层,随着训练次数的增加,权重没有发生变化,但是带有权值初始化的网络,随着训练的加深,网络的权重也在降低,最后控制在[-0.25,0.25]之间。
在这里插入图片描述
权值下降原理
在优化器更新这行打上断点,进入debug模型,进入到SGD优化器函数当中;
在这里插入图片描述
找到权重衰减实现公式:
该行代码表示d_p=d_p+param*alpha,d_p表示的就是求导;
在这里插入图片描述
在这里插入图片描述

二、正则化-dropout

2.1 dropout概念

    Dropout是一种用于深度学习模型的正则化技术。正则化旨在防止模型过度拟合训练数据,提高模型的泛化能力。Dropout的基本思想是在训练期间随机“丢弃”(即将其权重设置为零)神经网络中的一些单元,从而减少神经网络的复杂度,防止过拟合。
    具体来说,Dropout在训练期间随机选择一些神经元,并将它们的输出设置为零。这样,每个神经元都不能依赖于特定的其他神经元,因为任何神经元在任何时刻都有可能被“丢弃”。这迫使网络中的每个神经元都变得更加独立,减少了神经元之间的复杂依赖关系
    在实践中,Dropout通常通过在训练期间以一定的概率(通常在0.2到0.5之间)随机将神经元的输出置为零来实现。在测试期间,所有神经元都保持激活。这是因为在测试时,我们希望使用整个模型进行预测,而不是随机地“关闭”一些神经元。
    Dropout的优势在于它能够显著减少过拟合,提高模型的泛化性能。这种技术已经被广泛应用于深度学习中的各种任务,如图像分类、自然语言处理等。

下面这幅图分别是正常神经元连接,和神经元随机失活,随机失活之后神经元的weight=0
在这里插入图片描述

2.2 数据尺度变化

测试时,所有权重乘以1-drop_prob,为什么要做这样的一个变化?
例如:drop_prob = 0.3 , 1-drop_prob = 0.7,我们有100个神经元,在训练过程中随机失活30%,那么实际训练过程中是有70个事有权重的,所以训练过程中的数据尺度是70,但是在测试过程中所有神经元都存在,此时的数据尺度为100,那么训练过程中和测试过程中的数据尺度会存在差异,这会导致我们模型的精度产生差异,所以在测试过程中,需要对所有的权值乘以0.7,也就是1-drop_prob,这样可以保证数据尺度一致。

2.3 nn.Dropout

功能:Dropou t层
参数:
• p:被舍弃概率,失活概率

pytorch实现细节:
这样做的好处,在训练的时候增加神经元权值,在测试阶段不需要做任何处理。
在这里插入图片描述
代码实现:

# -*- coding:utf-8 -*-  # 定义编码格式为utf-8

import torch  # 导入PyTorch库,一个开源的神经网络库
import torch.nn as nn  # 导入PyTorch的神经网络模块
import matplotlib.pyplot as plt  # 导入Matplotlib库,用于绘图
import sys, os  # 导入系统模块和os库

hello_pytorch_DIR = os.path.abspath(
    os.path.dirname(__file__) + os.path.sep + ".." + os.path.sep + "..")  # 获取当前文件所在的目录的上一级目录的上一级目录的绝对路径,通常用于指定路径
sys.path.append(hello_pytorch_DIR)  # 将该路径添加到Python的系统路径中,使得可以导入该路径下的模块

from tools.common_tools import set_seed  # 导入common_tools模块中的set_seed函数,用于设置随机种子
from torch.utils.tensorboard import SummaryWriter  # 导入TensorBoard模块中的SummaryWriter类,用于写入tensorboard的日志

set_seed(1)  # 设置随机种子为1,为了使结果可复现
n_hidden = 200  # 定义隐藏层单元数量为200
max_iter = 2000  # 最大迭代次数为2000次
disp_interval = 500  # 每隔disp_interval轮迭代显示一次信息
lr_init = 0.01  # 初始学习率为0.01


# ============================ step 1/5 数据 ============================
def gen_data(num_data=10, x_range=(-1, 1)):  # 定义一个函数,用于生成数据,num_data表示生成数据的数量,x_range表示数据范围
    w = 1.5  # 定义权重w
    train_x = torch.linspace(*x_range, num_data).unsqueeze_(
        1)  # 生成训练数据x,使用linspace生成等间距的数据,unsqueeze_将数据形状扩展为[样本数, 特征]的形式
    train_y = w * train_x + torch.normal(0, 0.5, size=train_x.size())  # 根据训练数据x和权重w生成对应的y值,并添加高斯噪声
    test_x = torch.linspace(*x_range, num_data).unsqueeze_(1)  # 生成测试数据x
    test_y = w * test_x + torch.normal(0, 0.3, size=test_x.size())  # 根据测试数据x和权重w生成对应的y值,并添加更小的噪声
    return train_x, train_y, test_x, test_y  # 返回训练数据、标签,测试数据、标签


train_x, train_y, test_x, test_y = gen_data(x_range=(-1, 1))  # 在这里调用gen_data函数生成数据,范围为(-1,1)


# ============================ step 2/5 模型 ============================
class MLP(nn.Module):  # 定义一个神经网络模型MLP,继承自PyTorch的nn.Module类
    def __init__(self, neural_num, d_prob=0.5):  # 在初始化函数中定义模型的结构,neural_num表示神经元的数量,d_prob表示dropout的概率
        super(MLP, self).__init__()  # 调用父类的初始化函数
        self.linears = nn.Sequential(  # 定义一个序列模型,包含多个线性层和ReLU激活函数
            nn.Linear(1, neural_num),  # 第一层线性层,输入为1维,输出为neural_num维
            nn.ReLU(inplace=True),  # 添加ReLU激活函数,inplace=True表示原地操作,即不创建额外的内存空间

            nn.Dropout(d_prob),  # 应用d_prob概率的dropout层,对每个样本的特征进行随机失活(即不传递)一部分特征
            nn.Linear(neural_num, neural_num),  # 第二层线性层,输入为neural_num维,输出为neural_num维
            nn.ReLU(inplace=True),  # 添加ReLU

            nn.Dropout(d_prob),
            nn.Linear(neural_num, neural_num),
            nn.ReLU(inplace=True),

            nn.Dropout(d_prob),
            nn.Linear(neural_num, 1),
        )

    def forward(self, x):
        return self.linears(x)


net_prob_0 = MLP(neural_num=n_hidden, d_prob=0.)
net_prob_05 = MLP(neural_num=n_hidden, d_prob=0.5)

# ============================ step 3/5 优化器 ============================
optim_normal = torch.optim.SGD(net_prob_0.parameters(), lr=lr_init, momentum=0.9)
optim_reglar = torch.optim.SGD(net_prob_05.parameters(), lr=lr_init, momentum=0.9)

# ============================ step 4/5 损失函数 ============================
loss_func = torch.nn.MSELoss()

# ============================ step 5/5 迭代训练 ============================

writer = SummaryWriter(comment='_test_tensorboard', filename_suffix="12345678")
for epoch in range(max_iter):

    pred_normal, pred_wdecay = net_prob_0(train_x), net_prob_05(train_x)
    loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)

    optim_normal.zero_grad()
    optim_reglar.zero_grad()

    loss_normal.backward()
    loss_wdecay.backward()

    optim_normal.step()
    optim_reglar.step()

    if (epoch + 1) % disp_interval == 0:

        net_prob_0.eval() #测试阶段一定要设置eval模式
        net_prob_05.eval()

        # 可视化
        for name, layer in net_prob_0.named_parameters():
            writer.add_histogram(name + '_grad_normal', layer.grad, epoch)
            writer.add_histogram(name + '_data_normal', layer, epoch)

        for name, layer in net_prob_05.named_parameters():
            writer.add_histogram(name + '_grad_regularization', layer.grad, epoch)
            writer.add_histogram(name + '_data_regularization', layer, epoch)

        test_pred_prob_0, test_pred_prob_05 = net_prob_0(test_x), net_prob_05(test_x)

        # 绘图
        plt.clf()
        plt.scatter(train_x.data.numpy(), train_y.data.numpy(), c='blue', s=50, alpha=0.3, label='train')
        plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='red', s=50, alpha=0.3, label='test')
        plt.plot(test_x.data.numpy(), test_pred_prob_0.data.numpy(), 'r-', lw=3, label='d_prob_0')
        plt.plot(test_x.data.numpy(), test_pred_prob_05.data.numpy(), 'b--', lw=3, label='d_prob_05')
        plt.text(-0.25, -1.5, 'd_prob_0 loss={:.8f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})
        plt.text(-0.25, -2, 'd_prob_05 loss={:.6f}'.format(loss_wdecay.item()), fontdict={'size': 15, 'color': 'red'})

        plt.ylim((-2.5, 2.5))
        plt.legend(loc='upper left')
        plt.title("Epoch: {}".format(epoch + 1))
        plt.savefig('image_{}.png'.format(epoch + 1))
        plt.show()
        plt.close()

        net_prob_0.train()
        net_prob_05.train()

plt绘图展示
训练2000轮之后,发现虽然不带dropout的模型可以很好的拟合训练集,但是在测试集上面的拟合效果很差,出现了严重的过拟合现象,但是带有dropout的网络不会出现过拟合现象。
在这里插入图片描述
tensorboard展示
不带dropout的线性层,随着训练轮数的叠加,权值没有发生太多的变换,但是带有dropout的线性层,随着训练轮数的叠加,权值在不断减小。
在这里插入图片描述

2.4 两种模式

在神经网络的训练过程中,PyTorch提供了两种模型状态:eval()模式和train()模式。

  1. train()模式:
    在神经网络训练阶段,通常使用train()模式。在这种模式下,神经网络会保留所有的层和参数,并对输入进行高效地求导和反向传播,以便进行参数的更新。此外,训练模式还会启用Dropout层和Batch Normalization层,以便在每一次前向传播和反向传播中对数据进行随机失活和归一化处理,从而提高模型的泛化能力和训练效果。

  2. eval()模式:
    在神经网络测试和验证阶段,通常使用eval()模式。在这种模式下,神经网络会关闭Dropout层和Batch Normalization层的随机失活和归一化处理,以便保持模型的稳定性和一致性。此外,eval()模式还会关闭自动求导机制,减少了内存占用和提高了前向传播的速度,使得模型的性能更加高效。

总之,train()模式主要用于训练神经网络,包括前向传播、反向传播和参数更新;eval()模式主要用于测试和验证神经网络,包括前向传播和模型预测。在实际使用中,通过在不同阶段使用不同的模式,可以更好地控制神经网络的行为,从而获得更好的训练和测试效果。

三、Batch Normalization

参考文献:《Batch Normalization: Accelerating Deep Network Training byReducing Internal Covariate Shift》

3.1 ICS现象(Internal Covariate Shift,内部协变量偏移)

BN的提出最开始是要解决ICS现象,那么什么是ICS现象呢?从下面这幅图理解,我们神经网络是累乘的形式,当中间的乘积出现增加或者减少的情况,会导致梯度爆炸或者梯度消失的现象。
在这里插入图片描述

ICS现象:输入数据分布变化,导致的模型训练困难,对深度神经网络影响极大

模型训练过程中,中间隐藏层每次训练输入神经元的数据分布发生变化,从而导致训练困难

内部协变量偏移(Internal Covariate Shift)是深度学习中一个常见的问题。它指的是在神经网络的训练过程中,网络的每一层输入分布的变化导致模型难以训练的情况。这种现象通常在深度神经网络的训练中出现,尤其是在使用批量归一化(Batch Normalization)等技术之前。

具体来说,神经网络的每一层在训练过程中都会接收前一层的输出作为输入,而这个输入的分布会随着网络参数的更新而变化。如果每一层的输入分布发生变化,那么每一层都需要不断适应新的分布,这会使得训练变得更加困难。

内部协变量偏移的影响包括:

  1. 训练收敛缓慢: 由于每一层都需要适应新的输入分布,模型的训练可能会收敛得相对较慢。
  2. 需要更小的学习率: 为了应对输入分布的变化,通常需要减小学习率,以确保模型的权重能够适应新的数据分布。
  3. 可能导致梯度爆炸或梯度消失: 输入分布的变化可能导致梯度在网络中传播时出现梯度爆炸或梯度消失的问题。

批量归一化是一种用于缓解内部协变量偏移的技术。它通过在每一层的输入上进行归一化,使得每层的输入分布保持稳定,有助于更快的训练收敛。

总体而言,理解和处理内部协变量偏移是深度学习中非常重要的一部分,以提高模型的训练效果和泛化能力。

3.2 BN原理

计算公式:
首先计算mini-batch的平均值,再计算方差,然进行normalize,完成0均值,1标准差,最后再进行affine transform缩放和位移;
在这里插入图片描述
:一批数据,通常为mini-batch
标准化:使得分布为 mean=0, std=1

例如:如 1, 2 ;mean=1.5, std=0.5, 变换得到-1, 1 一定有正有负,并且拉到0附近了

bn层计算原理:一个网络中有多个网络层,假设batch设置为2,此时对于两个网络中同一个网络层同一个位置的神经元进行bn计算,如下图:

并不是对同一个网络层中所有的神经元进行bn计算,而且按照下方红色方框中不同批次同一维度进行计算。
在这里插入图片描述

3.3 BN的优点

优点:

  1. 可以用更大学习率,加速模型收敛,如果学习率过大,会导致梯度的递增,从而导致模型无法训练,使用BN之后可以使用较大的学习率,从而加速学习率的收敛;
  2. 可以不用精心设计权值初始化:因为数据的尺度可能会逐渐的变大或者变小,从而导致梯度激增或者减小,使用BN可以规范我们的数据尺度;
  3. 可以不用dropout或较小的dropout:在实验过程中得到的结果;
  4. 可以不用L2或者较小的weight decay:实验所得;
  5. 可以不用LRN(local response normalization):对数据尺度进行规范

3.4 数据尺度实验

设置bn层的数据尺度变化:

class MLP(nn.Module):
    def __init__(self, neural_num, layers=100):
        super(MLP, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(neural_num, neural_num, bias=False) for i in range(layers)])
        self.bns = nn.ModuleList([nn.BatchNorm1d(neural_num) for i in range(layers)])
        self.neural_num = neural_num
    def forward(self, x):
        for (i, linear), bn in zip(enumerate(self.linears), self.bns):
            x = linear(x)
            x = bn(x)  # 设置bn
            x = torch.relu(x)
            if torch.isnan(x.std()):
                print("output is nan in {} layers".format(i))
                break
            print("layers:{}, std:{}".format(i, x.std().item()))
        return x

输出结果:
在这里插入图片描述

不设置bn层数据尺度,在forward中注释掉bn方法,数据尺度会随着网络层数增加,逐渐变小:
在这里插入图片描述
完整代码:

# -*- coding: utf-8 -*-

import torch
import numpy as np
import torch.nn as nn

import sys, os

hello_pytorch_DIR = os.path.abspath(os.path.dirname(__file__) + os.path.sep + ".." + os.path.sep + "..")
sys.path.append(hello_pytorch_DIR)

from tools.common_tools import set_seed

set_seed(1)  # 设置随机种子


class MLP(nn.Module):
    def __init__(self, neural_num, layers=100):
        super(MLP, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(neural_num, neural_num, bias=False) for i in range(layers)])
        self.bns = nn.ModuleList([nn.BatchNorm1d(neural_num) for i in range(layers)])
        self.neural_num = neural_num

    def forward(self, x):

        for (i, linear), bn in zip(enumerate(self.linears), self.bns):
            x = linear(x)
            # x = bn(x)  # 设置bn
            x = torch.relu(x)

            if torch.isnan(x.std()):
                print("output is nan in {} layers".format(i))
                break

            print("layers:{}, std:{}".format(i, x.std().item()))

        return x

    def initialize(self):
        for m in self.modules():
            if isinstance(m, nn.Linear):
                # method 1
                # nn.init.normal_(m.weight.data, std=1)    # normal: mean=0, std=1

                # method 2 kaiming
                nn.init.kaiming_normal_(m.weight.data)


neural_nums = 256
layer_nums = 100
batch_size = 16

net = MLP(neural_nums, layer_nums)
# net.initialize()

inputs = torch.randn((batch_size, neural_nums))  # normal: mean=0, std=1

output = net(inputs)
print(output)

3.5 实际模型训练

1、以人民币二分类实验为例
不设置权值初始化和BN层,会发现训练过程中损失波动很大:
在这里插入图片描述

2、设置权值初始化,不设置bn层,虽然也会有波动,但是最后依旧可以收敛。
在这里插入图片描述

3、设置BN层,不设置权值初始化,训练过程中损失波动非常小,并且可以收敛。
在这里插入图片描述

3.6 _BatchNorm

3.6.1 相关参数分析

在这里插入图片描述
• nn.BatchNorm1d
• nn.BatchNorm2d
• nn.BatchNorm3d
参数:
num_features:一个样本特征数量(最重要)
• eps:分母修正项,通常会设置一个非常小的数,避免分母为0;
• momentum:指数加权平均估计当前mean/var,通常设置为0.1;
• affine:是否需要affine transform,默认为True;
• track_running_stats:是训练状态,还是测试状态,训练状态的话均值和方差需要重新估计,测试状态则是采用当前的均值和方差;


主要属性:
• running_mean:均值
• running_var:方差
weight:affine transform中的gamma
bias: affine transform中的beta
在这里插入图片描述

注意:均值、方差采用指数加权平均计算得来,测试时候采用当前统计值;
running_mean = (1 - momentum) * pre_running_mean + momentum * mean_t
running_var = (1 - momentum) * pre_running_var + momentum * var_t
weight、bias是在模型训练过程中计算出来的,会发生变化;

3.6.2 1d、2d、3d特征区别

在这里插入图片描述

1d:输出输入形式是batch_sizex特征数x特征维度=3x5x1
2d:输入形式是3x3x(2x2),一个特征图的shape是2x2
3d:输入形式是3x3x(2x2x3)
我们计算均值和方差都是在不同batch同一维度上进行计算,也就是红色虚线框当中的所有数据。

3.6.3 1d代码实现

flag = 1
# flag = 0
if flag:

    batch_size = 3  # 批大小
    num_features = 5  # 特征数量
    momentum = 0.3  # 动量

    features_shape = (1)  # 一个黄色框,表示一个特征图

    feature_map = torch.ones(features_shape)  # 1D
    feature_maps = torch.stack([feature_map * (i + 1) for i in range(num_features)], dim=0)  # 2D
    feature_maps_bs = torch.stack([feature_maps for i in range(batch_size)], dim=0)  # 3D
    print("input data:\n{} shape is {}".format(feature_maps_bs, feature_maps_bs.shape))  # 打印输入数据及其形状

    bn = nn.BatchNorm1d(num_features=num_features, momentum=momentum)  # 创建BatchNorm1d层对象

    running_mean, running_var = 0, 1  # 运行时均值和方差初始化

    for i in range(2):  # 循环迭代两次
        outputs = bn(feature_maps_bs)  # BatchNorm1d前向传播

        print("\niteration:{}, running mean: {} ".format(i, bn.running_mean))  # 打印运行时均值
        print("iteration:{}, running var:{} ".format(i, bn.running_var))  # 打印运行时方差

        mean_t, var_t = 2, 0  # 设定均值和方差

        running_mean = (1 - momentum) * running_mean + momentum * mean_t  # 更新运行时均值
        running_var = (1 - momentum) * running_var + momentum * var_t  # 更新运行时方差

        print("iteration:{}, 第二个特征的running mean: {} ".format(i, running_mean))  # 打印更新后的运行时均值
        print("iteration:{}, 第二个特征的running var:{}".format(i, running_var))  # 打印更新后的运行时方差

输出结果:
在这里插入图片描述
分析
我们第一个维度所有特征都为1,按照正常计算方法应该均值为1,但是为什么计算会得到0.3,因为我们加了一个momentum动量,我们看一下running_mean计算公式如下,running_mean等于当前的均值x动量+上一层均值x(1-动量),因为上一层没有数据,所以均值设置为0,所以running_mean=0.3x1=0.3;
在这里插入图片描述

3.6.4 2d代码实现

# ======================================== nn.BatchNorm2d
flag = 1
# flag = 0
if flag:

    batch_size = 3  # 批大小
    num_features = 3  # 特征数量
    momentum = 0.3  # 动量

    features_shape = (2, 2)  # 特征图形状

    feature_map = torch.ones(features_shape)  # 2D
    feature_maps = torch.stack([feature_map * (i + 1) for i in range(num_features)], dim=0)  # 3D
    feature_maps_bs = torch.stack([feature_maps for i in range(batch_size)], dim=0)  # 4D

    print("input data:\n{} shape is {}".format(feature_maps_bs, feature_maps_bs.shape))  # 打印输入数据及其形状

    bn = nn.BatchNorm2d(num_features=num_features, momentum=momentum)  # 创建BatchNorm2d层对象

    running_mean, running_var = 0, 1  # 运行时均值和方差初始化

    for i in range(2):  # 循环迭代两次
        outputs = bn(feature_maps_bs)  # BatchNorm2d前向传播

        print("\niter:{}, running_mean.shape: {}".format(i, bn.running_mean.shape))  # 打印运行时均值的形状
        print("iter:{}, running_var.shape: {}".format(i, bn.running_var.shape))  # 打印运行时方差的形状

        print("iter:{}, weight.shape: {}".format(i, bn.weight.shape))  # 打印权重的形状
        print("iter:{}, bias.shape: {}".format(i, bn.bias.shape))  # 打印偏置的形状

输出结果:
在这里插入图片描述


在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/322771.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

本地搭建Oracle数据库结合内网穿透实现公网环境远程访问

最近&#xff0c;我发现了一个超级强大的人工智能学习网站。它以通俗易懂的方式呈现复杂的概念&#xff0c;而且内容风趣幽默。我觉得它对大家可能会有所帮助&#xff0c;所以我在此分享。点击这里跳转到网站。 文章目录 前言1. 数据库搭建2. 内网穿透2.1 安装cpolar内网穿透2…

解决:ModuleNotFoundError: No module named ‘pymysql’

解决&#xff1a;ModuleNotFoundError: No module named ‘pymysql’ 文章目录 解决&#xff1a;ModuleNotFoundError: No module named pymysql背景报错问题报错翻译报错位置代码报错原因解决方法方法一&#xff0c;直接安装方法二&#xff0c;手动下载安装方法三&#xff0c;…

国图公考:2024山东省事业单位发布招聘公告

更多信息可以登录山东人事考试信息查看&#xff01;

134基于matlab的时间序列预测

基于matlab的时间序列预测&#xff0c;包括最小二乘支持向量机和粒子群优化支持向量机及改进的粒子群优化支持向量机。输出测试结果&#xff0c;具有GUI可视化界面。程序已调通&#xff0c;可直接运行。 134matlab时间序列预测粒子群优化 (xiaohongshu.com)

Transformer原理与代码实现

Transformer原理与代码实现 概览 一、嵌入层 Embedding 二、位置编码 Positional Encoding 三、&#xff08;整合&#xff09;Transformer嵌入层 Transformer Embedding 四、带缩放的点积注意力机制 Scaled Dot-Product Attention 五、多头注意力 Multi-Head Attention 六…

基于ssm的社区流浪动物救助领养系统的设计与开发+vue论文

摘 要 传统信息的管理大部分依赖于管理人员的手工登记与管理&#xff0c;然而&#xff0c;随着近些年信息技术的迅猛发展&#xff0c;让许多比较老套的信息管理模式进行了更新迭代&#xff0c;流浪动物信息因为其管理内容繁杂&#xff0c;管理数量繁多导致手工进行处理不能满足…

JavaScript SEO:如何为搜索引擎优化 JS

什么是 JavaScript SEO&#xff1f; JavaScript SEO 是技术 SEO 的一部分&#xff0c;其重点是使使用 JavaScript 构建的网站更容易被搜索引擎抓取、呈现和索引。 常见任务包括以下内容&#xff1a; 优化通过 JavaScript 注入的内容正确实施懒加载遵循内部链接最佳实践预防、…

国图公考:2024年度国考笔试成绩、合格分数线已出

中央机关及其直属机构2024年度考试录用公务员笔试成绩和合格分数线公布&#xff0c;考生可于即日起登录“中央机关及其直属机构2024年度考试录用公务员专题网站”查询。 按照笔试成绩从高到低的顺序&#xff0c;进面人员名单也已经公布。 如果没有进面也可以报考调剂&#xf…

探索自动化测试断言:提升测试效率与质量的关键!

前言 断言在自动化测试中起着关键的作用&#xff0c;它是验证测试结果是否符合预期的重要手段。如果在自动化测试过程中忽视了断言&#xff0c;那么这个测试就失去了其本质的意义&#xff0c;因为我们无法得知测试结果是否达到了预期的效果。因此&#xff0c;断言在自动化测试…

完美解决idea一直indexing,无法操作的问题

今天主要分享一下在使用idea 2020.3版本开发maven项目的时候&#xff0c;一直出现有效件index&#xff0c; 有时候是scaning indexing, 有时候是update indexing, indexing的时候&#xff0c;idea基本上就没办法操作了&#xff0c;连跳入到类或方法里都跳不了。不厌其烦。 于是…

导出功能开发

1.导出功能&#xff08;仅表头&#xff09; package nc.ui.yhlypx.yhlypxfkd.ace.action;import java.awt.event.ActionEvent; import java.io.FileOutputStream; import java.util.ArrayList; import java.util.List;import nc.ui.pubapp.uif2app.model.BillManageModel; imp…

keycloak部署

https://downloads.jboss.org/keycloak/11.0.2/keycloak-11.0.2.zip 1.上传zip 并解压 uzip keycloak-11.0.2.zip 2.创建mysql数据库 CREATE SCHEMA keycloak DEFAULT CHARACTER SET utf8 ; 3.安装mysql的jdbc驱动 下载mysql的JDBC驱动&#xff08;mysql-connector-java-8…

代码随想录 Leetcode15. 三数之和

题目&#xff1a; 代码(首刷看解析 2024年1月15日&#xff09;&#xff1a; class Solution { public:vector<vector<int>> threeSum(vector<int>& nums) {vector<vector<int>> res;int n nums.size();sort(nums.begin(),nums.end());for(…

如何在 Ubuntu 22.04 上使用 LEMP 安装 WordPress

前些天发现了一个人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;最重要的屌图甚多&#xff0c;忍不住分享一下给大家。点击跳转到网站。 如何在 Ubuntu 22.04 上使用 LEMP 安装 WordPress 介绍 WordPress 是互联网上最流行的内容管理系统 (CMS) 之一…

清华裴丹|大模型时代的AIOps

在大模型时代下&#xff0c;运维界普遍关注一些问题&#xff1a;大模型能带来哪些收益&#xff1f;面临哪些技术挑战&#xff1f;与以往的 AIOps小模型是什么关系&#xff1f;有了大模型之后&#xff0c;那么AIOps的整体框架是什么&#xff1f;近期、中期、长期有哪些应用&…

基于ssm的线上旅游体验系统+vue论文

目 录 目 录 I 摘 要 III ABSTRACT IV 1 绪论 1 1.1 课题背景 1 1.2 研究现状 1 1.3 研究内容 2 2 系统开发环境 3 2.1 vue技术 3 2.2 JAVA技术 3 2.3 MYSQL数据库 3 2.4 B/S结构 4 2.5 SSM框架技术 4 3 系统分析 5 3.1 可行性分析 5 3.1.1 技术可行性 5 3.1.2 操作可行性 5 3…

工程项目管理系统源码与Spring Cloud:实现高效系统管理与二次开发

随着企业规模的不断扩大和业务的快速发展&#xff0c;传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性&#xff0c;企业需要借助先进的数字化技术进行转型。本文将介绍一款采用Spring CloudSpring BootMybat…

java基础之线程知识点

线程 进程的概念 操作系统(OS)中并发(同时)执行的多个程序任务 进程的特点 宏观并行,微观串行 在一个时间段内,CPU会将时间段划分为若干个时间片,一个时间片是能被一个程序拥有,且只有拥有时间片的程序才能执行自身内容,所以当时间片的划分足够细小,交替频率足够快,就会形…

9 - 数据分片概述|部署MyCat服务

数据分片概述&#xff5c;部署MyCat服务&#xff5c;测试配置 数据分片概述分库分表分割方式水平分割&#xff08;横向切分&#xff09;垂直分割&#xff08;纵向切分&#xff09; 提供分库分表存储服务软件&#xff08;中间件&#xff09;MyCAT软件分片服务器的工作过程 部署M…

[Kubernetes]10. k8s部署Goweb+mysql项目实战演练

一.安装docker构建镜像 如果要本地构建镜像的话,对应节点还需要安装docker,安装教程见:[Docker]一.Docker 简介与安装 linux环境,centos8下 docker及docker compose安装教程 k8s部署Goweb+mysql项目有两种方法:第一种是传统部署方法,第二种是通过ConfigMap实现应用配置分离部署…