【Pytorch神经网络理论篇】 05 Module类的使用方法+参数Parameters类+定义训练模型的步骤与方法

同学你好!本文章于2021年末编写,获得广泛的好评!

故在2022年末对本系列进行填充与更新,欢迎大家订阅最新的专栏,获取基于Pytorch1.10版本的理论代码(2023版)实现,

Pytorch深度学习·理论篇(2023版)目录地址为:

CSDN独家 | 全网首发 | Pytorch深度学习·理论篇(2023版)目录本专栏将通过系统的深度学习实例,从可解释性的角度对深度学习的原理进行讲解与分析,通过将深度学习知识与Pytorch的高效结合,帮助各位新入门的读者理解深度学习各个模板之间的关系,这些均是在Pytorch上实现的,可以有效的结合当前各位研究生的研究方向,设计人工智能的各个领域,是经过一年时间打磨的精品专栏!https://v9999.blog.csdn.net/article/details/127587345欢迎大家订阅(2023版)理论篇

以下为2021版原文~~~~

 

【Pytorch神经网络理论篇】 05 Module类的使用方法+参数Parameters类+定义训练模型的步骤与方法_第1张图片

1 Module类的使用方法

1.1 Module类的add_module()方法

1.1.1 概述

add_module():将XX层插入到模型结构中

1.1.2 add_module()----LogicNet_fun.py(第1部分)

import torch.nn as nn
import torch
import numpy as np
import matplotlib.pyplot as plt

class LogicNet(nn.Module):
    def __init__(self,inputdim,hiddendim,outputdim):
        super(LogicNet, self).__init__()
        ### 方法①
        self.Linear1 = nn.Linear(inputdim,hiddendim)
        self.Linear2 = nn.Linear(hiddendim,outputdim)
        ### 方法②
        self.add_module("Linear1",nn.Linear(inputdim,hiddendim))
        self.add_module("Linear2",nn.Linear(hiddendim,outputdim))
        self.criterion = nn.CrossEntropyLoss()
    def forward(self,x):
        x = self.Linear1(x)
model = LogicNet(inputdim=2,hiddendim=3,outputdim=2)
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)

1.2 Module类的children()方法

1.2.1 children()概述

children()方法获取模型中的各层函数

1.2.2 children()代码实现----LogicNet_fun.py(第2部分)

### Module类的children()方法===》获取模型中的各层函数
for sub_module in model.children():
    print(sub_module)
    # 输出 Linear(in_features=2, out_features=3, bias=True)
    #     Linear(in_features=3, out_features=2, bias=True)
    #     CrossEntropyLoss()

1.3 Module类的named_children()方法

1.3.1named_children()概述

named_children()获取模型中的各层名字与结构信息

1.3.2 named_children()代码实现----LogicNet_fun.py(第3部分)

### Module类的named_children()===>获取模型中的各层名字与结构信息
for name,module in model.named_children():
    print(name,"is:",module)
    # 输出 Linear1 is: Linear(in_features=2, out_features=3, bias=True)
    #     Linear2 is: Linear(in_features=3, out_features=2, bias=True)
    #     criterion is: CrossEntropyLoss()

1.4 Module类的modules()方法

1.4.1 modules()概述

modules()获取整个网络的结构信息

1.4.2 modules()()代码实现----LogicNet_fun.py(第4部分)

### Module类的modules()===>获取整个网络的结构信息
for module in model.modules():
    print(module)
    # 输出 LogicNet(
    #               (Linear1): Linear(in_features=2, out_features=3, bias=True)
    #               (Linear2): Linear(in_features=3, out_features=2, bias=True)
    #               (criterion): CrossEntropyLoss()
    # )
    model.eval()
    # 输出 Linear(in_features=2, out_features=3, bias=True)
    #     Linear(in_features=3, out_features=2, bias=True)
    #     CrossEntropyLoss()

2 模型中的参数Parameters类

2.1 概述

2.1.2 模型与参数的关系

训练过程中,模型通过公式的计算结果与目标值进行对比,通过调整参数来实现误差的最小化。经过多次调整后的参数,可以使得整个模型的结果高度接近于目标值,进而得到有效的模型。

2.1.2 Parameter参数的属性

Parameters是Variable类的子类,但是存在以下两点不同

①将Parameter参数赋值给Module的属性时候,会将其自动加到Module参数列表中

②将Variable变量赋值给Module的属性时候,不会将其加到Module参数列表中

2.2模型添加参数

2.2.1 register_parameter(name,param) 为模型添加parameter参数

class Example(nn.Module):
    def __init__(self):
        super(Example, self).__init__()
        print('看看我们的模型有哪些parameter:\t', self._parameters, end='\n')
        # 输出 mymodel = Example()
        # '''
        # 看看我们的模型有哪些parameter:	 OrderedDict()

        self.W1_params = nn.Parameter(torch.rand(2,3))
        print('增加W1后看看:',self._parameters, end='\n')
        # 增加W1后看看: OrderedDict([('W1_params', Parameter containing:
        # tensor([[0.0479, 0.9264, 0.1193],
        #         [0.5004, 0.7336, 0.6464]], requires_grad=True))])

        
        self.register_parameter('W2_params' , nn.Parameter(torch.rand(2,3)))
        print('增加W2后看看:',self._parameters, end='\n')
        # 增加W2后看看: OrderedDict([('W1_params', Parameter containing:
        # tensor([[0.0479, 0.9264, 0.1193],
        #         [0.5004, 0.7336, 0.6464]], requires_grad=True)), ('W2_params',         Parameter containing:
        # tensor([[0.1028, 0.2370, 0.8500],
        #         [0.6116, 0.0463, 0.4229]], requires_grad=True))])
        # '''
    def forward(self, x):
        return x

2.2.2 register_buffer(name,param) 增加状态参数

代码:

import torch 
import torch.nn as nn
torch.manual_seed(seed=20200910)
class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.conv1=torch.nn.Sequential(  # 输入torch.Size([64, 1, 28, 28])
                torch.nn.Conv2d(1,64,kernel_size=3,stride=1,padding=1),
                torch.nn.ReLU(),  # 输出torch.Size([64, 64, 28, 28])
        )
        self.attribute_buffer_in = torch.randn(3,5)
        register_buffer_in_temp = torch.randn(4,6)
        self.register_buffer('register_buffer_in', register_buffer_in_temp)

    def forward(self,x): 
        pass

print('cuda(GPU)是否可用:',torch.cuda.is_available())
print('torch的版本:',torch.__version__)
model = Model() #.cuda()


print('初始化之后模型修改之前'.center(100,"-"))
print('调用named_buffers()'.center(100,"-"))
for name, buf in model.named_buffers():
    print(name,'-->',buf.shape)

print('调用named_parameters()'.center(100,"-"))
for name, param in model.named_parameters():
    print(name,'-->',param.shape)

print('调用buffers()'.center(100,"-"))
for buf in model.buffers():
    print(buf.shape)

print('调用parameters()'.center(100,"-"))
for param in model.parameters():
    print(param.shape)

print('调用state_dict()'.center(100,"-"))
for k, v in model.state_dict().items():
    print(k, '-->', v.shape)



model.attribute_buffer_out = torch.randn(10,10)
register_buffer_out_temp = torch.randn(15,15)
model.register_buffer('register_buffer_out', register_buffer_out_temp)
print('模型初始化以及修改之后'.center(100,"-"))
print('调用named_buffers()'.center(100,"-"))
for name, buf in model.named_buffers():
    print(name,'-->',buf.shape)

print('调用named_parameters()'.center(100,"-"))
for name, param in model.named_parameters():
    print(name,'-->',param.shape)

print('调用buffers()'.center(100,"-"))
for buf in model.buffers():
    print(buf.shape)

print('调用parameters()'.center(100,"-"))
for param in model.parameters():
    print(param.shape)

print('调用state_dict()'.center(100,"-"))
for k, v in model.state_dict().items():
    print(k, '-->', v.shape)

输出结果:

cuda(GPU)是否可用: True
torch的版本: 1.10.0+cu113
--------------------------------------------初始化之后模型修改之前---------------------------------------------
-----------------------------------------调用named_buffers()------------------------------------------
register_buffer_in --> torch.Size([4, 6])
----------------------------------------调用named_parameters()----------------------------------------
conv1.0.weight --> torch.Size([64, 1, 3, 3])
conv1.0.bias --> torch.Size([64])
--------------------------------------------调用buffers()---------------------------------------------
torch.Size([4, 6])
-------------------------------------------调用parameters()-------------------------------------------
torch.Size([64, 1, 3, 3])
torch.Size([64])
-------------------------------------------调用state_dict()-------------------------------------------
register_buffer_in --> torch.Size([4, 6])
conv1.0.weight --> torch.Size([64, 1, 3, 3])
conv1.0.bias --> torch.Size([64])
--------------------------------------------模型初始化以及修改之后---------------------------------------------
-----------------------------------------调用named_buffers()------------------------------------------
register_buffer_in --> torch.Size([4, 6])
register_buffer_out --> torch.Size([15, 15])
----------------------------------------调用named_parameters()----------------------------------------
conv1.0.weight --> torch.Size([64, 1, 3, 3])
conv1.0.bias --> torch.Size([64])
--------------------------------------------调用buffers()---------------------------------------------
torch.Size([4, 6])
torch.Size([15, 15])
-------------------------------------------调用parameters()-------------------------------------------
torch.Size([64, 1, 3, 3])
torch.Size([64])
-------------------------------------------调用state_dict()-------------------------------------------
register_buffer_in --> torch.Size([4, 6])
register_buffer_out --> torch.Size([15, 15])
conv1.0.weight --> torch.Size([64, 1, 3, 3])
conv1.0.bias --> torch.Size([64])

2.2.3 对比

缓冲buffer和参数Parameter的区别是前者不需要训练优化,而后者需要训练优化.在创建方法上也有区别,前者必须要将一个张量使用方法register_buffer()来登记注册,后者比较灵活,可以直接赋值给模块的属性,也可以使用方法register_parameter()来登记注册.

3 从模型中获取参数

3.1 使用parameters()方法获取模型的Parameter参数

3.1.1 parameters()方法获取模型的Parameter参数的代码----LogicNet_fun.py(第5部分)

### 使用parameters()方法获取模型的Parameter参数
for param in model.parameters():
    print(type(param.data),param.size())
    # 输出  torch.Size([3, 2])
    #      torch.Size([3])
    #      torch.Size([2, 3])
    #      torch.Size([2])

3.2 使用named_parameters()获取模型中的参数和参数名字

3.2.1 使用named_parameters()获取模型中的参数和参数名字----LogicNet_fun.py(第6部分)

### 使用named_parameters()获取模型中的参数和参数名字
for name, param in model.named_parameters():
    print(type(param.data),param.size(),name)
    # 输出  torch.Size([3, 2]) Linear1.weight
    #      torch.Size([3]) Linear1.bias
    #      torch.Size([2, 3]) Linear2.weight
    #      torch.Size([2]) Linear2.bias

3.3 state_dict()获取模型的全部参数

3.3.1 state_dict()概述

state_dict()可以将模型中的Parameter和buffer参数取出,但不可取出Variable变量

3.3.2 tate_dict()代码实现

import torch
from torch.autograd import Variable
import torch.nn as nn

class ModelPar(nn.Module):
    def __init__(self):
        super(ModelPar, self).__init__()
        self.Line1 = nn.Linear(1,2) # 定义全连接层
        self.var1 = Variable(torch.rand([1])) # 定义Variable变量
        self.par = nn.Parameter(torch.rand([1])) # 定义Parameter变量
        self.register_buffer("buffer",torch.randn([2,3])) # 定义buffer变量

model = ModelPar()
for par in model.state_dict():
    print(par,':',model.state_dict()[par])
    # 输出 par : tensor([0.0285])
    #     buffer : tensor([[-0.7736,  0.7613,  0.5444],[ 1.0695,  0.7132, -0.3575]])
    #     Line1.weight : tensor([[0.7708],[0.6926]])
    #     Line1.bias : tensor([-0.0628, -0.6818])

3.4 为模型中的参数指定名称,并查看权重

即:通过指定名称的方式对该层的权重进行快速提取

3.4.1 代码实现

import torch
import torch.nn as nn
from collections import  OrderedDict

model = nn.Sequential(
    OrderedDict(
        [
            ('conv1',nn.Conv2d(1,20,5)),
            ('rule1',nn.ReLU()),
            ('conv2',nn.Conv2d(20,64,5)),
            ('relu2',nn.ReLU())
        ]
    )
)
print(model)
# 输出 Sequential(
#       (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
#       (rule1): ReLU()
#       (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
#       (relu2): ReLU()
#     )

params = model.state_dict()
print(params['conv1.weight'])
print(params['conv1.bias'])

4 保存与载入模型

4.1 保存模型+载入模型+将模型载入指定的硬件设备

4.1.1 代码实现 ----LogicNet_fun.py(第7部分)

### 保存模型
torch.save(model.state_dict(),'./model.path')
### 载入模型
model.load_state_dict(torch.load('./model.path'))
### 将模型载入到指定的硬件设备中===>该方法并不常用
### 为实现细粒度控制 通常将其分解为  1、将模型载入内存。2、使用模型的to()方法,将模型复制到指定的设备中
model.load_state_dict(torch.load('./model.path',map_location={'cuda:1','cuda:0'}))

5 模型结构中的钩子函数

5.1 正向钩子函数概述

5.1.1 模型正向结构中的钩子

模型正向结构中的钩子函数定义:

register_forward_hook(hook)

hook(module,input,output) #不可修改input和output的数值,返回一个句柄
#调用handle的remove()方法可以将hook从module中去除

在module上注册一个forward_hook,使得每次调用forward()计算输出的时候,这个hook函数就会被调用。

5.1.2 正向结构中的钩子函数的代码实现

import torch
from torch import nn
from torch.autograd import  Variable

def for_hook(module,input,output): # 定义钩子函数
    print("模型:",module)
    for val in input:
        print("输入:",val)
    for out_val in output :
        print("输出:",out_val)

class Model(nn.Module): #定义模型
    def __init__(self):
        super(Model, self).__init__()
    def forward(self,x):
        return x+1

model = Model() #实例化模型
x = Variable(torch.FloatTensor([1]),requires_grad=True)
handle = model.register_forward_hook(for_hook) # 注册钩子
print("模型结果",model(x)) # 运行模型
# 输出 模型: Model()
#     输入: tensor([1.], requires_grad=True)
#     输出: tensor(2., grad_fn=)
#     模型结果 tensor([2.], grad_fn=)

###删除钩子
handle.remove()
print("模型结果",model(x)) # 运行模型
# 输出 模型结果 tensor([2.], grad_fn=)

5.2 反向钩子函数概述

5.2.1 反向结构中的钩子函数

模型反向结构中的钩子函数定义:

register_backward_hook(hook)
### 在module上注册一个backward_hook,每次计算module的input的梯度时,这个hook就会被调用

hook(module,grad_input,grad_output) #不可修改grad_input和grad_outpu的数值,返回一个句柄
# 但可以选择性的返回关于输入的梯度,返回的梯度会在后续的计算中替换grad_input
#多个输入输出时,grad_input,grad_output会是个元组

#调用handle的remove()方法可以将hook从module中去除

在module上注册一个backward_hook,使得每次计算module的input的梯度时,调用hook()

LogicNet_fun.py汇总

import torch.nn as nn
import torch

class LogicNet(nn.Module):
    def __init__(self,inputdim,hiddendim,outputdim):
        super(LogicNet, self).__init__()
        ### 方法①
        self.Linear1 = nn.Linear(inputdim,hiddendim)
        self.Linear2 = nn.Linear(hiddendim,outputdim)
        ### 方法②
        self.add_module("Linear1",nn.Linear(inputdim,hiddendim))
        self.add_module("Linear2",nn.Linear(hiddendim,outputdim))
        self.criterion = nn.CrossEntropyLoss()
    def forward(self,x):
        x = self.Linear1(x)
model = LogicNet(inputdim=2,hiddendim=3,outputdim=2)
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)

### Module类的children()方法===》获取模型中的各层函数
for sub_module in model.children():
    print(sub_module)
    # 输出 Linear(in_features=2, out_features=3, bias=True)
    #     Linear(in_features=3, out_features=2, bias=True)
    #     CrossEntropyLoss()

### Module类的named_children()===>获取模型中的各层名字与结构信息
for name,module in model.named_children():
    print(name,"is:",module)
    # 输出 Linear1 is: Linear(in_features=2, out_features=3, bias=True)
    #     Linear2 is: Linear(in_features=3, out_features=2, bias=True)
    #     criterion is: CrossEntropyLoss()

### Module类的modules()===>获取整个网络的结构信息
for module in model.modules():
    print(module)
    # 输出 LogicNet(
    #               (Linear1): Linear(in_features=2, out_features=3, bias=True)
    #               (Linear2): Linear(in_features=3, out_features=2, bias=True)
    #               (criterion): CrossEntropyLoss()
    # )
    model.eval()
    # 输出 Linear(in_features=2, out_features=3, bias=True)
    #     Linear(in_features=3, out_features=2, bias=True)
    #     CrossEntropyLoss()


### 使用parameters()方法获取模型的Parameter参数
for param in model.parameters():
    print(type(param.data),param.size())
    # 输出  torch.Size([3, 2])
    #      torch.Size([3])
    #      torch.Size([2, 3])
    #      torch.Size([2])

### 使用named_parameters()获取模型中的参数和参数名字
for name, param in model.named_parameters():
    print(type(param.data),param.size(),name)
    # 输出  torch.Size([3, 2]) Linear1.weight
    #      torch.Size([3]) Linear1.bias
    #      torch.Size([2, 3]) Linear2.weight
    #      torch.Size([2]) Linear2.bias


### 保存模型
torch.save(model.state_dict(),'./model.path')
### 载入模型
model.load_state_dict(torch.load('./model.path'))
### 将模型载入到指定的硬件设备中===>该方法并不常用
### 常将其分解为  1、将模型载入内存。2、使用模型的to()方法,将模型复制到指定的设备中
model.load_state_dict(torch.load('./model.path',map_location={'cuda:1','cuda:0'}))

你可能感兴趣的:(#,深度学习理论篇(2021版),深度学习,神经网络,pytorch)