基于ResNet的图片分类问题实战_resnet文本图像和非文本图像分类器

前言

本文将尝试应用残差神经网络网络解决图片分类的问题。实践平台为Kaggle。
链接: Kaggle - 树叶分类竞赛

一、任务介绍

任务是预测叶子图像的类别。 该数据集包含 176 个类别，18353 张训练图像，8800 张测试图像。 每个类别至少有 50 张图像用于训练。 测试集平均分为公共和私人排行榜。本次比赛的评估指标是分类准确率。

下图是竞赛提供的一部分样本图片的样例。

训练集的标签数据长下图这样：

二、具体实现

由于深度学习涉及到模型训练，需要较大的算力资源，因此我们直接使用Kaggle平台进行训练（试过用自己的小笔记本，毫不意外地跑不动，也尝试过谷歌的colab，感觉不如kaggle稳定）。在Kaggle上的代码用Juypter进行编辑，这是一个非常友好的行际代码编辑器，可以直接上手摸索。

代码框架

1. 定义dataloader，做导入数据并做预处理
2. 定义网络模型，初始化参数
3. 训练网络
4. 预测及模型评估

导入包及读入数据

首先导入各种后续用到的包

# 网络模型相关
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

然后从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()}
1
2
3
4
5
6

接下来，我们需要根据数据集的样子来定义自己的数据集类。其中，考虑到树叶图像的上下左右翻转不应该影响特征的学习，因此我们对数据以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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

初始化训练集、测试集和验证集

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')
1
2
3

定义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
    )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

网络模型定义

我们这里采用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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

一些超参数设置

learning_rate = 3e-4
weight_decay = 1e-3
num_epoch = 50
model_path = './res_model.ckpt'	# 保存模型参数的路径，预测时直接读取模型
1
2
3
4

模型训练

# 目标分类有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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

三、模型改进

此模型的最终准确率为0.88，如果将Resnet改为Resnext，准确率可以提升至0.94。