专栏首页机器学习炼丹术小白学PyTorch | 6 模型的构建访问遍历存储(附代码)

小白学PyTorch | 6 模型的构建访问遍历存储(附代码)

文章目录:

  • 1 模型构建函数
    • 1.1 add_module
    • 1.2 ModuleList
    • 1.3 Sequential
    • 1.4 小总结
  • 2 遍历模型结构
    • 2.1 modules()
    • 2.2 named_modules()
    • 2.3 parameters()
  • 3 保存与载入

本文是对一些函数的学习。函数主要包括下面四个方便:

  • 模型构建的函数:add_module,add_module,add_module
  • 访问子模块:add_module,add_module,add_moduleadd_module
  • 网络遍历:add_module,add_module
  • 模型的保存与加载:add_module,add_module,add_module

1 模型构建函数

torch.nn.Module是所有网络的基类,在PyTorch实现模型的类中都要继承这个类(这个在之前的课程中已经提到)。在构建Module中,Module是一个包含其他的Module的,类似于,你可以先定义一个小的网络模块,然后把这个小模块作为另外一个网络的组件。因此网络结构是呈现树状结构

我们先简单定义一个网络:

import torch.nn as nn
import torch 
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet,self).__init__()
        self.conv1 = nn.Conv2d(3,64,3)
        self.conv2 = nn.Conv2d(64,64,3)

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        return x
net = MyNet()
print(net)

输出结果:

MyNet中有两个属性conv1conv2是两个卷积层,在正向传播forward的过程中,依次调用这两个卷积层实现网络的功能。

1.1 add_module

这种是最常见的定义网络的功能,在有些项目中,会看到这样的方法add_module。我们用这个方法来重写上面的网络:

class MyNet(nn.Module):
    def __init__(self):
        super(MyNet,self).__init__()
        self.add_module('conv1',nn.Conv2d(3,64,3))
        self.add_module('conv2',nn.Conv2d(64,64,3))

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        return x

其实add_module(name,layer)self.name=layer实现了相同的功能,个人感觉也许是因为add_module可以使用字符串来定义变量名字,所以可以放在循环中?反正这个先了解熟悉熟悉

上面的两种方法都是一层一层的添加layer,如果网络复杂的话,那就需要写很多重复的代码了。因此接下来来讲解一下网络模块的构建,torch.nn.ModuleListtorch.nn.Sequential

1.2 ModuleList

ModuleList按照字面意思是用list的形式保存网络层的。这样就可以先将网络需要的layer构建好,保存到一个list,然后通过ModuleList方法添加到网络中.

class MyNet(nn.Module):
    def __init__(self):
        super(MyNet,self).__init__()
        self.linears = nn.ModuleList(
            [nn.Linear(10,10) for i in range(5)]
        )

    def forward(self,x):
        for l in self.linears:
            x = l(x)
        return x
net = MyNet()
print(net)

输出结果是:

这个ModuleList主要是用在读取config文件来构建网络模型中的,下面用VGG模型的构建为例子:

vgg_cfg = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M',
           512, 512, 512, 'M']

def vgg(cfg, i, batch_norm=False):
    layers = []
    in_channels = i
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        elif v == 'C':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    return layers

class Model1(nn.Module):
    def __init__(self):
        super(Model1,self).__init__()

        self.vgg = nn.ModuleList(vgg(vgg_cfg,3))

    def forward(self,x):

        for l in self.vgg:
            x = l(x)
m1 = Model1()
print(m1)

先读取网络结构的配置文件vgg_cfg然后根据这个文件创建对应的Layer list,然后使用ModuleList添加到网络中,这样可以快速创建不同的网络(用上面为例子的话,可以通过修改配置文件,然后快速修改网络结构

1.3 Sequential

在一些自己做的小项目中,Sequential其实用的更为频繁。依然重写最初最简单的例子:

class MyNet(nn.Module):
    def __init__(self):
        super(MyNet,self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(3,64,3),
            nn.Conv2d(64,64,3)
        )

    def forward(self,x):
        x = self.conv(x)
        return x
net = MyNet()
print(net)

运行结果:

观察细致的朋友可以发现这个问题,Seqential内的网络层是默认用数字进行标号的,而一开始我们使用self.conv1self.conv2的时候,使用conv1和conv2作为标号的。

我们如何修改Sequential中网络层的名称呢?这里需要使用到collections.OrderedDict有序字典。Sequential是支持有序字典构建的。

from collections import OrderedDict 
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet,self).__init__()
        self.conv = nn.Sequential(OrderedDict([
            ('conv1',nn.Conv2d(3,64,3)),
            ('conv2',nn.Conv2d(64,64,3))
        ]))

    def forward(self,x):
        x = self.conv(x)
        return x
net = MyNet()
print(net)

输出结果:

1.4 小总结

  • 单独增加一个网络层或者子模块,可以用add_module或者直接赋予属性;
  • ModuleList可以将一个Module的List增加到网络中,自由度较高。
  • Sequential按照顺序产生一个Module模块。这里推荐习惯使用OrderedDict的方法进行构建。对网络层加上规范的名称,这样有助于后续查找与遍历

2 遍历模型结构

本章节使用下面的方法进行遍历之前提到的Module。(个人理解,Module是多个layer的合并,但是一个layer可以说成Module。 ) 先定义一个网络吧,随便写一个:

import torch.nn as nn
import torch 
from collections import OrderedDict
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet,self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3)
        self.conv2 = nn.Conv2d(64,64,3)
        self.maxpool1 = nn.MaxPool2d(2,2)

        self.features = nn.Sequential(OrderedDict([
            ('conv3', nn.Conv2d(64,128,3)),
            ('conv4', nn.Conv2d(128,128,3)),
            ('relu1', nn.ReLU())
        ]))

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.maxpool1(x)
        x = self.features(x)

        return x
net = MyNet()
print(net)

输出结果是:

2.1 modules()

在第四课中初始化模型各个层的参数的时候,用到了这个方法,现在我们再来理解一下:

for idx,m in enumerate(net.modules()):
    print(idx,"-",m)

运行结果:

上面那个网络构建的时候用到了Sequential,所以网络中其实是嵌套了一个小的Module,这就是之前提到的树状结构,然后上面便利的时候也是树状结构的便利过程,可以看出来应该是一个深度遍历的过程。

  • 首先第一个输出的是最大的那个Module,也就是整个网络,0-Model整个网络模块;
  • 1-2-3-4是网络的四个子模块,4-Sequential中间仍然包含子模块
  • 5-6-7是模块4-Sequential的子模块。

【总结】

modules()是递归的返回网络的各个module(深度遍历),从最顶层直到最后的叶子的module。

2.2 named_modules()

named_modules()module()类似,只是同时返回name和module。

for idx,(name,m) in enumerate(net.named_modules()):
    print(idx,"-",name)

输出结果:

2.3 parameters()

for p in net.parameters():
    print(type(p.data),p.size())

运行结果:

输出的是四个卷积层的权重矩阵参数和偏置参数。值得一提的是,对网络进行训练时需要将parameters()作为优化器optimizer的参数。

optimizer = torch.optim.SGD(net.parameters(),
                            lr = 0.001,
                            momentum=0.9)

总之呢,这个parameters()是返回网络所有的参数,主要用在给optimizer优化器用的。而要对网络的某一层的参数做处理的时候,一般还是使用named_parameters()方便一些。

for idx,(name,m) in enumerate(net.named_parameters()):
    print(idx,"-",name,m.size())

输出结果:

【小扩展】

我个人有时会使用下面的方法来获取参数:

for idx,(name,m) in enumerate(net.named_modules()):
    if isinstance(m,nn.Conv2d):
        print(m.weight.shape)
        print(m.bias.shape)

先判断是否是卷积层,然后获取其参数,输出结果:

3 保存与载入

PyTorch使用torch.savetorch.load方法来保存和加载网络,而且网络结构和参数可以分开的保存和加载。

torch.save(model,'model.pth') # 保存
model = torch.load("model.pth") # 加载

pytorch中网络结构和模型参数是可以分开保存的。上面的方法是两者同时保存到了.pth文件中,当然,你也可以仅仅保存网络的参数来减小存储文件的大小。注意:如果你仅仅保存模型参数,那么在载入的时候,是需要通过运行代码来初始化模型的结构的。

torch.save(model.state_dict(),"model.pth") # 保存参数
model = MyNet() # 代码中创建网络结构
params = torch.load("model.pth") # 加载参数
model.load_state_dict(params) # 应用到网络结构中

至此,我们今天已经学习了不少的内容,大家对PyTorch的掌握更近一步了呢~

本文分享自微信公众号 - 机器学习炼丹术(liandanshu),作者:机器学习炼丹术

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-09-05

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 小白学PyTorch | 4 构建模型三要素与权重初始化

    第一行是初始化,往后定义了一系列组件。nn.Conv2d就是一般图片处理的卷积模块,然后池化层,全连接层等等。

    机器学习炼丹术
  • 小白学PyTorch | 12 SENet详解及PyTorch实现

    上一节课讲解了MobileNet的一个DSC深度可分离卷积的概念,希望大家可以在实际的任务中使用这种方法,现在再来介绍EfficientNet的另外一个基础知识...

    机器学习炼丹术
  • AI面试题之GBDT梯度提升树

    【Boost】就是让多个弱分类器,通过不同的集成方式,来让多个弱分类器变成一个强分类器。

    机器学习炼丹术
  • PyTorch最佳实践,怎样才能写出一手风格优美的代码

    虽然这是一个非官方的 PyTorch 指南,但本文总结了一年多使用 PyTorch 框架的经验,尤其是用它开发深度学习相关工作的最优解决方案。请注意,我们分享的...

    机器之心
  • 基于PyTorch实现MNIST手写字识别

    本篇不涉及模型原理,只是分享下代码。想要了解模型原理的可以去看网上很多大牛的博客。

    Awesome_Tang
  • 组合

    py3study
  • 获取 zabbix 挂件数据(widget)

    Zabbix 有非常丰富的 API ,但没有 widget 的 API。 所以获取 widget 的数据需要通过模拟登录爬取网页的形式来做。虽然我们可以用一定的...

    用户1416054
  • 打牢地基-链表

    注意: 关键点: 找到要插入节点的前一个节点 LinkedList - (head实现)

    用户1081422
  • 使用以 Tensorflow 为后端的 Keras 构建生成对抗网络的代码示例

    生成式对抗网络(GAN)是近期深度学习领域中最有前景的发展之一。 GAN由Ian Goodfellow于2014年推出,它通过分别训练两个相互竞争和合作的深度网...

    AI研习社
  • 说说地图中的聚类

    虽然Openlayers4会有自带的聚类效果,但是有些时候是不能满足我们的业务场景的,本文结合一些业务场景,讲讲地图中的聚类展示。

    lzugis

扫码关注云+社区

领取腾讯云代金券