请给我一段用python写的高精度RBP神经网络代码，解决用变量phi,变量r拟合变量ld的问题，实际的变量phi、r、ld从excel表格中读取，数据量约为400，数据需要归一化处理，数据需要划分为训练集和测试集，要求绘制变量ld的实际值与预测值的对比图和训练误差下降曲线，尽量不要出现变量维度方面的错误。

好的，下面是一个基于PyTorch的高精度RBP神经网络代码，可以解决您提出的问题：

import torch
import torch.nn as nn
import torch.optim as optim
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# 读取数据
df = pd.read_excel('data.xlsx')
X = df[['phi', 'r']].values
Y = df['ld'].values.reshape(-1, 1)

# 归一化处理
scaler_x = MinMaxScaler()
scaler_y = MinMaxScaler()
X_scaled = scaler_x.fit_transform(X)
Y_scaled = scaler_y.fit_transform(Y)

# 划分训练集和测试集
X_train, X_test, Y_train, Y_test = train_test_split(X_scaled, Y_scaled, test_size=0.2, random_state=42)

# 定义神经网络
class RBPNet(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim):
        super(RBPNet, self).__init__()
        self.hidden = nn.Linear(input_dim, hidden_dim)
        self.out = nn.Linear(hidden_dim, output_dim)
        self.rbf = nn.Sequential(
            nn.Linear(2, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, output_dim, bias=False)
        )
        
    def forward(self, x, c):
        # RBF层
        radial = torch.exp(-1 * c * torch.sum((x.unsqueeze(1) - self.rbf[0].weight)**2, dim=2))
        # 隐藏层
        hidden = self.hidden(x)
        # 输出层
        out = self.out(hidden + radial)
        return out

# 训练模型
def train_model(model, criterion, optimizer, X_train, Y_train, X_test, Y_test, epochs):
    train_losses = []
    test_losses = []
    for epoch in range(epochs):
        # 训练
        model.train()
        optimizer.zero_grad()
        y_train_pred = model(torch.tensor(X_train, dtype=torch.float32), torch.tensor(1.0))
        train_loss = criterion(y_train_pred, torch.tensor(Y_train, dtype=torch.float32))
        train_loss.backward()
        optimizer.step()
        train_losses.append(train_loss.item())
        # 测试
        model.eval()
        with torch.no_grad():
            y_test_pred = model(torch.tensor(X_test, dtype=torch.float32), torch.tensor(1.0))
            test_loss = criterion(y_test_pred, torch.tensor(Y_test, dtype=torch.float32))
            test_losses.append(test_loss.item())
        # 打印训练过程
        if (epoch+1) % 100 == 0:
            print('Epoch [{}/{}], Train Loss: {:.4f}, Test Loss: {:.4f}'.format(epoch+1, epochs, train_loss.item(), test_loss.item()))

    # 绘制训练误差下降曲线
    plt.plot(train_losses, label='Train Loss')
    plt.plot(test_losses, label='Test Loss')
    plt.legend()
    plt.show()

# 训练模型
input_dim = 2
output_dim = 1
hidden_dim = 10
model = RBPNet(input_dim, output_dim, hidden_dim)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.1)
epochs = 500
train_model(model, criterion, optimizer, X_train, Y_train, X_test, Y_test, epochs)

# 预测测试集
model.eval()
with torch.no_grad():
    Y_test_pred = model(torch.tensor(X_test, dtype=torch.float32), torch.tensor(1.0))
    Y_test_pred = scaler_y.inverse_transform(Y_test_pred.numpy())

# 绘制实际值与预测值的对比图
plt.plot(Y_test, label='Actual')
plt.plot(Y_test_pred, label='Predicted')
plt.legend()
plt.show()

在这个代码中，我们首先读取了Excel表格中的数据，并使用`MinMaxScaler`对数据进行归一化处理。然后，我们使用`train_test_split`函数将数据划分为训练集和测试集。

接着，我们定义了一个RBP神经网络模型，并使用`nn.Module`类来创建一个自定义的PyTorch模型。在这个模型中，我们使用了两个线性层和一个RBF层，其中RBF层用于处理输入样本的非线性特征。

最后，我们使用PyTorch提供的优化器`optim.Adam`和损失函数`nn.MSELoss`来优化模型，并使用`train_model`函数来训练模型。在训练过程中，我们使用了训练集和测试集来计算训练误差和测试误差，并使用`matplotlib`库绘制了训练误差下降曲线。

在训练完成后，我们使用训练好的模型来预测测试集，并使用`MinMaxScaler`将预测结果进行反归一化处理，最后使用`matplotlib`库绘制了实际值与预测值的对比图。