A production-grade LSTM + Attention options trading system — with Interactive Brokers integration, ensemble inference, and a complete 9-module course that teaches you to build, train, and tune it. Even if you've never written a line of code.
Most courses give you toy examples. You finish with knowledge but no working infrastructure.
Random scripts, no documentation, broken dependencies. You waste weeks stitching pieces together.
No bracket orders, no risk controls, no paper trading. One mistake and real money is gone.
Not just a course. Not just code. A production-ready system you can learn from, customize, and deploy.
3-layer bidirectional LSTM with 4-head attention. ~3.5M parameters trained on options data with IV, Greeks, and order flow features.
Real IBKR data ingestion via NautilusTrader. Download IV, HV, market data — all normalized to Parquet.
3 models trained with different seeds. Average their predictions for more robust signals — like getting 3 doctors' opinions.
Every trade has automatic stop-loss and take-profit. Risk-per-trade limits. Consecutive loss tracking. Built-in safety.
Real-time probability charts, P&L tracking, and strategy status — all in your browser while the system runs.
The ML model is a reference implementation. Subclass it, replace it, or ensemble multiple architectures without touching execution code.
Data flows from your broker through ML models to automated execution — with safety controls at every step.
IBKR → IV, HV, Greeks, market data → normalized Parquet files
Feature engineering → LSTM training → evaluation reports → ensemble
Live inference → Z-score signals → bracket orders → NautilusTrader → IBKR
Designed for non-programmers. Jupyter notebooks. AI agent prompts included. Zero to deployed in 12–18 hours.
Understand the complete lifecycle: data → model → signal → decision → tuning.
Safe local environment. Paper trading only. No risk to real money.
Inspect real data. Understand schemas. See what the model will learn from.
Run a guided training flow. Understand checkpoints, scalers, and feature metadata.
Read metrics in business terms. Accuracy, precision, recall, ROC — explained simply.
Load artifacts. Feed features. Get probability signals. Build the product loop.
Convert probability streams into rule-based actions with threshold tuning.
7 ready-made AI prompts. Run experiments. Keep or revert with discipline.
Assemble everything end-to-end. Self-score with the included rubric.
Here's a glimpse of the actual model architecture you'll get.
class LSTMAttentionClassifier(nn.Module):
"""
3-layer bidirectional LSTM with multi-head attention.
~3.5M parameters for options trade signal classification.
"""
def __init__(self, input_size, hidden_layer_size=128):
# Three stacked bidirectional LSTM layers
self.lstm1 = nn.LSTM(input_size, hidden_layer_size,
bidirectional=True, dropout=0.2)
self.lstm2 = nn.LSTM(hidden_layer_size * 2, hidden_layer_size,
bidirectional=True, dropout=0.2)
self.lstm3 = nn.LSTM(hidden_layer_size * 2, hidden_layer_size,
bidirectional=True, dropout=0.2)
# Multi-head attention (4 heads)
self.attention = MultiHeadAttention(hidden_layer_size * 2,
seq_len, num_heads=4)
# Deep classification with residual connections
self.fc1 = nn.Linear(combined_size, 512)
self.fc2 = nn.Linear(512, 256)
self.fc3 = nn.Linear(256, 128)
self.fc4 = nn.Linear(128, 64)
self.fc5 = nn.Linear(64, 1) # Binary signal outputSeerStack isn't a theoretical exercise. It's extracted from a real trading system running against Interactive Brokers. The architecture decisions — ensemble models, bracket orders, Z-score signal filtering, adaptive volatility thresholds — come from live market experience, not textbook examples.
Yes. The course is designed specifically for non-programmers. You'll use Jupyter notebooks (runs in your browser), and AI agents will help write code. Your job is to be the "manager" who makes decisions — the system and course handle the technical details.
No. The course strictly uses offline data, paper trading, and simulations. You're completely safe to experiment and make mistakes. The codebase supports live trading, but that's for when you're ready — and the course never goes there.
SeerStack is built for Interactive Brokers (IBKR). You'll need an IBKR account for data ingestion and execution. The course works with IBKR's paper trading mode, which is free.
Absolutely not. The included model is a reference implementation — it demonstrates architecture and integration patterns. You're expected to validate, tune, or replace it. Trading options involves substantial risk. This gives you professional infrastructure and education, not a magic button.
Yes. The architecture is designed for this. Subclass LSTMAttentionClassifier, match the
input/output interface, and swap it in. The data pipeline and execution layer work independently of the
model.
Python 3.10 or later. The course includes a setup module that walks you through installation step by step — even if you've never installed Python before.
Choose the tier that fits your goals. Upgrade anytime.
One-time payment.
One-time payment. Lifetime updates.
One-time payment.
30-Day Action-Based Guarantee: Go through the course, run the ML pipeline, and if you don't feel you have a working architecture in your hands, reach out for a full refund.