精华内容
参与话题
问答
  • Python——模块(Module)和包(Package)

    万次阅读 多人点赞 2018-01-30 17:21:01
    1. 模块(Module) 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。 为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含...

    本文绝大部分内容转载至:廖雪峰官方网站

    1. 模块(Module)

    在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。

    为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的代码就相对较少,很多编程语言都采用这种组织代码的方式。在Python中,一个.py文件就称之为一个模块(Module)

    使用模块有什么好处?

    最大的好处是大大提高了代码的可维护性。其次,编写代码不必从零开始。当一个模块编写完毕,就可以被其他地方引用。我们在编写程序的时候,也经常引用其他模块,包括Python内置的模块和来自第三方的模块

    使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中,因此,我们自己在编写模块时,不必考虑名字会与其他模块冲突。但是也要注意,尽量不要与内置函数名字冲突

    你也许还想到,如果不同的人编写的模块名相同怎么办?为了避免模块名冲突,Python又引入了按目录来组织模块的方法,称为包(Package)

    举个例子,一个abc.py的文件就是一个名字叫abc的模块,一个xyz.py的文件就是一个名字叫xyz的模块。

    现在,假设我们的abcxyz这两个模块名字与其他模块冲突了,于是我们可以通过包来组织模块,避免冲突。方法是选择一个顶层包名,比如mycompany,按照如下目录存放:

    mycompany
    ├─ __init__.py
    ├─ abc.py
    └─ xyz.py

    引入了包以后,只要顶层的包名不与别人冲突,那所有模块都不会与别人冲突。现在,abc.py模块的名字就变成了mycompany.abc,类似的,xyz.py的模块名变成了mycompany.xyz

    请注意,每一个包目录下面都会有一个__init__.py的文件,这个文件是必须存在的,否则,Python就把这个目录当成普通目录,而不是一个包。__init__.py可以是空文件,也可以有Python代码,因为__init__.py本身就是一个模块,而它的模块名就是mycompany。

    类似的,可以有多级目录,组成多级层次的包结构。比如如下的目录结构:

    mycompany
     ├─ web
     │  ├─ __init__.py
     │  ├─ utils.py
     │  └─ www.py
     ├─ __init__.py
     ├─ abc.py
     └─ xyz.py

    文件www.py的模块名就是mycompany.web.www

    Notes: 自己创建模块时要注意命名,不能和Python自带的模块名称冲突。例如,系统自带了sys模块,自己的模块就不可命名为sys.py,否则将无法导入系统自带的sys模块。

    2. 使用模块

    Python本身就内置了很多非常有用的模块,只要安装完毕,这些模块就可以立刻使用。

    我们以内建的sys模块为例,编写一个hello的模块:

    #!/usr/bin/env python3 
    # -*- coding: utf-8 -*-
    
    ' a test module '
    
    __author__ = 'Michael Liao'
    
    import sys
    
    def test():
        args = sys.argv   # argv参数用列表存储命令行的所有参数
        if len(args)==1:  # 当列表长度为1时即只有一个参数时
            print('Hello, world!')
        elif len(args)==2: # 当命令行有两个参数时
            print('Hello, %s!' % args[1])
        else:
            print('Too many arguments!')
    
    if __name__=='__main__':
        test()

    第1行和第2行是标准注释,第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行,第2行注释表示.py文件本身使用标准UTF-8编码;

    第4行是一个字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

    第6行使用__author__变量把作者写进去,这样当你公开源代码后别人就可以瞻仰你的大名;

    以上就是Python模块的标准文件模板,当然也可以全部删掉不写,但是,按标准办事肯定没错。

    后面开始就是真正的代码部分。

    你可能注意到了,使用sys模块的第一步,就是导入该模块:

    import sys

    导入sys模块后,我们就有了变量sys指向该模块,利用sys这个变量,就可以访问sys模块的所有功能。

    sys模块有一个argv变量,list存储了命令行的所有参数argv至少有一个元素,因为第一个参数永远是该.py文件的名称,例如:

    运行python3 hello.py获得的sys.argv就是['hello.py'],注意这里python3不算是参数;

    运行python3 hello.py Michael获得的sys.argv就是['hello.py', 'Michael]

    最后,注意到这两行代码:

    if __name__=='__main__':
        test()

    当我们在命令行运行hello模块文件时,Python解释器把一个特殊变量__name__置为__main__,而如果在其他地方导入该hello模块时,if判断将失败,因此,这种if测试可以让一个模块通过命令行运行时执行一些额外的代码,最常见的就是运行测试

    我们可以用命令行运行hello.py看看效果:

    $ python3 hello.py
    Hello, world!
    $ python hello.py Michael
    Hello, Michael!

    如果启动Python交互环境,再导入hello模块:

    >>> import hello
    >>>

    导入时,没有打印Hello, word!,因为没有执行test()函数。

    调用hello.test()时,才能打印出Hello, word!

    >>> hello.test()
    Hello, world!
    展开全文
  • module是干什么的?

    千次阅读 2012-11-07 09:22:16
    以前一直搞不太清楚module是干什么的? 我们公司到底干什么的? 前几天听同事说,IC公司只是一个CPU+MAC层程序控制GPIO口,需要添加射频部分,也就是信号的发送与接收那些硬件的东西,就是电源+天线。 这就是...
    以前一直搞不太清楚module是干什么的? 我们公司到底干什么的?
    前几天听同事说,IC公司只是一个CPU+MAC层程序控制GPIO口,需要添加射频部分,也就是信号的发送与接收那些硬件的东西,就是电源+天线。
    这就是module厂商的工作。
    不过,IC厂商慢慢把这些都做了,所以module厂商没落了。
    添加射频部分,需要各种电容电感的配合,最后才能决定信号最好的,这个是个很复杂的东西,需要的设备也很昂贵,反复的测试,真的是经验为大!
    2012.11.07
    展开全文
  • 前言:pytorch中对于一般的序列模型,直接使用torch.nn.Sequential类及可以实现,这点类似于keras,但是更多的时候面对复杂的模型,比如:多输入多输出、多分支...一、torch.nn.Module类概述 个人理解,pytorch不...

     

     

    前言:pytorch中对于一般的序列模型,直接使用torch.nn.Sequential类及可以实现,这点类似于keras,但是更多的时候面对复杂的模型,比如:多输入多输出、多分支模型、跨层连接模型、带有自定义层的模型等,就需要自己来定义一个模型了。本文将详细说明如何让使用Mudule类来自定义一个模型。

    一、torch.nn.Module类概述

    个人理解,pytorch不像tensorflow那么底层,也不像keras那么高层,这里先比较keras和pytorch的一些小区别。

    (1)keras更常见的操作是通过继承Layer类来实现自定义层,不推荐去继承Model类定义模型,详细原因可以参见官方文档

    (2)pytorch中其实一般没有特别明显的Layer和Module的区别,不管是自定义层、自定义块、自定义模型,都是通过继承Module类完成的,这一点很重要。其实Sequential类也是继承自Module类的。

    注意:我们当然也可以直接通过继承torch.autograd.Function类来自定义一个层,但是这很不推荐,不提倡,至于为什么后面会介绍。

    总结:pytorch里面一切自定义操作基本上都是继承nn.Module类来实现的

    本文仅仅先讨论使用Module来实现自定义模块,自定义层先不做讨论。

    二、torch.nn.Module类的简介

    先来简单看一它的定义:

    class Module(object):
        def __init__(self):
        def forward(self, *input):
    
        def add_module(self, name, module):
        def cuda(self, device=None):
        def cpu(self):
        def __call__(self, *input, **kwargs):
        def parameters(self, recurse=True):
        def named_parameters(self, prefix='', recurse=True):
        def children(self):
        def named_children(self):
        def modules(self):  
        def named_modules(self, memo=None, prefix=''):
        def train(self, mode=True):
        def eval(self):
        def zero_grad(self):
        def __repr__(self):
        def __dir__(self):
    '''
    有一部分没有完全列出来
    '''

    我们在定义自已的网络的时候,需要继承nn.Module类,并重新实现构造函数__init__构造函数和forward这两个方法。但有一些注意技巧:

    (1)一般把网络中具有可学习参数的层(如全连接层、卷积层等)放在构造函数__init__()中,当然我也可以吧不具有参数的层也放在里面;

    (2)一般把不具有可学习参数的层(如ReLU、dropout、BatchNormanation层)可放在构造函数中,也可不放在构造函数中,如果不放在构造函数__init__里面,则在forward方法里面可以使用nn.functional来代替
        
    (3)forward方法是必须要重写的,它是实现模型的功能,实现各个层之间的连接关系的核心

    下面先看一个简单的例子。

    import torch
    
    class MyNet(torch.nn.Module):
        def __init__(self):
            super(MyNet, self).__init__()  # 第一句话,调用父类的构造函数
            self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
            self.relu1=torch.nn.ReLU()
            self.max_pooling1=torch.nn.MaxPool2d(2,1)
    
            self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
            self.relu2=torch.nn.ReLU()
            self.max_pooling2=torch.nn.MaxPool2d(2,1)
    
            self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
            self.dense2 = torch.nn.Linear(128, 10)
    
        def forward(self, x):
            x = self.conv1(x)
            x = self.relu1(x)
            x = self.max_pooling1(x)
            x = self.conv2(x)
            x = self.relu2(x)
            x = self.max_pooling2(x)
            x = self.dense1(x)
            x = self.dense2(x)
            return x
    
    model = MyNet()
    print(model)
    '''运行结果为:
    MyNet(
      (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (relu1): ReLU()
      (max_pooling1): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
      (conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (relu2): ReLU()
      (max_pooling2): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)
      (dense1): Linear(in_features=288, out_features=128, bias=True)
      (dense2): Linear(in_features=128, out_features=10, bias=True)
    )
    '''

    注意:上面的是将所有的层都放在了构造函数__init__里面,但是只是定义了一系列的层,各个层之间到底是什么连接关系并没有,而是在forward里面实现所有层的连接关系,当然这里依然是顺序连接的。下面再来看一下一个例子:

    import torch
    import torch.nn.functional as F
    
    class MyNet(torch.nn.Module):
        def __init__(self):
            super(MyNet, self).__init__()  # 第一句话,调用父类的构造函数
            self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
            self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
    
            self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
            self.dense2 = torch.nn.Linear(128, 10)
    
        def forward(self, x):
            x = self.conv1(x)
            x = F.relu(x)
            x = F.max_pool2d(x)
            x = self.conv2(x)
            x = F.relu(x)
            x = F.max_pool2d(x)
            x = self.dense1(x)
            x = self.dense2(x)
            return x
    
    model = MyNet()
    print(model)
    '''运行结果为:
    MyNet(
      (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (dense1): Linear(in_features=288, out_features=128, bias=True)
      (dense2): Linear(in_features=128, out_features=10, bias=True)
    )
    '''

    注意:此时,将没有训练参数的层没有放在构造函数里面了,所以这些层就不会出现在model里面,但是运行关系是在forward里面通过functional的方法实现的。

    总结:所有放在构造函数__init__里面的层的都是这个模型的“固有属性”.

    三、torch.nn.Module类的的多种实现

    上面是为了一个简单的演示,但是Module类是非常灵活的,可以有很多灵活的实现方式,下面将一一介绍。

    3.1 通过Sequential来包装层

    即将几个层包装在一起作为一个大的层(块),前面的一篇文章详细介绍了Sequential类的使用,包括常见的三种方式,以及每一种方式的优缺点,参见:https://blog.csdn.net/qq_27825451/article/details/90551513

    所以这里对层的包装当然也可以通过这三种方式了。

    (1)方式一:

    import torch.nn as nn
    from collections import OrderedDict
    class MyNet(nn.Module):
        def __init__(self):
            super(MyNet, self).__init__()
            self.conv_block = nn.Sequential(
                nn.Conv2d(3, 32, 3, 1, 1),
                nn.ReLU(),
                nn.MaxPool2d(2))
            self.dense_block = nn.Sequential(
                nn.Linear(32 * 3 * 3, 128),
                nn.ReLU(),
                nn.Linear(128, 10)
            )
        # 在这里实现层之间的连接关系,其实就是所谓的前向传播
        def forward(self, x):
            conv_out = self.conv_block(x)
            res = conv_out.view(conv_out.size(0), -1)
            out = self.dense_block(res)
            return out
    
    model = MyNet()
    print(model)
    '''运行结果为:
    MyNet(
      (conv_block): Sequential(
        (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): ReLU()
        (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      )
      (dense_block): Sequential(
        (0): Linear(in_features=288, out_features=128, bias=True)
        (1): ReLU()
        (2): Linear(in_features=128, out_features=10, bias=True)
      )
    )
    '''

    同前面的文章,这里在每一个包装块里面,各个层是没有名称的,默认按照0、1、2、3、4来排名。

    (2)方式二:

    import torch.nn as nn
    from collections import OrderedDict
    class MyNet(nn.Module):
        def __init__(self):
            super(MyNet, self).__init__()
            self.conv_block = nn.Sequential(
                OrderedDict(
                    [
                        ("conv1", nn.Conv2d(3, 32, 3, 1, 1)),
                        ("relu1", nn.ReLU()),
                        ("pool", nn.MaxPool2d(2))
                    ]
                ))
    
            self.dense_block = nn.Sequential(
                OrderedDict([
                    ("dense1", nn.Linear(32 * 3 * 3, 128)),
                    ("relu2", nn.ReLU()),
                    ("dense2", nn.Linear(128, 10))
                ])
            )
    
        def forward(self, x):
            conv_out = self.conv_block(x)
            res = conv_out.view(conv_out.size(0), -1)
            out = self.dense_block(res)
            return out
    
    model = MyNet()
    print(model)
    '''运行结果为:
    MyNet(
      (conv_block): Sequential(
        (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (relu1): ReLU()
        (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      )
      (dense_block): Sequential(
        (dense1): Linear(in_features=288, out_features=128, bias=True)
        (relu2): ReLU()
        (dense2): Linear(in_features=128, out_features=10, bias=True)
      )
    )
    '''

    (3)方式三:

    import torch.nn as nn
    from collections import OrderedDict
    class MyNet(nn.Module):
        def __init__(self):
            super(MyNet, self).__init__()
            self.conv_block=torch.nn.Sequential()
            self.conv_block.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
            self.conv_block.add_module("relu1",torch.nn.ReLU())
            self.conv_block.add_module("pool1",torch.nn.MaxPool2d(2))
    
            self.dense_block = torch.nn.Sequential()
            self.dense_block.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
            self.dense_block.add_module("relu2",torch.nn.ReLU())
            self.dense_block.add_module("dense2",torch.nn.Linear(128, 10))
    
        def forward(self, x):
            conv_out = self.conv_block(x)
            res = conv_out.view(conv_out.size(0), -1)
            out = self.dense_block(res)
            return out
    
    model = MyNet()
    print(model)
    '''运行结果为:
    MyNet(
      (conv_block): Sequential(
        (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (relu1): ReLU()
        (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      )
      (dense_block): Sequential(
        (dense1): Linear(in_features=288, out_features=128, bias=True)
        (relu2): ReLU()
        (dense2): Linear(in_features=128, out_features=10, bias=True)
      )
    )
    '''

    上面的方式二和方式三,在每一个包装块里面,每个层都是有名称的。

    3.2 Module类的几个常见方法使用

    特别注意:Sequential类虽然继承自Module类,二者有相似部分,但是也有很多不同的部分,集中体现在:

    Sequenrial类实现了整数索引,故而可以使用model[index] 这样的方式获取一个曾,但是Module类并没有实现整数索引,不能够通过整数索引来获得层,那该怎么办呢?它提供了几个主要的方法,如下:

    def children(self):
    
    def named_children(self):
    
    def modules(self):
    
    def named_modules(self, memo=None, prefix=''):
    
    '''
    注意:这几个方法返回的都是一个Iterator迭代器,故而通过for循环访问,当然也可以通过next
    '''

    下面就以上面的构建的网络为例子来说明,

    (1)model.children()方法

    import torch.nn as nn
    from collections import OrderedDict
    class MyNet(nn.Module):
        def __init__(self):
            super(MyNet, self).__init__()
            self.conv_block=torch.nn.Sequential()
            self.conv_block.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))
            self.conv_block.add_module("relu1",torch.nn.ReLU())
            self.conv_block.add_module("pool1",torch.nn.MaxPool2d(2))
    
            self.dense_block = torch.nn.Sequential()
            self.dense_block.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))
            self.dense_block.add_module("relu2",torch.nn.ReLU())
            self.dense_block.add_module("dense2",torch.nn.Linear(128, 10))
    
        def forward(self, x):
            conv_out = self.conv_block(x)
            res = conv_out.view(conv_out.size(0), -1)
            out = self.dense_block(res)
            return out
    
    model = MyNet()
    
    for i in model.children():
        print(i)
        print(type(i)) # 查看每一次迭代的元素到底是什么类型,实际上是 Sequential 类型,所以有可以使用下标index索引来获取每一个Sequenrial 里面的具体层
    
    '''运行结果为:
    Sequential(
      (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (relu1): ReLU()
      (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    )
    <class 'torch.nn.modules.container.Sequential'>
    Sequential(
      (dense1): Linear(in_features=288, out_features=128, bias=True)
      (relu2): ReLU()
      (dense2): Linear(in_features=128, out_features=10, bias=True)
    )
    <class 'torch.nn.modules.container.Sequential'>
    '''

    (2)model.named_children()方法

    for i in model.children():
        print(i)
        print(type(i)) # 查看每一次迭代的元素到底是什么类型,实际上是 返回一个tuple,tuple 的第一个元素是
    
    '''运行结果为:
    ('conv_block', Sequential(
      (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (relu1): ReLU()
      (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    ))
    <class 'tuple'>
    ('dense_block', Sequential(
      (dense1): Linear(in_features=288, out_features=128, bias=True)
      (relu2): ReLU()
      (dense2): Linear(in_features=128, out_features=10, bias=True)
    ))
    <class 'tuple'>
    '''

    总结:

    (1)model.children()和model.named_children()方法返回的是迭代器iterator

    (2)model.children():每一次迭代返回的每一个元素实际上是 Sequential 类型,而Sequential类型又可以使用下标index索引来获取每一个Sequenrial 里面的具体层,比如conv层、dense层等;

    (3)model.named_children():每一次迭代返回的每一个元素实际上是 一个元组类型,元组的第一个元素是名称,第二个元素就是对应的层或者是Sequential。

    (3)model.modules()方法

    for i in model.modules():
        print(i)
        print("==================================================")
    '''运行结果为:
    MyNet(
      (conv_block): Sequential(
        (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (relu1): ReLU()
        (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      )
      (dense_block): Sequential(
        (dense1): Linear(in_features=288, out_features=128, bias=True)
        (relu2): ReLU()
        (dense2): Linear(in_features=128, out_features=10, bias=True)
      )
    )
    ==================================================
    Sequential(
      (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (relu1): ReLU()
      (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    )
    ==================================================
    Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    ==================================================
    ReLU()
    ==================================================
    MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    ==================================================
    Sequential(
      (dense1): Linear(in_features=288, out_features=128, bias=True)
      (relu2): ReLU()
      (dense2): Linear(in_features=128, out_features=10, bias=True)
    )
    ==================================================
    Linear(in_features=288, out_features=128, bias=True)
    ==================================================
    ReLU()
    ==================================================
    Linear(in_features=128, out_features=10, bias=True)
    ==================================================
    '''

    (4)model.named_modules()方法

    for i in model.named_modules():
        print(i)
        print("==================================================")
    '''运行结果是:
    ('', MyNet(
      (conv_block): Sequential(
        (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (relu1): ReLU()
        (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      )
      (dense_block): Sequential(
        (dense1): Linear(in_features=288, out_features=128, bias=True)
        (relu2): ReLU()
        (dense2): Linear(in_features=128, out_features=10, bias=True)
      )
    ))
    ==================================================
    ('conv_block', Sequential(
      (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (relu1): ReLU()
      (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    ))
    ==================================================
    ('conv_block.conv1', Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)))
    ==================================================
    ('conv_block.relu1', ReLU())
    ==================================================
    ('conv_block.pool1', MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))
    ==================================================
    ('dense_block', Sequential(
      (dense1): Linear(in_features=288, out_features=128, bias=True)
      (relu2): ReLU()
      (dense2): Linear(in_features=128, out_features=10, bias=True)
    ))
    ==================================================
    ('dense_block.dense1', Linear(in_features=288, out_features=128, bias=True))
    ==================================================
    ('dense_block.relu2', ReLU())
    ==================================================
    ('dense_block.dense2', Linear(in_features=128, out_features=10, bias=True))
    ==================================================
    '''

    总结:

    (1)model.modules()和model.named_modules()方法返回的是迭代器iterator

    (2)model的modules()方法和named_modules()方法都会将整个模型的所有构成(包括包装层、单独的层、自定义层等)由浅入深依次遍历出来,只不过modules()返回的每一个元素是直接返回的层对象本身,而named_modules()返回的每一个元素是一个元组,第一个元素是名称,第二个元素才是层对象本身。

    (3)如何理解children和modules之间的这种差异性。注意pytorch里面不管是模型、层、激活函数、损失函数都可以当成是Module的拓展,所以modules和named_modules会层层迭代,由浅入深,将每一个自定义块block、然后block里面的每一个层都当成是module来迭代。而children就比较直观,就表示的是所谓的“孩子”,所以没有层层迭代深入。

     

    注意:上面这四个方法是以层包装为例来说明的,如果没有层的包装,我们依然可以使用这四个方法,其实结果也是类似的这样去推,这里就不再列出来了。

    展开全文
  • 什么是module 以及如何写一个module

    千次阅读 2006-01-16 13:09:00
  • IDEA 导入多个Module,多个Module在同一个Project 下显示

    万次阅读 多人点赞 2017-08-24 15:19:48
    使用IDEA 过程中遇到的问题,我想一一记录下来并希望对后面使用IDEA时遇此问题的人到有所帮助。  1、打开IDEA , 点击右上角 File ---&gt; Project Structure (快捷键:Ctrl + Alt + Shift + S)     ...
  • 简单说明 exports 与module.export的区别

    万次阅读 2018-07-13 10:11:30
    exports只能使用.语法向外暴露内部变量 例 exports.xxx=xxxmodule.exports既可以通过点语法,也可以直接赋值一个对象 例 module.exports.xxx=xxx ...
  • 一、工程目录 dac_parent 父目录 dac-utils 继承 dac_parent(不依赖 dac_parent) dac-csr 依赖 dac_parent dac-label 依赖 dac_parent 和 dac-csr ...新建project名称,其中底部是module名称 ...
  • 终于讲清楚了nodejs中exports和module.exports的区别

    万次阅读 多人点赞 2018-09-06 15:06:39
    module.exports 对象是由模块系统创建的。在我们自己写模块的时候,需要在模块最后写好模块接口,声明这个模块对外暴露什么内容,module.exports 提供了暴露接口的方法。 1、返回一个JSON Object var app = { ...
  • Android Studio中no module问题

    万次阅读 多人点赞 2019-02-16 00:37:34
    问题描述: 想要在Android Studio中运行项目,但是如下图所示,运行按钮为灰色不可用 点击下拉按钮,选择Edit Configurations ...此时,运行按钮为绿色,但是左侧的HBKNApp却标注存在错误,如下图所示 ...
  • module

    2019-03-22 06:00:00
    新闻 管理 ...在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。...为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的...
  • vb的module 和class module 有什么区别?

    万次阅读 2007-07-03 13:46:00
    标准模块与类模块的比较 在数据存储方式上,类不同于标准模块。标准模块的数据不可能多于一份。这意味着若程序中某个部分改动了标准模块的公共变量,随后程序的其它部分读取该变量会得到该值。 相反,类模块数据则...
  • 在PyCharm中运行代码报错: import torch ModuleNotFoundError: No module named ‘torch’
  • IntelliJ IDEA 中 Project 和 Module 的概念及区别

    万次阅读 多人点赞 2017-03-23 20:29:04
    在 IntelliJ IDEA 中,没有类似于 Eclipse 工作空间(Workspace)的概念,而是提出了Project和Module这两个概念。接下来,就让咱们一起看看 IntelliJ IDEA 官方是如何描述两者的吧!对于 Project,IntelliJ IDEA 是...
  • Go module的介绍及使用

    万次阅读 多人点赞 2018-08-31 18:46:32
    Go1.1.1版本发布(2018-08-24发布)已经过去几天,从官方的博客中看到,有两个比较突出的特色,一个就是今天讲的module,模块概念。目前该功能还在试验阶段,有些地方还需要不断的进行完善。不过可以先尝尝鲜,感受下...
  • 问题描述: Anaconda3安装tensorflow,安装完anaconda后,在prompt中activate tensorflow,进入"python"环境下,"import tensorflow as tf"报错: 但是在(base)模式中“conda list"...
  • 3.7版本需要一个新的包libffi-devel,安装此包之后再次进行编译安装即可。 #yum install libffi-devel -y #make install 若在安装前移除了/usr/bin下python的文件链接依赖,此时yum无法正常使用,需要自己下载...
  • 前言:前面介绍了如何自定义一个模型——通过继承nn.Module类来实现,在__init__构造函数中申明各个层的定义,在forward中实现层之间的连接关系,实际上就是前向传播的过程。 事实上,在pytorch里面自定义层也是...
  • Failed to compile../src/components/1-模板语法/test.vueModule not found: Error: Can't resolve 'less-loader' in 'D:\vue\myVue\myVue\src\components\1-模板语法' @ ./src/components/1-模板语法/test.vue 4:2-...
  • TensorFlow报错:AttributeError: module ‘tensorflow._api.v1.train’ has no attribute 'SummaryWriter’等 分析:版本更新,方法调用方式改变 解决方式: 报错 原方法 更改后方法 ...
  • 由于重新装了一个系统,很多环境配置要重新配置。在想run 一个项目时,出现下面的...Module build failed: Error: Cannot find module 'node-sass' at Function.Module._resolveFilename (internal/modules/cjs/...

空空如也

1 2 3 4 5 ... 20
收藏数 1,124,186
精华内容 449,674
关键字:

module