pytorch写对抗神经网络学习波士顿房价，且数据划分为训练集和测试集，且batch size为128

好的，我可以帮你解答这个问题。

首先，对抗神经网络（GAN）是一种非监督学习方法，它由生成器和判别器两个部分组成。在波士顿房价预测问题中，可以将生成器看作是一个生成房价的模型，判别器则是一个用于判断输入数据是否为真实房价的模型。两个模型通过对抗训练的方式来提高性能。

接下来，我们需要准备数据。波士顿房价数据集可以通过PyTorch内置的数据集`torchvision.datasets`来获取。我们可以使用`torch.utils.data.DataLoader`类来创建数据加载器，并将数据分为训练集和测试集。

import torch
from torchvision.datasets import BostonHousing
from torch.utils.data import DataLoader, random_split

# 加载数据集
dataset = BostonHousing(root='.', download=True)
# 将数据集分为训练集和测试集
train_dataset, test_dataset = random_split(dataset, [400, 106])
# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=True)

接下来，我们可以定义生成器和判别器模型。在这里，我们可以使用多层感知器（MLP）来作为生成器和判别器的基本模型。生成器的输入为随机噪声，输出为生成的房价数据。判别器的输入为真实房价或生成的房价数据，输出为0或1，表示输入数据的真假。

import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, input_dim=100, output_dim=13*3):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(input_dim, 128)
        self.fc2 = nn.Linear(128, 256)
        self.fc3 = nn.Linear(256, output_dim)
        self.relu = nn.ReLU()
        self.tanh = nn.Tanh()

    def forward(self, z):
        out = self.fc1(z)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        out = self.tanh(out)
        return out

class Discriminator(nn.Module):
    def __init__(self, input_dim=13*3):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(input_dim, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

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

接下来，我们可以定义训练过程。在每个epoch中，我们会先更新判别器的参数，然后再更新生成器的参数。对于判别器的loss，我们使用二元交叉熵损失函数。对于生成器的loss，我们使用判别器的输出作为目标值，使用均方误差损失函数。

import torch.optim as optim

# 定义模型
generator = Generator()
discriminator = Discriminator()

# 定义优化器
g_optimizer = optim.Adam(generator.parameters(), lr=0.0002)
d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002)

# 定义损失函数
criterion = nn.BCELoss()

# 训练过程
num_epochs = 100

for epoch in range(num_epochs):
    for i, (real_data, _) in enumerate(train_loader):
        batch_size = real_data.size(0)

        # 训练判别器
        discriminator.zero_grad()
        # 真实数据
        real_data = real_data.view(batch_size, -1)
        real_label = torch.ones(batch_size, 1)
        real_prob = discriminator(real_data)
        real_loss = criterion(real_prob, real_label)
        # 生成数据
        noise = torch.randn(batch_size, 100)
        fake_data = generator(noise)
        fake_label = torch.zeros(batch_size, 1)
        fake_prob = discriminator(fake_data.detach())
        fake_loss = criterion(fake_prob, fake_label)
        # 总loss
        d_loss = real_loss + fake_loss
        d_loss.backward()
        d_optimizer.step()

        # 训练生成器
        generator.zero_grad()
        noise = torch.randn(batch_size, 100)
        fake_data = generator(noise)
        fake_label = torch.ones(batch_size, 1)
        fake_prob = discriminator(fake_data)
        g_loss = criterion(fake_prob, fake_label)
        g_loss.backward()
        g_optimizer.step()

    # 打印loss
    print("Epoch [{}/{}], d_loss: {:.4f}, g_loss: {:.4f}"
          .format(epoch+1, num_epochs, d_loss.item(), g_loss.item()))

最后，在测试集上评估模型的性能。我们可以使用均方误差（MSE）来评估生成器生成的房价数据与真实房价数据的差距。

# 测试过程
mse = nn.MSELoss()

with torch.no_grad():
    for test_data, _ in test_loader:
        batch_size = test_data.size(0)
        real_data = test_data.view(batch_size, -1)
        noise = torch.randn(batch_size, 100)
        fake_data = generator(noise)
        mse_loss = mse(fake_data, real_data)
    print("MSE loss on test set: {:.4f}".format(mse_loss.item()))

希望这个代码示例能够帮助你更好地理解如何使用PyTorch实现对抗神经网络。