pytorch 在MNIST数据集上实现logistic regression

MNIST数据集逻辑回归

首先来load数据集

import torch 
import torch.nn as nn
from torch.autograd import Variable
# torchvision可以帮助我们处理常用数据集，如MNIST，COCO, ImageNET等
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt

# hyper parameter
input_size = 28 * 28 # image size of MNIST data
num_classes = 10
num_epochs = 10
batch_size = 100
learning_rate = 1e-3

# MNIST dataset
train_dataset = dsets.MNIST(root = '../../data_sets/mnist', #选择数据的根目录
                           train = True, # 选择训练集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = False) # 不从网络上download图片
test_dataset = dsets.MNIST(root = '../../data_sets/mnist', #选择数据的根目录
                           train = False, # 选择训练集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = False) # 不从网络上download图片

正常情况下是没有输出的

下面定义模型

#加载数据

train_loader = torch.utils.data.DataLoader(dataset = train_dataset, 
                                           batch_size = batch_size, 
                                           shuffle = True)  # 将数据打乱
test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
                                          batch_size = batch_size,
                                          shuffle = True)

# 定义网络
class logistic_regression(nn.Module):
    def __init__(self,input_size, num_classes):
        super(logistic_regression, self).__init__()
        self.linear = nn.Linear(input_size, num_classes)

    def forward(self, x):
        out = self.linear(x)
        return out

model = logistic_regression(input_size, num_classes)
print(model)

我们照例还是打出了模型：

logistic_regression (
  (linear): Linear (784 -> 10)
)

接着进行优化求解，

# optimization

criterion = nn.CrossEntropyLoss() # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)

#print(train_loader)

for epoch in range(num_epochs):
#for epoch in range(2):
    print(' epoch = %d' % epoch)
    for i, (images, labels) in enumerate(train_loader): #利用enumerate取出一个可迭代对象的内容
        images = Variable(images.view(-1, 28 * 28))
        labels = Variable(labels)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        if  i % 100 == 0:
            print('current loss = %.5f' % loss.data[0])

    #print(np.shape(images))

下面把中间的每步结果打印了出来，这个是在一个i7的笔记本上跑的，速度非常的慢，没有显卡

 epoch = 0
current loss = 2.36456
current loss = 2.23192
current loss = 2.12668
current loss = 2.04541
current loss = 1.98960
current loss = 1.85134
 epoch = 1
current loss = 1.80007
current loss = 1.76028
current loss = 1.61215
current loss = 1.57158
current loss = 1.64932
current loss = 1.57139
 epoch = 2
current loss = 1.45576
current loss = 1.46784
current loss = 1.44147
current loss = 1.41077
current loss = 1.28766
current loss = 1.23206
 epoch = 3
current loss = 1.32952
current loss = 1.24508
current loss = 1.15732
current loss = 1.20442
current loss = 1.15869
current loss = 1.12833
 epoch = 4
current loss = 1.06003
current loss = 1.12300
current loss = 1.13433
current loss = 1.04556
current loss = 0.96975
current loss = 0.98416
 epoch = 5
current loss = 0.94991
current loss = 0.96482
current loss = 0.93888
current loss = 0.95575
current loss = 0.97824
current loss = 0.90590
 epoch = 6
current loss = 0.97614
current loss = 0.99771
current loss = 0.91240
current loss = 0.89928
current loss = 0.78394
current loss = 1.01064
 epoch = 7
current loss = 0.82341
current loss = 0.82106
current loss = 0.83107
current loss = 0.97058
current loss = 0.79333
current loss = 0.80935
 epoch = 8
current loss = 0.78961
current loss = 0.83180
current loss = 0.70934
current loss = 0.74009
current loss = 0.88906
current loss = 0.86189
 epoch = 9
current loss = 0.86894
current loss = 0.75770
current loss = 0.78109
current loss = 0.73139
current loss = 0.67064
current loss = 0.69243

来看一下prediction的结果

# test the model
correct = 0
total = 0

for images, labels in test_loader:
    images = Variable(images.view(-1, 28 * 28))
    outputs = model(images)
    #torch.max(x, n) 沿着n维进行某种操作。得到的是某一维度的最大值之类的，如果不加维度n，则返回所有元素的最大值之类的
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('accuracy of the model %.2f' % (100 * correct / total))

结果：

accuracy of the model 85.67