pytorch两个网络模型解决椭圆个界面问题的代码

好的，这是一个使用 PyTorch 实现的示例代码，其中包括两个神经网络模型来解决椭圆形界面问题：

import torch
from torch import nn, optim
from torch.utils.data import DataLoader, Dataset
import numpy as np
import matplotlib.pyplot as plt

# 定义一个椭圆形界面的数据集
class EllipseDataset(Dataset):
    def __init__(self, num_samples=1000, noise=0.05):
        super().__init__()
        self.num_samples = num_samples
        self.noise = noise
        
        # 生成随机的椭圆的参数
        self.a = np.random.uniform(0.5, 1.5)
        self.b = np.random.uniform(0.5, 1.5)
        self.theta = np.random.uniform(0, 2*np.pi)
        self.center = np.random.uniform(-1, 1, size=2)
        
        # 生成随机的样本点
        x = np.random.uniform(-2, 2, size=(self.num_samples, 2))
        y = ((x[:, 0] - self.center[0]) * np.cos(self.theta) + (x[:, 1] - self.center[1]) * np.sin(self.theta)) ** 2 / self.a ** 2 + ((x[:, 0] - self.center[0]) * np.sin(self.theta) - (x[:, 1] - self.center[1]) * np.cos(self.theta)) ** 2 / self.b ** 2
        y += np.random.normal(scale=self.noise, size=y.shape)
        self.data = torch.from_numpy(np.hstack([x, y.reshape(-1, 1)])).float()
        
    def __getitem__(self, index):
        return self.data[index]
    
    def __len__(self):
        return self.num_samples

# 定义一个简单的全连接神经网络模型
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(2, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 1)
        
    def forward(self, x):
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 定义一个深度神经网络模型
class DeepNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(2, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 1)
        
    def forward(self, x):
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = nn.functional.relu(self.fc3(x))
        x = self.fc4(x)
        return x

# 训练模型
def train(model, train_loader, criterion, optimizer, num_epochs=100):
    losses = []
    for epoch in range(num_epochs):
        epoch_loss = 0
        for batch in train_loader:
            optimizer.zero_grad()
            output = model(batch[:, :2])
            loss = criterion(output, batch[:, 2:])
            loss.backward()
            optimizer.step()
            epoch_loss += loss.item()
        epoch_loss /= len(train_loader)
        losses.append(epoch_loss)
        print(f"Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss}")
    return losses

# 生成数据集
train_dataset = EllipseDataset(num_samples=1000, noise=0.05)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 定义模型和优化器
simple_net = SimpleNet()
deep_net = DeepNet()
criterion = nn.MSELoss()
simple_optimizer = optim.Adam(simple_net.parameters(), lr=0.01)
deep_optimizer = optim.Adam(deep_net.parameters(), lr=0.01)

# 训练简单的全连接神经网络模型
simple_losses = train(simple_net, train_loader, criterion, simple_optimizer, num_epochs=50)

# 训练深度神经网络模型
deep_losses = train(deep_net, train_loader, criterion, deep_optimizer, num_epochs=50)

# 画出损失函数曲线
plt.plot(simple_losses, label="Simple Net")
plt.plot(deep_losses, label="Deep Net")
plt.legend()
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.show()

# 画出椭圆形界面和模型预测的分割线
x = np.linspace(-2, 2, num=100)
y = np.linspace(-2, 2, num=100)
xx, yy = np.meshgrid(x, y)
z_simple = simple_net(torch.from_numpy(np.hstack([xx.reshape(-1, 1), yy.reshape(-1, 1)])).float()).detach().numpy().reshape(xx.shape)
z_deep = deep_net(torch.from_numpy(np.hstack([xx.reshape(-1, 1), yy.reshape(-1, 1)])).float()).detach().numpy().reshape(xx.shape)

fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 5))
ax1.contourf(xx, yy, (xx - train_dataset.center[0])**2 / train_dataset.a**2 + (yy - train_dataset.center[1])**2 / train_dataset.b**2, levels=20, cmap=plt.cm.Blues)
ax1.set_title("Ellipse")
ax2.contourf(xx, yy, z_simple, levels=20, cmap=plt.cm.Blues)
ax2.set_title("Simple Net")
fig.tight_layout()
plt.show()

fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 5))
ax1.contourf(xx, yy, (xx - train_dataset.center[0])**2 / train_dataset.a**2 + (yy - train_dataset.center[1])**2 / train_dataset.b**2, levels=20, cmap=plt.cm.Blues)
ax1.set_title("Ellipse")
ax2.contourf(xx, yy, z_deep, levels=20, cmap=plt.cm.Blues)
ax2.set_title("Deep Net")
fig.tight_layout()
plt.show()

在这个示例代码中，我们定义了一个 `EllipseDataset` 类来生成一个随机的椭圆形界面数据集。我们还定义了两个神经网络模型，一个是简单的全连接神经网络模型，另一个是深度神经网络模型。我们使用均方误差作为损失函数，使用 Adam 优化器进行优化。

我们首先训练了简单的全连接神经网络模型，然后训练了深度神经网络模型。在训练过程中，我们记录了每个 epoch 的损失函数值，最后画出损失函数曲线。最后，我们将椭圆形界面和两个模型预测的分割线画出来，以便比较它们的效果。

请注意，这个示例代码只是一个简单的示例，用于演示如何使用 PyTorch 实现解决椭圆形界面问题的神经网络模型。您可以根据您的实际需求进行修改和改进。