kaggle 竞赛：手写数字识别源代码与相关总结

Myth丶恋晨 2023-07-25 08:54 9阅读 0赞

# 前言 #

第一次尝试Kaggle，是经典的手写数字识别的例子，其实这个MNIST数据集识别已经玩腻了，只不过这次是在Kaggle上，用他完成一整套的竞赛流程，为以后的大数据竞赛做好准备，其实，对我而言，这次的MNIST数据集识别与平时的工作只有两点不同，分别是在输入和输出方面。

## 重点 ##

### 1、输入是CSV文件，如何构建Pytorch数据集形式 ###

### 2、输出是标签，如何转为CSV文件进行上传 ###

以上，接下来开始上代码。

# 代码： #

## 1、导入包 ##

import os
    import time
    
    import numpy as np
    import pandas as pd
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from torch.utils.data import DataLoader,TensorDataset
    
    from torchvision import datasets
    from torchvision import transforms
    
    import matplotlib.pyplot as plt
    from PIL import Image
    
    
    if torch.cuda.is_available():
        torch.backends.cudnn.deterministic = True

## 2、超参数 ##

##########################
    ### SETTINGS
    ##########################
    
    # Hyperparameters
    RANDOM_SEED = 1
    LEARNING_RATE = 0.001
    BATCH_SIZE = 128
    NUM_EPOCHS = 10
    
    # Architecture
    NUM_FEATURES = 28*28
    NUM_CLASSES = 10
    
    # Other
    DEVICE = "cpu"
    GRAYSCALE = True

## 3、数据集建立 ##

traindata_pd = pd.read_csv("./data/train.csv")
    traindata_x_np = (traindata_pd.to_numpy()[:, 1:].reshape(-1, 1, 28, 28) / 255.0 - 0.5) / 0.5
    traindata_y_np = traindata_pd.to_numpy()[:, 0].astype(int)
    traindata_x_t = torch.from_numpy(traindata_x_np).float()
    traindata_y_t = torch.from_numpy(traindata_y_np).long()
    traindata = TensorDataset(traindata_x_t, traindata_y_t)
    
    testdata_pd = pd.read_csv("./data/test.csv")
    testdata_t = torch.from_numpy(((testdata_pd.to_numpy().reshape(-1, 1, 28, 28) / 255.0) - 0.5) / 0.5).float()
    testdata = TensorDataset(testdata_t)

## 4、封装成Dataloader ##

train_loader = DataLoader(dataset=traindata, 
                              batch_size=BATCH_SIZE, 
                              shuffle=True)
    
    test_loader = DataLoader(dataset=testdata, 
                             batch_size=BATCH_SIZE, 
                             shuffle=False)
    for images, labels in train_loader:  
        print('Image batch dimensions:', images.shape)
        print('Image label dimensions:', labels.shape)
        break
    device = torch.device(DEVICE)
    torch.manual_seed(0)
    
    for epoch in range(2):
    
        for batch_idx, (x, y) in enumerate(train_loader):
            
            print('Epoch:', epoch+1, end='')
            print(' | Batch index:', batch_idx, end='')
            print(' | Batch size:', y.size()[0])
            
            x = x.to(device)
            y = y.to(device)
            break

## 5、模型搭建 ##

##########################
    ### MODEL
    ##########################
    
    
    def conv3x3(in_planes, out_planes, stride=1):
        """3x3 convolution with padding"""
        return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                         padding=1, bias=False)
    
    
    class BasicBlock(nn.Module):
        expansion = 1
    
        def __init__(self, inplanes, planes, stride=1, downsample=None):
            super(BasicBlock, self).__init__()
            self.conv1 = conv3x3(inplanes, planes, stride)
            self.bn1 = nn.BatchNorm2d(planes)
            self.relu = nn.ReLU(inplace=True)
            self.conv2 = conv3x3(planes, planes)
            self.bn2 = nn.BatchNorm2d(planes)
            self.downsample = downsample
            self.stride = stride
    
        def forward(self, x):
            residual = x
    
            out = self.conv1(x)
            out = self.bn1(out)
            out = self.relu(out)
    
            out = self.conv2(out)
            out = self.bn2(out)
    
            if self.downsample is not None:
                residual = self.downsample(x)
    
            out += residual
            out = self.relu(out)
    
            return out
    
    
    
    
    class ResNet(nn.Module):
    
        def __init__(self, block, layers, num_classes, grayscale):
            self.inplanes = 64
            if grayscale:
                in_dim = 1
            else:
                in_dim = 3
            super(ResNet, self).__init__()
            self.conv1 = nn.Conv2d(in_dim, 64, kernel_size=7, stride=2, padding=3,
                                   bias=False)
            self.bn1 = nn.BatchNorm2d(64)
            self.relu = nn.ReLU(inplace=True)
            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
            self.layer1 = self._make_layer(block, 64, layers[0])
            self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
            self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
            self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
            self.avgpool = nn.AvgPool2d(7, stride=1)
            self.fc = nn.Linear(512 * block.expansion, num_classes)
    
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                    m.weight.data.normal_(0, (2. / n)**.5)
                elif isinstance(m, nn.BatchNorm2d):
                    m.weight.data.fill_(1)
                    m.bias.data.zero_()
    
        def _make_layer(self, block, planes, blocks, stride=1):
            downsample = None
            if stride != 1 or self.inplanes != planes * block.expansion:
                downsample = nn.Sequential(
                    nn.Conv2d(self.inplanes, planes * block.expansion,
                              kernel_size=1, stride=stride, bias=False),
                    nn.BatchNorm2d(planes * block.expansion),
                )
    
            layers = []
            layers.append(block(self.inplanes, planes, stride, downsample))
            self.inplanes = planes * block.expansion
            for i in range(1, blocks):
                layers.append(block(self.inplanes, planes))
    
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.conv1(x)
            x = self.bn1(x)
            x = self.relu(x)
            x = self.maxpool(x)
    
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            x = self.layer4(x)
            # because MNIST is already 1x1 here:
            # disable avg pooling
            #x = self.avgpool(x)
            
            x = x.view(x.size(0), -1)
            logits = self.fc(x)
            probas = F.softmax(logits, dim=1)
            return logits, probas
    
    
    
    def resnet34(num_classes):
        """Constructs a ResNet-34 model."""
        model = ResNet(block=BasicBlock, 
                       layers=[3, 4, 6, 3],
                       num_classes=NUM_CLASSES,
                       grayscale=GRAYSCALE)
        return model

## 6、训练过程 ##

torch.manual_seed(RANDOM_SEED)
    model = resnet34(NUM_CLASSES)
    model.to(DEVICE)
    
    optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)

def compute_accuracy(model, data_loader, device):
        correct_pred, num_examples = 0, 0
        for i, (features, targets) in enumerate(data_loader):
                
            features = features.to(device)
            targets = targets.to(device)
    
            logits, probas = model(features)
            _, predicted_labels = torch.max(probas, 1)
            num_examples += targets.size(0)
            correct_pred += (predicted_labels == targets).sum()
        return correct_pred.float()/num_examples * 100
        
    cost_list = []
    start_time = time.time()
    for epoch in range(NUM_EPOCHS):
        
        model.train()
        for batch_idx, (features, targets) in enumerate(train_loader):
            
            features = features.to(DEVICE)
            targets = targets.to(DEVICE)
                
            ### FORWARD AND BACK PROP
            logits, probas = model(features)
            cost = F.cross_entropy(logits, targets)
            optimizer.zero_grad()
            
            cost.backward()
            
            ### UPDATE MODEL PARAMETERS
            optimizer.step()
            
            ### LOGGING
            if not batch_idx % 50:
                print ('Epoch: %03d/%03d | Batch %04d/%04d | Cost: %.4f' 
                       %(epoch+1, NUM_EPOCHS, batch_idx, 
                         len(train_loader), cost))
                cost_list.append(cost)
            
    
        model.eval()
        with torch.set_grad_enabled(False): # save memory during inference
            print('Epoch: %03d/%03d | Train: %.3f%%' % (
                  epoch+1, NUM_EPOCHS, 
                  compute_accuracy(model, train_loader, device=DEVICE)))
            
        print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))
        
    print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))

## 7、模型存储、结果导出 ##

torch.save(model,'resnet_34_model.pth')
    np.save('cost.npy',cost_list)
    model.eval()
    pred =[]
    
    
    with torch.set_grad_enabled(False): # save memory during inference
        for batch_idx, (features) in enumerate(test_loader):
            features = features[0].float()
            logits, probas = model(features)
            _, _pred = torch.max(probas, 1)
            pred += _pred.tolist()

data1 = {
        'ImageId': [i + 1 for i in range(len(pred))], 'Label': pred}
    df1 = pd.DataFrame(data1)
    df1.to_csv("./data/submission.csv", index=None)

# 最后 #

## 参考文献： ##

\[1\]、https://blog.csdn.net/qq\_16907619/article/details/103765237  
\[2\]、https://github.com/rasbt/deeplearning-models

# 有用请点赞，疑问可留言。 #