零基礎入門CV賽事- 街景字符編碼識別Task3

繼上篇的數據的讀取，這裏介紹介紹計算機視覺關鍵的一步。識別模型的構建。說到視覺識別模型肯定少不了卷積神經網絡（cnn）。這裏重點介紹cnn神經網絡。

1.簡介卷積神經網絡的發展

1979和1980年發表的論文中，福島仿造生物的視覺皮層（visual cortex）設計了以“neocognitron”命名的神經網絡。neocognitron是一個具有深度結構的神經網絡，並且是最早被提出的深度學習算法之一。1987年由Alexander Waibel等提出的時間延遲網絡（Time Delay Neural Network, TDNN）。TDNN是一個應用於語音識別問題的卷積神經網絡。1988年，Wei Zhang提出了第一個二維卷積神經網絡：平移不變人工神經網絡（SIANN），並將其應用於檢測醫學影像。1989年，Yann LeCun構建了應用於計算機視覺問題的卷積神經網絡，即LeNet的最初版本。1993年由貝爾實驗室（AT&T Bell Laboratories）完成LeNet代碼開發。二十一世紀，計算機硬件的提高，神經網絡得到了長足發展。

2.簡介卷積神經網絡的結構

卷積神經網絡和傳統的神經網絡一樣。都是層級網絡，只是層的功能和形式做了變化，可以說是傳統神經網絡的一個改進。

卷積神經網絡的層級結構：

• 數據輸入層/ Input layer
• 卷積計算層/ CONV layer
• ReLU激勵層 / ReLU layer
• 池化層 / Pooling layer
• 全連接層 / FC layer

數據輸入層：

該層要做的處理主要是對原始圖像數據進行預處理，其中包括：

• 去均值：把輸入數據各個維度都中心化爲0，如下圖所示，其目的就是把樣本的中心拉回到座標系原點上。
• 歸一化：幅度歸一化到同樣的範圍，如下所示，即減少各維度數據取值範圍的差異而帶來的干擾，比如，我們有兩個維度的特徵A和B，A範圍是0到10，而B範圍是0到10000，如果直接使用這兩個特徵是有問題的，好的做法就是歸一化，即A和B的數據都變爲0到1的範圍。
• PCA/白化：用PCA降維；白化是對數據各個特徵軸上的幅度歸一化

卷積計算層：

這一層就是卷積神經網絡最重要的一個層次，也是“卷積神經網絡”的名字來源。
在這個卷積層，有兩個關鍵操作：

• 局部關聯。每個神經元看做一個濾波器(filter)
• 窗口(receptive field)滑動， filter對局部數據計算

激勵層：

把卷積層輸出結果做非線性映射。CNN採用的激勵函數一般爲ReLU(The Rectified Linear Unit/修正線性單元)，它的特點是收斂快，求梯度簡單，但較脆弱。

池化層：

池化層夾在連續的卷積層中間， 用於壓縮數據和參數的量，減小過擬合。簡而言之，如果輸入是圖像的話，那麼池化層的最主要作用就是壓縮圖像。

全連接層：

兩層之間所有神經元都有權重連接，通常全連接層在卷積神經網絡尾部。也就是跟傳統的神經網絡神經元的連接方式是一樣的。

3.代碼實現與見解

·

# 讀取數據，準備訓練數據與驗證數據

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)

train_path = glob.glob('cv/mchar_train/mchar_train/*.png')
train_path.sort()
train_json = json.load(open('cv/mchar_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=0,
)

val_path = glob.glob('cv/mchar_val/mchar_val/*.png')
val_path.sort()
val_json = json.load(open('cv/mchar_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=0,
)


# 定義模型，這裏追求精度，使用與訓練模型

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

        # CNN提取特徵模塊
        # self.cnn = nn.Sequential(
        #     nn.Conv2d(3, 16, kernel_size=(3, 3), stride=(2, 2)),
        #     nn.ReLU(),
        #     nn.MaxPool2d(2),
        #     nn.Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2)),
        #     nn.ReLU(),
        #     nn.MaxPool2d(2),
        # )

        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)
        #self.fc6 = nn.Linear(32 * 3 * 7, 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)
        #c6 = self.fc6(feat)
        return c1, c2, c3, c4, c5#, c6


model = SVHN_Model1()

#訓練數據
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), 0.0001)
best_loss = 100.0

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

if __name__ == '__main__':
    for epoch in range(10):
        #train_loss = train(train_loader, model, criterion, optimizer, epoch)
        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),
            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_1.pt')


 

這裏直接應用預訓練模型進行訓練。

總結

通過對卷積神經網絡的發展歷程，明確了現代計算機科學辛路發展歷程。總體收穫不小。