从零到上手的Python时序数据预测完整指南

import pandas as pd

# 前向填充（适合连续数据，如传感器）
df['value'] = df['value'].ffill()

# 线性插值（适合有趋势的数据）
df['value'] = df['value'].interpolate(method='linear')

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
train_scaled = scaler.fit_transform(train[['value']])  # 只fit训练集
test_scaled = scaler.transform(test[['value']])        # 只transform

import numpy as np

def create_sequences(data, seq_len):
    xs, ys = [], []
    for i in range(len(data) - seq_len):
        xs.append(data[i:i+seq_len])
        ys.append(data[i+seq_len])
    return np.array(xs), np.array(ys)

seq_len = 30  # 用过去30步预测下1步
X, y = create_sequences(train_scaled, seq_len)

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

# ---- 模型定义 ----
class LSTMPredictor(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,
                            batch_first=True, dropout=0.2)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])  # 取最后一步输出
        return out

# ---- 训练 ----
model = LSTMPredictor(input_size=1, hidden_size=64,
                      num_layers=2, output_size=1)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

train_dataset = TensorDataset(
    torch.FloatTensor(X), torch.FloatTensor(y)
)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=False)  # 时序不能shuffle

for epoch in range(50):
    for batch_x, batch_y in train_loader:
        pred = model(batch_x)
        loss = criterion(pred, batch_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# ---- 预测 ----
model.eval()
with torch.no_grad():
    test_input = torch.FloatTensor(X_test)
    pred = model(test_input)
    pred_original = scaler.inverse_transform(pred.numpy())  # 反归一化

from sklearn.metrics import mean_absolute_error, mean_absolute_percentage_error

mae = mean_absolute_error(y_true, y_pred)
mape = mean_absolute_percentage_error(y_true, y_pred)
rmse = np.sqrt(np.mean((y_true - y_pred) ** 2))

print(f"MAE: {mae:.2f}, RMSE: {rmse:.2f}, MAPE: {mape:.2%}")

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))
plt.plot(y_true, label='真实值')
plt.plot(y_pred, label='预测值')
plt.legend()
plt.title('时序预测 vs 真实值')
plt.show()