前言
本文将尝试应用残差神经网络网络解决图片分类的问题。实践平台为Kaggle。
链接: Kaggle - 树叶分类竞赛
一、任务介绍
任务是预测叶子图像的类别。 该数据集包含 176 个类别,18353 张训练图像,8800 张测试图像。 每个类别至少有 50 张图像用于训练。 测试集平均分为公共和私人排行榜。本次比赛的评估指标是分类准确率。
下图是竞赛提供的一部分样本图片的样例。
训练集的标签数据长下图这样:
二、具体实现
由于深度学习涉及到模型训练,需要较大的算力资源,因此我们直接使用Kaggle平台进行训练(试过用自己的小笔记本,毫不意外地跑不动,也尝试过谷歌的colab,感觉不如kaggle稳定)。在Kaggle上的代码用Juypter进行编辑,这是一个非常友好的行际代码编辑器,可以直接上手摸索。
代码框架
- 定义dataloader,做导入数据并做预处理
- 定义网络模型,初始化参数
- 训练网络
- 预测及模型评估
导入包及读入数据
首先导入各种后续用到的包
# 网络模型相关
import torch
import torch.nn as nn
import torchvision.models as models
# 数据处理
import pandas as pd
import numpy as np
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os
import matplotlib.pyplot as plt
# 以下包用于显示进度条
from tqdm import tqdm
import seaborn as sns
然后从train文件中读入数据名称及标签,由于数据标签是树叶的种类名称,为了便于后续处理,我们将其转为数字,为了最后预测方便,我们也记录每个数字对应的树叶种类名称。
labels_dataframe = pd.read_csv('../input/classify-leaves/train.csv')
# 把label转成对应的数字
leaves_labels = sorted(list(set(labels_dataframe['label'])))
class_to_num = dict(zip(leaves_labels, range(len(leaves_labels))))
# 再转换回来,以便最后预测的时候使用
num_to_class = {v : k for k, v in class_to_num.items()}
接下来,我们需要根据数据集的样子来定义自己的数据集类。其中,考虑到树叶图像的上下左右翻转不应该影响特征的学习,因此我们对数据以0.5的概率做水平和垂直翻转的数据增强。
# 继承pytorch的dataset
class LeavesData(Dataset):
def __init__(self, csv_path, file_path, mode='train', valid_ratio=0.2, resize_height=256, resize_width=256):
# csv_path (string): csv 文件路径
# img_path (string): 图像文件所在路径
# mode (string): 训练模式还是测试模式
# valid_ratio (float): 验证集比例
# resize_height, resize_width(int): 裁剪后的图片尺寸
self.file_path = file_path
self.mode = mode
# 需要调整后的照片尺寸
self.resize_height = resize_height
self.resize_width = resize_width
# 读取 csv 文件
# 利用pandas读取csv文件(不需要保存表头)
self.data_info = pd.read_csv(csv_path, header=None)
# 计算 length
self.data_len = len(self.data_info.index) - 1
self.train_len = int(self.data_len * (1 - valid_ratio))
if mode == 'train':
# 第一列包含图像文件的名称
self.train_image = np.asarray(self.data_info.iloc[1:self.train_len, 0]) #self.data_info.iloc[1:,0]表示读取第一列,从第二行开始到train_len
# 第二列是图像的 label
self.train_label = np.asarray(self.data_info.iloc[1:self.train_len, 1])
self.image_arr = self.train_image
self.label_arr = self.train_label
elif mode == 'valid':
self.valid_image = np.asarray(self.data_info.iloc[self.train_len:, 0])
self.valid_label = np.asarray(self.data_info.iloc[self.train_len:, 1])
self.image_arr = self.valid_image
self.label_arr = self.valid_label
elif mode == 'test':
self.test_image = np.asarray(self.data_info.iloc[1:, 0])
self.image_arr = self.test_image
self.real_len = len(self.image_arr)
def __getitem__(self, index):
# 从 image_arr中得到索引对应的文件名
single_image_name = self.image_arr[index]
# 读取图像文件
img_as_img = Image.open(self.file_path + single_image_name)
# 对训练集做数据增强
# 并将数据化为可被pytorch快速处理的张量类型
if self.mode == 'train':
transform = transforms.Compose([
transforms.Resize((224, 224)),
# 数据增强:随机水平翻转,概率为0.5
transforms.RandomHorizontalFlip(p=0.5),
transforms.ToTensor()
# 数据增强:随机垂直翻转,概率为0.5
transforms.RandomVerticalFlip(p=0.5),
transforms.ToTensor()
])
else:
# valid和test不做数据增强
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor()
])
img_as_img = transform(img_as_img)
if self.mode == 'test':
return img_as_img
else:
# 得到图像的 string label
label = self.label_arr[index]
# number label
number_label = class_to_num[label]
return img_as_img, number_label #返回每一个index对应的图片数据和对应的label
def __len__(self):
return self.real_len
初始化训练集、测试集和验证集
train_dataset = LeavesData(train_path, img_path, mode='train')
val_dataset = LeavesData(train_path, img_path, mode='valid')
test_dataset = LeavesData(test_path, img_path, mode='test')
定义dataloader
# 定义data loader
train_loader = torch.utils.data.DataLoader(
dataset=train_dataset,
batch_size=8,
shuffle=False,
num_workers=5
)
val_loader = torch.utils.data.DataLoader(
dataset=val_dataset,
batch_size=8,
shuffle=False,
num_workers=5
)
test_loader = torch.utils.data.DataLoader(
dataset=test_dataset,
batch_size=8,
shuffle=False,
num_workers=5
)
网络模型定义
我们这里采用resnet34模型,可以直接从torchvision中导入预训练的模型。由于预训练模型前面的一些层学习的是较底层的特征,因此也可以考虑冻结前面的一些层。
# 是否要冻住模型的前面一些层
def set_parameter_requires_grad(model, feature_extracting):
if feature_extracting:
model = model
for param in model.parameters():
param.requires_grad = False
# resnet34模型
def res_model(num_classes, feature_extract = False, use_pretrained=True):
model_ft = models.resnet34(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Sequential(nn.Linear(num_ftrs, num_classes))
return model_ft
一些超参数设置
learning_rate = 3e-4
weight_decay = 1e-3
num_epoch = 50
model_path = './res_model.ckpt' # 保存模型参数的路径,预测时直接读取模型
模型训练
# 目标分类有176类
model = res_model(176)
model = model.to(device)
model.device = device
# 交叉熵损失
criterion = nn.CrossEntropyLoss()
# 采用Adam优化算法
optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate, weight_decay=weight_decay)
# The number of training epochs.
n_epochs = num_epoch
best_acc = 0.0
for epoch in range(n_epochs):
# ---------- Training ----------
model.train()
train_loss = []
train_accs = []
for batch in tqdm(train_loader):
imgs, labels = batch
imgs = imgs.to(device)
labels = labels.to(device)
logits = model(imgs)
# softmax已包含在交叉熵损失中
loss = criterion(logits, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc = (logits.argmax(dim=-1) == labels).float().mean()
# 记录损失
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(f"[ Train | {epoch + 1:03d}/{n_epochs:03d} ] loss = {train_loss:.5f}, acc = {train_acc:.5f}")
# ---------- Validation ----------
model.eval()
valid_loss = []
valid_accs = []
for batch in tqdm(val_loader):
imgs, labels = batch
with torch.no_grad():
logits = model(imgs.to(device))
loss = criterion(logits, labels.to(device))
acc = (logits.argmax(dim=-1) == labels.to(device)).float().mean()
valid_loss.append(loss.item())
valid_accs.append(acc)
valid_loss = sum(valid_loss) / len(valid_loss)
valid_acc = sum(valid_accs) / len(valid_accs)
print(f"[ Valid | {epoch + 1:03d}/{n_epochs:03d} ] loss = {valid_loss:.5f}, acc = {valid_acc:.5f}")
if valid_acc > best_acc:
best_acc = valid_acc
torch.save(model.state_dict(), model_path)
print('saving model with acc {:.3f}'.format(best_acc))
三、模型改进
此模型的最终准确率为0.88,如果将Resnet改为Resnext,准确率可以提升至0.94。