天池大赛——街景字符编码识别比赛（零基础入门CV赛事）

1 赛题理解

1.1 题目内容

识别街景图像中的门牌号。

1.2 数据集

数据集来自Google街景图像中的门牌号数据集（The Street View House Numbers Dataset, SVHN），并根据一定方式采样得到比赛数据集。其中训练集30000张图片，检验集10000张图片，测试集A和B各40000张图片。图片大小不一，为三色RGB图片。标记信息为图片中各个数字的位置框和数字信息。

1.3 解题思路：

方法一：将问题看作定长字符串的分类问题，使用深度神经网络直接预测各个数字。
方法二：先对字符进行检测，再进行分类。

2 数据读取与数据扩增

2.1 数据读取

赛题举办方提供的数据包括由30000张图片组成的训练集，10000张图片组成的检验集和40000张图片组成的测试集A，图片格式为png格式。数据标签为json格式。
数据读取方式：

torch.utils.data.DataLoader, PIL.Image, glob, json库的使用

# 数据标签的 json格式读取，转化为字典格式
import json
train_json = json.load(open('mchar_train.json'))

# 读取训练图片的路径信息
import glob
train_path = glob.glob('./input/mchar_train/*.png')
train_path.sort()

# 数据读取
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)
# 设置最⻓长的字符⻓长度为4个
lbl = np.array(self.img_label[index], dtype=np.int)
lbl = list(lbl) + (4 - len(lbl)) * [10]
return img, torch.from_numpy(np.array(lbl[:4]))
def __len__(self):
return len(self.img_path)

# 这里暂时不使用标签中的图片位置信息，只使用类别信息
train_label = [train_json[x]['label'] for x in train_json]

# 数据扩充
import torchvision.transforms as transforms

# torch中的数据读取方式，利用torch.utils.data.DataLoader 来实现
# transforms 为数据扩充方法
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(5),
# 转化为pytorch的tensor
transforms.ToTensor(),
# 图片像素归一化
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])),
batch_size=40,
shuffle=True,
num_workers=0,
)

2.2 数据扩充方法

对于图片的数据扩充方法，有尺度变化、随机裁剪、中心裁剪、随机旋转、水平翻转、垂直翻转、颜色对比度变换等。对于数字识别而言，由于数字6和数字9的相似性，不可以使用随机翻转的方法。在上述代码中，使用了随机裁剪、颜色变换、随机旋转这三种数据扩充方法。

3 字符识别模型

3.1 尝试一：定长字符识别模型

对于数据集中的图片，大多数图片的标签数字数量小于5。训练集中的数字标签数字数量统计结果如下：
含有1个数字：4636， 占比15.45%；
含有2个数字：16262， 占比54.21%；
含有3个数字：7813， 占比26.04%；
含有4个数字：1280， 占比4.27%；
含有5个数字：8， 占比0.03%；
含有6个数字，1， 占比0.00%。
对于定长字符识别模型而言，其做法是设定字符长度，将不定长的字符补全（在10个数字类别之外，补充背景类别）。由于绝大多数图片的字符数量小于5， 因此设定定长字符的长度为4。
同时，模型使用了ResNet预训练模型。在ResNet模型的最后一层，并联接上4个子分支，每个分支由两个全连接层组成，分别预测对应位置的数字。
在使用不同ResNet主干网络的情况下，模型取得了不同的预测效果。在使用相同数据增强方法的情况下，使用ResNet18预训练模型，最终得分为0.52；ResNet52 得分为 0.63； ResNet101得分为0.69。在模型训练的过程中出现了过拟合的现象，训练集的误差不断减小，而检验集上的误差最后却保持在一定范围。为了缓解这样的问题，使用额外的数据增强方法对训练集的数据进行了扩增。包括高斯模糊和加入随机噪声等。最后在使用ResNet101主干网络的情况下，模型得分达到了0.73。

3.2 尝试二：两个定长字符识别模型的组合

在使用定长字符模型时，模型最后的4个子分支分别预测不同位置的数字。但是由于不同位置数字出现频率并不相同，比如所有图片都存在第1位数字，因此预测第1位数字的子分支应该可以取得比较准确的预测结果；而对于预测第4位数字的子分支，由于95.7%的标签标记为背景，其预测的效果可能是有问题的。在这样的分析下，从预测效率上来看，可能出现的情况是：子分支1>子分支2>子分支3>子分支4。
因此，一个比较自然的想法是：训练两个模型，其中一个模型从左往右预测数字，另一个模型从右往左预测数字，最后再综合两个模型的预测结果，确定最后的结果。
初步的实验表明：该方法似乎不起效果。。

3.3 尝试三：使用检测+预测的思路

由于数据标签同时包含类别和位置信息，因此可以使用检测+预测的思路来做。同样包括两种方法，第一种方法是同时做检测和类别预测；第二种方法是先做检测，将数字框识别出来，再对图像做裁剪进行分类预测。目前尝试使用了yolov3和yolov4模型来进行预测。初步的实验结果显示模型预测效果极差，基本不具有预测功能。。。

3.4 其它方法

其它方法还包括不定长字符识别方法，其中典型的代表是CTPN；以及两阶段的检测模型，比如Faster RCNN。之后计划将这两个模型都实现一遍。

4 模型训练与验证

定义型的训练函数和验证函数，设置相应的参数，进行训练。其中训练函数train()包含梯度反向传播和参数更新。

def train(train_loader, model, criterion, optimizer):
# 切换模型为训练模式
model.train()
train_loss = []
T0 = time.time()
for i, (input, target) in enumerate(train_loader):
if use_cuda:
input = input.cuda()
target = target.cuda()
c0, c1, c2, c3 = model(input)
target = target.long()
loss = criterion(c0, target[:, 0]) + \
criterion(c1, target[:, 1]) + \
criterion(c2, target[:, 2]) + \
criterion(c3, target[:, 3])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i % 100 == 0:
TT = time.time()
print(loss.item(), TT-T0)
T0 = time.time()
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 = model(input)
target = target.long()
loss = criterion(c0, target[:, 0]) + \
criterion(c1, target[:, 1]) + \
criterion(c2, target[:, 2]) + \
criterion(c3, target[:, 3])
val_loss.append(loss.item())
return np.mean(val_loss)

模型训练和验证。将验证结果最好的模型加以保存。

model = SVHN_Model1()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), 0.001)
best_loss = 1000.0
use_cuda = True
if use_cuda:
model = model.cuda()
for epoch in range(5):
train_loss = train(train_loader, model, criterion, optimizer)
val_loss = validate(val_loader, model, criterion)
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),
]).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_char_acc)
# 记录下验证集精度
if val_loss < best_loss:
best_loss = val_loss
torch.save(model.state_dict(), './model.pt')

5 模型集成

对于模型集成，使用了两种方法。第一种方法是在训练过程中保留了两个“最优模型”，分别对应于检验集损失最少和准确率最高两种情形，最后将两个“最优模型”集成，进行预测。

# 记录下验证集精度
if val_loss < best_loss:
best_loss = val_loss
torch.save(model.state_dict(), './weights/model.pt')
if val_acc > best_acc:
best_acc = val_acc
torch.save(model.state_dict(), './weights/model_acc.pt')

第二种方法在预测的时候，通过transforms.RandomCrop方法，预测10次，将10次预测结果进行集成。

def predict2(test_loader, model1, model2, tta=10):
model1.eval()
model2.eval()
test_pred_tta = True
# 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 = model1(input)
output = np.concatenate([
c0.data.cpu().numpy(),
c1.data.cpu().numpy(),
c2.data.cpu().numpy(),
c3.data.cpu().numpy()], axis=1)
c0, c1, c2, c3 = model1(input)
output2 = np.concatenate([
c0.data.cpu().numpy(),
c1.data.cpu().numpy(),
c2.data.cpu().numpy(),
c3.data.cpu().numpy()], axis=1)
test_pred.append(output+output2)

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

最后，在通过设置动态学习率，补充额外的数据增强方法和进行模型集成之后，预测得分达到了0.84。