pytorch入门（二）—— 逻辑回归算法

逻辑回归

算法
Logistic Regression（逻辑回归）是当前业界比较常用的机器学习方法，用于估计某种事物的可能性。

二分类问题
二分类问题是指预测的 $y$值只有两个取值(0 或 1)，二分类问题可以扩展到多分类问题。

Logistic 函数
LR分类器(Logistic Regression Classifier)，在分类情形下，经过学习之后的LR分类器其实就是一组权值$w_0,w_1,w_2,...,w_m$。当测试样本集中的测试数据来到时，这一组权值按照与测试数据线性加和的方式，求出一个$\mathbf{z}$值。
$\mathbf{z}=w_0+w_1{x}_1+w_2{x}_2+...+w_m{x}_m$。(其中 $x_1,x_2,...,x_m$是样本数据的各个特征，维度为$m$)，如果忽略二分类问题中的 $y$ 的取值是一个离散的取值(0 或 1)，继续使用线性回归来预测 $y$ 的取值，这样会导致 $y$ 的取值并不为 0 或 1。逻辑回归使用一个函数来归一化 $y$ 值，使 $y$ 的取值在区间(0, 1)内，这个函数称为 Logistic 函数 (Logistic Function)，也称为 Sigmoid 函数 (Sigmoid Function)。
然后按照Sigmoid 函数的形式求出$g(z)$。
$$g(z)=\frac{1}{1+e^{-z}}$$
由于Sigmoid 函数的定义域是 (-inf, inf)，而值域为 (0, 1)。因此最基本的LR分类器适合对两类目标进行分类。
Logistic 函数当 $z$ 趋近于无穷大时，$g(z)$ 趋近于1；当 $z$ 趋近于无穷小时，$g(z)$ 趋近于0

代码实现

import torch as tr
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable

input_size = 784
num_classes = 10
num_epochs = 10
batch_size = 50

learning_rate = 0.001

train_dataset = dsets.MNIST(root='./data',
        train=True,
        transform=transforms.ToTensor(),
        download=True)

test_dataset = dsets.MNIST(root='./data',
        train=False,
        transform=transforms.ToTensor())

train_loader = tr.utils.data.DataLoader(dataset=train_dataset,
        batch_size=batch_size,
        shuffle=True)

test_loader = tr.utils.data.DataLoader(dataset=test_dataset,
        batch_size=batch_size,
        shuffle=True)

class LogisticRegression(nn.Module):
    def __init__(self, input_size, num_classes):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, num_classes)

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


net = LogisticRegression(5, 1)
print(net)

model = LogisticRegression(input_size, num_classes)

loss_fun = nn.CrossEntropyLoss()
optimizer = tr.optim.SGD(model.parameters(), lr=learning_rate)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = Variable(images.view(-1, 28*28))
        labels = Variable(labels)
        optimizer.zero_grad()
        outputs = model(images)
        loss = loss_fun(outputs, labels)
        loss.backward()
        optimizer.step()
        if (i+1) % 100 == 0:
            print('Epoch: [%d/%d], Step: [%d/%d], Loss: %.4f' % (epoch+1, num_epochs, i+1,
                len(train_dataset)//batch_size, loss.item()))


correct = 0
total = 0
for images, labels in test_loader:
    images = Variable(images.view(-1, 28*28))
    outputs = model(images)
    _, predicted = tr.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Acdcuracy of the model on the 10000 test images: %d %%' %
        (100 * correct / total))

tr.save(model.state_dict(), 'model.pkl')