利用pytorch框架写一个神经网络进行波士顿房价预测

当然可以！下面是使用PyTorch框架编写的一个简单的神经网络模型来进行波士顿房价预测的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# 加载波士顿房价数据集
data = load_boston()
X, y = data.data, data.target

# 数据标准化
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义神经网络模型
class Net(nn.Module):
    def __init__(self, input_dim):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_dim, 32)
        self.fc2 = nn.Linear(32, 64)
        self.fc3 = nn.Linear(64, 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

# 实例化模型
input_dim = X_train.shape[1]
model = Net(input_dim)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 模型训练
num_epochs = 1000
batch_size = 32

for epoch in range(num_epochs):
    for i in range(0, len(X_train), batch_size):
        inputs = torch.tensor(X_train[i:i+batch_size], dtype=torch.float32)
        targets = torch.tensor(y_train[i:i+batch_size], dtype=torch.float32)

        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs.squeeze(), targets)

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

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

# 模型评估
model.eval()
with torch.no_grad():
    inputs = torch.tensor(X_test, dtype=torch.float32)
    targets = torch.tensor(y_test, dtype=torch.float32)
    outputs = model(inputs)
    test_loss = criterion(outputs.squeeze(), targets)
    print(f'Test Loss: {test_loss.item():.4f}')

这是一个简单的三层全连接神经网络模型，使用MSE损失函数和Adam优化器进行训练。训练过程中，将数据分为小批量进行训练，每个批次的大小为32。代码中还包括了数据标准化的步骤以及训练集和测试集的划分。

希望以上代码对您有所帮助！如果还有其他问题，请随时提问。