DataWhales深入浅出Pytorch-第三章/第四章

Posted 2022-02-01 Paul-Huang

【DataWhales】深入浅出Pytorch-第三章/第四章

• 第三章： Pytorch 的主要组成模块
• • 3.1 神经网络学习机制和深度学习在实现上的特殊性
  • • 3.1.1 神经网络学习机制
    • 3.1.2 深度学习在实现上的特殊性
  • 3.2 PyTorch深度学习模块
• 第四章 基础实战——FashionMNIST时装分类
• • 4.1 基本配置
  • • 4.1.1 导入必要的包
    • 4.1.2 配置训练环境
    • 4.1.3 配置超参数
  • 4.2 数据读入
  • • 4.2.1 读取方式一：使用torchvision自带数据集
    • 4.2.2 读取方式二：读入csv格式的数据，自行构建Dataset类
    • 4.2.3 使用DataLoader类加载数据
  • 4.3 模型构建
  • • 4.3.1 模型建立
    • 4.3.2 定义损失函数
    • 4.3.3 优化器
  • 4.4 训练与评估
  • • 4.4.1 训练
    • 4.4.2 测试
  • 4.5 模型保存

第三章： Pytorch 的主要组成模块

3.1 神经网络学习机制和深度学习在实现上的特殊性

3.1.1 神经网络学习机制

一般分为：

• 数据预处理
• 模型设计
• 损失函数和优化方案设计
• 前向传播
• 反向传播
• 更新参数

3.1.2 深度学习在实现上的特殊性

1. 样本量大，通常需要$\text{分批(batch)加载}$
2. 逐层、模块化搭建网络（卷积层、全连接层、LSTM等)多样化的$\text{损失函数和优化器设计}$
3. GPU的使用
4. 以上各个模块之间的配合

3.2 PyTorch深度学习模块

1. 将PyTorch完成深度学习的步骤拆解为几个主要模块
2. 实际使用根据自身需求修改对应模块即可
3. $\text{深度学习}\Rightarrow \text{搭积木}$.，分为：$\text{基本配置}$，$\text{数据读入}$，$\text{模型构建}$，$\text{损失函数}$，$\text{优化器}$，$\text{训练与评估}$
4. 任务:FashionMNIST时装分类数据简介∶
   • 10类图片
   • 每张图$32\times 32$px

第四章 基础实战——FashionMNIST时装分类

4.1 基本配置

1. 导入必要的packages
   • os, numpy, pandas, torch, torch.nn, torch.optim, torch.utils.data
2. 配置训练过程的超参数
   • batch size, learning rate, max_epochs, num_workers
3. 配置训练用的硬件设备
   • CPU or GPU, which GPU(s)代码演示

4.1.1 导入必要的包

import os
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

4.1.2 配置训练环境

# 配置GPU，这里有两种方式
## 方案一：使用os.environ, 后续往GPU中添加数据使用***.cuda()
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
# 方案二：使用“device”，后续对要使用GPU的变量用.to(device)即可；
device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")

1. 使用os.environ, 后续往GPU中添加数据使用***.cuda()
2. 使用“device”，后续对要使用GPU的变量用.to(device)即可；

4.1.3 配置超参数

## 配置其他超参数，如batch_size, num_workers, learning rate, 以及总的epochs
batch_size = 256
num_workers = 4
lr = 1e-4
epochs = 20

4.2 数据读入

1. 如何读取格式不定的本地数据:Dataset
   • __init__: 用于向类中传入外部参数，同时定义样本集
   • __getitem__: 用于逐个读取样本集合中的元素，可以进行一定的变换，并将返回训练/验证所需的数据
   • __len__: 用于返回数据集的样本数
2. 如何将数据加载以供模型输入:DataLoader
   • batch_size, num_workders, shuffle, drop_last, pin_memory

   这些变换可以很方便地借助torchvision包来完成，这是PyTorch官方用于图像处理的工具库，上面提到的使用内置数据集的方式也要用到。PyTorch的一大方便之处就在于它是一整套“生态”。

4.2.1 读取方式一：使用torchvision自带数据集

 使用torchvision 自带的数据集处理，
from torchvision import datasets

train_data = datasets.FashionMNIST(root = './', train= True, download=True, transform = data_transform)
test_data = datasets.FashionMNIST(root='./', train=False, download=True, transform = data_transform)

4.2.2 读取方式二：读入csv格式的数据，自行构建Dataset类

class FMDataset(Dataset):
    def __init__(self, df, transform=None):
        self.df = df
        self.transform = transform
        self.images = df.iloc[:,1:].values.astype(np.uint8)
        self.labels = df.iloc[:,0].values
        
    def __len__(self):
            return len(self.images)
        
    def __getitem__(self, idx):
        image = self.images[idx].reshape(image_size, image_size, 1)
        label = int(self.labels[idx])
        if self.transform is not None:
            image = self.transform(images)
        else:
            image = torch.tensor(image/255. , dtype=torch.float)
        label = torch.tensor(label, dtype=torch.long)
        return image, label
        
train_df = pd.read_csv("./fashion-mnist_train.csv")
test_df = pd.read_csv("./fashion-mnist_test.csv")
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)

注意iloc的使用。

4.2.3 使用DataLoader类加载数据

1. DataLoader加载数据

   train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)
   test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=num_workers)
   

2. 数据可视化

4.3 模型构建

1. 神经网络的构造∶基于nn.Module
   1. __init__ , forward
2. 神经网络是通过“层定义+层顺序”的方式构建起来的·神经网络常见层
   • nn.Conv2d, nn.MaxPool2d, nn.Linear, nn.ReLU

4.3.1 模型建立

1. 按次序导入Sequential，定义前向传播函数

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3),
            nn.Conv2d(32, 64, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3)
        )
        self.fc = nn.Sequential(
            nn.Linear(64*4*4, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )
        
    def forward(self, x):
        x = self.conv(x)
        x = x.view(-1, 64*4*4)
        x = self.fc(x)
        # x = nn.functional.normalize(x)
        return x

model = Net()
model = model.cuda()
# model = nn.DataParallel(model).cuda()

4.3.2 定义损失函数

1. 使用torch.nn模块自带的CrossEntropy损失

   1. PyTorch会自动把整数型的label转为one-hot型，用于计算CE loss
   2. 这里需要确保label是从0开始的，同时模型不加softmax层（使用logits计算）,这也说明了PyTorch训练中各个部分不是独立的，需要通盘考虑

   criterion = nn.CrossEntropyLoss()
   # criterion = nn.CrossEntropyLoss(weight=[1,1,1,1,3,1,1,1,1,1])
   

2. 可以加权重

   criterion = nn.CrossEntropyLoss(weight=[1,1,1,1,3,1,1,1,1,1])
   

4.3.3 优化器

1. torch.optim提供了多种预定义的优化器
2. 可以自己定义优化器
3. 根据实际需求选用对应的优化器
4. 优化器常用操作∶
   • step(), zero_grad(), load_state_dict(), …

optimizer = optim.Adam(model.parameters(), lr=0.001)

4.4 训练与评估

1. 模型状态设置
   • model.train(), model.eval()
2. 训练流程︰$\text{读取、转换、梯度清零、输入、计算损失、反向传播、参数更新}$。
3. 验证流程：$\text{读取、转换、输入、计算损失、计算指标}$

4.4.1 训练

def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data, label = data.cuda(), label.cuda()
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()*data.size(0)
    train_loss = train_loss/len(train_loader.dataset)
    print('Epoch:  \\tTraining Loss: :.6f'.format(epoch, train_loss))

4.4.2 测试

def val(epoch):       
    model.eval()
    val_loss = 0
    gt_labels = []
    pred_labels = []
    with torch.no_grad():
        for data, label in test_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output, label)
            val_loss += loss.item()*data.size(0)
    val_loss = val_loss/len(test_loader.dataset)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
    acc = np.sum(gt_labels==pred_labels)/len(pred_labels)
    print('Epoch:  \\tValidation Loss: :.6f, Accuracy: :6f'.format(epoch, val_loss, acc))

4.5 模型保存

save_path = "./FahionModel.pkl"
torch.save(model, save_path)