精华内容
下载资源
问答
  • 查看optimizer的参数 当然,查看优化器的参数时,除了使用查看模型参数的方法四,还有以下这种方式。 #打印optimizer的参数 print("optimizer.param_groups的长度:{}".format(len(optimizer.param_groups))) for ...

    准备工作

    import torch.optim as optim
    import torch
    import torchvision.models as models
    device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model=models.resnet50(pretrained=False).to(device)
    optimizer=optim.Adam(model.parameters(),0.01)
    scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[3, 6, 10, 15, 21], gamma=1/3.)
    
    #--------------------------------
    
    

    查看模型的参数

    方法一

    通过torchsummary这个包,首先安装这个包,

    pip install torchsummary
    

    然后

    from torchsummary import summary
    summary(model,input_size=(3,416,416))
    

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

    方法二

    使用model.named_parameters()

    sum=0
    for name,param in model.named_parameters():
        num=1
        for size in param.shape:
            num *= size
        sum+=num
        print("{:30s} : {}".format(name,param.shape))    
    print("total param num {}".format(sum))
    

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

    方法三

    直接使用model.parameters(),但是这样看不见参数名。

    for param in model.parameters():
        print(param.shape)
    

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

    方法四

    利用state_dict,state_dict以字典的方式保持了模型的参数名称和参数,通过遍历可以获取所有的参数。

    for name in model.state_dict():
        print("{:30s}:{}".format(name,model.state_dict()[name].shape))
    

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

    pytorch中带有参数的不止有model,还有optimizer和lr_scheduler,因此它们都有一个共同的属性state_dict,所以要想查看他们的参数名称,这个方法是通用的。

    查看optimizer的参数

    当然,查看优化器的参数时,除了使用查看模型参数的方法四,还有以下这种方式。

    #打印optimizer的参数
    print("optimizer.param_groups的长度:{}".format(len(optimizer.param_groups)))
    for param_group in optimizer.param_groups:
        print(param_group.keys())
        print([type(value) for value in param_group.values()])
        print('查看学习率: ',param_group['lr'])
    

    结果:

    optimizer.param_groups的长度:1
    dict_keys(['params', 'lr', 'betas', 'eps', 'weight_decay', 'amsgrad', 'initial_lr'])
    [<class 'list'>, <class 'float'>, <class 'tuple'>, <class 'float'>, <class 'int'>, <class 'bool'>, <class 'float'>]
    查看学习率:  0.01
    

    冻结训练

    可以选择性的冻结模型的某些层。

    for layer in list(model.parameters())[:2]:
        layer.requires_grad=False
    

    关于,冻结训练,可以看我这篇文章

    展开全文
  • pytorch 打印模型参数

    千次阅读 2019-10-20 10:21:53
    pytorch 打印模型参数值 对于简单的网络 例如全连接层Linear 可以使用以下方法打印linear层: fc = nn.Linear(3, 5) params = list(fc.named_parameters()) print(params.__len__()) print(params[0]) print...

    pytorch 打印模型的参数值

    对于简单的网络

    例如全连接层Linear

    可以使用以下方法打印linear层:

    fc = nn.Linear(3, 5)
    params = list(fc.named_parameters())
    print(params.__len__())
    print(params[0])
    print(params[1])
    

    输出如下:
    在这里插入图片描述

    由于Linear默认是偏置bias的,所有参数列表的长度是2。第一个存的是全连接矩阵,第二个存的是偏置。

    对于稍微复杂的网络

    例如MLP

    mlp = nn.Sequential(
                nn.Dropout(p=0.3),
                nn.Linear(1024, 256),
                nn.Linear(256, 64),
                nn.Linear(64, 16),
                nn.Linear(16, 1)
            )
    params = list(mlp.named_parameters())
    print(params.__len__())
    
    print(params[0])
    print(params[1])
    
    print(params[2])
    print(params[3])
    

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

    在这里插入图片描述

    可以发现,堆叠起来的网络,参数是依次放置的。先是全连接的权重,然后偏置。然后是下一层网络的权重+偏置。依次进行下去。

    这里有4层fc,4*2=8.所以一共有8个参数矩阵。

    展开全文
  • pytorch计算模型参数

    千次阅读 2019-10-11 15:04:17
    pytorch计算模型参数量: count_params(model) def count_params(model, input_size=224): # param_sum = 0 with open('models.txt', 'w') as fm: fm.write(str(model)) calc_flops(model, in...

    1. 安装 thop
    1.1 常规安装
    pip install thop

    1.2 若上述安装方式错误,可以参考以下方式:
    pip install thop-i http://pypi.douban.com/simple --trusted-host pypi.douban.com

    参考:https://editor.csdn.net/md/?articleId=1064660472. 使用thop计算参数量和计算量
     

    from nets.yolo4 import YoloBody  ## 导入模型
    from thop import profile         ## 导入thop模块
    
    model = YoloBody(3,20)
    input = torch.randn(1, 3, 416, 416)
    flops, params = profile(model, inputs=(input,))
    print('flops',flops)            ## 打印计算量
    print('params',params)            ## 打印参数量


    原文链接:https://blog.csdn.net/weixin_44239195/article/details/110390705

     

    统计张量元素个数:

    import torch
     
    a = torch.randn(1, 2, 3, 4)
    b = a.numel()
    print(type(b)) # int
    print(b) # 24

    pytorch计算模型参数量: 

    count_params(model)

     

    def count_params(model, input_size=224):
        # param_sum = 0
        with open('models.txt', 'w') as fm:
            fm.write(str(model))
        calc_flops(model, input_size)
    
        model_parameters = filter(lambda p: p.requires_grad, model.parameters())
        params = sum([np.prod(p.size()) for p in model_parameters])
    
        print('The network has {} params.'.format(params))
    
    
    import torch
    from torch.autograd.variable import Variable
    import numpy as np
    
    
    USE_GPU = torch.cuda.is_available()
    
    
    def calc_flops(model, input_size):
        global USE_GPU
    
        def conv_hook(self, input, output):
            batch_size, input_channels, input_height, input_width = input[0].size()
            output_channels, output_height, output_width = output[0].size()
    
            kernel_ops = self.kernel_size[0] * self.kernel_size[1] * (self.in_channels / self.groups) * (
                2 if multiply_adds else 1)
            bias_ops = 1 if self.bias is not None else 0
    
            params = output_channels * (kernel_ops + bias_ops)
            flops = batch_size * params * output_height * output_width
    
            list_conv.append(flops)
    
        def linear_hook(self, input, output):
            batch_size = input[0].size(0) if input[0].dim() == 2 else 1
    
            weight_ops = self.weight.nelement() * (2 if multiply_adds else 1)
            bias_ops = self.bias.nelement()
    
            flops = batch_size * (weight_ops + bias_ops)
            list_linear.append(flops)
    
        def bn_hook(self, input, output):
            list_bn.append(input[0].nelement())
    
        def relu_hook(self, input, output):
            list_relu.append(input[0].nelement())
    
        def pooling_hook(self, input, output):
            batch_size, input_channels, input_height, input_width = input[0].size()
            output_channels, output_height, output_width = output[0].size()
    
            kernel_ops = self.kernel_size * self.kernel_size
            bias_ops = 0
            params = output_channels * (kernel_ops + bias_ops)
            flops = batch_size * params * output_height * output_width
    
            list_pooling.append(flops)
    
        def foo(net):
            childrens = list(net.children())
            if not childrens:
                if isinstance(net, torch.nn.Conv2d):
                    net.register_forward_hook(conv_hook)
                if isinstance(net, torch.nn.Linear):
                    net.register_forward_hook(linear_hook)
                if isinstance(net, torch.nn.BatchNorm2d):
                    net.register_forward_hook(bn_hook)
                if isinstance(net, torch.nn.ReLU):
                    net.register_forward_hook(relu_hook)
                if isinstance(net, torch.nn.MaxPool2d) or isinstance(net, torch.nn.AvgPool2d):
                    net.register_forward_hook(pooling_hook)
                return
            for c in childrens:
                foo(c)
    
        multiply_adds = False
        list_conv, list_bn, list_relu, list_linear, list_pooling = [], [], [], [], []
        foo(model)
        if '0.4.' in torch.__version__:
            if USE_GPU:
                input = torch.cuda.FloatTensor(torch.rand(2, 3, input_size, input_size).cuda())
            else:
                input = torch.FloatTensor(torch.rand(2, 3, input_size, input_size))
        else:
            input = Variable(torch.rand(2, 3, input_size, input_size), requires_grad=True)
        _ = model(input)
    
        total_flops = (sum(list_conv) + sum(list_linear) + sum(list_bn) + sum(list_relu) + sum(list_pooling))
    
        print('  + Number of FLOPs: %.2fM' % (total_flops / 1e6 / 2))
    
    
    
    
    

     

      model_path="mf_pele.pth"
        torch.save(net.state_dict(),model_path)
        # input = torch.Tensor(2, 3, 112, 112)
        # net = ResNet_SEIR()  # 100,ir/se_ir
    
        # print(net)
        net.eval()
    
        fsize = os.path.getsize(model_path)
        fsize = fsize / float(1024 * 1024)
    
        print(f"model size {round(fsize, 2)} m")
    
        count = 0
        for parameter in net.parameters():
            count += parameter.numel()
        print('net has {} parameters'.format(count))
        print('net size ~ {}M'.format(count * 4 / 1024 / 1024))

     

    展开全文
  • pytorch 查看模型参数

    2020-10-28 08:39:02
    对于模型model,可以使用下面的方式打印模型参数: for name, param in model.named_parameters(): print(name, ' ', param.size())

    对于模型model,可以使用下面的方式打印模型参数:

    for name, param in model.named_parameters():
    	print(name, '      ', param.size())
    
    展开全文
  • pytorch打印模型

    千次阅读 2020-12-19 22:17:46
    参考链接pytorch详解nn.Module类,children和modules方法区别       1、print(model) import torch class MyNet(torch.nn.Module): def __init__(self): # 必须调用父类的构造函数,因为想要使用父类的方法...
  • 到时候把dict的item换成你所用模型的 print(model) total_params = sum(p.numel() for p in model.parameters()) print(f'{total_params:,} total parameters.') _dict = {} _dict['encoder'] = 0 _dict['...
  • pytorch保存模型参数

    2021-03-19 23:02:02
    1、代码 有保存路径 PATH='my_model.pth' ...加载已经训练好的模型参数 new_model.load_state_dict(torch.load(PATH)) 打印准确率 test_correct=0 test_total=0 new_model.eval() with torch.no_grad():
  • 查看模型参数(以AlexNet为例) import torch import torch.nn as nn import torchvision class AlexNet(nn.Module): def __init__(self,num_classes=1000): super(AlexNet,self).__init__() self.feature...
  • 计算这两个值之前要进行模型加载,模型加载的方法见...方法1:pytorch自带方法,计算模型参数总量 total = sum([param.nelement() for param in model.parameters()]) p...
  • 参数结构打印 TensorFlow1.12的打印结构: for var in tf.trainable_variables(): print("Listing trainable variables ... ") print(var) TensorFlow1.12的打印参数: import tensorflow as tf reader = ...
  • 最近在研究HRank的论文和代码,发现里面的模型结构化剪枝后,模型大小没有变小,打印最终训练完后的网络模型中的参数,发现它只是把一些channel的参数全部稀疏化为0,并没有把channel的个数裁剪下来。 于是想自己...
  • 今天小编就为大家分享一篇pytorch 实现打印模型参数值,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 3、模型参数量统计打印 简单方法 详细输出(以AlexNet为例) 第三方工具stat 第三方工具OpCouter 1、简介 最近学习代码的过程中,看到下面这么一样代码,不晓得什么意思,于是开始学习,发现是在统计全部的模型...
  • Encoder :设计的编码其模型 weights_init(): 用来初始化模型 model.apply():实现初始化 # coding:utf-8 from torch import nn def weights_init(mod): """设计初始化函数""" classname=mod.__c...
  • pytorch resnet 152 模型参数数据 pytorch resnet 152 模型参数数据 pytorch resnet 152 模型参数数据 pytorch resnet 152 模型参数数据 pytorch resnet 152 模型参数数据 pytorch resnet 152 模型参数数据
  • 其中i是迭代次数,x是我dataloader中的第一个tensor,y是dataloader中的第二个tensor 2 训练模型时,要写model.train() 模型加载并用于预测 在同一个文件中,我们要加载保存的模型,需要先重新实例化一个网络: best_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,936
精华内容 1,974
关键字:

pytorch打印模型参数