6、pytorch学习-- nn.Module

目录

*前置知识：python中的类和模块

1、创建一个类

2、继承

3、多态

4、模块

二、pytorch api调用

用API实现5中的回归

模型评估：

整理流程总结：

模型的保存与加载

---

*前置知识：python中的类和模块 1、创建一个类

__init__函数，理解起来是类实例化之后就默认自动执行的函数，必须包含一个self作为参数，也可以定义其他的参数，但是定义了的话在实例化的时候就需要把这个参数传进去。无论后面是否要写到这个方法，实例化对象之后就默认执行一下这个函数。

#在python中定义一个类
class Person:
  #attribute field
  #属性
  name=“Mike”
  age=22
  #方法
  def greet(self):
    print("Hello my name is"+ self.name)
  #定义一个初始化的方法，
  def __init__(self):
    self.name="Alice"
#缩进结束，类的定义也结束
p1=Person()#实例化
p1.greet()
del p1.age#删除已经实例化的类中的一个属性

#init函数限制必须传入参数进行初始化的 *** 作
class Person2:
  def __init__(self,init_name):
    self.name=init_name
#实例化一个类的时候就需要输入init_name
p2=Person2("David")

2、继承

注意父类和子类的逻辑关系，父类定义最基础的属性和方法，子类继承与延展

class Animal:
  def __init__(self,init_name):
    self.name=init_name
  def greet(self):#里面的self作为定位的参数必须写上！
    print("hello I am an %s" %self.name)#百分号S作为字符型占位符

#dog继承于animal，只需要重新定义/修改/重新添加里面需要的方法就可以
class Dog(Animal):
  def greet(self):
    print("wangwang I am a %s" %self.name)
  def run(self):#重新定义一个新的函数
    print("I am running!")
    
dog=Dog("dog")
dog.greet()
dog.run()

3、多态

理解起来就是同一个函数定义下面用了父类，然后子类调用的时候可以自动定位到子类的相关定义中去

#承接上面继承的代码
class Cat(Animal):
  def greet(self):
    print("miaomiao I am a %s" %self.name)
  def run(self):#重新定义一个新的函数
    print("I am running!")
    
def hello(animal):
    animal.greet()

cat=Cat("cat")
hello(dog)
hello(cat)

4、模块

模块理解为py结尾的python文件，Python标准库中有很多已经写好的这种文件，直接进行调用即可。或者通过pip（包管理器）的方式来下载一些其他的库

from animal import Animal
#从名字为animal的模块（文件）中调用Animal函数

import animal
#调用整个模块
cat=animal.Cat("Kitty")
#注意这里需要表上模块名字才可以，否则就要import的时候写清楚

二、pytorch api调用

1、nn.module

2、optimizer优化器类

用API实现5中的回归

import torch
import torch.nn as nn
from torch.optim import SGD
#准备数据
x=torch.rand([500,1])#随机创建数据
y_true=3*x+0.8
#定义模型
class MyLinear(nn.Module):#定义一个子类
    def __init__(self):#init函数要继承父类
        super(MyLinear,self).__init__()
        self.linear=nn.Linear(1,1)#线性模型，（输入，输出，0次项）
    def forward(self,x):
        out=self.linear(x)
        return out
    
#实例化模型、优化器类、损失
my_linear=MyLinear()
optimizer=SGD(my_linear.parameters(),0.001)
loss_fn=nn.MSELoss()

#循环进行梯度下降
for i in range(2000):
    y_predict=my_linear(x)
    loss=loss_fn(y_predict,y_true)
    optimizer.zero_grad()#用优化器类将梯度设置为0
    loss.backward()
    optimizer.step()
    if i%50==0:
        print(loss.item(),my_linear.parameters())

模型评估：

my_linear.train(False)
model.eval()
#这两行代码是等价的，都是告诉程序这是进入预测模式，而不是训练模式

整理流程总结：

• 实例化模型，设置模型为训练模式
• 实例化优化器类，实例化损失函数
• 获取dataset，遍历dataloader
• 梯度清零
• 进行前向计算forward，得到output
• 计算损失
• 反向传播
• 更新参数优化器类的step *** 作

#实现学习过程
model=MnistModel()#实例化，在train函数外面，方便多次调用该函数
#mnist数据集，手写数字识别
optimizer=optim.Adam(mnist_net.parameters(),lr=0.001)
#optim优化器类中的Adam函数，动态调整学习率，使整体保证较为平稳。初始学习率lr
def train(epoch):#train方法实现训练过程
    mode=True
    mnist_net.train(mode=mode)#设置模型为训练模式
    train_dataloader=get_dataloader(train=mode)
    for idx,(data,target) in enumerate(trian_dataloader):
    #idx用在for里面，后面使用enumerate函数可以返回下标
        optimizer.zero_grad()#梯度设置为0
        output=mnist_net(data)#进行前向计算
        loss=F.nll_loss(output,target)#得到损失
        loss.backward()#进行反向传播并计算梯度
        optimizer.step()#参数更新
        if idx%100==0:
            print(loss.item())

模型的保存与加载

也可以设置每隔一百个idx保存一次

#保存
torch.save(mnist_net.state_dict(),"model_data.pt")#保存参数
torch.save(optimizer.state_dict(),"result_optimizer.pt")#保存优化器

#加载
mnist_net.load_state_dict(torch.load("model_data.pt")
optimizer.load_state_dict(torch.load("result_optimizer.pt")