pytorch训练一个简单的线性模型

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, random_split, TensorDataset
import numpy as np

input_dimension = 10
output_dimension = 1

# 定义一个简单的线性回归模型
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(in_features=input_dimension, out_features=output_dimension, bias=True , dtype=torch.double)
        self.sigmoid = nn.Sigmoid()

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

# 设置随机种子以确保可重复性
torch.manual_seed(0)
np.random.seed(0)

# 生成随机特征数据 每一条数据有10个特征
data = np.random.rand(1000, 10).astype(np.double)

# 生成随机标签，只有0或者1，表示2分类
labels = np.random.randint(0, 2, 1000).astype(np.double)

# 转换数据为 PyTorch 张量
data_tensor = torch.tensor(data)
# 标签转为二维
labels_tensor = torch.tensor(labels).view(-1, 1)  # 使标签数据形状为 (1000, 1)

# 创建 TensorDataset
dataset = TensorDataset(data_tensor, labels_tensor)

# 定义数据集的大小
train_size = int(0.8 * len(dataset))
val_size = int(0.1 * len(dataset))
test_size = len(dataset) - train_size - val_size

# 使用 random_split 函数划分数据集
train_dataset, val_dataset, test_dataset = random_split(dataset, [train_size, val_size, test_size])

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 实例化模型
model = LinearRegressionModel()

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


# 训练模型
num_epochs = 200
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct_predictions = 0
    total_predictions = 0
    for data, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(data)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        # 计算准确率
        predicted = outputs.round()
        correct_predictions += (predicted == labels).sum().item()
        total_predictions += labels.size(0)

    training_accuracy = correct_predictions / total_predictions

    # 计算验证集上的损失
    model.eval()
    val_loss = 0.0
    correct_val_predictions = 0
    total_val_predictions = 0
    with torch.no_grad():
        for data, labels in val_loader:
            outputs = model(data)
            loss = criterion(outputs, labels)
            val_loss += loss.item()
            # 计算准确率
            predicted = outputs.round()
            correct_val_predictions += (predicted == labels).sum().item()
            total_val_predictions += labels.size(0)

        validation_accuracy = correct_val_predictions / total_val_predictions

    print(f'Epoch [{epoch + 1}/{num_epochs}], Training Loss: {running_loss / len(train_loader):.4f}, Training Accuracy: {training_accuracy:.4f}, Validation Loss: {val_loss / len(val_loader):.4f}, Validation Accuracy: {validation_accuracy:.4f}')

# 保存模型
torch.save(model.state_dict(), 'linear_regression_model.pth')
print('Model saved to linear_regression_model.pth')

# 测试模型
model.eval()
test_loss = 0.0
with torch.no_grad():
    for data, labels in test_loader:
        outputs = model(data)
        loss = criterion(outputs, labels)
        test_loss += loss.item()

print(f'Test Loss: {test_loss/test_size}')