MLP生成一些训练和预测数据

下面是一个使用 PyTorch 实现的简单多层感知机（MLP）的示例，包括生成一些数据用于训练和预测。

### 步骤：
1. 生成随机数据。
2. 定义一个简单的MLP模型。
3. 训练模型。
4. 使用模型进行预测。

```python
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 1. 生成随机数据
# 假设我们有一个二分类问题，每个样本有两个特征

# 生成1000个样本，每个样本有两个特征
num_samples = 1000
input_dim = 2

# 生成特征数据，形状为 (num_samples, input_dim)
X = torch.randn(num_samples, input_dim)

# 生成标签，假设标签是线性可分的，加一点噪声
y = (X.sum(dim=1) > 0).float()  # 如果特征和大于0，标签为1，否则为0

# 添加一些噪声
y[np.random.rand(num_samples) < 0.1] = 1 - y[np.random.rand(num_samples) < 0.1]

# 2. 定义MLP模型
class MLP(nn.Module):
    def __init__(self, input_dim):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_dim, 64)  # 输入层到隐藏层
        self.fc2 = nn.Linear(64, 32)         # 隐藏层到隐藏层
        self.fc3 = nn.Linear(32, 1)          # 隐藏层到输出层
        self.relu = nn.ReLU()               # 激活函数
        self.sigmoid = nn.Sigmoid()         # 输出层的激活函数（二分类问题）

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.sigmoid(self.fc3(x))
        return x

# 3. 训练模型
model = MLP(input_dim)

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

# 训练循环
num_epochs = 100
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X)
    loss = criterion(outputs.squeeze(), y)

    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 4. 使用模型进行预测
with torch.no_grad():
    predicted = (model(X).squeeze() > 0.5).float()
    accuracy = (predicted == y).float().mean()
    print(f'Accuracy of the model on the training data: {accuracy.item() * 100:.2f}%')

# 你可以使用下面的代码来预测新的数据
new_data = torch.randn(5, input_dim)  # 生成5个新的样本
with torch.no_grad():
    predicted_new = (model(new_data).squeeze() > 0.5).float()
    print(f'Predictions on new data: {predicted_new}')
```

### 代码解释：
1. **生成数据**：我们生成了1000个样本，每个样本有两个特征，标签是基于特征的和是否大于0来决定的（二分类问题）。
2. **MLP模型**：定义了一个简单的MLP，包含两个隐藏层，使用ReLU激活函数，输出层使用Sigmoid激活函数。
3. **训练模型**：使用二元交叉熵损失函数和Adam优化器进行训练。
4. **预测**：训练完成后，使用模型对训练数据和新的数据进行预测。

### 输出示例：
```
Epoch [10/100], Loss: 0.6868
Epoch [20/100], Loss: 0.6216
Epoch [30/100], Loss: 0.5429
...
Epoch [100/100], Loss: 0.3932
Accuracy of the model on the training data: 86.60%
Predictions on new data: tensor([0., 1., 1., 0., 1.])
```

你可以根据需要调整模型的结构、学习率、训练次数等参数。