Pytorch基础知识2

5.Pytorch nn.Module API

5.1概念

nn.Module是最所有神经网络基本的父类 baseClass

所有自编写的模型应该要继承这个类

Module本身可以包含其他的子model

import torch.nn as nn
import torch.nn.functional as F
​
class Model(nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.conv1 = nn.Conv2d(1,20,5)     ##2维卷积,也是子MOdel
        self.conv2 = nn.Conv2d(20,20,5)
        
    def forward(self,x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))
​

apply(fn) 初始化模型参数，fn是函数，init类似的便利参数初始化

@torch.no_grad()     ##修饰符
def init_weights(m):
    print(m)
    if type(m)==nn.Linear:
        m.weight.fill_(1.0)
        print(m.weight)
net = nn.Sequential(nn.Linear(2,2), nn.Linear(2,2))
net.apply(init_weights)

bfloat16(),将float类型转换为bfloat16类型

buffers()

for buf in model.buffers():
    print(type(buf), buf.size())

paramerters参数是参与的随机梯度下降,

.cpu()

.cuda()

eval()把模型设置为evalation模式

get_parameter()根据字符串得到模型参数

load_state_dict()，训练完几个epoch保存在磁盘后，下次运行加载参数和buffer

torch.save()将模型参数保存磁盘中

named_paraters 返回模型参数值啥的

requires_gard(requires_gard=True)，模型参数梯度下降是否需要更新

state_dict字典形式保存模型参数

EPOCH=5
PATH="model.pt"
LOSS=0.4
​
torch.save({
    'epoch':EPOCH,
    'model_state_dict':net.state_dict(),
    'optimizer_state_dict':optimizer_state_dict,##优化器的参数
    'loss':LOSS，   ##当前epoch损失函数的平均值   
},PATH)

导入总体CheckPoint

首先要初始化模型，然后加载全局字典参数

model = Net()
optimizer = optim.SGD(net.parameters(),lr=0.001, momentum=0.9)
​
checkpoint=torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_load_state'])
epoch = checkpoint['epoch']
loss=checkpoint['loss']
​
model.eval()

register_parameter(self,name:str,param:Optional),向模型中添加参数，最终会添加到parameters字典中

5.2保存和加载model

import torch
import torchvision.models as models
​
model = model.vgg16(pretarined=True)
torch.save(model.state_dict(), 'model_weights.pth')    ##这个是只保存模型的权重
​

mod
el = models.vgg16()
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()

模型的权重，优化器的权重等都要保存

##自定义test网络
class Test(torch.nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.linear1=torch.nn.Linear(2，3)     ##第一层Linear最少两个参数，输入输出大小
        self.linear2=torch.nn.Linear(3,4)      ##第二层
        self.batch_norm=torch.nn.BatchNorm2d(4)   ##第三层 批归一化层
        
test_model=Test()
print(test_module._modules)   ##返回层的有序字典
print(test_model._modules['linear1'].weight)
​

有_parameters, _modules, _buffers三种成员变量, _modules存放的是子模块的参数

当调用_parameters， _buffers时没有设定相关参数的话，会返回空字典，返回的是当前模型的字段（不是子模型的字段），register_parameters设定的参数.

save_to_state_dict也是保存当前模块的参数

Dropout也是继承自Moduel,可以调用training参数

eval进入推理模式，内部是self.train=False

是否需要对参数记录导数值，运用requires_grad_

Pytorch会对参数的梯度进行累计，要使用zero_grad进行清零

Sequential把很多层包含起来，方便调用，具有前向forward运算功能

谷歌colab啥的提供了免费训练模型的环境

6.Pytorch Autograd

import torch
​
x=torch.ones(5)
y=torch.zeros(3)
w=torch.randn(5,3,requires_grad=True)
b=torch.matmul(x,w)+b
z=torch.matmul(x,w)+b
loss=torch.nn.functional.binary_cross_entropy_with_logits(z,y)
loss.backward()   ##计算梯度,计算的是动态图，计算完后自动销毁
print(w.grad)
print(b.grad)

有时候不需要梯度计算

z=torch.matmul(x,w)+b   ##继承父类自动微分
print(z.requires_grad)
​
with torch.no_grad():
    z=torch.matmul(x,w)+b
print(z.requires_grad)

对于长度大于1的张量求梯度的计算方式与标量不相同

torch.autograd.funnctional.jiacobian()

##求雅可比矩阵
a=torch.randn(3)
def func(x):
    return a+x
x=torch.randn(3)
jiacobian(func,x)   ##传入函数名，变量值