银行港币基准汇率数据集（多货币对，高频采集）

       在这种情况下，可以考虑使用门控循环单元（GRU），它是RNN的一种变体，与LSTM类似，但在参数量上更少，同样能够处理长期依赖的问题。

       我们将使用PyTorch库来实现一个基本的GRU模型。以下是使用PyTorch构建GRU模型的基本代码示例：

       首先，确保安装了必要的库：

pip install pandas numpy torch

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

# 加载数据
data_path = 'exchange_rates.csv'  # 假设这是你的数据文件路径
df = pd.read_csv(data_path, parse_dates=['datetime'])  # 假设'datetime'是时间戳列

# 确保时间戳被正确解析
df['datetime'] = pd.to_datetime(df['datetime'])

# 将时间戳转换为数值特征（例如，Unix时间戳）
df['timestamp'] = df['datetime'].apply(lambda x: x.timestamp())

# 定义特征和目标变量
# 这里我们使用前n个货币对作为特征来预测USD对HKD的汇率
features = list(df.columns[2:-1])  # 假设除了第一个时间戳列外的所有其他列都是特征
target = 'USD_to_HKD'

# 数据预处理
scaler = MinMaxScaler()
df[features] = scaler.fit_transform(df[features])
df[target] = scaler.fit_transform(df[[target]])

# 准备训练数据
class ExchangeRateDataset(Dataset):
    def __init__(self, features, target, seq_length=10):
        self.features = features
        self.target = target
        self.seq_length = seq_length
        self.data_size = len(features) - seq_length

    def __len__(self):
        return self.data_size

    def __getitem__(self, index):
        start_index = index
        end_index = start_index + self.seq_length
        feature_seq = self.features[start_index:end_index]
        target_val = self.target[end_index]
        return feature_seq, target_val

seq_length = 10  # 序列长度
X = df[features].values
y = df[target].values
dataset = ExchangeRateDataset(X, y, seq_length)

# 划分数据集
train_size = int(0.8 * len(dataset))
train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, len(dataset) - train_size])

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 定义GRU模型
class GRUModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, n_layers):
        super(GRUModel, self).__init__()
        self.hidden_dim = hidden_dim
        self.n_layers = n_layers
        self.gru = nn.GRU(input_dim, hidden_dim, n_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        h0 = torch.zeros(self.n_layers, x.size(0), self.hidden_dim).requires_grad_()
        out, (hn) = self.gru(x, (h0.detach()))
        out = self.fc(out[:, -1, :])
        return out

input_dim = len(features)
hidden_dim = 32
output_dim = 1
n_layers = 1

model = GRUModel(input_dim, hidden_dim, output_dim, n_layers)

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

# 训练模型
n_epochs = 100
early_stopping = EarlyStopping(patience=10, verbose=True)

for epoch in range(n_epochs):
    model.train()
    for i, (seq, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        seq = seq.float()
        labels = labels.float()
        y_pred = model(seq)
        loss = criterion(y_pred, labels)
        loss.backward()
        optimizer.step()

    early_stopping(loss, model)
    if early_stopping.early_stop:
        print("Early stopping")
        break

print(f"Training complete after {epoch+1} epochs.")

       这段代码展示了如何使用PyTorch来定义一个GRU模型，并使用给定的数据集进行训练。注意，实际应用时可能需要根据数据的具体情况进行调整，比如调整序列长度、隐藏层大小、层数、学习率等超参数。此外，这里使用了一个简单的早停策略来防止过拟合。