LSTM for Financial Time Series: Architecture and Validation
Imagine this: you trained an LSTM on five years of daily data, got 68% accuracy on the test set. In production, the model shows 49% — worse than random. Typical mistake: data leakage during normalization or incorrect validation. We deploy production-ready LSTM architecture for financial time series based on real projects with multi-asset portfolios and walk-forward validation. Our team has 10+ years of experience in AI/ML for finance, implementing 30+ models for hedge funds and brokers. We guarantee no lookahead bias and experiment reproducibility. We use PyTorch and Hugging Face Transformers, train on an A100 GPU cluster, monitor via MLflow and Weights & Biases. Hyperparameter optimization is done with Optuna, validation is strict walk-forward with an embargo period to eliminate leakage. Result: stable Information Coefficient (IC) > 0.05 and ICIR > 1.5 on out-of-sample test. Development cost depends on model complexity and data volume — final price is discussed after analysis. Estimated duration for a single-asset solution is 2 to 3 weeks of team work, multi-asset with attention is 8 to 10 weeks.
Why LSTM, not gradient boosting?
LSTM wins when sequence of events is more important than aggregates, and nonlinear time patterns are explicit. LightGBM with lag features often beats LSTM on small datasets (<10,000 observations). But on multivariate series (multiple instruments simultaneously) and complex cross-asset dependencies, LSTM offers an advantage. The architecture was first described in the paper Long Short-Term Memory (Hochreiter & Schmidhuber). LSTM is the base architecture.
Model Architecture
View model code
import torch import torch.nn as nn class FinancialLSTM(nn.Module): def __init__(self, input_size, hidden_size=128, num_layers=2, dropout=0.2): super().__init__() self.lstm = nn.LSTM( input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True, dropout=dropout ) self.attention = nn.MultiheadAttention(hidden_size, num_heads=8) self.fc = nn.Linear(hidden_size, 1) self.dropout = nn.Dropout(dropout) def forward(self, x): lstm_out, _ = self.lstm(x) # [batch, seq_len, hidden] # Self-attention over time dimension attn_out, _ = self.attention(lstm_out, lstm_out, lstm_out) # Last step or attention-weighted pool out = self.fc(self.dropout(attn_out[:, -1, :])) return out Input data (seq_len × n_features): OHLCV, normalized by rolling window, technical indicators (RSI, MACD, ATR, Bollinger). For multi-asset — concatenation along feature dimension. Implementation is available in PyTorch LSTM.
Preprocessing and Normalization
Critically important: normalization without lookahead bias. We use rolling window normalization:
def rolling_normalize(X, window=252): mu = X.rolling(window).mean() sigma = X.rolling(window).std() return (X - mu) / (sigma + 1e-8) Price returns instead of prices: raw prices are non-stationary, log returns are stationary:
returns = np.log(prices / prices.shift(1)).dropna() Sequence generation:
def create_sequences(data, seq_len=60, horizon=5): X, y = [], [] for i in range(len(data) - seq_len - horizon): X.append(data[i:i+seq_len]) y.append(data[i+seq_len+horizon-1, 0]) return np.array(X), np.array(y) Training and Regularization
How to tune hyperparameters for financial LSTMs?
Sequence length: 20–60 days for daily data, 50–200 for hourly. Hidden size: 64–256. Layers: 2–3 (deeper is usually worse on financial data). Dropout: 0.1–0.4. Batch size: 32–128. Regularization: temporal dropout, feature noise, L2 weight decay (1e-4 to 1e-3). Optimizer: AdamW with cosine annealing LR scheduler. Early stopping on validation loss on a 20% holdout.
For a portfolio of N instruments, we use Cross-sectional LSTM with parallel processing of all instruments and cross-attention between them to capture correlation patterns (oil → oil stocks, DXY → EM assets).
Validation Without Data Leakage
Walk-forward with embargo:
embargo_size = horizon train_end = int(0.6 * len(data)) embargo_end = train_end + embargo_size val_end = int(0.8 * len(data)) Metrics: Directional Accuracy, Information Coefficient (spearman correlation), ICIR (IC / std(IC) — stability; ICIR > 1.5 is considered good).
Comparison of Normalization Methods
| Method | Lookahead bias | Stationarity | Applicability |
|---|---|---|---|
| StandardScaler (entire dataset) | Yes | Yes | Not for time series |
| Rolling normalize (window 252) | No | Yes | Recommended for finance |
| MinMaxScaler (entire dataset) | Yes | No | Only for non-temporal tasks |
| Log returns + rolling normalize | No | Yes | Best option for prices |
LSTM vs Transformer for Finance
| Aspect | LSTM | Transformer |
|---|---|---|
| Long-range dependencies | Good | Excellent |
| Training speed | Slower | Faster |
| Data requirement | Less | More |
| Interpretability | Low | Medium (attention) |
| Production latency | Lower | Higher |
For short sequences (< 100 steps), LSTM often matches Transformer with significantly less data requirements.
What Is Included in the Work
- Baseline single-asset model with built pipeline and documentation
- Multi-asset architecture with cross-attention and walk-forward validation
- Hyperparameter optimization (Optuna) with logs in MLflow
- Docker deployment with Triton Inference Server and monitoring in Prometheus
- Training of the operations team and handover of the model card
Each stage is accompanied by reports and code comments. We don't just deliver weights — we hand over a reproducible experiment.
Process and Timelines
- Analysis — data collection and visualization, defining the forecast horizon.
- Design — selection of architecture (LSTM/Transformer, single/multi-asset).
- Implementation — writing pipeline, training baseline, optimization.
- Testing — walk-forward validation, stress testing on anomalies.
- Deployment — packaging in Docker, deploying on a GPU server, monitoring.
Timelines: single-asset baseline — 2 to 3 weeks; multi-asset model with attention and production pipeline — 8 to 10 weeks. Cost is calculated individually.
Request a consultation for a preliminary assessment of your dataset — we will analyze it in 1–2 days. Contact us to discuss the model architecture and timelines.