module_modules - CSDN
  • module是干什么的?

    2012-11-07 09:22:16
    以前一直搞不太清楚module是干什么的? 我们公司到底干什么的? 前几天听同事说,IC公司只是一个CPU+MAC层程序控制GPIO口,需要添加射频部分,也就是信号的发送与接收那些硬件的东西,就是电源+天线。 这就是...
    以前一直搞不太清楚module是干什么的? 我们公司到底干什么的?
    前几天听同事说,IC公司只是一个CPU+MAC层程序控制GPIO口,需要添加射频部分,也就是信号的发送与接收那些硬件的东西,就是电源+天线。
    这就是module厂商的工作。
    不过,IC厂商慢慢把这些都做了,所以module厂商没落了。
    添加射频部分,需要各种电容电感的配合,最后才能决定信号最好的,这个是个很复杂的东西,需要的设备也很昂贵,反复的测试,真的是经验为大!
    2012.11.07
    展开全文
  • 在JavaScript中Module模式模拟了类的概念,用闭包封装了"私有"状态和方法。 Module(模块)模式 通常能够帮助我们清晰地分离和组织项目中的代码单元 js中实现模块的方法 1》对象字面量表示法 2》...

    JavaScript模块是用于保持代码块之间相互独立而普遍使用的设计模式。对于熟悉面向对象语言的人来说,模块是JavaScript的"类"。在JavaScript中Module模式模拟了类的概念,用闭包封装了"私有"状态和方法。

    Module(模块)模式

    通常能够帮助我们清晰地分离和组织项目中的代码单元

    js中实现模块的方法

    1》对象字面量表示法

    2》Module模式

    3》AMD模式

    4》CommonJS模块

    5》ECMAScript Harmony模块

    Module模式某种程度上是基于对象的字面量

    9.2.1对象字面量

    在对象字面量表示法中,一个对象被描述为一组包含在大括号{}中、以逗号分隔的name/value对。对象内的名称可以是字符串或标识符,后面跟着一个冒号。对象中最后的一个name/value对的后面不用加逗号,如果加逗号将会导致出错。

    Var myObjectLiteral={

    variableKey:variableValue;

    functionKey:function(){

    //

    }

    };

    对象字面量不需要使用new运算符进行实例化,但不能用在一个语句的开头,因为开始的可能被解读为一个块的开始。在对象的外部,新成员可以使用如下赋值语句添加在字面量上,如:

    myModule.property="some Value";

    使用对象字面量有助于封装和组织代码,Module模式仍然使用对象字面量,但只是作为一个作用域函数的返回值。

    复制代码

       var myModule={
            myProperty:"somevalue",
            //对象字面量可以包含属性和方法
            //例如,可以声明模块的配置对象
            myConfig:{
                useCaching:true,
                language:"en"
            },
            //基本方法
            myMethod:function(){
                console.log("myMethod");
            },
            //根据当前配置输出信息
            myMethod2:function(){
                console.log("caching is:" + (this.myConfig.useCaching) ? "enabled":"disabled");
            },
            //重写当前配置
            myMethod3:function(newConfig){
                if(typeof newConfig==="object"){
                    this.myConfig=newConfig;
                    console.log(this.myConfig.language);
                }
            }
        };
        myModule.myMethod();
        myModule.myMethod2();//打印出来的是enabled,没有加上前面的字符串
        myModule.myMethod3({
            language:"fr",
            useCaching:false
        });

    复制代码

    9.2.2Module(模块)模式

    Module模式最初被定义为一种在传统软件工程中为类提供私有和公有封装的方法。

    在js中,Module模式用于进一步模拟类的概念,通过这种方式,能够使一个单独的对象用于公有/私有方法和变量,从而屏蔽来自全局作用域的特殊部分。产生的结果是:函数名与在页面上其他脚本定义的函数冲突的可能性降低。

    模块模式的模板

    复制代码

    var myNamespace=(function(){
        //私有计数器变量
        var myPrivateVar=0;
        //记录所有参数的私有函数
        var myPrivateMethod=function(foo){
            console.log(foo);
        }
        return{
            //公有变量
            myPublicVar:"foo",
            //调用私有变量和方法的公有函数
            myPublicFunction:function(bar){
                //增加私有计数器值
                myPrivateVar++;
                //传入bar调用私有方法
                myPrivateMethod(bar);
            }
        };
    })();

    复制代码

    9.2.2.1 私有

    Module模式使用闭包封装“私有”状态和组织。它提供了一种包装混合公有/私有方法和变量的方式,防止其泄露至全局作用域,并与别的开发人员的接口发生冲突。通过该模式,只需返回一个公有API,而其他的一切则都维持在私有闭包里 。

    这为我们提供了一个屏蔽处理底层时间逻辑的整洁解决方案,同时只暴露一个接口供应用程序的其他部分使用。该模式除了返回一个对象而并不是函数之外,非常类似于一个立即调用的函数表达式。

    应该指出的是,在js中没有正真意义上的“私有”,因为js没有访问修饰符,因此我们使用函数作用域来模拟这个概念。在Module模式内:闭包声明的变量和方法只在该模式内部可用。但在返回对象上定义的变量和方法,则对外部使用者都是可用的。

    复制代码

        var basketModule=(function(){
            //私有
            var basket=[];
            function doSomethingPrivate(){
                console.log("private");
            }
            function doSomethingElsePrivate(){
                //
            }
            //返回一个暴露出的公有对象
            return{
                //添加item到购物车
                addItem:function(values){
                    basket.push(values);
                },
                //获取购物车里的item数
                getItemCount:function(){
                    return basket.length;
                },
                //私有函数的公有形式别名,
                // doSomething:doSomethingPrivate自动调用doSomethingPrivate函数
                doSomething:doSomethingPrivate,
                //获取购物车里所有item的价格总值
                getTotal:function(){
                    var itemCount=this.getItemCount(),total=0;
                    while(itemCount--){
                        total+=basket[itemCount].price;
                    }
                    return total;
                }
            };
        })();
    
        //basketModule返回了一个拥有公用API的对象
        basketModule.addItem({
            item:"bread",
            price: 0.5
        });
        basketModule.addItem({
            item:"butter",
            price:0.3
        });
        console.log(basketModule.getItemCount());
        console.log(basketModule.getTotal());
        //会打印一个private和一个undefined,原因不明
        console.log(basketModule.doSomething());
        console.log(basketModule.basket);

    复制代码

     

    basket模块的优点:

     

    1》只有模块自身才能享有拥有私有函数的自由,因为它只会暴露我们输出的API。

     

    2》鉴于函数往往已声明并命名,在试图找到哪些函数抛出异常时,这将使得在调试器中显示调用堆栈变得更容易。(没感觉)

     

    3》根据环境,还可以让我们返回不同 的函数

     

    9.2.2.3 示例

    复制代码

        /**
         * counter的存在被局限在模块的闭包内,唯一能访问其作用域的代码是return中的2个函数
         */
        var testModule=(function(){
            var counter=0;
            return{
                incrementCounter:function(){
                    return ++counter;
                },
                resetCounter:function(){
                    console.log("counter value prior to reset "+counter);
                    counter=0;
                }
            };
        })();
        //增加计数器
        testModule.incrementCounter();
        //检查并重置计数器
        testModule.resetCounter();

    复制代码

     

    复制代码

    //引入混入
        var myModule=(function(jQ,_){
            function privateMethod1(){
                jQ(".container").html("test");
            }
            return{
                publicMethod:function(){
                    privateMethod1();
                }
            };
        //引入JQuery和Underscore
        })(jQuery,_);

    复制代码

     

    我们用立即执行函数(Immediately-Invoked-Function-Expressions (IIFE)) 创建私有空间,防止其泄露全局作用域。其样子如下:

    var myGirlfriend = (function() {
    
      // 定义私有变量或方法
      var name = '小郑';
    
      var _kiss = function() {
        console.log('吻');
      }
    
      var _smile = function() {
        console.log('微笑');
      }
    
      return {
        // 暴露给公有的变量或方法
        simle: _smile,
        name: name
      }
    
    })();
    
    console.log(myGirlfriend.name); 
    myGirlfriend.simle();
    
    console.log(myGirlfriend._simle);
    console.log(myGirlfriend._kiss);
    
    /**
     * 结果:
     *     小美
     *     微笑
     *     undefined
     *     undefined
    */
    

    在Module模式内,由于闭包的存在,声明的变量和方法只在模式内部可用,但在返回的对象上定义的变量和方法,在对外部也可用。如上面例子:其他人可以知道我的女朋友的名字,也可以看到我女朋友微笑,但不可以吻我女朋友。

    Module模式的优缺点:

    优点:

    • 实现代码的封装模块化
    • 实现私有化变量和方法

    缺点:

    • 无法应用私有变量,造成无法对私有变量进行单元测试
    • 当我们想改可见性时,实际上要修改每一个曾经使用过该成员的地方。

    这里只举例了一种简单Module的设计模式,从Module模式上还衍生出Revealing Module(揭示模块)模式、Singleton(单例)模式。这些模式都很有使用价值,不同当我们的系统中出现了它们,则表示我们能需要评估我们的设计,例如Singleton的存在往往表明系统中的模块要么是系统紧密耦合,要么是其逻辑过于分散在代码库的多个部分中。



    作者:内孤
    链接:https://www.jianshu.com/p/03c5b939e5d4
    來源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • Go module的介绍及使用

    2019-09-24 16:57:49
    Go1.1.1版本发布(2018-08-24发布)已经过去几天,从官方的博客中看到,有两个比较突出的特色,一个就是今天讲的module,模块概念。目前该功能还在试验阶段,有些地方还需要不断的进行完善。不过可以先尝尝鲜,感受下...

    Go1.1.1版本发布(2018-08-24发布)已经过去几天,从官方的博客中看到,有两个比较突出的特色,一个就是今天讲的module,模块概念。目前该功能还在试验阶段,有些地方还需要不断的进行完善。在官方正式宣布之前,打算不断修正这种支持。到时候就可以移除对GOPATHgo get命令的支持。
    如果你想现在想就试试这个新功能module,需要你将你的代码仓库放到GOPATH/src目录之外。然后在那个目录下创建一个go.mod文件,从文件树中运行go命令。

    主要概念介绍

    module是一个相关Go包的集合,它是源代码更替和版本控制的单元。模块由源文件形成的go.mod文件的根目录定义,包含go.mod文件的目录也被称为模块根。moudles取代旧的的基于GOPATH方法来指定在工程中使用哪些源文件或导入包。模块路径是导入包的路径前缀,go.mod文件定义模块路径,并且列出了在项目构建过程中使用的特定版本。

    go.mod文件

    go.mod文件定义module路径以及列出其他需要在build时引入的模块的特定的版本。例如下面的例子中,go.mod声明example.com/m路径时module的根目录,同时也声明了module依赖特定版本的golang.org/x/textgopkg.in/yaml.v2

    module example.com/m
    
    require (
        golang.org/x/text v0.3.0
        gopkg.in/yaml.v2  v2.1.0
    )
    

    go.mod文件还可以指定要替换和排除的版本,命令行会自动根据go.mod文件来维护需求声明中的版本。如果想获取更多的有关go.mod文件的介绍,可以使用命令go help go.mod
    go.mod文件用//注释,而不用/**/。文件的每行都有一条指令,由一个动作加上参数组成。例如:

    module my/thing
    require other/thing 	v1.0.2
    require new/thing 		v2.3.4
    exclude old/thing 		v1.2.3
    replace bad/thing 		v1.4.5 	=> good/thing v1.4.5
    

    上面三个动词requireexcludereplace分别表示:项目需要的依赖包及版本、排除某些包的特别版本、取代当前项目中的某些依赖包。
    相同动作的命令可以放到一个动词+括号组成的结构中,例如:

    require (
        new/thing v2.3.4
        old/thing v1.2.3
    )
    

    其他命令的支持

    旧的版本,构建编译命令go build中的参数没有-mod参数,最新的版本现在多了这个,用来对go.mod文件进行更新或其他使用控制。形式如:go build -mod [mode],其中mode有以下几种取值:readonlyreleasevendor。当执行go build -mod=vendor的时候,会在生成可执行文件的同时将项目的依赖包放到主模块的vendor目录下。
    go get -m [packages]会将下载的依赖包放到GOPATH/pkg/mod目录下,并且将依赖写入到go.mod文件。go get -u=patch会更新主模块下的所有依赖包。
    如果遇到不熟悉的导入包,任何可以查找包含该引入包模块的go命令,都会自动将该模块的最新版本添加到go.mod文件中。同时也会添加缺失的模块,以及删除无用的module。例如:go build, go test或者go list命令。另外,有一个专门的命令go mod tidy,用来查看和添加缺失的module需求声明以及移除不必要的。
    go.mod文件是可读,也是可编辑的。go命令行会自动更新go.mod文件来维持一个标准格式以及精确的引入声明。

    Go mod命令

    Go mod提供了一系列操作modules的命令,记住,所有的go命令中现在已经内置了对module的支持,而不仅仅是go mod命令。例如使用go get时,会经常自动在后台添加、移除、升级、降级依赖包版本。
    命令语法:go mod <command> [arguments]Go mod提供的命令有下面几个,对于比较常用的命令进行详细说明。

    download                //下载模块到本地缓存,具体可以通过命令go env查看,其中环境变量GOCACHE就是缓存的地址,如果该文件夹的内容太大,可以通过命令go clean -cache
    edit                    //从工具或脚本中编辑go.mod文件
    graph                   //打印模块需求图
    init                    //在当前目录下初始化新的模块
    tidy                    //添加缺失的模块以及移除无用的模块
    verify                  //验证依赖项是否达到预期的目的
    why                     //解释为什么需要包或模块
    

    go mod download
    用法:go mod download [-dir] [-json] [modules]。使用此命令来下载指定的模块,模块的格式可以根据主模块依赖的形式或者path@version形式指定。如果没有指定参数,此命令会将主模块下的所有依赖下载下来。
    go mod download命令非常有用,主要用来预填充本地缓存或者计算Go模块代理的回答。默认情况下,下载错误会输出到标准输出,正常情况下没有任何输出。-json参数会以JSON的格式打印下载的模块对象,对应的Go对象结构是这样。

    type Module struct {
        Path        string      //module path
        Version     string      //module version
        Error       string      //error loading module
        Info        string      //absolute path to cached .info file
        GoMod       string      //absolute path to cached .mod file
        Zip         string      //absolute path to cached .zip file
        Dir         string      //absolute path to cached source root directory
        Sum         string      //checksum for path, version (as in go.sum)
        GoModSum    string      //checksum for go.mod (as in go.sum)
    }
    

    go mod init
    用法:go mod init [module]。此命令会在当前目录中初始化和创建一个新的go.mod文件,当然你也可以手动创建一个go.mod文件,然后包含一些module声明,这样就比较麻烦。go mod init命令可以帮助我们自动创建,例如:

    go mod init example.com/m
    

    使用这条命令时,go.mod文件必须提前不能存在。初始化会根据引入包声明来推测模块的路径或者如果你工程中之前已经存在一些依赖包管理工具,例如godepglide或者dep。那么go mod init同样也会根据依赖包管理配置文件来推断。
    go mod tidy
    默认情况下,Go不会移除go.mod文件中的无用依赖。所以当你的依赖中有些使用不到了,可以使用go mod tidy命令来清除它。
    用法:go mod tidy [-v]它会添加缺失的模块以及移除不需要的模块。执行后会生成go.sum文件(模块下载条目)。添加参数-v,例如go mod tidy -v可以将执行的信息,即移除的模块打印到标准输出。
    go mod vendor
    用法:go mod vendor [-v],此命令会将build阶段需要的所有依赖包放到主模块所在的vendor目录中,并且测试所有主模块的包。同理go mod vendor -v会将添加到vendor中的模块打印到标准输出。
    go mod verify
    用法:go mod verify。此命令会检查当前模块的依赖是否已经存储在本地下载的源代码缓存中,以及检查自从下载下来是否有修改。如果所有的模块都没有修改,那么会打印all modules verified,否则会打印变化的内容。

    虚拟版本号

    go.mod文件和go命令通常使用语义版本作为描述模块版本的标准形式,这样可以比较不同版本的先后顺序。例如模块的版本是v1.2.3,那么通过重新对版本号进行标签处理,得到该版本的虚拟版本。形式如:v0.0.0-yyyymmddhhmmss-abcdefabcdef。其中时间是提交时的UTC时间,最后的后缀是提交的哈希值前缀。时间部分确保两个虚拟版本号可以进行比较,以确定两者顺序。
    下面有三种形式的虚拟版本号:

    • vX.0.0-yyyymmddhhmmss-abcdefabcdef,这种情况适合用在在目标版本提交之前 ,没有更早的的版本。(这种形式本来是唯一的形式,所以一些老的go.mod文件使用这种形式)
    • vX.Y.Z-pre.0.yyyymmddhhmmss-abcdefabcdef,这种情况被用在当目标版本提交之前的最新版本提交是vX.Y.Z-pre
    • vX.Y.(Z+1)-0.yyyymmddhhmmss-abcdefabcdef,同理,这种情况是当目标版本提交之前的最新版本是vX.Y.Z

    虚拟版本的生成不需要你去手动操作,go命令会将接收的commit哈希值自动转化为虚拟版本号。

    环境变量——GO111MODULE

    Go 1.11中module支持临时环境变量——GO111MODULE,它可以设置以下三个值:off,on或者auto(默认)。

    • 如果GO111MODULE=off,那么go命令行将不会使用新的module功能,相反的,它将会在vendor目录下和GOPATH目录中查找依赖包。也把这种模式叫GOPATH模式
    • 如果GO111MODULE=on,那么go命令行就会使用modules功能,而不会访问GOPATH。也把这种模式称作module-aware模式,这种模式下,GOPATH不再在build时扮演导入的角色,但是尽管如此,它还是承担着存储下载依赖包的角色。它会将依赖包放在GOPATH/pkg/mod目录下。
    • 如果GO111MODULE=auto,这种模式是默认的模式,也就是说在你不设置的情况下,就是auto。这种情况下,go命令行会根据当前目录来决定是否启用module功能。只有当当前目录在GOPATH/src目录之外而且当前目录包含go.mod文件或者其子目录包含go.mod文件才会启用。

    具体使用步骤:

    1. 首先将你的版本更新到最新的Go版本(>=1.11),如何更新版本可以自行百度。
    2. 通过go命令行,进入到你当前的工程目录下,在命令行设置临时环境变量set GO111MODULE=on
    3. 执行命令go mod init在当前目录下生成一个go.mod文件,执行这条命令时,当前目录不能存在go.mod文件。如果之前生成过,要先删除;
    4. 如果你工程中存在一些不能确定版本的包,那么生成的go.mod文件可能就不完整,因此继续执行下面的命令;
    5. 执行go mod tidy命令,它会添加缺失的模块以及移除不需要的模块。执行后会生成go.sum文件(模块下载条目)。添加参数-v,例如go mod tidy -v可以将执行的信息,即删除和添加的包打印到命令行;
    6. 执行命令go mod verify来检查当前模块的依赖是否全部下载下来,是否下载下来被修改过。如果所有的模块都没有被修改过,那么执行这条命令之后,会打印all modules verified
    7. 执行命令go mod vendor生成vendor文件夹,该文件夹下将会放置你go.mod文件描述的依赖包,文件夹下同时还有一个文件modules.txt,它是你整个工程的所有模块。在执行这条命令之前,如果你工程之前有vendor目录,应该先进行删除。同理go mod vendor -v会将添加到vendor中的模块打印出来;
    展开全文
  • linux/module.h

    2019-06-01 21:20:04
    #ifndef _LINUX_MODULE_H #define _LINUX_MODULE_H /* * Dynamic loading of modules into the kernel. * * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996 * Rewritten again by Rusty Russel....
    #ifndef _LINUX_MODULE_H
    #define _LINUX_MODULE_H
    /*
     * Dynamic loading of modules into the kernel.
     *
     * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
     * Rewritten again by Rusty Russell, 2002
     */
    #include <linux/list.h>
    #include <linux/stat.h>
    #include <linux/compiler.h>
    #include <linux/cache.h>
    #include <linux/kmod.h>
    #include <linux/init.h>
    #include <linux/elf.h>
    #include <linux/stringify.h>
    #include <linux/kobject.h>
    #include <linux/moduleparam.h>
    #include <linux/jump_label.h>
    #include <linux/export.h>
    #include <linux/rbtree_latch.h>
    #include <linux/error-injection.h>
    #include <linux/tracepoint-defs.h>
    
    #include <linux/percpu.h>
    #include <asm/module.h>
    
    /* In stripped ARM and x86-64 modules, ~ is surprisingly rare. */
    #define MODULE_SIG_STRING "~Module signature appended~\n"
    
    /* Not Yet Implemented */
    #define MODULE_SUPPORTED_DEVICE(name)
    
    #define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
    
    struct modversion_info {
    	unsigned long crc;
    	char name[MODULE_NAME_LEN];
    };
    
    struct module;
    struct exception_table_entry;
    
    struct module_kobject {
    	struct kobject kobj;
    	struct module *mod;
    	struct kobject *drivers_dir;
    	struct module_param_attrs *mp;
    	struct completion *kobj_completion;
    } __randomize_layout;
    
    struct module_attribute {
    	struct attribute attr;
    	ssize_t (*show)(struct module_attribute *, struct module_kobject *,
    			char *);
    	ssize_t (*store)(struct module_attribute *, struct module_kobject *,
    			 const char *, size_t count);
    	void (*setup)(struct module *, const char *);
    	int (*test)(struct module *);
    	void (*free)(struct module *);
    };
    
    struct module_version_attribute {
    	struct module_attribute mattr;
    	const char *module_name;
    	const char *version;
    } __attribute__ ((__aligned__(sizeof(void *))));
    
    extern ssize_t __modver_version_show(struct module_attribute *,
    				     struct module_kobject *, char *);
    
    extern struct module_attribute module_uevent;
    
    /* These are either module local, or the kernel's dummy ones. */
    extern int init_module(void);
    extern void cleanup_module(void);
    
    #ifndef MODULE
    /**
     * module_init() - driver initialization entry point
     * @x: function to be run at kernel boot time or module insertion
     *
     * module_init() will either be called during do_initcalls() (if
     * builtin) or at module insertion time (if a module).  There can only
     * be one per module.
     */
    #define module_init(x)	__initcall(x);
    
    /**
     * module_exit() - driver exit entry point
     * @x: function to be run when driver is removed
     *
     * module_exit() will wrap the driver clean-up code
     * with cleanup_module() when used with rmmod when
     * the driver is a module.  If the driver is statically
     * compiled into the kernel, module_exit() has no effect.
     * There can only be one per module.
     */
    #define module_exit(x)	__exitcall(x);
    
    #else /* MODULE */
    
    /*
     * In most cases loadable modules do not need custom
     * initcall levels. There are still some valid cases where
     * a driver may be needed early if built in, and does not
     * matter when built as a loadable module. Like bus
     * snooping debug drivers.
     */
    #define early_initcall(fn)		module_init(fn)
    #define core_initcall(fn)		module_init(fn)
    #define core_initcall_sync(fn)		module_init(fn)
    #define postcore_initcall(fn)		module_init(fn)
    #define postcore_initcall_sync(fn)	module_init(fn)
    #define arch_initcall(fn)		module_init(fn)
    #define subsys_initcall(fn)		module_init(fn)
    #define subsys_initcall_sync(fn)	module_init(fn)
    #define fs_initcall(fn)			module_init(fn)
    #define fs_initcall_sync(fn)		module_init(fn)
    #define rootfs_initcall(fn)		module_init(fn)
    #define device_initcall(fn)		module_init(fn)
    #define device_initcall_sync(fn)	module_init(fn)
    #define late_initcall(fn)		module_init(fn)
    #define late_initcall_sync(fn)		module_init(fn)
    
    #define console_initcall(fn)		module_init(fn)
    
    /* Each module must use one module_init(). */
    #define module_init(initfn)					\
    	static inline initcall_t __maybe_unused __inittest(void)		\
    	{ return initfn; }					\
    	int init_module(void) __copy(initfn) __attribute__((alias(#initfn)));
    
    /* This is only required if you want to be unloadable. */
    #define module_exit(exitfn)					\
    	static inline exitcall_t __maybe_unused __exittest(void)		\
    	{ return exitfn; }					\
    	void cleanup_module(void) __copy(exitfn) __attribute__((alias(#exitfn)));
    
    #endif
    
    /* This means "can be init if no module support, otherwise module load
       may call it." */
    #ifdef CONFIG_MODULES
    #define __init_or_module
    #define __initdata_or_module
    #define __initconst_or_module
    #define __INIT_OR_MODULE	.text
    #define __INITDATA_OR_MODULE	.data
    #define __INITRODATA_OR_MODULE	.section ".rodata","a",%progbits
    #else
    #define __init_or_module __init
    #define __initdata_or_module __initdata
    #define __initconst_or_module __initconst
    #define __INIT_OR_MODULE __INIT
    #define __INITDATA_OR_MODULE __INITDATA
    #define __INITRODATA_OR_MODULE __INITRODATA
    #endif /*CONFIG_MODULES*/
    
    /* Generic info of form tag = "info" */
    #define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
    
    /* For userspace: you can also call me... */
    #define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
    
    /* Soft module dependencies. See man modprobe.d for details.
     * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
     */
    #define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep)
    
    /*
     * The following license idents are currently accepted as indicating free
     * software modules
     *
     *	"GPL"				[GNU Public License v2 or later]
     *	"GPL v2"			[GNU Public License v2]
     *	"GPL and additional rights"	[GNU Public License v2 rights and more]
     *	"Dual BSD/GPL"			[GNU Public License v2
     *					 or BSD license choice]
     *	"Dual MIT/GPL"			[GNU Public License v2
     *					 or MIT license choice]
     *	"Dual MPL/GPL"			[GNU Public License v2
     *					 or Mozilla license choice]
     *
     * The following other idents are available
     *
     *	"Proprietary"			[Non free products]
     *
     * There are dual licensed components, but when running with Linux it is the
     * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
     * is a GPL combined work.
     *
     * This exists for several reasons
     * 1.	So modinfo can show license info for users wanting to vet their setup
     *	is free
     * 2.	So the community can ignore bug reports including proprietary modules
     * 3.	So vendors can do likewise based on their own policies
     */
    #define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
    
    /*
     * Author(s), use "Name <email>" or just "Name", for multiple
     * authors use multiple MODULE_AUTHOR() statements/lines.
     */
    #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
    
    /* What your module does. */
    #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
    
    #ifdef MODULE
    /* Creates an alias so file2alias.c can find device table. */
    #define MODULE_DEVICE_TABLE(type, name)					\
    extern typeof(name) __mod_##type##__##name##_device_table		\
      __attribute__ ((unused, alias(__stringify(name))))
    #else  /* !MODULE */
    #define MODULE_DEVICE_TABLE(type, name)
    #endif
    
    /* Version of form [<epoch>:]<version>[-<extra-version>].
     * Or for CVS/RCS ID version, everything but the number is stripped.
     * <epoch>: A (small) unsigned integer which allows you to start versions
     * anew. If not mentioned, it's zero.  eg. "2:1.0" is after
     * "1:2.0".
    
     * <version>: The <version> may contain only alphanumerics and the
     * character `.'.  Ordered by numeric sort for numeric parts,
     * ascii sort for ascii parts (as per RPM or DEB algorithm).
    
     * <extraversion>: Like <version>, but inserted for local
     * customizations, eg "rh3" or "rusty1".
    
     * Using this automatically adds a checksum of the .c files and the
     * local headers in "srcversion".
     */
    
    #if defined(MODULE) || !defined(CONFIG_SYSFS)
    #define MODULE_VERSION(_version) MODULE_INFO(version, _version)
    #else
    #define MODULE_VERSION(_version)					\
    	static struct module_version_attribute ___modver_attr = {	\
    		.mattr	= {						\
    			.attr	= {					\
    				.name	= "version",			\
    				.mode	= S_IRUGO,			\
    			},						\
    			.show	= __modver_version_show,		\
    		},							\
    		.module_name	= KBUILD_MODNAME,			\
    		.version	= _version,				\
    	};								\
    	static const struct module_version_attribute			\
    	__used __attribute__ ((__section__ ("__modver")))		\
    	* __moduleparam_const __modver_attr = &___modver_attr
    #endif
    
    /* Optional firmware file (or files) needed by the module
     * format is simply firmware file name.  Multiple firmware
     * files require multiple MODULE_FIRMWARE() specifiers */
    #define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
    
    struct notifier_block;
    
    #ifdef CONFIG_MODULES
    
    extern int modules_disabled; /* for sysctl */
    /* Get/put a kernel symbol (calls must be symmetric) */
    void *__symbol_get(const char *symbol);
    void *__symbol_get_gpl(const char *symbol);
    #define symbol_get(x) ((typeof(&x))(__symbol_get(__stringify(x))))
    
    /* modules using other modules: kdb wants to see this. */
    struct module_use {
    	struct list_head source_list;
    	struct list_head target_list;
    	struct module *source, *target;
    };
    
    enum module_state {
    	MODULE_STATE_LIVE,	/* Normal state. */
    	MODULE_STATE_COMING,	/* Full formed, running module_init. */
    	MODULE_STATE_GOING,	/* Going away. */
    	MODULE_STATE_UNFORMED,	/* Still setting it up. */
    };
    
    struct mod_tree_node {
    	struct module *mod;
    	struct latch_tree_node node;
    };
    
    struct module_layout {
    	/* The actual code + data. */
    	void *base;
    	/* Total size. */
    	unsigned int size;
    	/* The size of the executable code.  */
    	unsigned int text_size;
    	/* Size of RO section of the module (text+rodata) */
    	unsigned int ro_size;
    	/* Size of RO after init section */
    	unsigned int ro_after_init_size;
    
    #ifdef CONFIG_MODULES_TREE_LOOKUP
    	struct mod_tree_node mtn;
    #endif
    };
    
    #ifdef CONFIG_MODULES_TREE_LOOKUP
    /* Only touch one cacheline for common rbtree-for-core-layout case. */
    #define __module_layout_align ____cacheline_aligned
    #else
    #define __module_layout_align
    #endif
    
    struct mod_kallsyms {
    	Elf_Sym *symtab;
    	unsigned int num_symtab;
    	char *strtab;
    };
    
    #ifdef CONFIG_LIVEPATCH
    struct klp_modinfo {
    	Elf_Ehdr hdr;
    	Elf_Shdr *sechdrs;
    	char *secstrings;
    	unsigned int symndx;
    };
    #endif
    
    struct module {
    	enum module_state state;
    
    	/* Member of list of modules */
    	struct list_head list;
    
    	/* Unique handle for this module */
    	char name[MODULE_NAME_LEN];
    
    	/* Sysfs stuff. */
    	struct module_kobject mkobj;
    	struct module_attribute *modinfo_attrs;
    	const char *version;
    	const char *srcversion;
    	struct kobject *holders_dir;
    
    	/* Exported symbols */
    	const struct kernel_symbol *syms;
    	const s32 *crcs;
    	unsigned int num_syms;
    
    	/* Kernel parameters. */
    #ifdef CONFIG_SYSFS
    	struct mutex param_lock;
    #endif
    	struct kernel_param *kp;
    	unsigned int num_kp;
    
    	/* GPL-only exported symbols. */
    	unsigned int num_gpl_syms;
    	const struct kernel_symbol *gpl_syms;
    	const s32 *gpl_crcs;
    
    #ifdef CONFIG_UNUSED_SYMBOLS
    	/* unused exported symbols. */
    	const struct kernel_symbol *unused_syms;
    	const s32 *unused_crcs;
    	unsigned int num_unused_syms;
    
    	/* GPL-only, unused exported symbols. */
    	unsigned int num_unused_gpl_syms;
    	const struct kernel_symbol *unused_gpl_syms;
    	const s32 *unused_gpl_crcs;
    #endif
    
    #ifdef CONFIG_MODULE_SIG
    	/* Signature was verified. */
    	bool sig_ok;
    #endif
    
    	bool async_probe_requested;
    
    	/* symbols that will be GPL-only in the near future. */
    	const struct kernel_symbol *gpl_future_syms;
    	const s32 *gpl_future_crcs;
    	unsigned int num_gpl_future_syms;
    
    	/* Exception table */
    	unsigned int num_exentries;
    	struct exception_table_entry *extable;
    
    	/* Startup function. */
    	int (*init)(void);
    
    	/* Core layout: rbtree is accessed frequently, so keep together. */
    	struct module_layout core_layout __module_layout_align;
    	struct module_layout init_layout;
    
    	/* Arch-specific module values */
    	struct mod_arch_specific arch;
    
    	unsigned long taints;	/* same bits as kernel:taint_flags */
    
    #ifdef CONFIG_GENERIC_BUG
    	/* Support for BUG */
    	unsigned num_bugs;
    	struct list_head bug_list;
    	struct bug_entry *bug_table;
    #endif
    
    #ifdef CONFIG_KALLSYMS
    	/* Protected by RCU and/or module_mutex: use rcu_dereference() */
    	struct mod_kallsyms *kallsyms;
    	struct mod_kallsyms core_kallsyms;
    
    	/* Section attributes */
    	struct module_sect_attrs *sect_attrs;
    
    	/* Notes attributes */
    	struct module_notes_attrs *notes_attrs;
    #endif
    
    	/* The command line arguments (may be mangled).  People like
    	   keeping pointers to this stuff */
    	char *args;
    
    #ifdef CONFIG_SMP
    	/* Per-cpu data. */
    	void __percpu *percpu;
    	unsigned int percpu_size;
    #endif
    
    #ifdef CONFIG_TRACEPOINTS
    	unsigned int num_tracepoints;
    	tracepoint_ptr_t *tracepoints_ptrs;
    #endif
    #ifdef CONFIG_BPF_EVENTS
    	unsigned int num_bpf_raw_events;
    	struct bpf_raw_event_map *bpf_raw_events;
    #endif
    #ifdef CONFIG_JUMP_LABEL
    	struct jump_entry *jump_entries;
    	unsigned int num_jump_entries;
    #endif
    #ifdef CONFIG_TRACING
    	unsigned int num_trace_bprintk_fmt;
    	const char **trace_bprintk_fmt_start;
    #endif
    #ifdef CONFIG_EVENT_TRACING
    	struct trace_event_call **trace_events;
    	unsigned int num_trace_events;
    	struct trace_eval_map **trace_evals;
    	unsigned int num_trace_evals;
    #endif
    #ifdef CONFIG_FTRACE_MCOUNT_RECORD
    	unsigned int num_ftrace_callsites;
    	unsigned long *ftrace_callsites;
    #endif
    
    #ifdef CONFIG_LIVEPATCH
    	bool klp; /* Is this a livepatch module? */
    	bool klp_alive;
    
    	/* Elf information */
    	struct klp_modinfo *klp_info;
    #endif
    
    #ifdef CONFIG_MODULE_UNLOAD
    	/* What modules depend on me? */
    	struct list_head source_list;
    	/* What modules do I depend on? */
    	struct list_head target_list;
    
    	/* Destruction function. */
    	void (*exit)(void);
    
    	atomic_t refcnt;
    #endif
    
    #ifdef CONFIG_CONSTRUCTORS
    	/* Constructor functions. */
    	ctor_fn_t *ctors;
    	unsigned int num_ctors;
    #endif
    
    #ifdef CONFIG_FUNCTION_ERROR_INJECTION
    	struct error_injection_entry *ei_funcs;
    	unsigned int num_ei_funcs;
    #endif
    } ____cacheline_aligned __randomize_layout;
    #ifndef MODULE_ARCH_INIT
    #define MODULE_ARCH_INIT {}
    #endif
    
    #ifndef HAVE_ARCH_KALLSYMS_SYMBOL_VALUE
    static inline unsigned long kallsyms_symbol_value(const Elf_Sym *sym)
    {
    	return sym->st_value;
    }
    #endif
    
    extern struct mutex module_mutex;
    
    /* FIXME: It'd be nice to isolate modules during init, too, so they
       aren't used before they (may) fail.  But presently too much code
       (IDE & SCSI) require entry into the module during init.*/
    static inline bool module_is_live(struct module *mod)
    {
    	return mod->state != MODULE_STATE_GOING;
    }
    
    struct module *__module_text_address(unsigned long addr);
    struct module *__module_address(unsigned long addr);
    bool is_module_address(unsigned long addr);
    bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
    bool is_module_percpu_address(unsigned long addr);
    bool is_module_text_address(unsigned long addr);
    
    static inline bool within_module_core(unsigned long addr,
    				      const struct module *mod)
    {
    	return (unsigned long)mod->core_layout.base <= addr &&
    	       addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
    }
    
    static inline bool within_module_init(unsigned long addr,
    				      const struct module *mod)
    {
    	return (unsigned long)mod->init_layout.base <= addr &&
    	       addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
    }
    
    static inline bool within_module(unsigned long addr, const struct module *mod)
    {
    	return within_module_init(addr, mod) || within_module_core(addr, mod);
    }
    
    /* Search for module by name: must hold module_mutex. */
    struct module *find_module(const char *name);
    
    struct symsearch {
    	const struct kernel_symbol *start, *stop;
    	const s32 *crcs;
    	enum {
    		NOT_GPL_ONLY,
    		GPL_ONLY,
    		WILL_BE_GPL_ONLY,
    	} licence;
    	bool unused;
    };
    
    /*
     * Search for an exported symbol by name.
     *
     * Must be called with module_mutex held or preemption disabled.
     */
    const struct kernel_symbol *find_symbol(const char *name,
    					struct module **owner,
    					const s32 **crc,
    					bool gplok,
    					bool warn);
    
    /*
     * Walk the exported symbol table
     *
     * Must be called with module_mutex held or preemption disabled.
     */
    bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
    				    struct module *owner,
    				    void *data), void *data);
    
    /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
       symnum out of range. */
    int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
    			char *name, char *module_name, int *exported);
    
    /* Look for this name: can be of form module:name. */
    unsigned long module_kallsyms_lookup_name(const char *name);
    
    int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
    					     struct module *, unsigned long),
    				   void *data);
    
    extern void __noreturn __module_put_and_exit(struct module *mod,
    			long code);
    #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code)
    
    #ifdef CONFIG_MODULE_UNLOAD
    int module_refcount(struct module *mod);
    void __symbol_put(const char *symbol);
    #define symbol_put(x) __symbol_put(__stringify(x))
    void symbol_put_addr(void *addr);
    
    /* Sometimes we know we already have a refcount, and it's easier not
       to handle the error case (which only happens with rmmod --wait). */
    extern void __module_get(struct module *module);
    
    /* This is the Right Way to get a module: if it fails, it's being removed,
     * so pretend it's not there. */
    extern bool try_module_get(struct module *module);
    
    extern void module_put(struct module *module);
    
    #else /*!CONFIG_MODULE_UNLOAD*/
    static inline bool try_module_get(struct module *module)
    {
    	return !module || module_is_live(module);
    }
    static inline void module_put(struct module *module)
    {
    }
    static inline void __module_get(struct module *module)
    {
    }
    #define symbol_put(x) do { } while (0)
    #define symbol_put_addr(p) do { } while (0)
    
    #endif /* CONFIG_MODULE_UNLOAD */
    int ref_module(struct module *a, struct module *b);
    
    /* This is a #define so the string doesn't get put in every .o file */
    #define module_name(mod)			\
    ({						\
    	struct module *__mod = (mod);		\
    	__mod ? __mod->name : "kernel";		\
    })
    
    /* Dereference module function descriptor */
    void *dereference_module_function_descriptor(struct module *mod, void *ptr);
    
    /* For kallsyms to ask for address resolution.  namebuf should be at
     * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
     * found, otherwise NULL. */
    const char *module_address_lookup(unsigned long addr,
    			    unsigned long *symbolsize,
    			    unsigned long *offset,
    			    char **modname,
    			    char *namebuf);
    int lookup_module_symbol_name(unsigned long addr, char *symname);
    int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
    
    int register_module_notifier(struct notifier_block *nb);
    int unregister_module_notifier(struct notifier_block *nb);
    
    extern void print_modules(void);
    
    static inline bool module_requested_async_probing(struct module *module)
    {
    	return module && module->async_probe_requested;
    }
    
    #ifdef CONFIG_LIVEPATCH
    static inline bool is_livepatch_module(struct module *mod)
    {
    	return mod->klp;
    }
    #else /* !CONFIG_LIVEPATCH */
    static inline bool is_livepatch_module(struct module *mod)
    {
    	return false;
    }
    #endif /* CONFIG_LIVEPATCH */
    
    bool is_module_sig_enforced(void);
    
    #else /* !CONFIG_MODULES... */
    
    static inline struct module *__module_address(unsigned long addr)
    {
    	return NULL;
    }
    
    static inline struct module *__module_text_address(unsigned long addr)
    {
    	return NULL;
    }
    
    static inline bool is_module_address(unsigned long addr)
    {
    	return false;
    }
    
    static inline bool is_module_percpu_address(unsigned long addr)
    {
    	return false;
    }
    
    static inline bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
    {
    	return false;
    }
    
    static inline bool is_module_text_address(unsigned long addr)
    {
    	return false;
    }
    
    /* Get/put a kernel symbol (calls should be symmetric) */
    #define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
    #define symbol_put(x) do { } while (0)
    #define symbol_put_addr(x) do { } while (0)
    
    static inline void __module_get(struct module *module)
    {
    }
    
    static inline bool try_module_get(struct module *module)
    {
    	return true;
    }
    
    static inline void module_put(struct module *module)
    {
    }
    
    #define module_name(mod) "kernel"
    
    /* For kallsyms to ask for address resolution.  NULL means not found. */
    static inline const char *module_address_lookup(unsigned long addr,
    					  unsigned long *symbolsize,
    					  unsigned long *offset,
    					  char **modname,
    					  char *namebuf)
    {
    	return NULL;
    }
    
    static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
    {
    	return -ERANGE;
    }
    
    static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
    {
    	return -ERANGE;
    }
    
    static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
    					char *type, char *name,
    					char *module_name, int *exported)
    {
    	return -ERANGE;
    }
    
    static inline unsigned long module_kallsyms_lookup_name(const char *name)
    {
    	return 0;
    }
    
    static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
    							   struct module *,
    							   unsigned long),
    						 void *data)
    {
    	return 0;
    }
    
    static inline int register_module_notifier(struct notifier_block *nb)
    {
    	/* no events will happen anyway, so this can always succeed */
    	return 0;
    }
    
    static inline int unregister_module_notifier(struct notifier_block *nb)
    {
    	return 0;
    }
    
    #define module_put_and_exit(code) do_exit(code)
    
    static inline void print_modules(void)
    {
    }
    
    static inline bool module_requested_async_probing(struct module *module)
    {
    	return false;
    }
    
    static inline bool is_module_sig_enforced(void)
    {
    	return false;
    }
    
    /* Dereference module function descriptor */
    static inline
    void *dereference_module_function_descriptor(struct module *mod, void *ptr)
    {
    	return ptr;
    }
    
    #endif /* CONFIG_MODULES */
    
    #ifdef CONFIG_SYSFS
    extern struct kset *module_kset;
    extern struct kobj_type module_ktype;
    extern int module_sysfs_initialized;
    #endif /* CONFIG_SYSFS */
    
    #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
    
    /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
    
    #define __MODULE_STRING(x) __stringify(x)
    
    #ifdef CONFIG_STRICT_MODULE_RWX
    extern void set_all_modules_text_rw(void);
    extern void set_all_modules_text_ro(void);
    extern void module_enable_ro(const struct module *mod, bool after_init);
    extern void module_disable_ro(const struct module *mod);
    #else
    static inline void set_all_modules_text_rw(void) { }
    static inline void set_all_modules_text_ro(void) { }
    static inline void module_enable_ro(const struct module *mod, bool after_init) { }
    static inline void module_disable_ro(const struct module *mod) { }
    #endif
    
    #ifdef CONFIG_GENERIC_BUG
    void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
    			 struct module *);
    void module_bug_cleanup(struct module *);
    
    #else	/* !CONFIG_GENERIC_BUG */
    
    static inline void module_bug_finalize(const Elf_Ehdr *hdr,
    					const Elf_Shdr *sechdrs,
    					struct module *mod)
    {
    }
    static inline void module_bug_cleanup(struct module *mod) {}
    #endif	/* CONFIG_GENERIC_BUG */
    
    #ifdef CONFIG_RETPOLINE
    extern bool retpoline_module_ok(bool has_retpoline);
    #else
    static inline bool retpoline_module_ok(bool has_retpoline)
    {
    	return true;
    }
    #endif
    
    #ifdef CONFIG_MODULE_SIG
    static inline bool module_sig_ok(struct module *module)
    {
    	return module->sig_ok;
    }
    #else	/* !CONFIG_MODULE_SIG */
    static inline bool module_sig_ok(struct module *module)
    {
    	return true;
    }
    #endif	/* CONFIG_MODULE_SIG */
    
    #endif /* _LINUX_MODULE_H */
    
    展开全文
  • 参考PyTorch document和discuss在PyTorch中,所有的neural network module都是class torch.nn.Module的子类,在Modules中可以包含其它的Modules,以一种树状结构进行嵌套。当需要返回神经网络中的各个模块时,Module...

    参考PyTorch document和discuss 
    在PyTorch中,所有的neural network module都是class torch.nn.Module的子类,在Modules中可以包含其它的Modules,以一种树状结构进行嵌套。当需要返回神经网络中的各个模块时,Module.modules()方法返回网络中所有模块的一个iterator,而Module.children()方法返回所有直接子模块的一个iterator。具体而言:

    list ( nn.Sequential(nn.Linear(10, 20), nn.ReLU()).modules() )
    Out[9]:
    [Sequential (
    (0): Linear (10 -> 20)
    (1): ReLU ()
    ), Linear (10 -> 20), ReLU ()]

    In [10]: list( nn.Sequential(nn.Linear(10, 20), nn.ReLU()) .children() )
    Out[10]: [Linear (10 -> 20), ReLU ()]

    举例:Faster-RCNN基于vgg19提取features,但是只使用了vgg19一部分模型提取features。

    步骤:

    下载vgg19的pth文件,在anaconda中直接设置pretrained=True下载一般都比较慢,在model_zoo里面有各种预训练模型的下载链接:
    model_urls = {
    'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
    'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
    'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
    'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
    'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
    'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
    'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
    'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth'  }

    下载好的模型,可以用下面这段代码看一下模型参数,并且改一下模型。在vgg19.pth同级目录建立一个test.py。

    import torch
    import torch.nn as nn
    import torchvision.models as models

    vgg16 = models.vgg16(pretrained=False)

    #打印出预训练模型的参数
    vgg16.load_state_dict(torch.load('vgg16-397923af.pth'))
    print('vgg16:\n', vgg16) 

    modified_features = nn.Sequential(*list(vgg16.features.children())[:-1])
    # to relu5_3
    print('modified_features:\n', modified_features )#打印修改后的模型参数

    修改好之后features就可以拿去做Faster-RCNN提取特征用了。


     

    本文内容主要参考:https://www.cnblogs.com/wmlj/p/9917827.html

     

    转载于:https://www.cnblogs.com/czz0508/p/10502149.html

    展开全文
  • 当你想在Android Studio中删除某个module时,大家习惯性的做法都是选中要删除的module,右键去找delete。但是 在Android Studio中你选中module,右键会发现没有delete,如图: 为什么会没有delete按钮,不科学啊,...
  • 官方文档:https://docs.oracle.com/javase/9/index.html关于 java9的新特性,官方原文:https://docs.oracle.com/javase/9/whatsnew/toc.htm这玩意就是一个列表,具体的技术细节需要根据官方文档挖一挖。...
  • module

    2020-04-28 22:35:40
    module ES6之前javascript没有模块体系,无法将一个大型的项目拆分成互相依赖的小文件,再用简单的方式进行简单的拼接。 社区制定了模块化开发的规范,最主要的两种模块化解决的方案:Commonjs,AMD两种。 commonjs...
  • Module

    2019-07-09 18:26:59
    Module 模块 在Python中:一个.py文件就称之为一个模块(Module) 分类 但其实import加载的模块分为四个通用类别: 内置标准模块(又称标准库)执行help('modules')查看所有Python自带模块列表 第三方开源模块,可通过pip ...
  • module.exports 对象是由模块系统创建的。在我们自己写模块的时候,需要在模块最后写好模块接口,声明这个模块对外暴露什么内容,module.exports 提供了暴露接口的方法。 1、返回一个JSON Object var app = { ...
  • 在PyCharm中运行代码报错: import torch ModuleNotFoundError: No module named ‘torch’
  • @NgModule 的重要作用 在 Angular 中,NgModule 有以下几个重要的作用: NgModule 最根本的意义是帮助开发者组织业务代码,开发者可以利用 NgModule 把关系比较紧密的组件组织到一起,这是首要的。...
  • THIS_MODULE ?

    2011-04-23 16:42:00
     一直都在耿耿于怀,这个THIS_MODULE到底是个什么玩意,linux内核中无处不在的东西。今天上网搜了一下,算是基本明白了。网上牛人写的已经比较详细,另外目前暂时没有时间往更深层次分析,所以直接贴过来得了...
  • 代码功能是生成器的调用,为什么报这个错误,“TypeError: ‘module’ object is not callable”从这串英文可以看出,模块调用出问题,在看代码调用了哪个模块,看头导入了什么模块,一个是greenlet模块一个是time...
  • 的版本,结果一顿瞎折腾可,导致之前写的好多东西都不能import了,报错No module named xxx 顾名思义,就是Pycharm以及ipython找不到自定义的模块了。但是具体怎么解决呢? 1、在说这个之前,有一个
  • 1.依次点击File–>new–>Import Module,如下图:2.在弹出窗口中选中需要导入的第三方资源中的...此时会跳出错误提示(不一定跟我的一样):我们双击导入Module文件夹下的build.gradle文件:同时打开本项目下的build.gra
  • 在 IntelliJ IDEA 中,没有类似于 Eclipse 工作空间(Workspace)的概念,而是提出了Project和Module这两个概念。接下来,就让咱们一起看看 IntelliJ IDEA 官方是如何描述两者的吧!对于 Project,IntelliJ IDEA 是...
  • 前言:前面介绍了如何自定义一个模型——通过继承nn.Module类来实现,在__init__构造函数中申明各个层的定义,在forward中实现层之间的连接关系,实际上就是前向传播的过程。 事实上,在pytorch里面自定义层也是...
  • 有时我们在做项目时,我们为了方便需要将已有的module导入到项目中进行使用。那么如何将以有的module导入android studio项目中呢? 方法一: 最简单的方法就是找到这个module,直接复制到项目中; 方法二: 打开...
1 2 3 4 5 ... 20
收藏数 945,257
精华内容 378,102
关键字:

module