Task04: PyTorch实战——FashionMNIST时装分类

目标

对10个类别的“时装”图像进行分类，使用FashionMNIST数据集（https://github.com/zalandoresearch/fashion-mnist ）。数据集中每个小图对应一个样本。
FashionMNIST数据集中包含已经预先划分好的训练集和测试集，其中训练集共60,000张图像，测试集共10,000张图像。每张图像均为单通道黑白图像，大小为32*32pixel，分属10个类别。
以下按流程进行深度学习。

基本配置

导入包

#文件读写与数据处理包
import os
import numpy as np
import pandas as pd
#深度学习包
import torch 
from torch.utils,data import Dataset, DataLoader #数据读入包
import torch.nn as nn #模型包
import torch.optim as optim #优化器包

配置训练环境和超参数

batch_size = 256 #一次训练所选取的样本数
lr = 1e-4 #学习率
epochs = 20 #训练次数
num_workers = 0 #线程
#GPU配置，后续对要使用GPU的变量用.to(device)即可
device = torch.device("cuda: 1" if torch.cuda.is_available() else "cpu")

num_workers详解

数据读入和加载

以下对于内置数据集以及csv数据集有两种加载方式。第二种数据读入方式需要自己构建Dataset，这对于PyTorch应用于自己的工作中十分重要。下面逐一介绍。

设置数据变换

torchvision.transforms中定义了一系列数据转换形式，有PILImage,numpy,Tensor间相互转换，还能对数据进行处理。在torchvision.datasets下载数据的时候，作为一个参数传入，对下载的数据进行处理。
torchvision.transforms的用法

from torchvison import transforms
image_size = 28
data_transform = transform.Compose([
# transforms.ToPILImage(),   # 这一步取决于后续的数据读取方式，如果使用内置数据集则不需要
	transform.Resize(image_size),
	transform.ToTensor()
])

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

from torchvision import datasets

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

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

Pandas基础知识
.iloc与.values讲解
类中self用法讲解

#__init__: 用于向类中传入外部参数，同时定义样本集
class FMDataset(Dataset):
	def __init__(self, df, transform=None):
		self.df = df
		self.tansform = transform
		self.images = df.iloc[:, 0].values.astype.(np.uint8) #有讲解

#__getitem__: 用于逐个读取样本集合中的元素，可以进行一定的变换，并将返回训练/验证所需的数据
	def __getitem__(self, idx):
	        image = self.images[idx].reshape(28,28,1)
	        label = int(self.labels[idx])
	        if self.transform is not None:
	            image = self.transform(image)
	        else:
	            image = torch.tensor(image/255., dtype=torch.float)
	        label = torch.tensor(label, dtype=torch.long)
	        return image, label
	        
	#__len__: 用于返回数据集的样本数
	def __len__(self):
	        return len(self.images)
	        
train_df = pd.read_csv("./FashionMNIST/fashion-mnist_train.csv")
test_df = pd.read_csv("./FashionMNIST/fashion-mnist_test.csv")
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)'''

定义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)

读入后，我们可以做一些数据可视化操作，主要是验证我们读入的数据是否正确

import matplotlib.pyplot as plt
image, label = next(iter(train_loader))
print(image.shape, label.shape)
%matplotlib inline
plt.imshow(image[0][0], cmap="gray")

模型设计

使用CNN，不考虑复杂结构，在GPU上训练

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()   # 多卡训练时的写法，之后的课程中会进一步讲解

损失函数

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

?nn.CrossEntropyLoss # 这里方便看一下weighting等策略
criterion = nn.CrossEntropyLoss()
# criterion = nn.CrossEntropyLoss(weight=[1,1,1,1,3,1,1,1,1,1])

优化器

使用Adam优化器

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

训练和测试（验证）

各自封装成函数，方便后续调用
关注两者的主要区别：

模型状态设置
是否需要初始化优化器
是否需要将loss传回到网络
是否需要每步更新optimizer
此外，对于测试或验证过程，可以计算分类准确率

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))

for epoch in range(1, epochs+1):
    train(epoch)
    val(epoch)

模型保存

训练完成后，可以使用torch.save保存模型参数或者整个模型，也可以在训练过程中保存模型
这部分会在后面的课程中详细介绍

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