CV赛事实践-baseline模型

1 环境配置

什么是baseline模型？
1、baseline这个概念是作为算法提升的参照物而存在的，相当于一个基础模型，可以以此为基准来比较对模型的改进是否有效。将输入数据（特征）与目标变量（或者标签）之间关系建立模型的函数，是一个机器学习算法试图学习的对象。
2、基线（baseline）的正式定义是一种使用简单的启发式探索，统计规则，随机规则或者该领域中先前常使用算法对已知问题及数据集进行预测的方法。这些预测将用来评估基线算法的表现（比如准确率），并且作为标准来对比评估其他机器学习算法的表现。它通常在在正式的工作之前进行，为后面的工作效果提供表现评估的支持。
；

1.1 虚拟环境安装法：

虚拟环境安装法：就是再创建创建一个环境框架，然后在这里面独立安装所需要的python版本和各种库函数。先创建一个虚拟环境，然后里面的python版本或者是其他的安装包都安装在这里面，若是不用就在直接删除掉。

1.1.1 常用虚拟安装命令

查看已经安装的虚拟环境：conda env list
进入虚拟环境：conda activate 虚拟环境名称
退出虚拟环境：source deactivate
删除虚拟环境：conda remove -n 虚拟环境名称 --all
删除虚拟环境中的包：conda remove --name $虚拟环境名称 $包名称
查看包：conda list
删除该环境：conda remove -n pytorchCPU --all

1.1.2 安装pytorch库，无GPU版本

命令：
##创建虚拟环境名称
$conda create -n py37_torch131 python=3.7
##激活环境 并安装
$conda activate py37_torch131
$pip install pytorch=1.3.1 torchvision cudatoolkit=10.0 ##直接去官网查看下载命令
##通过下面的命令一键安装其他依赖库
$pip install jupyter tqdm opencv-python matplotlib pandas
##启动jupyter
jupyter-notebook

2 baseline模型创建

数据集：train、val、test三个数据集
val是validation的简称。
training dataset 和 validation dataset都是在训练的时候起作用。
而因为validation的数据集和training没有交集，所以这部分数据对最终训练出的模型没有贡献。
validation的主要作用是来验证是否过拟合、以及用来调节训练参数等。

2.1 导入使用的包

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

2.2 定义好读取图像的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.3 定义好训练数据路径和验证数据的路径

train_path=glob.glob('../input/train/*.png')
train_path.sort()
train_json=json.load(open('../input/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('../input/val/*.png') 
val_path.sort() 
val_json = json.load(open('../input/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,
)

2.4 定义好字符分类模型，使用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

2.5 定义好训练、验证和预测函数

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

2.6 迭代训练和验证模型

## 主函数
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)
    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')

2.7 对测试集样本进行预测，生成提交文件

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)

3