基于PyTorch的卷积神经网络（CNN）实现MNIST分类模型
最近第一次玩了一下Kaggle，用PyTorch手写了一个四不像的卷积神经网络（有一点Inception v1的结构），测试准确率约为99.2%
# -*- coding: utf-8 -*-
"""Digit Recognizer.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1sbq5hjhjO3I5jQQAN_5-mo7Hx4pSKcjH
"""
import torch
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import csv
dataset = list()
with open('train.csv','r') as f:
reader = csv.reader(f)
t = 0
for row in reader:
if t > 0:
dataset.append(row)
t = t + 1
dataset = np.array(dataset, dtype = np.float32)
print(dataset.shape)
#print(dataset[0])
#print(dataset)
np.random.shuffle(dataset)
#print(dataset[0])
#print(dataset)
VALID_RATE = 0.01
seg = int((1 - VALID_RATE) * len(dataset))
raw_train_data, raw_valid_data = dataset[:seg], dataset[seg:]
print(raw_train_data.shape, raw_valid_data.shape)
train_data_x = torch.empty(seg, 1, 28, 28, dtype=torch.float32)
train_data_y = torch.empty(seg, 1, dtype=int)
for i in range(seg):
train_data_x[i] = (torch.from_numpy(raw_train_data[i][1:].reshape(1, 28, 28)) / 255.0 - 0.5) / 0.5
train_data_y[i] = int(raw_train_data[i][0])
valid_data_x = torch.empty(42000 - seg, 1, 28, 28, dtype=torch.float32)
valid_data_y = torch.empty(42000 - seg, 1, dtype=int)
for i in range(42000 - seg):
valid_data_x[i] = (torch.from_numpy(raw_valid_data[i][1:].reshape(1, 28, 28)) / 255.0 - 0.5) / 0.5
valid_data_y[i] = int(raw_valid_data[i][0])
train_data_y = torch.squeeze(train_data_y)
valid_data_y = torch.squeeze(valid_data_y)
#print(valid_data_y[0].dtype)
def get_num_correct(a, b):
return a.argmax(dim=1).eq(b).sum().item()
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=0)
self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, padding=2)
self.conv4 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=3, padding=1)
self.bn1 = nn.BatchNorm2d(48)
self.conv5 = nn.Conv2d(in_channels=48, out_channels=48, kernel_size=1, padding=0)
self.conv6 = nn.Conv2d(in_channels=48, out_channels=64, kernel_size=3, padding=1)
self.conv7 = nn.Conv2d(in_channels=48, out_channels=64, kernel_size=5, padding=2)
self.conv8 = nn.Conv2d(in_channels=48, out_channels=64, kernel_size=3, padding=1)
self.bn2 = nn.BatchNorm2d(192)
self.conv9 = nn.Conv2d(in_channels=192, out_channels=128, kernel_size=1, padding=0)
self.fc = nn.Linear(in_features=128 * 4 * 4, out_features=128)
self.out = nn.Linear(in_features=128, out_features=10)
self.drop = nn.Dropout(p=0.5)
def forward(self, t):
t = F.relu(self.conv1(t))
t = F.max_pool2d(t, kernel_size=2, stride=2, padding=0)
t1 = F.relu(self.conv2(t))
t2 = F.relu(self.conv3(t))
t3 = F.max_pool2d(t, kernel_size=3, stride=1, padding=1)
t3 = F.relu(self.conv4(t))
t = torch.cat([t1, t2, t3], dim=1)
t = self.bn1(t)
t = F.relu(self.conv5(t))
t1 = F.relu(self.conv6(t))
t2 = F.relu(self.conv7(t))
t3 = F.max_pool2d(t, kernel_size=3, stride=1, padding=1)
t3 = F.relu(self.conv8(t))
t = torch.cat([t1, t2, t3], dim=1)
t = self.bn2(t)
t = F.relu(self.conv9(t))
t = F.max_pool2d(t, kernel_size=3, stride=3, padding=0)
t = t.reshape(-1, 128 * 4 * 4)
t = F.relu(self.fc(t))
t = self.drop(t)
t = self.out(t)
t = self.drop(t)
return t
net = Model()
bsize = 20
opt = optim.SGD(net.parameters(), lr=0.008, momentum=0.8)
def check_valid():
net.eval()
with torch.no_grad():
_total_loss = 0
_total_correct = 0
for i in range(0, 42000 - seg, bsize):
x, y = valid_data_x[i:i + bsize], valid_data_y[i:i + bsize]
yp = net.forward(x)
_loss = F.cross_entropy(yp, y)
_total_loss += _loss.item()
_total_correct += get_num_correct(yp, y)
print("Valid Accuracy:", _total_correct / (42000 - seg), "loss:", _total_loss)
return _total_correct / (42000 - seg)
def train():
idx = list()
acc_train = list()
acc_valid = list()
print("Train:")
net.train()
for epoch in range(20):
total_loss = 0
total_correct = 0
#t = 0
for i in range(0, seg, bsize):
# print(i, i + bsize - 1)
#print(t*bsize, (t+1)*bsize-1)
#t = t + 1
images, labels = train_data_x[i:i + bsize], train_data_y[i:i + bsize]
preds = net.forward(images)
loss = F.cross_entropy(preds, labels)
opt.zero_grad()
loss.backward()
opt.step()
total_loss += loss.item()
total_correct += get_num_correct(preds, labels)
print("Epoch", epoch + 1, "\nTrain Accuracy:", total_correct / seg, "Loss:", total_loss)
idx.append(epoch + 1)
acc_train.append(total_correct / seg)
acc_valid.append(check_valid())
plt.plot(idx, acc_train, ls="-", lw=2, label="train", c='red')
plt.plot(idx, acc_valid, ls="-", lw=2, label="valid", c='orange')
plt.legend()
plt.show()
train()
testset = list()
with open('test.csv','r') as f:
reader = csv.reader(f)
t = 0
for row in reader:
if t > 0:
testset.append(row)
t = t + 1
testset = np.array(testset, dtype = np.float32)
test_data_x = torch.empty(28000, 1, 28, 28, dtype=torch.float32)
test_data_y_hat = torch.empty(28000, 1, dtype=int)
for i in range(28000):
test_data_x[i] = (torch.from_numpy(testset[i].reshape(1, 28, 28)) / 255.0 - 0.5) / 0.5
def test():
net.eval()
with torch.no_grad():
for i in range(0, 28000):
x = test_data_x[i]
yp = net.forward(x.unsqueeze(dim=0))
test_data_y_hat[i] = yp.argmax(dim=1)
test()
test_data_y_hat = test_data_y_hat.squeeze()
with open('out.csv','w',newline='') as f:
writer = csv.writer(f)
writer.writerow(["ImageId", "Label"])
for i in range(28000):
row = list([i+1, test_data_y_hat[i].item()])
writer.writerow(row)