天池-街景字符編碼識別1-賽題理解

賽題地址

前期環境

運行環境及安裝
運行環境

python3.7
pytorch1.3.1
有GPU

首先在Anaconda中創建一個專門用於本次練習賽的虛擬環境。

$conda create -n pytorch_gpu python=3.7

激活環境，並安裝pytorch1.3.1

$source activate pytorch_gpu
$conda install pytorch=1.3.1 torchvision cudatoolkit=10.0

一鍵安裝所需其它依賴庫

$pip install jupyter tqdm opencv-python matplotlib pandas

預訓練

首先導入常用的包

import os, sys, glob, shutil, json
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
import cv2

from PIL import Image
import numpy as np

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

步驟1：定義好讀取圖像的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)
        
        # 設置最長的字符長度爲5個
        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)

步驟2：定義好訓練數據和驗證數據的Dataset

train_path = glob.glob('E:\python-project\deep-learning\cv-stree\mchar_val/*.png')
train_path.sort()
train_json = json.load(open('E:\python-project\deep-learning\cv-stree\train.json'))
train_label = [train_json[x]['label'] for x in train_json]
print(len(train_path), len(train_label))

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),
                    transforms.ToTensor(),
                    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('E:\python-project\deep-learning\cv-stree\mchar_val/*.png')
val_path.sort()
val_json = json.load(open('E:\python-project\deep-learning\cv-stree\val.json'))
val_label = [val_json[x]['label'] for x in val_json]
print(len(val_path), len(val_label))

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,
)

步驟3：定義好字符分類模型，使用renset18的模型作爲特徵提取模塊

class SVHN_Model1(nn.Module):
    def __init__(self):
        super(SVHN_Model1, self).__init__()
                
        model_conv = models.resnet18(pretrained=True)
        model_conv.avgpool = nn.AdaptiveAvgPool2d(1)
        model_conv = nn.Sequential(*list(model_conv.children())[:-1])
        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

步驟4：定義好訓練、驗證和預測模塊

def train(train_loader, model, criterion, optimizer):
    # 切換模型爲訓練模式
    model.train()
    train_loss = []
    
    for i, (input, target) in enumerate(train_loader):
        if use_cuda:
            input = input.cuda()
            target = target.cuda()
            
        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()
        
        if i % 100 == 0:
            print(loss.item())
        
        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)
            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 次數
    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)
                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

步驟5：迭代訓練和驗證模型

model = SVHN_Model1()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), 0.001)
best_loss = 1000.0

use_cuda = False
if use_cuda:
    model = model.cuda()

for epoch in range(2):
    train_loss = train(train_loader, model, criterion, optimizer, epoch)
    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),
        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_char_acc)
    # 記錄下驗證集精度
    if val_loss < best_loss:
        best_loss = val_loss
        torch.save(model.state_dict(), './model.pt')

步驟6：對測試集樣本進行預測，生成提交文件

test_path = glob.glob('../input/test_a/*.png')
test_path.sort()
test_label = [[1]] * len(test_path)
print(len(val_path), len(val_label))

test_loader = torch.utils.data.DataLoader(
    SVHNDataset(test_path, test_label,
                transforms.Compose([
                    transforms.Resize((64, 128)),
                    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,
)

test_predict_label = predict(test_loader, model, 1)

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('../input/test_A_sample_submit.csv')
df_submit['file_code'] = test_label_pred
df_submit.to_csv('renset18.csv', index=None)

賽題理解

賽題數據
賽題以街道字符爲爲賽題數據，數據集報名後可見並可下載，該數據來自收集的SVHN街道字符，並進行了匿名採樣處理。

訓練集數據包括3W張照片，驗證集數據包括1W張照片，每張照片包括顏色圖像和對應的編碼類別和具體位置；爲了保證比賽的公平性，測試集A包括4W張照片，測試集B包括4W張照片。

數據標籤
對於訓練數據每張圖片將給出對於的編碼標籤，和具體的字符框的位置（訓練集、驗證集都給出字符位置），可用於模型訓練：

Field	Description
top		左上角座標X
height	字符高度
left	左上角座標Y
width	字符寬度
label	字符編碼

字符的座標具體如下所示：

在比賽數據（訓練集和驗證集）中，同一張圖片中可能包括一個或者多個字符，因此在比賽數據的JSON標註中，會有兩個字符的邊框信息：

評測指標
選手提交結果與實際圖片的編碼進行對比，以編碼整體識別準確率爲評價指標。任何一個字符錯誤都爲錯誤，最終評測指標結果越大越好，具體計算公式如下：
Score=編碼識別正確的數量/測試集圖片數量

讀取數據
JSON中標籤的讀取方式：

import json
train_json = json.load(open('../input/train.json'))

# 數據標註處理
def parse_json(d):
   arr = np.array([
       d['top'], d['height'], d['left'],  d['width'], d['label']
   ])
   arr = arr.astype(int)
   return arr

img = cv2.imread('../input/train/000000.png')
arr = parse_json(train_json['000000.png'])

plt.figure(figsize=(10, 10))
plt.subplot(1, arr.shape[1]+1, 1)
plt.imshow(img)
plt.xticks([]); plt.yticks([])

for idx in range(arr.shape[1]):
   plt.subplot(1, arr.shape[1]+1, idx+2)
   plt.imshow(img[arr[0, idx]:arr[0, idx]+arr[1, idx],arr[2, idx]:arr[2, idx]+arr[3, idx]])
   plt.title(arr[4, idx])
   plt.xticks([]); plt.yticks([])

解題思路
賽題思路分析：賽題本質是分類問題，需要對圖片的字符進行識別。但賽題給定的數據圖片中不同圖片中包含的字符數量不等，如下圖所示。有的圖片的字符個數爲2，有的圖片字符個數爲3，有的圖片字符個數爲4。

字符屬性	圖片
字符：42 字符個數：2
字符：241 字符個數：3
字符：7358 字符個數：4

因此本次賽題的難點是需要對不定長的字符進行識別，與傳統的圖像分類任務有所不同。

簡單入門思路：定長字符識別

可以將賽題抽象爲一個定長字符識別問題，在賽題數據集中大部分圖像中字符個數爲2-4個，最多的字符個數爲6個。
因此可以對於所有的圖像都抽象爲6個字符的識別問題，字符23填充爲23XXXX，字符231填充爲231XXX。

經過填充之後，原始的賽題可以簡化了6個字符的分類問題。在每個字符的分類中會進行11個類別的分類，假如分類爲填充字符，則表明該字符爲空。

專業字符識別思路：不定長字符識別

在字符識別研究中，有特定的方法來解決此種不定長的字符識別問題，比較典型的有CRNN字符識別模型。
在本次賽題中給定的圖像數據都比較規整，可以視爲一個單詞或者一個句子。

專業分類思路：檢測再識別
在賽題數據中已經給出了訓練集、驗證集中所有圖片中字符的位置，因此可以首先將字符的位置進行識別，利用物體檢測的思路完成。

此種思路需要參賽選手構建字符檢測模型，對測試集中的字符進行識別。選手可以參考物體檢測模型SSD或者YOLO來完成。

天池-街景字符編碼識別1-賽題理解

賽題地址

前期環境

預訓練

賽題理解

微服務實踐之使用 Visual Studio 2022 調試Dapr 應用程序

wpf附加屬性理解 WPF附加屬性

CV之 HOG特徵描述算子-行人檢測

CV之Haar特徵描述算子-人臉檢測

數據挖掘之方差分析

數據挖掘之數理統計與常見分佈與假設檢驗

CV之LBP特徵描述算子-人臉檢測

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結