自定义数据集 使用paddlepaddle框架实现逻辑回归并保存模型，然后保存模型后再加载模型进行预测

自定义数据集：通过继承  paddle.io.Dataset  类创建自定义数据集，并重写  __getitem__  和  __len__  方法。

 

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

 

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

 

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

 

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

import paddle

import numpy as np

from paddle.io import Dataset, DataLoader

 

 

# 自定义数据集

class MyDataset(Dataset):

    def __init__(self, data, labels):

        self.data = data

        self.labels = labels

 

    def __getitem__(self, idx):

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

 

    def __len__(self):

        return len(self.data)

 

 

# 生成一些自定义数据

np.random.seed(0)

data = np.random.randn(100, 10).astype('float32')

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

 

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

dataset = MyDataset(data, labels)

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

 

# 定义逻辑回归模型

class LogisticRegression(paddle.nn.Layer):

    def __init__(self, input_dim):

        super(LogisticRegression, self).__init__()

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

 

    def forward(self, x):

        return paddle.nn.functional.sigmoid(self.linear(x))

 

 

model = LogisticRegression(input_dim=10)

 

# 定义损失函数和优化器

criterion = paddle.nn.BCELoss()

optimizer = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())

 

# 训练模型

num_epochs = 100

for epoch in range(num_epochs):

    for batch_data, batch_labels in dataloader:

        optimizer.clear_grad()

        outputs = model(batch_data)

        loss = criterion(outputs, batch_labels)

        loss.backward()

        optimizer.step()

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

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

 

# 保存模型

paddle.save(model.state_dict(), 'logistic_regression.pdparams')

 

# 加载模型进行预测

loaded_model = LogisticRegression(input_dim=10)

loaded_model.set_state_dict(paddle.load('logistic_regression.pdparams'))

loaded_model.eval()

 

# 进行预测

new_data = np.random.randn(10, 10).astype('float32')

new_data = paddle.to_tensor(new_data)

predictions = loaded_model(new_data)

print("Predictions:")

print(predictions)