Time series forecasting: stocks and weather prediction

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

# --- 1. Windowing ---
def create_sequences(data: np.ndarray, lookback: int = 60):
    """Slide a window of length `lookback` over 1-D time series data."""
    X, y = [], []
    for i in range(len(data) - lookback):
        X.append(data[i : i + lookback])
        y.append(data[i + lookback])
    return np.array(X), np.array(y)

# Assume `series` is a normalised numpy array of shape (T,)
series = np.sin(np.linspace(0, 20 * np.pi, 2000))  # placeholder
X, y = create_sequences(series, lookback=60)

X_t = torch.tensor(X, dtype=torch.float32).unsqueeze(-1)  # (N, 60, 1)
y_t = torch.tensor(y, dtype=torch.float32).unsqueeze(-1)  # (N, 1)

loader = DataLoader(TensorDataset(X_t, y_t), batch_size=64, shuffle=True)

# --- 2. Model ---
class LSTMForecaster(nn.Module):
    def __init__(self, input_size=1, hidden_size=64, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc   = nn.Linear(hidden_size, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])  # use last timestep

model    = LSTMForecaster()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

# --- 3. Training loop ---
for epoch in range(20):
    model.train()
    total_loss = 0.0
    for xb, yb in loader:
        optimizer.zero_grad()
        loss = criterion(model(xb), yb)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1:02d} | loss: {total_loss / len(loader):.4f}")

# --- 4. Inference ---
model.eval()
with torch.no_grad():
    sample = X_t[:1]          # shape (1, 60, 1)
    pred   = model(sample)
    print(f"Next-step prediction: {pred.item():.4f}")