基于Python的机器学习系列（30）：PyTorch - 逻辑回归

        在本篇文章中，我们将深入探讨如何使用PyTorch实现逻辑回归模型。逻辑回归是一种用于分类问题的简单而有效的算法。我们将以经典的MNIST数据集为例，构建一个简单的全连接神经网络，并使用逻辑回归进行分类任务。

1. 定义数据集

        我们首先加载MNIST数据集，这是一组包含手写数字的图像数据集。每张图像的尺寸为28x28像素，共有10个类别（0到9）。我们将使用PyTorch的torchvision库来加载数据集，并进行必要的预处理，将像素值从0-255归一化到0-1范围内。

import torch, torchvision
from torchvision import transforms
from torch import nn
import numpy as np

# 设置设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)

# 超参数
input_size = 784  # 28x28图像展平后的特征数
hidden_size = 89  # 隐藏层的神经元数量
num_classes = 10  # 输出类别数量
num_epochs = 1
batch_size = 100
learning_rate = 0.001

# 定义数据集
train_dataset = torchvision.datasets.MNIST(root='data', 
                                           train=True, 
                                           transform=transforms.ToTensor(),  # 将0-255转换为0-1
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='data', 
                                          train=False, 
                                          transform=transforms.ToTensor())

# 数据加载器
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)

2. 定义模型

        我们将构建一个全连接的神经网络，包含一个输入层、一个隐藏层和一个输出层。输入层接受784个特征（展平后的28x28图像），隐藏层包含89个神经元，输出层包含10个神经元，用于输出类别概率。我们使用Sigmoid激活函数来增加模型的非线性能力。

# 定义神经网络模型
class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes) 

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

model = NeuralNet(input_size, hidden_size, num_classes).to(device)

3. 定义损失函数和优化器

        我们选择交叉熵损失函数和Adam优化器。交叉熵损失函数通常用于多类别分类问题，Adam优化器则能够有效地调整模型参数。

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

4. 训练模型

        在训练过程中，我们将模型输入数据进行前向传播，计算损失，然后进行反向传播以更新模型参数。训练完成后，我们将在测试集上评估模型的性能。

# 训练模型
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = images.view(-1, 28*28).to(device)
        labels = labels.to(device)

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

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print (f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_dataset)//batch_size}], Loss: {loss.item():.4f}')

5. 测试模型

        使用测试数据集评估模型的性能，计算准确率并输出结果。

# 测试模型
model.eval()  # 设置为评估模式
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.view(-1, 28*28).to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f'Accuracy: {100 * correct / total:.2f}%')

结语

        在本篇文章中，我们介绍了如何使用PyTorch构建和训练逻辑回归模型，通过MNIST数据集演示了从数据加载、模型定义到训练和测试的完整流程。逻辑回归作为基础的分类算法，为我们提供了一个理解深度学习模型工作原理的良好起点。掌握这些基础知识将为进一步学习更复杂的模型和算法打下坚实的基础。

如果你觉得这篇博文对你有帮助，请点赞、收藏、关注我，并且可以打赏支持我！

欢迎关注我的后续博文，我将分享更多关于人工智能、自然语言处理和计算机视觉的精彩内容。

谢谢大家的支持！