Pytorch逻辑回归分类

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
from torch.autograd import Variable
import torchvision.datasets as dataset
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

input_size = 784  # 输入到逻辑回归模型中的输入大小
num_classes = 10  # 分类的类别个数
num_epochs = 10  # 迭代次数
batch_size = 50  # 批量训练个数
learning_rate = 0.01  # 学习率


# 下载训练数据和测试数据
train_dataset = dataset.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = dataset.MNIST(root='./data',train=False, transform=transforms.ToTensor)

# 使用DataLoader形成批处理文件
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 创建逻辑回归类模型  (sigmoid(wx+b))
class LogisticRegression(nn.Module):
    def __init__(self,input_size,num_classes):
        super(LogisticRegression,self).__init__()
        self.linear = nn.Linear(input_size,num_classes)
        self.sigmoid = nn.Sigmoid()

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

# 设定模型参数
model = LogisticRegression(input_size, num_classes)
# 定义损失函数，分类任务，使用交叉熵
criterion = nn.CrossEntropyLoss()
# 优化算法，随机梯度下降，lr为学习率，获得模型需要更新的参数值
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)


# 使用训练数据训练模型
for epoch in range(num_epochs):
    # 批量数据进行模型训练
    for i, (images, labels) in enumerate(train_loader):
        # 需要将数据转换为张量Variable
        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+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))  # 形式为(batch_size,28*28)
    outputs = model(images)
    _,predicts = torch.max(outputs.data,1)  # _输出的是最大概率的值，predicts输出的是最大概率值所在位置，max()函数中的1表示维度，意思是计算某一行的最大值
    total += labels.size(0)
    correct += (predicts==labels).sum()

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

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

criterion = nn.CrossEntropyLoss()
loss = criterion(outputs, labels)

loss = nn.CrossEntropyLoss()
loss = loss(outputs, labels)