Kaggle-手写数字（基于Pytorch和CNN）

Kaggle-手写数字识别

本人是一名小白，今天写一下自己第一次提交Kaggle的流程和体会

1.首先我们先导入所需要的库

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data   
import matplotlib.pyplot as plt
import torch.nn.funtional as F

2.定义我们的超参数

# Hyper Parameters
EOPCH = 1               # 几个世纪
BATCH_SIZE = 50
LR = 0.01              # learning rate

3.搭建我们的CNN神经网络（Pytorch）

解释：前3行是我们来继承Pytorch的神经网络这样，使我们可以快速的搭建神经网络。 这里不太懂我推荐看一下莫烦的视频。点这里出发

1. 首先我们来搭建我们第一个卷积层，参数说明如下：
   (1).初始图像的高度
   (2).输出图像的高度 过滤器的数量=输出的高度/输入的高度。
   (3).过滤器的大小
   (4).步长
   (5).填白
   然后用一个激活函数
   最后我们池化 池化就是一个取最大值的过滤器
2. 然后又是一个卷积层
3. 最后是一个全链接层 在通过softmax 函数可以映射成概率
4. 然后我们初始化我们的卷积神经网络

# start build CNN
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 一个卷积层
        self.conv1 = nn.Sequential(
            nn.Conv2d(  # (1,28,28)
                in_channels=1,      # 1个通道
                out_channels=16,    # 输出多少层 也就是有多少个过滤器
                kernel_size=5,      # 过滤器的大小
                stride=1,           # 步长
                padding=2           # 填白
            ),      # --> (16,28,28)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),    # -->(16,14,14)
        )
        self.conv2 = nn.Sequential(     # --> (16,14,14)
            nn.Conv2d(16,32,5,1,2), # 这里用了两个过滤器，将将16层变成了32层
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2) # --> (32,7,7)
        )
        self.out = nn.Linear(32*7*7,10) # 将三维的数据展为2维的数据
    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)       # (batch,32,7,7)
        x = x.view(x.size(0),-1)    # (batch,32,7,7)    batch 就是一批
        output = F.softmax(self.out(x))    # import torch.nn.funtional as F
        return output

cnn = CNN()
# print(cnn)  # net architecture
optimzer = torch.optim.Adam(cnn.parameters(),lr=LR) # define optimezer
loss_func = nn.CrossEntropyLoss()   # define loss_function 交叉嫡误差

4.开始导入我们的数据

1. 我的数据都是从Kaggle平台上下载的，可能有些慢如果你需要，我将放在最后面。你可以去下载。
2. 由于我使用的是CNN，我们必须要把数据整理成能输入的形式
3. 其中我总结了几点注意事项
   - Cup计算结点的类型不能是LONG型的，否则会报错
   - reshape中的-1 表示自适应，这样我们能让我们更好的变化数据的形式
   - Pytorch的Data.Tensorset(x,y) 可以把数据进行打包，以方便我们更好的使用
   - Data.DataLoader() 可以将我们的数据打乱并且分批

# 加载数据集
train= pd.read_csv('./data//train.csv')
train_labels__ = torch.from_numpy(np.array(train.label[:]))
train_data__ = torch.FloatTensor(np.array(train.iloc[:,1:]).reshape((-1,1,28,28)))/255

# CUP 计算的结点不可以是LONG型的
print(train_data__.type())
test= pd.read_csv('./data//test.csv')
test_data = torch.FloatTensor(np.array(test).reshape((-1,1,28,28)))/255

train_data = Data.TensorDataset(train_data__,train_labels__)
train_loader = Data.DataLoader(
    dataset=train_data,
    batch_size=BATCH_SIZE,
    shuffle=True
)

print('load data is over')

5.展示一个数据

要点：

1. squeeze() 这个函数是降维的例如 从 [[1]] -----> [1]
2. 与之相反的是便是unsqueeze(dim=1) 就可以从 [1]-----> [[1]]
3. plt.imshow 可以用来展示图片

plt.imshow(train_data__[1].squeeze().numpy(),cmap='gray')
plt.title('%i' % train_labels__[1])
plt.show()

6.训练与测试

要点：

• step是第几批数据
• epoch 是第几轮，我们通常称之为世纪 一个世纪就是将数据全部使用一回
• 注释update W下的三行分别是（必要步骤）
  • 梯度清零
  • 计算梯度
  • 跟新梯度
• 然后打印一下进度

for epoch in range(EOPCH):
    for step,(x,y) in enumerate(train_loader):  # gives batch data
        b_x = Variable(x)
        b_y = Variable(y)
        output = cnn(b_x)   # cnn output
        loss = loss_func(output,b_y)    # cross entropy loss
        # update W
        optimzer.zero_grad()
        loss.backward()
        optimzer.step()
        print('epoch %d'%(epoch+1),'start %d'%step)
    print('train is over')

7.然后到了我们最后的一步了，预测题目中给的未知数据了

要点：

• 我们一定要最后打印一下结束了，要不然我们可能不容易知道程序运行的情况
• torch 和 pandas 的类型不能直接的转换，所以我们借助，numpy中间的步骤，将torhc的数据转给

test = cnn(test_data[:])
pred_test = torch.max(test,1)[1].squeeze()
out = pd.DataFrame(np.array(pred_test),index=range(1,1+len(pred_test)),columns=['ImageId','Label'])
out.to_csv('./kaggle.csv',header=None)
print('结束了')

8.展望未来，优化模型

• 将数据分成训练集和测试集，然后搜索最好的学习率，优化器等等
• 尝试不同的算法

附件

• 数据
• 升级后的代码