kaggle——Digit Recognizer MNIST手写数字识别（CNN版）

1） 目标

任务网址：kaggle_Digit Recognizer
任务回顾：识别数字。

上次采用KNN实现，最终准确率为0.97，受限于算法已经比较难以提升。
本次采用CNN实现，开始使用pytorch。

PyTorch主要优势：
1、调用GPU多线程张量运算。
2、深度神经网络自动求导。

2）流程思路

本次思路采用CNN实现，使用pytorch。
参考LE-NET5模型：

代码版本如下：

		#LENET-5
		#nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=1),
        #nn.ReLU(),
        #nn.MaxPool2d(2),
        #nn.Conv2d(6, 16, 5, 1, 1),
        #nn.ReLU(),
        #nn.MaxPool2d(2),
        #nn.Linear(400,120),
        #nn.ReLU(),
        #nn.Linear(120, 84),
        #nn.ReLU(),
        #nn.Linear(84, 10)
1
2
3
4
5
6
7
8
9
10
11
12

3）数据处理

head()头文件：

总共有784组feature，label为y值，表示的该手写数字是几；
其余都是乘客feature，包括：
28*28=784个灰度像素，值代表亮度。

info()信息：

观察可以发现，train数据共42000个，维度为42000784；
test数据共28000个，维度为28000784。
其他数据处理：归一化。

4）代码总结

• train_np = train_data.values
  pandas转numpy
• output = torch.max(input, dim)
  输入 :
  input是softmax函数输出的一个tensor
  dim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值
  输出:
  函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引。
• train_test_split(x_train,y_train,test_size = 0.2,random_state = 42)
  数据分割
• loss.backward()
  将求导结果加在 grad上
• torch.autograd.grad
  不改变变量的 grad 值
• optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False
  随机梯度下降法主要参数：
  params：管理的参数组
  lr：初始学习率
  momentum：动量系数 [公式]
  weight_decay：L2 正则化系数
  nesterov：是否采用 NAG
• zero_grad()
  清空所管理参数的梯度。由于 PyTorch 的特性是张量的梯度不自动清零，因此每次反向传播之后都需要清空梯度。
• x = torch.flatten(x, 1)
  平整为一维送入全连接层

5）代码

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
from torch.autograd import Variable

#超参数
batch_size = 64 # 2^5=64
aerfa=0.1
num_epoc=30

#导入数据
train_data = pd.read_csv(r'D:\python\kaggle\识别数字\digit-recognizer\train.csv',dtype=np.float32)
test_data = pd.read_csv(r'D:\python\kaggle\识别数字\digit-recognizer\test.csv',dtype=np.float32)


#处理数据
train_np = train_data.values
x_test = test_data.values
y_train_np = train_np[:,0]
x_train_np = train_np[:,1:]

#数据分割
from sklearn.model_selection import train_test_split
x_train_np, x_valid_np, y_train_np, y_valid_np = train_test_split(x_train_np,y_train_np,test_size = 0.2,random_state = 42)

y_train_ts = torch.from_numpy(y_train_np).type(torch.LongTensor)
x_train_ts = torch.from_numpy(x_train_np)

#BATCH
train_dataset=torch.utils.data.TensorDataset(x_train_ts,y_train_ts)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size = batch_size, shuffle = True , drop_last = True)

#MODEL
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv = nn.Sequential(
            #LENET-5
            #nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=1),
            #nn.ReLU(),
            #nn.MaxPool2d(2),
            #nn.Conv2d(6, 16, 5, 1, 1),
            #nn.ReLU(),
            #nn.MaxPool2d(2),

            #不知道是啥
            nn.Conv2d(in_channels=1, out_channels=8, kernel_size=3, stride=1, padding=1),  #
            nn.ReLU(),
            nn.Conv2d(8, 16, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(16, 16, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(16, 8, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )
        self.fc = nn.Sequential(

            #nn.Linear(400,120),
            #nn.ReLU(),
            #nn.Linear(120, 84),
            #nn.ReLU(),
            #nn.Linear(84, 10)

            nn.Linear(8 * 7 * 7, 256),
            nn.ReLU(),
            #nn.Dropout(0.5),
            nn.Linear(256, 256),
            nn.ReLU(),
            #nn.Dropout(0.5),
            nn.Linear(256, 10)
        )

    def forward(self,img):
        x = self.conv(img)
        x = torch.flatten(x, 1)
        x = self.fc(x.view(x.shape[0], -1))
        return x

#模型实例化
model = CNN()
model = model.cuda()

error = nn.CrossEntropyLoss()
error = error.cuda()

optim = torch.optim.SGD(model.parameters(), lr=aerfa)

#训练
for epoch in range(1,num_epoc+1):
    print('Epoch:{}/{}'.format(epoch, num_epoc))
    for data in train_loader:

        images, labels = data
        images = Variable(images.view(batch_size, 1, 28, 28))
        labels = Variable(labels)

        images = images.cuda()
        labels = labels.cuda()

        outputs = model(images)
        loss = error(outputs, labels)

        optim.zero_grad()
        loss.backward()
        optim.step()

model=model.cpu()

#训练集准确率
train_right=0
output_train = model(torch.from_numpy(x_train_np).view(x_train_np.shape[0],1,28,28))
train_predict = torch.max(output_train,1)[1].numpy()
for i in range(x_train_np.shape[0]):
    if train_predict[i] == y_train_np[i]:
        train_right+=1
print(train_right,x_train_np.shape[0],train_right/x_train_np.shape[0])

#测试机准确率
valid_right=0
output_valid = model(torch.from_numpy(x_valid_np).view(x_valid_np.shape[0],1,28,28))
valid_predict = torch.max(output_valid,1)[1].numpy()
for i in range(x_valid_np.shape[0]):
    if valid_predict[i] == y_valid_np[i]:
        valid_right+=1
print(valid_right,x_valid_np.shape[0],valid_right/x_valid_np.shape[0])

#输出到文件
test_results = np.zeros((x_test.shape[0],2),dtype='int32') ## test_results.size=(测试样本个数，2)
for i in range(x_test.shape[0]): ##对于每一个测试样本
    one_image = torch.from_numpy(x_test[i]).view(1,1,28,28) ##one_image=第i个测试样本，shape=1*1*28*28
    one_output = model(one_image) ##将one_image输入到模型中
    test_results[i,0] = i+1 ##test_results第0列表示第i个样本（从1到m）
    test_results[i,1] = torch.max(one_output.data,1)[1].numpy()##第一列表示预测的类别
Data = {'ImageId': test_results[:, 0], 'Label': test_results[:, 1]}
DataFrame = pd.DataFrame(Data)
DataFrame.to_csv('CNN.csv', index=False, sep=',')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

4）运行结果

训练集准确率：0.996
cv集准确率：0.986

测试集准确率：
使用LE-NET5的准确率为0.91(程序中注释掉的部分)，采用改良版的LENET5的准确率为0.985。