假期小作业

import paddle
import paddle.nn as nn
import paddle.optimizer as optim
import paddle.io as io
import numpy as np
 
# 设置随机种子以保证结果的可重复性
np.random.seed(42)
paddle.seed(42)
 
# 示例数据（这里你需要用你自己的数据替换）
X = np.random.rand(100, 10).astype('float32')  # 100个样本，每个样本10个特征
y = (np.random.rand(100, 1) > 0.5).astype('float32')  # 二分类标签，使用随机浮点数生成标签并转换为float32
 
# 将数据转换为PaddlePaddle张量
X_tensor = paddle.to_tensor(X)
y_tensor = paddle.to_tensor(y)
 
class LogisticRegression(nn.Layer):
    def __init__(self, input_dim):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_dim, 1)
        self.sigmoid = nn.Sigmoid()
 
    def forward(self, x):
        out = self.linear(x)
        return self.sigmoid(out)
 
input_dim = X.shape[1]
model = LogisticRegression(input_dim)
criterion = nn.BCELoss()  # 二分类交叉熵损失
# 使用Adam优化器替代SGD，通常Adam在训练深度网络时表现更好
optimizer = optim.Adam(parameters=model.parameters(), learning_rate=0.001)
epochs = 150  # 增加训练轮次以观察更稳定的训练过程
batch_size = 20  # 改变批量大小
 
# 使用DataLoader加载数据
dataset = io.TensorDataset(X_tensor, y_tensor)
data_loader = io.DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True)  # 添加drop_last以避免最后一个不完整的批次
 
for epoch in range(epochs):
    model.train()  # 确保模型处于训练模式
    for batch_id, (data, label) in enumerate(data_loader()):
        # 前向传播
        logits = model(data)
        # 注意：由于标签已经是float32类型，无需再转换
        loss = criterion(logits, label.unsqueeze(1))
 
        # 反向传播和优化
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()
 
        if batch_id % 10 == 0:
            print(f"Epoch [{epoch+1}/{epochs}], Batch [{batch_id}], Loss: {loss.numpy()[0]}")
 
# 保存模型，使用静态图模式保存，注意这里使用的是paddle.static.save_inference_model
# paddle.jit.save是为动态图保存的API，但这里我们改用静态图保存方式作为示例
paddle.static.save_inference_model(
    dirname='logistic_regression_model',
    feeded_var_names=['x'],
    target_vars=[model.linear.weight, model.sigmoid.apply(model.linear(paddle.static.data(name='x', shape=[None, input_dim], dtype='float32')))],
    executor=paddle.static.Executor(paddle.CPUPlace())
)
 
# 加载模型，这里使用静态图加载方式
# 注意：加载静态图模型时，需要构建前向计算图
def create_inference_program():
    # 定义计算图
    x = paddle.static.data(name='x', shape=[None, input_dim], dtype='float32')
    linear_out = nn.functional.linear(x, paddle.create_parameter(shape=[input_dim, 1], dtype='float32'))
    sigmoid_out = nn.functional.sigmoid(linear_out)
    return x, sigmoid_out
 
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
[feed_target_names, fetch_targets] = paddle.static.io.load_inference_model(dirname='logistic_regression_model', executor=exe)
x, prediction = create_inference_program()
 
# 示例预测数据
X_new = np.random.rand(5, 10).astype('float32')  # 5个新样本，每个样本10个特征
X_new_tensor = paddle.to_tensor(X_new)
 
# 转换为静态图所需的输入格式
feed_dict = {feed_target_names[0]: X_new_tensor}
 
# 进行预测
result = exe.run(feed=feed_dict, fetch_list=fetch_targets)
predictions = result[0]
predicted_classes = predictions.numpy() > 0.5  # 阈值设为0.5
 
print("Predictions:", predicted_classes)