自定义数据集：通过继承 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)