阿里云天池-街景字符编码识别-基于ResNet-18_阿里天池图像分类

一、任务介绍 

赛题以计算机视觉中字符识别为背景，要求选手预测真实场景下的字符识别，这是一个典型的字符识别问题。通过这道赛题可以引导大家走入计算机视觉的世界，主要针对竞赛选手上手视觉赛题，提高对数据建模能力。

---

1.1数据来源

零基础入门CV - 街景字符编码识别_学习赛_天池大赛-阿里云天池的赛制 (aliyun.com)

赛题来源自Google街景图像中的门牌号数据集（The Street View House Numbers Dataset, SVHN），并根据一定方式采样得到比赛数据集。训练集数据包括3W张照片，验证集数据包括1W张照片，每张照片包括颜色图像和对应的编码类别和具体位置；为了保证比赛的公平性，测试集A包括4W张照片，测试集B包括4W张照片。

所有的数据（训练集、验证集和测试集）的标注使用JSON格式，并使用文件名进行索引。如果一个文件中包括多个字符，则使用列表将字段进行组合。

1.2评测标准

评价标准为准确率，选手提交结果与实际图片的编码进行对比，以编码整体识别准确率为评价指标，结果越大越好，具体计算公式如下：

                                score=编码识别正确数量/测试集图片数量

1.3思路 

赛题本质是分类问题，需要对图片的字符进行识别。但赛题给定的数据图片中不同图片中包含的字符数量不等。可以将赛题抽象为一个定长字符识别问题，在赛题数据集中大部分图像中字符个数为2-4个，最多的字符 个数为6个。因此可以对于所有的图像都抽象为6个字符的识别问题，字符23填充为23XXXX，字符231填充为231XXX。 

---

二、算法原理

使用resnet18网络结构作为模型，详细关于ResNet-18模型见---------------------->

https://blog.csdn.net/m0_64799972/article/details/132753608?spm=1001.2014.3001.5502

三、实现过程 

3.1下载数据集

首先得报名，报了名才可以下载数据集。 在这里下载

然后执行此代码 

import pandas as pd
import os
import requests
import zipfile
import shutil
links = pd.read_csv('./content/mchar_data_list_0515.csv')
dir_name = 'NDataset'
mypath = './content/'
if not os.path.exists(mypath + dir_name):
    os.mkdir(mypath + dir_name)
for i,link in enumerate(links['link']):
    file_name = links['file'][i]
    print(file_name, '\t', link)
    file_name = mypath + dir_name + '/' + file_name
    if not os.path.exists(file_name):
        response = requests.get(link, stream=True)
        with open( file_name, 'wb') as f:
            for chunk in response.iter_content(chunk_size=1024):
                if chunk:
                    f.write(chunk)
zip_list = ['mchar_train', 'mchar_test_a', 'mchar_val']
for little_zip in zip_list: # 卖萌可耻
    if not os.path.exists(mypath + dir_name + '/' + little_zip):
        zip_file = zipfile.ZipFile(mypath + dir_name + '/' + little_zip + '.zip', 'r')
        zip_file.extractall(path = mypath + dir_name )
if os.path.exists(mypath + dir_name + '/' + '__MACOSX'):
    shutil.rmtree(mypath + dir_name + '/' + '__MACOSX')

 运行结果如下：

---

3.2数据处理 

在街道字符识别任务中。在赛题中我们需要对的图像进行字符识别，因此需要我们完成的数据的读取操作，同时也需要完成数据扩增（Data Augmentation）操作。

在深度学习中数据扩增方法非常重要，数据扩增可以增加训练集的样本，同时也可以有效缓解模型过拟合的情况，也可以给模型带来的更强的泛化能力。

数据扩增方法有很多：从颜色空间、尺度空间到样本空间，同时根据不同任务数据扩增都有相应的区别。对于图像分类，数据扩增一般不会改变标签；对于物体检测，数据扩增会改变物体坐标位置；对于图像分割，数据扩增会改变像素标签。 

在常见的数据扩增方法中，一般会从图像颜色、尺寸、形态、空间和像素等角度进行变换。当然不同的数据扩增方法可以自由进行组合，得到更加丰富的数据扩增方法。

以torchvision为例，常见的数据扩增方法包括：

• transforms.CenterCrop 对图片中心进行裁剪
• transforms.ColorJitter 对图像颜色的对比度、饱和度和零度进行变换
• transforms.FiveCrop 对图像四个角和中心进行裁剪得到五分图像
• transforms.Grayscale 对图像进行灰度变换
• transforms.Pad 使用固定值进行像素填充
• transforms.RandomAffine 随机仿射变换
• transforms.RandomCrop 随机区域裁剪
• transforms.RandomHorizontalFlip 随机水平翻转
• transforms.RandomRotation 随机旋转
• transforms.RandomVerticalFlip 随机垂直翻转

 在本次赛题中，赛题任务是需要对图像中的字符进行识别，因此对于字符图片并不能进行翻转操作。比如字符6经过水平翻转就变成了字符9，会改变字符原本的含义。

下图代码是本文采用的数据增强方法。

---

3.3实验代码

# %pylab inline
import matplotlib.pyplot as plt
import numpy as np
import os, sys, glob, shutil, json
#os用于操作文件和目录
#sys提供了与python解释器相关的功能
#glob用于文件通配符匹配
#shutil用于文件操作
#json用于处理JSON数据
from torch.optim.lr_scheduler import StepLR #PyTorch中的学习率调度器，用于动态地调整模型的学习率。
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
import cv2
from PIL import Image
from tqdm import tqdm, tqdm_notebook #用于创建进度条以监视代码中循环的进展。
import torch
torch.manual_seed(0) #通过设置随机种子，可以实现重复性，便于调试和验证模型的稳定性。
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = True
 
import torchvision.models as models
import torchvision.transforms as transforms  #用于图像预处理和数据增强的工具。例如，可以使用这些转换来对图像进行裁剪、缩放、标准化等操作。
import torchvision.datasets as datasets  #用于加载常见图像数据集的工具
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
from torch.utils.data.dataset import Dataset
 
 
class SVHNDataset(Dataset):
    def __init__(self, img_path, img_label, transform=None):
        self.img_path = img_path
        self.img_label = img_label
        if transform is not None:
            self.transform = transform
        else:
            self.transform = None
 
    def __getitem__(self, index):
        img = Image.open(self.img_path[index]).convert('RGB')
 
        if self.transform is not None:
            img = self.transform(img)
 
        lbl = np.array(self.img_label[index], dtype=np.int)
        lbl = list(lbl) + (5 - len(lbl)) * [10]
        return img, torch.from_numpy(np.array(lbl[:5]))
 
    def __len__(self):
        return len(self.img_path)
 
if __name__ == '__main__':
    train_path = glob.glob('./content/NDataset/mchar_train/*.png')
    train_path.sort()
    train_json = json.load(open('./content/NDataset/mchar_train.json'))
    train_label = [train_json[x]['label'] for x in train_json]
 
    train_loader = torch.utils.data.DataLoader(
        SVHNDataset(train_path, train_label,
                    transforms.Compose([
                        transforms.Resize((64, 128)),
                        transforms.RandomCrop((60, 120)), #随即裁剪，有助于模型学习不同部分的特征，同时也可以增加数据的多样性。
                        transforms.ColorJitter(0.3, 0.3, 0.2),#颜色抖动操作。这个操作会随机调整图像的亮度、对比度和饱和度，以增加数据的变化性。
                        transforms.RandomRotation(10),#随机旋转操作。它会随机旋转图像不超过10度，用于增加数据的多样性和鲁棒性。
                        transforms.ToTensor(),#将图像数据转换为张量（Tensor）格式。神经网络模型通常需要输入张量数据。
                        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])#标准化，以便更好地适应模型的训练。
        ])),
        batch_size=40,
        shuffle=True,
        num_workers=10,
    )
 
    val_path = glob.glob('./content/NDataset/mchar_val/*.png')
    val_path.sort()
    val_json = json.load(open('./content/NDataset/mchar_val.json'))
    val_label = [val_json[x]['label'] for x in val_json]
 
    val_loader = torch.utils.data.DataLoader(
        SVHNDataset(val_path, val_label,
                    transforms.Compose([
                        transforms.Resize((60, 120)),
                        # transforms.ColorJitter(0.3, 0.3, 0.2),
                        # transforms.RandomRotation(5),
                        transforms.ToTensor(),
                        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])),
        batch_size=40,
        shuffle=False,
        num_workers=10,
    )
 
 
class SVHN_Model1(nn.Module):
    def __init__(self):
        super(SVHN_Model1, self).__init__()
 
        model_conv = models.resnet18(pretrained=True) #会下载并加载在 ImageNet 数据集上预训练过的 ResNet-18 模型权重
        model_conv.avgpool = nn.AdaptiveAvgPool2d(1) #将平均池化替换为自适应平均池化层，为了在不同输入尺寸的图像上使用这个模型
        model_conv = nn.Sequential(*list(model_conv.children())[:-1]) #去除最后一层分类器，只有卷积层和池化层的ResNet-18
        self.cnn = model_conv
        #五个全连接层，每一个用于预测一个数字的类别
        self.fc1 = nn.Linear(512, 11)
        self.fc2 = nn.Linear(512, 11)
        self.fc3 = nn.Linear(512, 11)
        self.fc4 = nn.Linear(512, 11)
        self.fc5 = nn.Linear(512, 11)
 
    def forward(self, img):
        feat = self.cnn(img) #包含了提取的特征
        #print(feat.shape)
        feat = feat.view(feat.shape[0], -1) #展平
        c1 = self.fc1(feat)
        c2 = self.fc2(feat)
        c3 = self.fc3(feat)
        c4 = self.fc4(feat)
        c5 = self.fc5(feat)
        return c1, c2, c3, c4, c5
 
 
def train(train_loader, model, criterion, optimizer, epoch):
    # 切换模型为训练模式
    model.train()
    train_loss = []
 
    for i, (input, target) in enumerate(train_loader): #每个批次大小是40
        if use_cuda:
            input = input.cuda()
            target = target.cuda()
 
        target = target.long()
        c0, c1, c2, c3, c4 = model(input)
        loss = criterion(c0, target[:, 0]) + \
               criterion(c1, target[:, 1]) + \
               criterion(c2, target[:, 2]) + \
               criterion(c3, target[:, 3]) + \
               criterion(c4, target[:, 4])
 
        # loss /= 6
        optimizer.zero_grad() #将优化器的梯度缓冲区清零，以准备计算新的梯度。
        loss.backward() #进行反向传播，计算梯度
        optimizer.step() #更新参数，通过梯度下降来最小化损失函数
 
        train_loss.append(loss.item()) #将每一个批次的损失加入一个列表中
    return np.mean(train_loss) #返回每个批次的损失平均值
 
 
def validate(val_loader, model, criterion):
    # 切换模型为预测模型
    model.eval()
    val_loss = []
 
    # 不记录模型梯度信息
    with torch.no_grad():
        for i, (input, target) in enumerate(val_loader):
            if use_cuda:
                input = input.cuda()
                target = target.cuda()
 
            c0, c1, c2, c3, c4 = model(input)
            # 注意：将 target 转换为整数类型的张量
            target = target.long()
 
            loss = criterion(c0, target[:, 0]) + \
                   criterion(c1, target[:, 1]) + \
                   criterion(c2, target[:, 2]) + \
                   criterion(c3, target[:, 3]) + \
                   criterion(c4, target[:, 4])
            # loss /= 6
            val_loss.append(loss.item())
    return np.mean(val_loss)
 
 
def predict(test_loader, model, tta=10):
    model.eval()
    test_pred_tta = None
    #TTA是一种在测试过程中对输入数据进行多次变换或扰动，并对每个变换后的输入进行预测，然后取多次预测的平均值以提高模型性能的技术。
    # TTA 次数
    for _ in range(tta):
        test_pred = [] #存储每个测试样本的预测结果
 
        with torch.no_grad():
            for i, (input, target) in enumerate(test_loader):
                if use_cuda:
                    input = input.cuda()
 
                c0, c1, c2, c3, c4 = model(input)
                if use_cuda:
                    output = np.concatenate([
                        c0.data.cpu().numpy(),
                        c1.data.cpu().numpy(),
                        c2.data.cpu().numpy(),
                        c3.data.cpu().numpy(),
                        c4.data.cpu().numpy()], axis=1)
                else:
                    output = np.concatenate([
                        c0.data.numpy(),
                        c1.data.numpy(),
                        c2.data.numpy(),
                        c3.data.numpy(),
                        c4.data.numpy()], axis=1)
 
                test_pred.append(output)
 
        test_pred = np.vstack(test_pred)
        if test_pred_tta is None:
            test_pred_tta = test_pred
        else:
            test_pred_tta += test_pred
 
    return test_pred_tta
 
if __name__ == '__main__':
    # 定义初始学习率
    initial_lr=0.001
    # 定义初始学习率
    model = SVHN_Model1()
    criterion = nn.CrossEntropyLoss() #交叉熵通常用于分类问题，适用于多类别分类任务。
    optimizer = torch.optim.Adam(model.parameters(), 0.001)
    #optimizer = torch.optim.RMSprop(model.parameters(), lr=0.001, alpha=0.9)
    # 创建学习率调度器
    scheduler=StepLR(optimizer,step_size=5,gamma=0.5)
    best_loss = 1000.0
 
    # 是否使用GPU
    use_cuda = True
    if use_cuda:
        model = model.cuda()
 
    for epoch in range(10):
        train_loss = train(train_loader, model, criterion, optimizer, epoch)
        val_loss = validate(val_loader, model, criterion)
 
        # 在每个 epoch 结束时更新学习率
        scheduler.step()
 
        val_label = [''.join(map(str, x)) for x in val_loader.dataset.img_label]
        val_predict_label = predict(val_loader, model, 1)
        val_predict_label = np.vstack([
            val_predict_label[:, :11].argmax(1),
            val_predict_label[:, 11:22].argmax(1),
            val_predict_label[:, 22:33].argmax(1),
            val_predict_label[:, 33:44].argmax(1),
            val_predict_label[:, 44:55].argmax(1),
        ]).T
        val_label_pred = []
        for x in val_predict_label:
            val_label_pred.append(''.join(map(str, x[x != 10])))
 
        val_char_acc = np.mean(np.array(val_label_pred) == np.array(val_label))
 
        print('Epoch: {0}, Train loss: {1} \t Val loss: {2}'.format(epoch, train_loss, val_loss))
        print('Val Acc', val_char_acc)
        # 记录下验证集精度
        if val_loss < best_loss:
            best_loss = val_loss
            # print('Find better model in Epoch {0}, saving model.'.format(epoch))
            torch.save(model.state_dict(), './model.pt')
 
    test_path = glob.glob('./content/NDataset/mchar_test_a/*.png')
    test_path.sort()
    #test_json = json.load(open('../input/test_a.json'))
    test_label = [[1]] * len(test_path)
    #print(len(test_path), len(test_label))
 
    test_loader = torch.utils.data.DataLoader(
        SVHNDataset(test_path, test_label,
                    transforms.Compose([
                        transforms.Resize((70, 140)),
                        # transforms.RandomCrop((60, 120)),
                        # transforms.ColorJitter(0.3, 0.3, 0.2),
                        # transforms.RandomRotation(5),
                        transforms.ToTensor(),
                        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])),
        batch_size=40,
        shuffle=False,
        num_workers=10,
    )
 
    # 加载保存的最优模型
    model.load_state_dict(torch.load('model.pt'))
 
    test_predict_label = predict(test_loader, model, 1)
    #print(test_predict_label.shape)
 
    test_label = [''.join(map(str, x)) for x in test_loader.dataset.img_label]
    test_predict_label = np.vstack([
        test_predict_label[:, :11].argmax(1),
        test_predict_label[:, 11:22].argmax(1),
        test_predict_label[:, 22:33].argmax(1),
        test_predict_label[:, 33:44].argmax(1),
        test_predict_label[:, 44:55].argmax(1),
    ]).T
 
    test_label_pred = []
    for x in test_predict_label:
        test_label_pred.append(''.join(map(str, x[x != 10])))
 
    import pandas as pd
 
    df_submit = pd.read_csv('content/NDataset/mchar_sample_submit_A.csv')
    df_submit['file_code'] = test_label_pred
    df_submit.to_csv('content/NDataset/submit.csv', index=None)
 

 三、实验结果及分析

 

优化：

1.使用Adam优化器进行优化。

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

---

2.创建学习率调度器。

scheduler=StepLR(optimizer,step_size=5,gamma=0.5)

分析：

除了选择好的模型之外，我们可以选择从数据增强、学习率选择、正则化技术、注意力机制、标签平滑等策略技术来增加检测准确率。