自定义数据集：继承  torch.utils.data.Dataset  类创建自定义数据集，并重写  __len__  和  __getitem__  方法。

 

定义逻辑回归模型：继承  nn.Module  类，定义一个线性层，并在  forward  方法中应用sigmoid激活函数。

 

训练模型：使用二元交叉熵损失函数  BCELoss  和随机梯度下降优化器  SGD  进行训练。

 

保存模型：使用  torch.save  保存模型的参数。

 

加载模型并预测：加载保存的模型参数，设置模型为评估模式，对新数据进行预测。

 

计算评估指标：使用  sklearn.metrics  中的函数计算精确度、召回率及F1分数

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import Dataset, DataLoader

from sklearn.metrics import precision_score, recall_score, f1_score

 

 

# 自定义数据集

class MyDataset(Dataset):

    def __init__(self, data, labels):

        self.data = torch.FloatTensor(data)

        self.labels = torch.FloatTensor(labels)

 

    def __len__(self):

        return len(self.data)

 

    def __getitem__(self, idx):

        return self.data[idx], self.labels[idx]

 

 

# 生成一些自定义数据

np.random.seed(0)

data = np.random.randn(100, 10)

labels = np.random.randint(0, 2, size=(100, 1))

 

# 创建数据集和数据加载器

dataset = MyDataset(data, labels)

dataloader = DataLoader(dataset, batch_size=10, shuffle=True)

 

 

# 定义逻辑回归模型

class LogisticRegression(nn.Module):

    def __init__(self, input_dim):

        super(LogisticRegression, self).__init__()

        self.linear = nn.Linear(input_dim, 1)

 

    def forward(self, x):

        return torch.sigmoid(self.linear(x))

 

 

model = LogisticRegression(input_dim=10)

 

# 定义损失函数和优化器

criterion = nn.BCELoss()

optimizer = optim.SGD(model.parameters(), lr=0.01)

 

# 训练模型

num_epochs = 100

for epoch in range(num_epochs):

    for batch_data, batch_labels in dataloader:

        optimizer.zero_grad()

        outputs = model(batch_data)

        loss = criterion(outputs, batch_labels.view(-1, 1))

        loss.backward()

        optimizer.step()

    if (epoch + 1) % 10 == 0:

        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

 

# 保存模型

torch.save(model.state_dict(), 'logistic_regression.pth')

 

# 加载模型进行预测

loaded_model = LogisticRegression(input_dim=10)

loaded_model.load_state_dict(torch.load('logistic_regression.pth'))

loaded_model.eval()

 

# 进行预测

new_data = np.random.randn(10, 10)

new_data = torch.FloatTensor(new_data)

with torch.no_grad():

    predictions = loaded_model(new_data)

    predicted_labels = (predictions > 0.5).float()

 

# 计算精确度、召回率及F1分数

true_labels = np.random.randint(0, 2, size=(10, 1))

precision = precision_score(true_labels, predicted_labels.numpy())

recall = recall_score(true_labels, predicted_labels.numpy())

f1 = f1_score(true_labels, predicted_labels.numpy())

 

print(f'Precision: {precision:.4f}')

print(f'Recall: {recall:.4f}')

print(f'F1-score: {f1:.4f}')