Pytorch从0到1之逻辑回归——(3)

开篇

这次我们介绍用pytorch实现逻辑回归，用到的数据集是MNIST数据。Logistic Regression是一种广义的线性回归模型，既可以做回归也可以做分类。
这个线性回归的因变量不是x，而是x的线性函数，即wx+b，所以这个回归可以表示为y = S(wx+b)。这个S就是我们熟知的sigmod函数，它可以将数据的范围归到0-1之间，所以这个值也可以当成概率用作分类，以0.5作为分类阈值。Logistic Regression的损失函数是CrossEntropyLoss,交叉熵损失函数。
废话少说，我们开始。
引入库

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms

超参数的定义

input_size = 28 * 28
num_classes = 10
num_epochs = 5
batch_size = 10
learning_rate = 0.001

MNIST数据库的引入和下载

train_dataset = torchvision.datasets.MNIST(root = 'G:/pytorch_tutorials/MNIST_data/',
                                           train = True,
                                           transform = transforms.ToTensor(),
                                           download=True)
test_dataset = torchvision.datasets.MNIST(root = 'G:/pytorch_tutorials/MNIST_data/',
                                           train = False,
                                           transform = transforms.ToTensor())

如果你已经有了MNIST数据，你就可以把root改成你自己的数据路径，并把download改为False。
数据加载

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 = False)

数据的导入，我们引入了数据之后还需要进行导入，这个train_loader和test_loader才是我们真正取数据的地方。
逻辑回归模型，优化器以及损失函数的构建

model = nn.Linear(input_size,num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr = learning_rate)~

前面已经说了，Logistic Regression其实也是一种线性回归模型，所以我们用到的基本模型还是Linear，只是损失函数用到了交叉熵损失，这个具体可以看逻辑回归的理论知识，这里不赘述。(初学者建议去好好看，反正我当时看完觉得还是很奇妙的一个公式，这里面的数据范围是0-1)看完这个损失建议大家再搜一下Focal Loss,二者在形式上有一些相似。
训练模型

total_step = len(train_loader)
for epoch in range(num_epochs):
    for i,(images,labels) in enumerate(train_loader):
        # 将图片的尺寸改成(batch_size,input_size)大小
        images = images.reshape(-1,input_size)

        # 前向传播
        outputs = model(images)
        loss = criterion(outputs,labels)

        # 反向传播并优化，需要将优化器的导数先清零
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i + 1) % 100 == 0:
            print('Epoch [{}/{}],Step [{}/{}],Loss:{:.4f}'
                  .format(epoch+1,num_epochs,i+1,total_step,loss.iem()))~

模型测试

# 测试的时候不能计算梯度
with torch.no_grad():
    correct = 0
    total = 0
    for images,labels in test_loader:
        images = images.reshape(-1,input_size)
        outputs = model(images)
        # 找出outputs.data中每一行的最大值(在axis=1)
        _,predicted = torch.max(outputs.data,1)
        total += labels.size(0)
        correct += (predicted == labels).sum()

    print("Accuracy of the model on the 10000 test images:{} %".format(100 * correct / total))~

保存模型
.

torch.save(model.state_dict(),'model.ckpt')

总结

Logistic Regrssion无论在分类还是回归领域都是很重要的基础模型，它的一些知识无论在以后的神经网络领域或是SVM领域都有或多或少的体现，而且这个模型并不复杂，希望大家还是要弄清楚这一部分的理论知识再来写代码，起码要了解sigmod函数及其求导，以及交叉熵损失函数到底是什么。下一次我们说ConvNet卷积神经网络。