和我一起学机器学习-逻辑斯蒂回归（Logistic Regression）

小灰灰 2023-10-01 00:20 3阅读 0赞

逻辑斯蒂回归（`Logistic Regression`）是一种广泛使用的统计学习方法，它可以用来处理分类问题，例如二分类问题。

> 它的主要思想是建立一个线性分类器，然后将线性输出映射到一个`sigmoid`函数，从而将连续输出转化为概率值。`sigmoid`函数是一个`S`形函数，其输出范围在`0`到`1`之间。对于二分类问题，当输出概率值大于`0.5`时，我们将其归为一类，否则为另一类。

以下是一个使用`PyTorch`实现逻辑斯蒂回归的简单示例：

import torch
    import torch.nn as nn
    import torch.optim as optim
    
    # 定义逻辑斯蒂回归模型
    class LogisticRegression(nn.Module):
        def __init__(self, input_dim, output_dim):
            super(LogisticRegression, self).__init__()
            self.linear = nn.Linear(input_dim, output_dim)
    
        def forward(self, x):
            out = self.linear(x)
            return out
    
    # 训练模型
    def train(model, criterion, optimizer, train_loader, num_epochs):
        for epoch in range(num_epochs):
            for i, (inputs, labels) in enumerate(train_loader):
                # 将数据转化为PyTorch张量
                inputs = torch.tensor(inputs)
                labels = torch.tensor(labels)
    
                # 前向传播
                outputs = model(inputs)
                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, len(train_loader), loss.item()))
    
    # 测试模型
    def test(model, test_loader):
        with torch.no_grad():
            correct = 0
            total = 0
            for inputs, labels in test_loader:
                # 将数据转化为PyTorch张量
                inputs = torch.tensor(inputs)
                labels = torch.tensor(labels)
    
                # 前向传播
                outputs = model(inputs)
                _, predicted = torch.max(outputs.data, 1)
    
                # 统计预测结果的正确率
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
    
            print('Accuracy of the model on the test images: {:.2f} %'.format(100 * correct / total))
    
    # 定义超参数
    input_dim = 784  # 输入维度
    output_dim = 10  # 输出维度
    learning_rate = 0.001  # 学习率
    num_epochs = 5  # 迭代次数
    
    # 加载MNIST数据集
    train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), 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=100, shuffle=True)
    test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False

定义模型、损失函数和优化器

model = LogisticRegression(input_dim, output_dim)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=learning_rate)

训练模型

train(model, criterion, optimizer, train_loader, num_epochs)

测试模型

test(model, test_loader)

在这个例子中，我们使用了`PyTorch`内置的逻辑斯蒂回归函数`nn.Linear`来构建模型。输入维度`input_dim`是`MNIST`数据集中图像的像素数，输出维度`output_dim`是类别数，即`0-9`。我们还定义了损失函数`nn.CrossEntropyLoss()`和优化器`optim.SGD()`来训练模型。

在训练模型时，我们首先将输入和标签转换为`PyTorch`张量。我们然后执行前向传播和计算损失，使用反向传播和优化器来更新模型参数。我们还记录了损失值并定期打印输出。

在测试模型时，我们禁用梯度计算，对测试数据集中的每个图像进行前向传播，并将输出与标签进行比较以计算模型的准确性。  
你可以查看[with torch.no\_grad()和model.eval()在干什么？][with torch.no_grad_model.eval]了解为什么要禁用梯度。

逻辑斯蒂回归是一种简单但有效的分类方法，通常用于二分类问题，但也可以扩展到多分类问题，这里不做介绍。

[with torch.no_grad_model.eval]: https://blog.csdn.net/AdamCY888/article/details/130285660