给出一个用pytorch的bilstm实现时间序列预测的代码例子

好的，以下是一个用 PyTorch 实现时间序列预测的 BiLSTM 代码例子：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 创建 BiLSTM 模型
class BiLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(BiLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, bidirectional=True)
        self.fc = nn.Linear(hidden_size*2, output_size)

    def forward(self, input):
        lstm_out, _ = self.lstm(input.view(len(input), 1, -1))
        fc_out = self.fc(lstm_out.view(len(input), -1))
        return fc_out[-1]

# 数据生成函数
def generate_data(sequence_length=100, signal_periodicity=5, noise=0.1):
    # 生成 sin(x) + noise 序列
    x = np.linspace(0, signal_periodicity*np.pi, sequence_length+1)
    x = np.sin(x)
    x += noise * np.random.randn(len(x))
    return x[:-1], x[1:]

# 设定模型参数、优化器、损失函数
input_size = 1
hidden_size = 10
output_size = 1
lr = 0.01
n_epochs = 1000

model = BiLSTM(input_size, hidden_size, output_size)
optimizer = optim.Adam(model.parameters(), lr)
criterion = nn.MSELoss()

# 生成训练数据
input_data, output_data = generate_data()

# 训练模型
for epoch in range(n_epochs):
    optimizer.zero_grad()
    loss = criterion(model(torch.Tensor(input_data)), torch.Tensor(output_data))
    loss.backward()
    optimizer.step()
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss {loss.item()}")

# 预测未来序列
future_sequence_length = 50
future_input_data, _ = generate_data(future_sequence_length, noise=0.0)
future_sequence_pred = []
model.eval()
for i in range(future_sequence_length):
    input_data = torch.Tensor(future_input_data[i:i+input_size])
    with torch.no_grad():
        output_data = model(input_data)
    future_sequence_pred.append(output_data.item())

# 打印结果
print("Input:", future_input_data)
print("Output:", future_sequence_pred)

注意：这里演示的只是一个简单的例子，如果要用 BiLSTM 对实际时间序列数据进行预测，需要考虑更多的因素，例如时间间隔、数据间的相关性等。