模型的权值平均的原理和Pytorch的实现

这篇具有很好参考价值的文章主要介绍了模型的权值平均的原理和Pytorch的实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、前言

模型权值平均是一种用于改善深度神经网络泛化性能的技术。通过对训练过程中不同时间步的模型权值进行平均,可以得到更宽的极值点(optima)并提高模型的泛化能力。 在PyTorch中,官方提供了实现模型权值平均的方法。

这里我们首先介绍指数移动平均(EMA)方法,它使用一个衰减系数来平衡当前权值和先前平均权值。其次,介绍了随机加权平均(SWA)方法,它通过将当前权值与先前平均权值进行加权平均来更新权值。最后,介绍了Tanh自适应指数移动EMA算法(T_ADEMA),它使用Tanh函数来调整衰减系数,以更好地适应训练过程中的不同阶段。

为了方便使用这些权值平均方法,我将官方的代码写成了一个基类AveragingBaseModel,以此引出EMAModel、SWAModel和T_ADEMAModel等方法。这些类可以用于包装原始模型,并在训练过程中更新平均权值。 为了验证这些权值平均方法的效果,我还在ResNet18模型上进行了简单的实验。实验结果表明,使用权值平均方法可以提高模型的准确率,尤其是在训练后期。

但请注意,博客中所提供的代码示例仅用于演示权值平均的原理和PyTorch的实现方式,并不能保证在所有情况下都能取得理想的效果。实际应用中,还需要根据具体任务和数据集来选择适合的权值平均方法和参数设置。

二、算法介绍

基类实现

这里我们的基类完全是参照于torch源码部分,仅仅进行了一点细微的修改。

它首先通过de_parallel函数将原始模型转换为单个GPU模型。de_parallel函数用于处理并行模型,将其转换为单个GPU模型。然后,它将转换后的模型复制到适当的设备(CPU或GPU)上(这一步很重要,问题大多数就是因为计算不匹配),并注册一个名为n_averaged的缓冲区,用于跟踪已平均的次数。

在forward方法中,它简单地将调用传递给转换后的模型。update方法首先获取当前模型和新模型的参数,并将它们转换为可迭代对象,用于更新平均权值。它接受一个新的模型作为参数,并将其与当前模型(已平均的权值)进行比较。

from copy import deepcopy
from pyzjr.core.general import is_parallel
import itertools
from torch.nn import Module

def de_parallel(model):
    """
    将并行模型(DataParallel 或 DistributedDataParallel)转换为单 GPU 模型。
    """
    return model.module if is_parallel(model) else model

class AveragingBaseModel(Module):
    def __init__(self, model, cuda=False, avg_fn=None, use_buffers=False):
        super(AveragingBaseModel, self).__init__()
        device = 'cuda' if cuda and torch.cuda.is_available() else 'cpu'
        self.module = deepcopy(de_parallel(model))
        self.module = self.module.to(device)
        self.register_buffer('n_averaged',
                             torch.tensor(0, dtype=torch.long, device=device))
        self.avg_fn = avg_fn
        self.use_buffers = use_buffers

    def forward(self, *args, **kwargs):
        return self.module(*args, **kwargs)

    def update(self, model):
        self_param = itertools.chain(self.module.parameters(), self.module.buffers() if self.use_buffers else [])
        model_param = itertools.chain(model.parameters(), model.buffers() if self.use_buffers else [])

        self_param_detached = [p.detach() for p in self_param]
        model_param_detached = [p.detach().to(p_averaged.device) for p, p_averaged in zip(model_param, self_param_detached)]

        if self.n_averaged == 0:
            for p_averaged, p_model in zip(self_param_detached, model_param_detached):
                p_averaged.copy_(p_model)

        if self.n_averaged > 0:
            for p_averaged, p_model in zip(self_param_detached, model_param_detached):
                n_averaged = self.n_averaged.to(p_averaged.device)
                p_averaged.copy_(self.avg_fn(p_averaged, p_model, n_averaged))

        if not self.use_buffers:
            for b_swa, b_model in zip(self.module.buffers(), model.buffers()):
                b_swa.copy_(b_model.to(b_swa.device).detach())

        self.n_averaged += 1

若当前模型尚未进行过平均(即n_averaged为0),则直接将新模型的参数复制到当前模型中。若当前模型已经进行过平均,则通过avg_fn函数计算当前模型和新模型的加权平均,并将结果复制到当前模型中。如果use_buffers为True,则会将缓冲区从新模型复制到当前模型。最后,n_averaged增加1,表示已进行一次平均。

指数移动平均(EMA)

EMA被用于根据当前参数和之前的平均参数来更新平均参数。其计算公式如下所示:

模型的权值平均的原理和Pytorch的实现,Pytorch学习及实战,pytorch复现,pytorch,人工智能,python

这里的EMA param是当前的平均参数,current param是当前的参数,decay是一个介于0和1之间的衰减因子,它用于控制当前参数对平均参数的贡献程度。decay越接近1,平均参数对当前参数的影响就越小,反之亦是。

def get_ema_avg_fn(decay=0.999):
    @torch.no_grad()
    def ema_update(ema_param, current_param, num_averaged):
        return decay * ema_param + (1 - decay) * current_param
    return ema_update

class EMAModel(AveragingBaseModel):
    def __init__(self, model, cuda = False, decay=0.9, use_buffers=False):
        super().__init__(model=model, cuda=cuda, avg_fn=get_ema_avg_fn(decay), use_buffers=use_buffers)

随机加权平均(SWA)

SWA通过对神经网络的权重进行平均来改善模型的泛化能力。其计算公式如下所示:

模型的权值平均的原理和Pytorch的实现,Pytorch学习及实战,pytorch复现,pytorch,人工智能,python

SWA param是新的平均参数,averaged param是之前的平均参数,current param是当前的参数,num avg是已经平均的参数数量。

def get_swa_avg_fn():
    @torch.no_grad()
    def swa_update(averaged_param, current_param, num_averaged):
        return averaged_param + (current_param - averaged_param) / (num_averaged + 1)
    return swa_update

class SWAModel(AveragingBaseModel):
    def __init__(self, model, cuda = False,use_buffers=False):
        super().__init__(model=model, cuda=cuda, avg_fn=get_swa_avg_fn(), use_buffers=use_buffers)

Tanh自适应指数移动EMA算法(T_ADEMA)

这一个是在查询资料的时候,找到的一篇论文描述的,是否有效,还得经过实验才对。

全文阅读--XML全文阅读--中国知网 (cnki.net)

论文表示是为了在神经网络训练过程中根据不同的训练阶段更有效地过滤噪声,所提出的公式:

模型的权值平均的原理和Pytorch的实现,Pytorch学习及实战,pytorch复现,pytorch,人工智能,python

T_ADEMA param是新的平均参数,avg param是之前的平均参数,current param是当前的参数,num avg是已经平均的参数数量。alpha是一个控制衰减速率的超参数。通过将参数数量作为输入传递给切线函数的参数,动态地计算衰减因子。切线函数(tanh)的输出范围为[-1, 1],随着参数数量的增加,衰减因子会逐渐趋近于1。由于切线函数的特性,当参数数量较小时,衰减因子接近于0;当参数数量较大时,衰减因子接近于1。

def get_t_adema(alpha=0.9):
    num_averaged = [0]  # 使用列表包装可变对象,以在闭包中引用
    @torch.no_grad()
    def t_adema_update(averaged_param, current_param, num_averageds):
        num_averaged[0] += 1
        decay = alpha * torch.tanh(torch.tensor(num_averaged[0], dtype=torch.float32))
        tadea_update = decay * averaged_param + (1 - decay) * current_param
        return tadea_update
    return t_adema_update

class T_ADEMAModel(AveragingBaseModel):
    def __init__(self, model, cuda=False, alpha=0.9, use_buffers=False):
        super().__init__(model=model, cuda=cuda, avg_fn=get_t_adema(alpha), use_buffers=use_buffers)

三、构建一个简单的实验测试

这一部分我正在做实验,下面是调用了一个简单的resnet18网络,看看逻辑上面是否有错。

if __name__=="__main__":
    # 创建 ResNet18 模型
    import torch
    import torchvision.models as models
    from torch.utils.data import DataLoader
    from tqdm import tqdm
    from torch.optim.swa_utils import AveragedModel

    class RandomDataset(torch.utils.data.Dataset):
        def __init__(self, size=224):
            self.data = torch.randn(size, 3, 224, 224)
            self.labels = torch.randint(0, 2, (size,))

        def __getitem__(self, index):
            return self.data[index], self.labels[index]

        def __len__(self):
            return len(self.data)


    model = models.resnet18(pretrained=False)
    # model = model.to('cuda')
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    criterion = torch.nn.CrossEntropyLoss()

    # 创建数据加载器
    train_dataset = RandomDataset()
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

    # 定义权重平均模型
    swa_model = SWAModel(model, cuda=True)
    ema_model = EMAModel(model, cuda=True)
    t_adema_model = T_ADEMAModel(model, cuda=True)

    for epoch in range(5):
        for inputs, labels in tqdm(train_loader, desc=f"Epoch {epoch + 1}/{5}"):
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            # 更新权重平均模型
            ema_model.update(model)
            swa_model.update(model)
            t_adema_model.update(model)

    # 测试模型
    test_dataset = RandomDataset(size=100)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)


    def evaluate(model):
        model.eval()  # 切换到评估模式
        correct = 0
        total = 0

        with torch.no_grad():
            for inputs, labels in test_loader:
                inputs, labels = inputs.to('cuda'), labels.to('cuda')
                outputs = model(inputs)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

        accuracy = correct / total
        print(f"模型准确率:{accuracy * 100:.2f}%")

    # 原模型测试
    print("Model Evaluation:")
    evaluate(model.to('cuda'))   #
    # 测试权重平均模型
    print("SWAModel Evaluation:")
    evaluate(swa_model.to('cuda'))

    print("EMAModel Evaluation:")
    evaluate(ema_model.to('cuda'))

    print("T-ADEMAModel Evaluation:")
    evaluate(t_adema_model.to('cuda'))

运行效果:

Model Evaluation:
模型准确率:46.00%
SWAModel Evaluation:
模型准确率:54.00%
EMAModel Evaluation:
模型准确率:58.00%
T - ADEMAModel Evaluation:
模型准确率:58.00%

仅仅是测试是否能够跑通,过程中也有比原模型要低的时候,而且权值平均主要是用于训练中后期,所以有没有效果应该需要自己去做实验。

当前你可以下载pip install pyzjr==1.2.9,调用from pyzjr.nn import EMAModel运行。文章来源地址https://www.toymoban.com/news/detail-808874.html

到了这里,关于模型的权值平均的原理和Pytorch的实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • PyTorch深度学习实战(1)——神经网络与模型训练过程详解

    人工神经网络 ( Artificial Neural Network , ANN ) 是一种监督学习算法,其灵感来自人类大脑的运作方式。类似于人脑中神经元连接和激活的方式,神经网络接受输入,通过某些函数在网络中进行传递,导致某些后续神经元被激活,从而产生输出。函数越复杂,网络对于输入的数据拟

    2024年02月06日
    浏览(47)
  • PyTorch深度学习实战 | 基于多层感知机模型和随机森林模型的某地房价预测

    简介: 在现实生活中,除了分类问题外,也存在很多需要预测出具体值的回归问题,例如年龄预测、房价预测、股价预测等。相比分类问题而言,回归问题输出类型为一个连续值,如下表所示为两者的区别。在本文中,将完成房价预测这一回归问题。 ■ 分类问题与回归问题

    2023年04月12日
    浏览(49)
  • pytorch实战-图像分类(二)(模型训练及验证)(基于迁移学习(理解+代码))

    目录 1.迁移学习概念 2.数据预处理  3.训练模型(基于迁移学习) 3.1选择网络,这里用resnet 3.2如果用GPU训练,需要加入以下代码 3.3卷积层冻结模块 3.4加载resnet152模 3.5解释initialize_model函数 3.6迁移学习网络搭建 3.7优化器 3.8训练模块(可以理解为主函数) 3.9开始训练 3.10微调

    2024年02月14日
    浏览(46)
  • 时间序列预测模型实战案例(四)(Xgboost)(Python)(机器学习)图解机制原理实现时间序列预测和分类(附一键运行代码资源下载和代码讲解)

    目录图解机制原理 简介 Xgboost预测精度 实验一(回归) 实验二(分类) Xgboost的数学机制原理 图解Xgboost运行机制原理  决策树 决策树结构图 Xgboost Xgboost的机制原理 贪心算法 Xgboost总结 数据格式需求 Xgboost运行代码 Xgboost时间序列预测及代码 Xgboost分类任务及代码 Xgboost运行资源下

    2024年02月03日
    浏览(77)
  • Python 基于pytorch从头写GPT模型;实现gpt实战

            GPT(Generative Pre-trained Transformer)模型是一种基于Transformer架构的生成式预训练模型,由OpenAI开发。它采用了无监督学习的方式进行预训练,然后通过微调适应特定的任务。GPT模型的结构由多层Transformer解码器组成,每个解码器由多头自注意力机制和前馈神经网络组

    2024年01月23日
    浏览(42)
  • 机器学习:逻辑回归模型算法原理(附案例实战)

    作者:i阿极 作者简介:Python领域新星作者、多项比赛获奖者:博主个人首页 😊😊😊如果觉得文章不错或能帮助到你学习,可以点赞👍收藏📁评论📒+关注哦!👍👍👍 📜📜📜如果有小伙伴需要数据集和学习交流,文章下方有交流学习区!一起学习进步!💪 订阅专栏案

    2024年01月20日
    浏览(46)
  • 全局平均池化/全局最大池化Pytorch实现:

    普通池化方法汇总详见:https://blog.csdn.net/qq_43665602/article/details/126625116 全局池化与普通池化的区别在于“局部区域”和“全局”:普通池化根据滑动窗口以及步长以逐步计算局部区域的方式进行;而全局池化是分别对每个通道的所有元素进行计算,谓之全局池化。 全局池化方

    2023年04月08日
    浏览(34)
  • 深度学习实战24-人工智能(Pytorch)搭建transformer模型,真正跑通transformer模型,深刻了解transformer的架构

    大家好,我是微学AI,今天给大家讲述一下人工智能(Pytorch)搭建transformer模型,手动搭建transformer模型,我们知道transformer模型是相对复杂的模型,它是一种利用自注意力机制进行序列建模的深度学习模型。相较于 RNN 和 CNN,transformer 模型更高效、更容易并行化,广泛应用于神

    2023年04月22日
    浏览(58)
  • 【PyTorch 实战2:UNet 分割模型】10min揭秘 UNet 分割网络如何工作以及pytorch代码实现(详细代码实现)

      U-Net,自2015年诞生以来,便以其卓越的性能在生物医学图像分割领域崭露头角。作为FCN的一种变体,U-Net凭借其Encoder-Decoder的精巧结构,不仅在医学图像分析中大放异彩,更在卫星图像分割、工业瑕疵检测等多个领域展现出强大的应用能力。UNet是一种常用于图像分割的卷

    2024年04月28日
    浏览(40)
  • Python基于PyTorch实现循环神经网络回归模型(LSTM回归算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 LSTM网络是目前更加通用的循环神经网络结构,全称为Long Short-Term Memory,翻译成中文叫作“长‘短记忆’”网络。读的时候,“长”后面要稍

    2024年02月16日
    浏览(54)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包