Python深度学习：PyTorch API

1、nn.Module

• init
• forward：完成一次前向计算的过程
• nn.Linear(input的特征数量， output的特征数量)

class Lr(nn.Module):
    '''
        定义模型
    '''
    def __init__(self):
        super(Lr, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out

model = Lr()                                            # 实例化模型
predict = model(x)

2、优化器类

• optimizer = optim.Adam(model.parameters(), lr=val)
• optimizer = optim.SGD(model.parameters(), lr=val)

optimizer = optim.SGD(model.parameters(), lr=1e-3)      # 优化器
optimizer.zero_grad()           						# 梯度置0
loss.backward()                 						# 反向传播
optimizer.step()                						# 更新梯度

3、损失函数

• 均方误差：criterion = nn.MSELoss()，常用于分类
• 交叉熵损失：criterion = nn.CrossEntropyLoss()，常用于逻辑回归

criterion = nn.MSELoss()                                # loss函数
loss = criterion(y, out)        						# 计算损失

4、实现线性回归

• 导入要用的包，定义问题

import torch
from torch import nn
from torch import optim
import matplotlib.pyplot as plt


x = torch.rand([50, 1])
y = x * 3 + 0.8

• 定义模型

class Lr(nn.Module):
    '''
        定义模型
    '''
    def __init__(self):
        super(Lr, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out

• 模型评估

def model_eval(model):
    '''
        模型评估
    :param model: 模型
    :return: None
    '''
    model.eval()
    predict = model(x)
    predict = predict.data.numpy()
    plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
    plt.plot(x.data.numpy(), predict)
    plt.show()

• 训练模型

def run():
    '''
        实例化并训练模型
    :return: None
    '''

    # 实例化模型
    model = Lr()                                                # 实例化模型
    criterion = nn.MSELoss()                                    # loss函数
    optimizer = optim.Adam(model.parameters(), lr=1e-3)         # 优化器

    # 训练模型
    train_times = 30000
    for i in range(train_times):
        out = model(x)                  # 获取预测值
        loss = criterion(y, out)        # 计算损失
        optimizer.zero_grad()           # 梯度置0
        loss.backward()                 # 反向传播
        optimizer.step()                # 更新梯度

        if i % round(train_times / 10) == 0:
            print("Epoch[{}/{}], loss:{}".format(i, train_times, loss.data))

    # 模型评估
    model_eval(model)


if __name__ == '__main__':
    run()

运行结果

5、GPU版本

全局声明

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

自定义参数和数据需要转化为cuda支持的tensor

x = torch.rand([50, 1]).to(device)

model需要转化为cuda支持的model

model = Lr().to(device=device) 

执行的结果需要和CPU的tensor计算的时候，需要将cuda的tensor转化为CPU的tensor

tensor.cpu()