django设计工作流models

首先我们需要导入相关的库：

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

然后定义一个函数来生成数据集：

def generate_dataset(start, end, num_points):
    x = np.linspace(start, end, num_points)
    y = np.sin(x) * np.cos(x) + np.sin(x) * np.cos(x) + np.sin(x) * np.cos(x)
    return x, y

这个函数会生成一个包含x和y的元组，其中x是从start到end之间的num_points个均匀分布的点，y是x对应的函数值。

接下来，我们可以使用这个函数来生成训练集和测试集：

x_train, y_train = generate_dataset(0, 10, 1000)
x_test, y_test = generate_dataset(10, 20, 1000)

现在我们可以定义模型了。我们将使用一个包含两个隐藏层的前馈神经网络，每个隐藏层有10个神经元。我们将使用ReLU作为激活函数。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 10)
        self.fc3 = nn.Linear(10, 1)
        self.relu = nn.ReLU()

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

现在我们可以初始化模型并定义损失函数和优化器：

model = Net()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

我们可以开始训练模型了。我们将使用批量梯度下降来训练模型，每个批次包含32个数据点。我们将训练模型100个epoch。

batch_size = 32
num_epochs = 100

for epoch in range(num_epochs):
    # 将训练集打乱
    permutation = torch.randperm(x_train.shape[0])

    for i in range(0, x_train.shape[0], batch_size):
        # 获取一个批次的数据
        indices = permutation[i:i+batch_size]
        batch_x, batch_y = torch.Tensor(x_train[indices]), torch.Tensor(y_train[indices])

        # 将数据传递给模型
        optimizer.zero_grad()
        output = model(batch_x.unsqueeze(1))

        # 计算损失和梯度
        loss = criterion(output, batch_y.unsqueeze(1))
        loss.backward()

        # 更新模型参数
        optimizer.step()

    # 计算在训练集和测试集上的损失
    train_loss = criterion(model(torch.Tensor(x_train).unsqueeze(1)), torch.Tensor(y_train).unsqueeze(1))
    test_loss = criterion(model(torch.Tensor(x_test).unsqueeze(1)), torch.Tensor(y_test).unsqueeze(1))

    # 打印日志
    print(f"Epoch {epoch+1} | Train Loss: {train_loss:.5f} | Test Loss: {test_loss:.5f}")

在训练完成后，我们可以使用训练好的模型来生成预测值，并将其与真实值进行比较：

# 在训练集和测试集上进行预测
y_pred_train = model(torch.Tensor(x_train).unsqueeze(1)).detach().numpy()
y_pred_test = model(torch.Tensor(x_test).unsqueeze(1)).detach().numpy()

# 绘制真实值和预测值之间的关系
plt.figure(figsize=(12, 6))
plt.plot(x_train, y_train, label="True Function")
plt.plot(x_train, y_pred_train, label="Predicted Function")
plt.legend()
plt.show()

我们可以看到，模型已经成功地学习到了这个函数的形状，并且能够在训练集和测试集上进行准确的预测。