Building a Hello World MLP model

MLP Model

输入层 中间层 输出层
XOR输入 XOR输出

构建模型

XOR模型

1. 导入库
2. 准备数据
3. 配置模型
4. 训练模型
5. 加载模型
6. 做出预测

导入库

import pytorch_lightning as pl
import torch
from torch import nn, optim
from torch.autograd import Variable
import pytorch_lightning as pl
from pytorch_lightning.callbacks import ModelCheckpoint
from torch.utils.data import DataLoader
print("torch version:",torch.__version__)
print("pytorch ligthening version:",pl.__version__)

准备数据

# 对应异或4种输入  A B为两个输入（特征）
xor_input = [Variable(torch.Tensor([0, 0])),
            Variable(torch.Tensor([0, 1])),
            Variable(torch.Tensor([1, 0])),
            Variable(torch.Tensor([1, 1]))]
# 对应目标变量
xor_target = [Variable(torch.Tensor([0])),
           Variable(torch.Tensor([1])),
           Variable(torch.Tensor([1])),
           Variable(torch.Tensor([0]))]
# 创造数据加载器 我们可以通过多种方式创建数据集并将其作为数据加载器传递给 PyTorch Lightning
xor_data = list(zip(xor_input, xor_target))
train_loader = DataLoader(xor_data, batch_size=1)
# [(tensor([0., 0.]), tensor([0.])),
# (tensor([0., 1.]), tensor([1.])),
# (tensor([1., 0.]), tensor([1.])),
# (tensor([1., 1.]), tensor([0.]))]

配置模型

1. 初始化模型
2. 将输入映射到模型
3. 配置优化器
4. 设置训练参数

初始化模型

class XORModel(pl.LightningModule):
    def __init__(self):
    # super().__init__()
    super(XORModel,self).__init__()
    self.input_layer = nn.Linear(2, 4)
    self.output_layer = nn.Linear(4,1)
    self.sigmoid = nn.Sigmoid()
    #  mean squared error 
    self.loss = nn.MSELoss()

将输入映射到模型

  # 将输入映射到模型
  # 将接收的特征传递到输入层
  # 输入层生成结果传递到激活函数中
  # 激活函数生成的结果传递到输出层中
  def forward(self, input):
    #print("INPUT:", input.shape)
    x = self.input_layer(input)
    #print("FIRST:", x.shape)
    x = self.sigmoid(x)
    #print("SECOND:", x.shape)
    output = self.output_layer(x)
    #print("THIRD:", output.shape)
    return output

配置优化器

    def configure_optimizers(self):
        # 模型所有参数
        params = self.parameters()
        # 创建优化器
        optimizer = optim.Adam(params=params, lr = 0.01)
        return optimizer

设置训练参数

  # batch_idx为当前批次序号
  def training_step(self, batch, batch_idx):
    # 批量数据batch 里面包括输入/特征以及target目标
    xor_input, xor_target = batch
    # print("XOR INPUT:", xor_input.shape)
    # print("XOR TARGET:", xor_target.shape)
    # self会间接调用forward方法
    outputs = self(xor_input) 
    # print("XOR OUTPUT:", outputs.shape)
    loss = self.loss(outputs, xor_target)
    return loss

训练模型

# 训练模型
from pytorch_lightning.utilities.types import TRAIN_DATALOADERS
# 创建模型检查点回调函数 保存模型并不限于训练模型后 在训练模型中也要保存
checkpoint_callback = ModelCheckpoint()
model = XORModel()
# Trainer是一些关键事物的抽象，例如循环数据集、反向传播、清除梯度和优化器步骤
# Trainer类支持许多帮助构建模型的功能
# 其中一些功能是各种回调、模型检查点、提前停止、开发运行单元测试、对GPU和TPU、记录器、日志、时期等的支持
# 创建训练器
trainer = pl.Trainer(max_epochs=100, callbacks=[checkpoint_callback])
# 传递模型和训练数据 开始训练
trainer.fit(model, train_dataloaders=train_loader)

加载模型

# 加载模型
# 获取最新版本模型路径
print(checkpoint_callback.best_model_path)
# 从检测点中加载模型
train_model = model.load_from_checkpoint(checkpoint_callback.best_model_path)

做出预测

# 获取最新版本模型路径
print(checkpoint_callback.best_model_path)
# 从检测点中加载模型
train_model = model.load_from_checkpoint(checkpoint_callback.best_model_path)
test = torch.utils.data.DataLoader(xor_input, batch_size=1)
for val in xor_input:
  _ = train_model(val)
  print([int(val[0]),int(val[1])], int(_.round()))
from torchmetrics.functional import accuracy
print(checkpoint_callback.best_model_path)
train_model = model.load_from_checkpoint(checkpoint_callback.best_model_path)
total_accuracy = []
for xor_input, xor_target in train_loader:
  for i in range(100):
    output_tensor = train_model(xor_input)
    test_accuracy = accuracy(output_tensor, xor_target.int())
    total_accuracy.append(test_accuracy)
total_accuracy = torch.mean(torch.stack(total_accuracy))
print("TOTAL ACCURACY FOR 100 ITERATIONS: ", total_accuracy.item())