说明：本文源代码来源于MACHINE LEARNING 2022 SPRING课程，我只是针对源代码进行了一些加工处理。感谢互联网，让我们能免费接触到这些优秀的课程。
前置知识
- 卷积神经网络(Convolutional neural networks)
- 残差神经网络(Residual neural networks)
- 本文未提供残差网络的代码，读者可根据网络拓扑图自己实现
- 本文未提供残差网络的代码，读者可根据网络拓扑图自己实现
目标
- 借助卷积神经网络解决图像分类问题
- 利用数据增强(data augmentations)技术提升性能
- 理解主流的、被证明有效的图像模型技术，如残差(Residual)
增强技术
-
先进数据增强：mixup
- 无法将pytorch中的CrossEntropyLoss直接应用到mixup的情况，需要自己根据数学公式实现。
- 无法将pytorch中的CrossEntropyLoss直接应用到mixup的情况，需要自己根据数学公式实现。
-
多测试增强：
- 一般，在测试时会针对测试集做较为基础的转换，记作test_tfm(相比于对训练集做的一系列转换，目的是实现数据增强，记作train_tfm)。但若在测试时，也对测试集使用train_tfm手段，得到多张测试集图像，再通过模型预测类别，混合原有的预测(经test_tfm处理)可能得到更好的预测性能。
- 由于，经test_tfm处理的图像特征更强，在最终预测结果时赋予更大的权重
-
交叉验证
数据组成
- 原始图像收集自food-11数据集，所有图像被分成了11类
- 训练集：9866张有标签图像
- 验证集：3430张有标签图像
- 测试集：3347张无标签图像
性能指标
- 交叉熵损失
实现思路
源码解析
基础部分
导包
# Import necessary packages.
import numpy as np
import pandas as pd
import torch
import os
import torch.nn as nn
import torchvision.transforms as transforms
from PIL import Image
# "ConcatDataset" and "Subset" are possibly useful when doing semi-supervised learning.
from torch.utils.data import ConcatDataset, DataLoader, Subset, Dataset
from torchvision.datasets import DatasetFolder, VisionDataset
# 导入训练时显示进度条所用的包
from tqdm.auto import tqdm
import random
配置&功能函数
# 设置本次训练过程中所有随机数发生器的种子
# 目的是为了训练效果的可重复性
myseed = 6666
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(myseed)
torch.manual_seed(myseed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(myseed)
数据
数据的下载
# 从github上下载数据集并解压
# 解压完成后的目录结构：
# ./food11/test
# ./food11/training
# ./food11/validation
# 备选链接 1(从dropbox上下载)
# ! wget https://www.dropbox.com/s/6l2vcvxl54b0b6w/food11.zip
! wget -O food11.zip "https://github.com/virginiakm1988/ML2022-Spring/blob/main/HW03/food11.zip?raw=true"
! unzip food11.zip
数据转换器
# 通常针对测试集和验证集不需要采用数据增强手段
# 一般由 Resize和ToTensor两者组成
# 如前所述，为了使用集成方法以达成更好的效果，有时会对测试集采用与训练集相同的转换方法
test_tfm = transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor(),
])
train_tfm = transforms.Compose([
# 调整图像大小至固定的尺寸
transforms.Resize((128, 128)),
# 为了达成更好的效果，可以在此再添加一些有效的数据增强手段
# ToTensor()操作通常放在转换操作的最后一步
transforms.ToTensor(),
])
数据加载器的构造(DataSet、DataLoader)
# Dataset的子类，所需实现的方法：__init__()、__len__()、__geiitem__()
class FoodDataset(Dataset):
def __init__(self,path,tfm=test_tfm,files = None):
super(FoodDataset).__init__()
self.path = path
# 将path目录下所有.jpg文件的路径存到self.files数组中
self.files = sorted([os.path.join(path,x) for x in os.listdir(path) if x.endswith(".jpg")])
if files != None:
self.files = files
print(f"One {path} sample",self.files[0])
self.transform = tfm
def __len__(self):
return len(self.files)
def __getitem__(self,idx):
fname = self.files[idx]
im = Image.open(fname)
im = self.transform(im)
#im = self.data[idx]
try:
# 获取图像的标签，这一步受数据集特征的影响而不同
# 本次所采用的数据集，在文件名中存有所属类别的信息
label = int(fname.split("/")[-1].split("_")[0])
except:
label = -1 # test has no label
return im,label
batch_size = 64
_dataset_dir = "./food11"
train_set = FoodDataset(os.path.join(_dataset_dir,"training"), tfm=train_tfm)
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=0, pin_memory=True)
valid_set = FoodDataset(os.path.join(_dataset_dir,"validation"), tfm=test_tfm)
valid_loader = DataLoader(valid_set, batch_size=batch_size, shuffle=True, num_workers=0, pin_memory=True)
test_set = FoodDataset(os.path.join(_dataset_dir,"test"), tfm=test_tfm)
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=0, pin_memory=True)
网络结构
结构的实现
# 由卷积神经网络组成的分类器
class Classifier(nn.Module):
def __init__(self):
super(Classifier, self).__init__()
# torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
# torch.nn.MaxPool2d(kernel_size, stride, padding)
# input 維度 [3, 128, 128]
self.cnn = nn.Sequential(
nn.Conv2d(3, 64, 3, 1, 1), # [64, 128, 128]
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(2, 2, 0), # [64, 64, 64]
nn.Conv2d(64, 128, 3, 1, 1), # [128, 64, 64]
nn.BatchNorm2d(128),
nn.ReLU(),
nn.MaxPool2d(2, 2, 0), # [128, 32, 32]
nn.Conv2d(128, 256, 3, 1, 1), # [256, 32, 32]
nn.BatchNorm2d(256),
nn.ReLU(),
nn.MaxPool2d(2, 2, 0), # [256, 16, 16]
nn.Conv2d(256, 512, 3, 1, 1), # [512, 16, 16]
nn.BatchNorm2d(512),
nn.ReLU(),
nn.MaxPool2d(2, 2, 0), # [512, 8, 8]
nn.Conv2d(512, 512, 3, 1, 1), # [512, 8, 8]
nn.BatchNorm2d(512),
nn.ReLU(),
nn.MaxPool2d(2, 2, 0), # [512, 4, 4]
)
self.fc = nn.Sequential(
nn.Linear(512*4*4, 1024),
nn.ReLU(),
nn.Linear(1024, 512),
nn.ReLU(),
nn.Linear(512, 11)
)
def forward(self, x):
out = self.cnn(x)
# 返回一个新tensor，其数据与原始tensor相同，但形状不同
# 此处的操作是为了将 out 从 [512,4,4] 变形为 [512*4*4,1] 以符合全连接层的要求
out = out.view(out.size()[0], -1)
return self.fc(out)
训练与预测
参数设置及训练
# "cuda" only when GPUs are available.
device = "cuda" if torch.cuda.is_available() else "cpu"
_exp_name = "sample"
# The number of training epochs and patience.
n_epochs = 4
patience = 300 # If no improvement in 'patience' epochs, early stop
# Initialize a model, and put it on the device specified.
model = Classifier().to(device)
# For the classification task, we use cross-entropy as the measurement of performance.
criterion = nn.CrossEntropyLoss()
# Initialize optimizer, you may fine-tune some hyperparameters such as learning rate on your own.
optimizer = torch.optim.Adam(model.parameters(), lr=0.0003, weight_decay=1e-5)
# Initialize trackers, these are not parameters and should not be changed
stale = 0
best_acc = 0
for epoch in range(n_epochs):
# ---------- Training ----------
# Make sure the model is in train mode before training.
model.train()
# These are used to record information in training.
train_loss = []
train_accs = []
for batch in tqdm(train_loader):
# A batch consists of image data and corresponding labels.
imgs, labels = batch
#imgs = imgs.half()
#print(imgs.shape,labels.shape)
# Forward the data. (Make sure data and model are on the same device.)
logits = model(imgs.to(device))
# Calculate the cross-entropy loss.
# We don't need to apply softmax before computing cross-entropy as it is done automatically.
loss = criterion(logits, labels.to(device))
# Gradients stored in the parameters in the previous step should be cleared out first.
optimizer.zero_grad()
# Compute the gradients for parameters.
loss.backward()
# Clip the gradient norms for stable training.
grad_norm = nn.utils.clip_grad_norm_(model.parameters(), max_norm=10)
# Update the parameters with computed gradients.
optimizer.step()
# Compute the accuracy for current batch.
# 取全连接层最后输出的概率最大值作为预测的类别
acc = (logits.argmax(dim=-1) == labels.to(device)).float().mean()
# Record the loss and accuracy.
train_loss.append(loss.item())
train_accs.append(acc)
train_loss = sum(train_loss) / len(train_loss)
train_acc = sum(train_accs) / len(train_accs)
# Print the information.
print(f"[ Train | {epoch + 1:03d}/{n_epochs:03d} ] loss = {train_loss:.5f}, acc = {train_acc:.5f}")
# ---------- Validation ----------
# Make sure the model is in eval mode so that some modules like dropout are disabled and work normally.
model.eval()
# These are used to record information in validation.
valid_loss = []
valid_accs = []
# Iterate the validation set by batches.
for batch in tqdm(valid_loader):
# A batch consists of image data and corresponding labels.
imgs, labels = batch
#imgs = imgs.half()
# We don't need gradient in validation.
# Using torch.no_grad() accelerates the forward process.
with torch.no_grad():
logits = model(imgs.to(device))
# We can still compute the loss (but not the gradient).
loss = criterion(logits, labels.to(device))
# Compute the accuracy for current batch.
acc = (logits.argmax(dim=-1) == labels.to(device)).float().mean()
# Record the loss and accuracy.
valid_loss.append(loss.item())
valid_accs.append(acc)
#break
# The average loss and accuracy for entire validation set is the average of the recorded values.
valid_loss = sum(valid_loss) / len(valid_loss)
valid_acc = sum(valid_accs) / len(valid_accs)
# Print the information.
print(f"[ Valid | {epoch + 1:03d}/{n_epochs:03d} ] loss = {valid_loss:.5f}, acc = {valid_acc:.5f}")
# update logs
if valid_acc > best_acc:
with open(f"./{_exp_name}_log.txt","a"):
print(f"[ Valid | {epoch + 1:03d}/{n_epochs:03d} ] loss = {valid_loss:.5f}, acc = {valid_acc:.5f} -> best")
else:
with open(f"./{_exp_name}_log.txt","a"):
print(f"[ Valid | {epoch + 1:03d}/{n_epochs:03d} ] loss = {valid_loss:.5f}, acc = {valid_acc:.5f}")
# save models
if valid_acc > best_acc:
print(f"Best model found at epoch {epoch}, saving model")
torch.save(model.state_dict(), f"{_exp_name}_best.ckpt") # only save best to prevent output memory exceed error
best_acc = valid_acc
stale = 0
else:
stale += 1
if stale > patience:
print(f"No improvment {patience} consecutive epochs, early stopping")
break
开始测试
model_best = Classifier().to(device)
model_best.load_state_dict(torch.load(f"{_exp_name}_best.ckpt"))
model_best.eval()
prediction = []
with torch.no_grad():
for data,_ in test_loader:
test_pred = model_best(data.to(device))
test_label = np.argmax(test_pred.cpu().data.numpy(), axis=1)
prediction += test_label.squeeze().tolist()
# 将预测结果保存到.csv文件中
def pad4(i):
return "0"*(4-len(str(i)))+str(i)
df = pd.DataFrame()
df["Id"] = [pad4(i) for i in range(1,len(test_set)+1)]
df["Category"] = prediction
df.to_csv("submission.csv",index = False)
扫一扫
1995
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
