pytorch的使用（三）

一、基本组件的使用

1.使用Pytorch的nn.MSELoss()

2.使用Pytorch的optim.SGD

3.使用Pytorch的nn.Linear

#1.损失函数

def test01():
    #初始化平方损失函数
    criterion = nn.MSELoss()
    # 该类内部重写__call__方法，所以对象可以当做函数来使用
    y_pred = torch.randn(3,5, requires_grad=True)
    y_true = torch.randn((3,5))
    loss = criterion(y_pred, y_true)

    print(loss)

# 假设函数
def test02():

    model = nn.Linear(in_features=10,out_features=5)

    input = torch.randn(4,10)
    output = model(input)
    print(output.shape)

# 优化器
def test03():
    #优化方法
    model = nn.Linear(in_features=10,out_features=5)
    optimizer = optim.SGD(model.parameters(),lr=1e-3)
    
    #在backward（）函数调用之前，需要进行梯度清零
    optimizer.zero_grad()

    #此处省略了backward（）函数调用，假设该函数调用完毕
    # 更新参数
    optimizer.step()

二、数据加载器

1.构建数据类，可以自己编写一个数据类，并让该类继承自Dataset对象，并在类的内部实现

 __init__ 、__len__ 、__getitem__

2.如果样本比较简单、直接通过索引就可以退回，此时使用TensorDataset来构建数据集

3.把数据集传入到DataLoader类内就可以构建数据加载器

import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader,TensorDataset

# 1. 数据类的构建
class  SampleDataset(Dataset):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        self.len = len(y)

    def __len__(self):
        return self.len

    def __getitem__(self, idx):
        ids = min(max(idx,0),self.len-1)
        return self.x[ids],self.y[ids]



def test01():
    # 构建包含100个样本的数据集，每个样本有8个特征
    x = torch.randn(100,8)
    y = torch.randint(0,2,[x.size(0),])

    #构建数据加载器的步骤：1.构建数据类，2.构建数据加载器
    Sample_dataset = SampleDataset(x,y)
    print(Sample_dataset[0])



# 2. 数据加载器的使用
def test02():
    #1.构建数据类
    x = torch.randn(100,8)
    y = torch.randint(0,2,[x.size(0),])
    Sample_dataset = SampleDataset(x,y)

    #2. 使用DataLoader 构建数据加载器
    dataloader = DataLoader(Sample_dataset,batch_size=4,shuffle=True)

    for x,y in dataloader:
        print(x)
        print(y)
        break


# 3.简单的数据类型构建方法
def test03():
    x = torch.randn(100,8)
    y = torch.randint(0,2,[x.size(0),])
    Sample_dataset = TensorDataset(x,y)
    dataloader = DataLoader(Sample_dataset,batch_size=4,shuffle=True)

    for x,y in dataloader:
        print(x)
        print(y)
        break

三、模型的保存和加载

1.直接序列化模型对象

class Model(nn.Module):
    def __init__(self,input_size,output_size):
        super(Model,self).__init__()
        self.linear1 = nn.Linear(input_size,input_size*2)
        self.linear2 = nn.Linear(input_size*2,output_size)


    def forward(self,inputs):

        inputs = self.linear1(inputs)
        output = self.linear2(inputs)

        return output

def test01():
    model = Model(128,10)

    torch.save(model,'test_model_save.pth',pickle_module=pickle,pickle_protocol=2)

def test02():
    model = torch.load('test_model_save.pth',pickle_module=pickle,map_location='cpu')
    print(model)

注意：当我们训练的模型在GPU中，torch.save函数将其存储到磁盘中。当再次加载模型时，会改该模型从磁盘先加载在CPU中，在移动到指定的GPU中，例如：cuda:0 cuda:1 .但是当重新加载的机器不存在GPU时，模型在在可能会出错，这时，可通过map_location='cpu'将其加载到cpu中。

2.存储模型的网络参数

def test03():
    model = Model(128,10)
    # 初始化优化器
    optimizer = optim.Adam(model.parameters(),lr=1e-2)

    # 定义要存储的参数
    save_params = {
        'init_params':{'input_size':128,'output_size':10 },
        'acc_score':0.98,
        'avg_loss':0.86,
        'optim_params':optimizer.state_dict(),
        'model_params':model.state_dict()
    }
    #存储模型参数
    torch.save(save_params,'model_params.pth')

#实现模型的加载
def test04():
    model_params = torch.load('model_params.pth')

    model = Model(model_params['init_params']['input_size'],model_params['init_params']['output_size'])
    model.load_state_dict(model_params['model_params'])
    #使用指定参数初始化优化器
    optimizer = optim.Adam(model.parameters())
    optimizer.load_state_dict(model_params['optim_params'])