pytorch使用nn.Moudle实现逻辑回归

下面是使用PyTorch的nn.Module实现逻辑回归的完整攻略。

1. 准备数据

首先，我们需要准备要使用的数据集。假设我们使用的是一个二分类的问题，数据集中包含两种样本，每个样本有两个特征。我们可以通过以下代码生成一个包含100个样本的数据集：

import torch
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_features=2, n_redundant=0, n_informative=1,
                           n_clusters_per_class=1, n_samples=100)
# 将数据集分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 将数据转换为 PyTorch Tensor
X_train = torch.from_numpy(X_train).float()
X_test = torch.from_numpy(X_test).float()
y_train = torch.from_numpy(y_train).float()
y_test = torch.from_numpy(y_test).float()

2. 创建模型

创建一个模型需要继承 PyTorch 的 nn.Module 类并实现 __init__ 和 forward 方法。在 __init__ 中定义所有需要学习的参数，并在 forward 中实现模型的前向传递。下面是逻辑回归模型的代码实现：

import torch.nn as nn

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

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

在 __init__ 中定义了一个线性层（nn.Linear）和一个 Sigmoid 函数，forward 方法将输入传递给线性层，将结果传递给 Sigmoid 函数，并返回输出。这个模型仅有一个线性层和一个激活函数的结构，经过 Sigmoid 函数的特征值将被映射到[0,1]之间，可以看做是概率值。

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

在训练模型之前，我们需要定义一个损失函数和一个优化器。逻辑回归问题通常使用二元交叉熵作为损失函数，优化器可以选择随机梯度下降（SGD）或 Adam 优化器。下面是代码实现：

criterion = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

在上面的代码中，我们使用了二元交叉熵作为损失函数，使用了随机梯度下降作为优化器。

4. 训练模型

有了前面的准备工作，我们就可以开始训练模型了。下面是训练模型的代码实现：

num_epochs = 1000

for epoch in range(num_epochs):
    # 向前传递batch数据
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    # 向后传递并更新权重
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

在这段代码中，我们迭代 num_epochs 次，每次向前传递输入 X_train，计算损失，并向后传递并更新权重。最终输出了每轮训练的损失值。

5. 模型评估

在完成训练之后，我们需要对模型进行评估，看看它在测试集上的表现。下面是对模型进行评估的代码实现：

with torch.no_grad():
    # 计算模型在测试集上的预测值
    y_pred = model(X_test)
    # 将预测值进行四舍五入，得到最终的分类结果 
    y_pred = torch.round(y_pred)
    # 计算模型在测试集上的准确率
    accuracy = (y_pred == y_test).sum().item() / y_test.size(0)
    print('Accuracy of the model on the test set: {:.2f}%'.format(accuracy * 100))

在这段代码中，我们使用 torch.no_grad() 来避免在模型评估时计算梯度，计算测试集上的预测结果并将其四舍五入以获得最终的分类结果，然后计算模型在测试集上的准确率。

示例说明

下面是两个示例说明，展示如何使用上述攻略中的模型。

示例1: 基本应用

# 准备数据
import torch
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_features=2, n_redundant=0, n_informative=1,
                           n_clusters_per_class=1, n_samples=100)
# 将数据集分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 将数据转换为 PyTorch Tensor
X_train = torch.from_numpy(X_train).float()
X_test = torch.from_numpy(X_test).float()
y_train = torch.from_numpy(y_train).float()
y_test = torch.from_numpy(y_test).float()

# 创建模型
import torch.nn as nn

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

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

model = LogisticRegression(2)

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

# 训练模型
num_epochs = 1000

for epoch in range(num_epochs):
    # 向前传递batch数据
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    # 向后传递并更新权重
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 模型评估
with torch.no_grad():
    # 计算模型在测试集上的预测值
    y_pred = model(X_test)
    # 将预测值进行四舍五入，得到最终的分类结果 
    y_pred = torch.round(y_pred)
    # 计算模型在测试集上的准确率
    accuracy = (y_pred == y_test).sum().item() / y_test.size(0)
    print('Accuracy of the model on the test set: {:.2f}%'.format(accuracy * 100))

示例2: 对比不同优化器

# 准备数据
import torch
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_features=2, n_redundant=0, n_informative=1,
                           n_clusters_per_class=1, n_samples=100)
# 将数据集分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 将数据转换为 PyTorch Tensor
X_train = torch.from_numpy(X_train).float()
X_test = torch.from_numpy(X_test).float()
y_train = torch.from_numpy(y_train).float()
y_test = torch.from_numpy(y_test).float()

# 创建模型
import torch.nn as nn

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

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

model = LogisticRegression(2)

# 定义损失函数和优化器
criterion = nn.BCELoss()
sgd_optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
adam_optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 使用 SGD 优化器训练模型
print("Using SGD optimizer:")
num_epochs = 1000

for epoch in range(num_epochs):
    # 向前传递batch数据
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    # 向后传递并更新权重
    sgd_optimizer.zero_grad()
    loss.backward()
    sgd_optimizer.step()

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

# 模型评估
with torch.no_grad():
    # 计算模型在测试集上的预测值
    y_pred = model(X_test)
    # 将预测值进行四舍五入，得到最终的分类结果 
    y_pred = torch.round(y_pred)
    # 计算模型在测试集上的准确率
    accuracy = (y_pred == y_test).sum().item() / y_test.size(0)
    print('Accuracy of the model on the test set: {:.2f}%'.format(accuracy * 100))

# 使用 Adam 优化器训练模型
print("Using Adam optimizer:")
num_epochs = 1000

for epoch in range(num_epochs):
    # 向前传递batch数据
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    # 向后传递并更新权重
    adam_optimizer.zero_grad()
    loss.backward()
    adam_optimizer.step()

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

# 模型评估
with torch.no_grad():
    # 计算模型在测试集上的预测值
    y_pred = model(X_test)
    # 将预测值进行四舍五入，得到最终的分类结果 
    y_pred = torch.round(y_pred)
    # 计算模型在测试集上的准确率
    accuracy = (y_pred == y_test).sum().item() / y_test.size(0)
    print('Accuracy of the model on the test set: {:.2f}%'.format(accuracy * 100))

在这个示例中，我们训练了两个模型，一个使用 SGD 优化器，另一个使用 Adam 优化器，然后比较了它们的性能。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：pytorch使用nn.Moudle实现逻辑回归 - Python技术站