图像分类代码学习笔记

图像分类代码学习笔记

• 数据集：kaggle-ASL Alphabet
• 代码：ASL Alphabet classification PyTorch

数据集描述

数据集为美国手语图像数据（American Sign Language），包含87000张图像，每张图片都是200×200像素，总共有29个类，其中26个类表示字母 A-Z，剩下三种表示空格、删除和什么都没有。

代码笔记

train_data_path = '../input/asl-alphabet/asl_alphabet_train/asl_alphabet_train/'

train_data_path 存储训练数据集的轮径。

train_transforms = transforms.Compose([
    transforms.Resize(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])
test_transforms = transforms.Compose([
    transforms.Resize(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

原始数据的格式不一定和训练所需的数据格式相同。我们使用transforms模块对数据进行操作，使其适合训练。

transforms.Compose() 的主要作用是串联多个图片变换的操作。

transforms.Resize() 是调整 PILImage 对象的尺寸，注意不能是用 io.imread 或者 cv2.imread 读取的图片，这两种方法得到的是 ndarray。

将图片短边缩放至x，长宽比保持不变：

transforms.Resize(x)

而一般输入深度网络的特征图长宽是相等的，就不能采取等比例缩放的方式了，需要同时指定长宽：

transforms.Resize([h, w])

transform.ToTensor() 将PILImage 或者 numpy 的 ndarray 转化成 Tensor。

transform.Normalize() 逐channel的对图像进行标准化（均值变为0，标准差变为1），可以加快模型的收敛。

这里的参数 mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) 使用的数据是 ImageNet 数据集的均值和标准差。

如何计算图片的 mean 和 std：如何计算pytorch中图像输入的均值和方差

train_dataset = datasets.ImageFolder(train_data_path, transform=train_transforms)
val_dataset = datasets.ImageFolder(train_data_path, transform=test_transforms)

Datasets 都是 torch.utils.data.Dataset 的子类，所以，他们也可以通过 torch.utils.data.DataLoader 使用多线程（python的多进程）。

ImageFolder假设所有的文件按文件夹保存，每个文件夹下存储同一个类别的图片，文件夹名为类名，其构造函数如下：

ImageFolder(root, transform=None, target_transform=None, loader=default_loader)

• root：在 root 指定的路径下寻找图片
• transform：对 PIL Image 进行的转换操作，transform 的输入是使用 loader 读取图片的返回对象
• target_transform：对 label 的转换
• loader：给定路径后如何读取图片，默认读取为 RGB 格式的 PIL Image 对象

# 数据集划分
torch.manual_seed(1)
num_train_samples = len(full_dataset)
# num_train_samples = 5000
full_dataset, _ = torch.utils.data.random_split(full_dataset, [num_train_samples, len(full_dataset)-num_train_samples])

train_size = int(0.6 * num_train_samples)
val_size = int(0.2 * num_train_samples)
test_size = num_train_samples - train_size - val_size

train_dataset, val_dataset, test_dataset = torch.utils.data.random_split(full_dataset, [train_size, val_size, test_size])
len(train_dataset), len(val_dataset), len(test_dataset)

torch.manual_seed() 设置随机数种子。

torhc.utils.data.random_split对数据集进行随机划分，其中第一个参数是待划分的数据集，第二个参数是一个列表，其中存储划分后各个数据集占原数据集的比例。

这里划分后训练集、验证集和测试集的比例为 6:2:2。

# 设置 Dataloader
batch_size = 64 # 设置 batch_size

train_dataloader = torch.utils.data.DataLoader(
    dataset=train_dataset,
    batch_size=batch_size,
    shuffle=True
)

val_dataloader = torch.utils.data.DataLoader(
    dataset=val_dataset,
    batch_size=batch_size,
    shuffle=False
)

这一步将数据集装入 Pytorch 的 DataLoader，DataLoader 可以在训练时自动从 Dataset 中抽取样本进行训练，并且能够成批抽取，形成 Batch。

resnet = models.resnet50(pretrained=True)   # 直接使用 Pytorch 官方提供的 resnet 模型，并且获取预训练参数

Pytorch 封装了许多常见的模型，这里使用 Pytorch 提供的 ResNet50 模型，并且加载了模型提供的预训练参数。

# 冻结特征层的参数，进行迁移学习
for param in resnet.parameters():
    param.requires_grad = False
# 更换全连接层，调整输入和输出，释放全连接层的参数
in_features = resnet.fc.in_features
fc = nn.Linear(in_features=in_features, out_features=len(classes))
resnet.fc = fc

这一步冻结了特征层的参数，在后续的训练中不再需要对特征层的参数进行反向传播和更新，降低了训练的难度，这一步属于迁移学习。同时，由于全连接层的大小取决于输出的类别，所以需要对 ResNet50 模型的全连接层进行修改。

# 需要更新的参数（上一步中更换的全连接层参数）
params_to_update = []
for name, param in resnet.named_parameters():
    if param.requires_grad:
        params_to_update.append(param)

确定需要更新的参数，其实就是全连接层的参数，最后的全连接层主要负责分类，而之前的层叫做特征层，主要用于特征提取。

criterion = nn.CrossEntropyLoss()   # 交叉熵损失
optimizer = torch.optim.Adam(params_to_update, lr=0.001)    # Adam 优化器

设置损失函数和优化器，多分类任务常用的损失函数就是交叉熵损失，这里优化器选择 Adam 优化器。

# 选择显卡进行训练
device = 'cuda' if torch.cuda.is_available() else 'cpu'
device

设置显卡。

from time import time
from tqdm import tqdm   # 进度条

# 训练过程
def train(model,
          criterion,
          optimizer,
          train_dataloader,
          val_dataloader,
          print_every,
          num_epoch):
    '''
    :param model: Pytorch模型
    :param criterion: 损失函数
    :param optimizer:  优化器
    :param train_dataloader: 训练集
    :param val_dataloader: 验证集
    :param print_every: 多少个 epochs 输出一次
    :param num_epoch: 训练多少个 epochs
    :returns model: 模型
    :returns train_losses 训练集损失
    :returns val_losses 验证集损失
    '''
    steps = 0
    train_losses, val_losses = [], []
    train_accuracy, val_accuracy = [], []

    model.to(device)
    for epoch in tqdm(range(num_epoch)):
        running_loss = 0
        correct_train = 0
        total_train = 0
        start_time = time()
        iter_time = time()
        
        model.train()
        for i, (images, labels) in enumerate(train_dataloader):
            steps += 1
            # 把数据放到 GPU
            images = images.to(device)
            labels = labels.to(device)

            if epoch == 0 and i == 0:
                torch.onnx.export(resnet, images, 'resnet.pth')

            # 前向传播
            output = model(images)
            loss = criterion(output, labels)

            correct_train += (torch.max(output, dim=1)[1] == labels).sum().item()
            total_train += labels.size(0)

            # 反向传播与优化
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            running_loss += loss.item()

            # 记录输出
            if steps % print_every == 0:
                print(f'Epoch [{epoch + 1}]/[{num_epoch}]. Batch [{i + 1}]/[{len(train_dataloader)}].', end=' ')    # epoch数量
                print(f'Train loss {running_loss / steps:.3f}.', end=' ')
                print(f'Train acc {correct_train / total_train * 100:.3f}.', end=' ')
                train_accuracy.append(correct_train / total_train)
                # 使用验证集评估模型训练过程中的表现
                with torch.no_grad():
                    model.eval()
                    correct_val, total_val = 0, 0
                    val_loss = 0
                    for images, labels in val_dataloader:
                        images = images.to(device)
                        labels = labels.to(device)
                        output = model(images)
                        loss = criterion(output, labels)
                        val_loss += loss.item()

                        correct_val += (torch.max(output, dim=1)[1] == labels).sum().item()
                        total_val += labels.size(0)
                print(f'Val loss {val_loss / len(val_dataloader):.3f}. Val acc {correct_val / total_val * 100:.3f}.', end=' ')
                print(f'Took {time() - iter_time:.3f} seconds')
                val_accuracy.append(correct_val / total_val)
                iter_time = time()

                train_losses.append(running_loss / total_train)
                val_losses.append(val_loss / total_val)


        print(f'Epoch took {time() - start_time}')

        # 保存断点
        checkpoint = {"model_state_dict": model.state_dict(),
                      "optimizer_state_dict": optimizer.state_dict(),
                      "epoch": epoch}
        path_checkpoint = "./checkpoint_{}_epoch.pkl".format(epoch)
        torch.save(checkpoint, path_checkpoint)
        
    return model, train_losses, val_losses, train_accuracy, val_accuracy

定义训练过程，包括前向传播、反向传播、优化，每50次迭代使用验证集进行评估测试，并且输出信息。

print_every = 50    # 每50次迭代输出一次
num_epoch = 5   # 训练的epochs数量

resnet, train_losses, val_losses, train_accuracy, val_accuracy = train(
    model=resnet,
    criterion=criterion,
    optimizer=optimizer,
    train_dataloader=train_dataloader,
    val_dataloader=val_dataloader,
    print_every=print_every,
    num_epoch=num_epoch
)

实际调用训练过程，设置多少次迭代输出一次，以及设置训练多少个 epoch。

# 召回变化
plt.rcParams.update({"font.size": 10})
plt.plot(train_losses, label='Training loss')
plt.plot(val_losses, label='Validation loss')
plt.legend(frameon=False)
plt.savefig('/kaggle/working/loss', dpi=250)
plt.show()

使用 matplotlib 绘制损失变化曲线。

# 准确率变化
plt.rcParams.update({"font.size": 10})
plt.plot(train_accuracy, label='Training Accuracy')
plt.plot(val_accuracy, label='Validation Accuracy')
plt.legend(frameon=False)
plt.savefig('/kaggle/working/accuracy', dpi=250)
plt.show()

准确率变化曲线。

y_true = []
y_pred = []

# 测试过程
i, j = 0, 0
for img, label in test_dataset:
    img = torch.Tensor(img[None])
    img = img.to(device)
    resnet.eval()
    prediction = resnet(img)  # 在 img 最前面加上一维（batch维度）
    prediction_class = int(torch.max(prediction, dim=1)[1])
    y_pred.append(prediction_class)
    y_true.append(label)

测试过程，后续使用 scikit-learn 对测试结果进行评估，评估过程记录每个样本的真实标签 y_true 和预测值（标签）y_pred。

# 正确率
from sklearn.metrics import accuracy_score

accuracy_score(y_true, y_pred)
# 混淆矩阵
from sklearn.metrics import confusion_matrix

conf_matrix = confusion_matrix(y_true, y_pred)
xtick = classes
ytick = classes

plt.rcParams.update({"font.size": 5})
plt.savefig('/kaggle/working/conf_matrix', dpi=250)
sns.heatmap(conf_matrix, fmt='g', cmap='Blues', annot=True, cbar=False, xticklabels=xtick, yticklabels=ytick)
# 精确率
from sklearn.metrics import precision_score

precision_list = precision_score(y_true, y_pred, average=None)
precision_list
# 精确率
from sklearn.metrics import recall_score

recall_list = recall_score(y_true, y_pred, average=None)
recall_list
# 分类准确率/雅卡得相似系数
from sklearn.metrics import jaccard_score

accuracy_list = jaccard_score(y_true, y_pred, average=None)
accuracy_list
# f1 and macro-f1
from sklearn.metrics import f1_score

f1_list = f1_score(y_true, y_pred, average=None)
macro_f1 = f1_score(y_true, y_pred, average='macro')
f1_list, macro_f1

使用 scikit-learn 对结果进行评估，包括正确率、分类准确率、分类召回率、混淆矩阵、F1分数等指标，具体评估方法可以参考 scikit-learn 的参考手册。