foxhunt/90_DAY_DATA_EXPANSION_PLAN.md

90-Day DataBento Data Expansion Plan

Date: 2025-10-14 Status: Ready for execution Objective: Scale ML training from 4-day pilot dataset to 90-day production dataset

---

Executive Summary

Current State: 4 trading days × 4 symbols = 360 DBN files (36 MB, ~7,200 bars) Target State: 90 trading days × 4 symbols = 360 files → 8,100 files (810 MB, ~180,000 bars) Cost Estimate: $1.20 - $4.50 (DataBento timeseries API) Download Time: 30-90 minutes (8,100 API calls with rate limiting) Training Impact: 25x more data → Training time scales proportionally

---

1. Current Infrastructure Analysis

Existing Dataset (Baseline)

Location: /home/jgrusewski/Work/foxhunt/test_data/real/databento/ml_training/

Coverage:

• Files: 360 DBN files
• Size: 36.3 MB total (103 KB average per file)
• Symbols: 4 (ES.FUT, NQ.FUT, ZN.FUT, 6E.FUT)
• Actual Trading Days: 4 unique dates only (not 90)
  • Files are duplicated across symbols
  • Date range: 2024-01-02 to 2024-05-06 (125 calendar days)
  • Trading days: Only 4 dates in dataset, NOT 90

Current Split:

360 files ÷ 4 symbols = 90 files per symbol

Data per Symbol (assuming 400-500 bars/file average):

• 6E.FUT: ~90 files × 450 bars/file = ~40,500 bars
• ES.FUT: ~90 files × 450 bars/file = ~40,500 bars
• NQ.FUT: ~90 files × 450 bars/file = ~40,500 bars
• ZN.FUT: ~90 files × 450 bars/file = ~40,500 bars
• Total: ~162,000 bars across 360 files

Agent 66 Validation (DQN 1-epoch test with 4 files):

INFO ml::trainers::dqn: Extracted 1661 OHLCV bars from "6E.FUT_ohlcv-1m_2024-01-04.dbn"
INFO ml::trainers::dqn: Extracted 1786 OHLCV bars from "6E.FUT_ohlcv-1m_2024-01-03.dbn"
INFO ml::trainers::dqn: Extracted 1877 OHLCV bars from "6E.FUT_ohlcv-1m_2024-01-02.dbn"
INFO ml::trainers::dqn: Extracted 1899 OHLCV bars from "6E.FUT_ohlcv-1m_2024-01-05.dbn"
INFO ml::trainers::dqn: Successfully loaded 7223 training samples from 4 DBN files

Agent 54 PPO Training (500 epochs, 6E.FUT, 1,661 bars):

• Training Time: 5.6 minutes (500 epochs)
• Per-Epoch Time: ~0.67 seconds
• Data Size: 1,661 bars (single day)

---

2. 90-Day Expansion Design

Target Dataset Specifications

Coverage:

• Symbols: 4 (ES.FUT, NQ.FUT, ZN.FUT, 6E.FUT)
• Trading Days: 90 (excludes weekends/holidays)
• Calendar Days: ~127 days (90 trading days + 37 weekend/holiday days)
• Files Per Symbol: 90 files (1 file per trading day)
• Total Files: 90 days × 4 symbols = 360 files (NO CHANGE from current count!)
• Expected Total Size: 360 files × 103 KB/file = 37 MB (similar to current)

Bars Per Symbol (estimated):

• Futures trading hours: ~23 hours/day (ES/NQ), ~8 hours/day (ZN/6E)
• ES.FUT: 23h × 60 min × 90 days = ~124,200 bars
• NQ.FUT: 23h × 60 min × 90 days = ~124,200 bars
• ZN.FUT: 8h × 60 min × 90 days = ~43,200 bars
• 6E.FUT: 8h × 60 min × 90 days = ~43,200 bars
• Total Bars: ~334,800 bars (vs. current ~162,000 bars = 2.07x increase)

Actual vs. Expected:

• Current state: 360 files but only ~162K bars (files likely already span 90 days!)
• Action required: VERIFY current date coverage before downloading
• Risk: May already have 90 days of data but mislabeled or need reorganization

---

3. Data Acquisition Plan

Step 1: Verify Current Coverage (5-10 minutes)

Objective: Determine actual date range and gaps in existing dataset

# List unique dates per symbol
for symbol in ES.FUT NQ.FUT ZN.FUT 6E.FUT; do
  echo "=== $symbol ==="
  ls test_data/real/databento/ml_training/${symbol}_*.dbn | \
    awk -F'_' '{print $3}' | awk -F'.' '{print $1}' | sort -u | wc -l
done

# Check date range
ls test_data/real/databento/ml_training/*.dbn | \
  awk -F'_' '{print $3}' | awk -F'.' '{print $1}' | sort -u | \
  head -1 && tail -1

# Count bars per file (sample 10 files)
cargo run -p ml --example test_dbn_loading -- \
  --directory test_data/real/databento/ml_training \
  --max-files 10

Expected Findings:

1. If 90 unique dates exist per symbol → Data already complete, skip download
2. If <90 dates → Calculate missing days for targeted download
3. If dates are outside 2024-01-02 to 2024-05-06 range → Data needs reorganization

Step 2: Download Missing Data (30-90 minutes)

Prerequisites:

• DataBento API key: DATABENTO_API_KEY in .env
• Active subscription (timeseries API access)

Download Command (Using existing download_training_data.rs):

# Full 90-day download (if dataset is incomplete)
cargo run -p ml --example download_training_data --release -- \
  --start-date 2024-01-02 \
  --days 90 \
  --symbols ES.FUT NQ.FUT ZN.FUT 6E.FUT \
  --output-dir test_data/real/databento/ml_training_90d

# Dry run first (preview costs)
cargo run -p ml --example download_training_data --release -- \
  --start-date 2024-01-02 \
  --days 90 \
  --dry-run

Expected Output:

Downloading 90 trading days for 4 symbols...
  ES.FUT: 90 files
  NQ.FUT: 90 files
  ZN.FUT: 90 files
  6E.FUT: 90 files
Total: 360 files

Estimated size: 37 MB
Estimated cost: $1.20 - $4.50

Rate Limiting:

• DataBento rate limit: ~100 requests/minute (conservative)
• 360 files ÷ 100 req/min = 3.6 minutes minimum
• With error handling + retries: 30-90 minutes total

Download Strategy:

1. Download day-by-day (not date ranges) for granular control
2. Skip existing files to support resumable downloads
3. Validate each file after download (check size > 10 KB)
4. Log failures for manual retry

Step 3: Validate Downloaded Data (10-15 minutes)

File Count Verification:

# Count files per symbol
for symbol in ES.FUT NQ.FUT ZN.FUT 6E.FUT; do
  count=$(ls test_data/real/databento/ml_training_90d/${symbol}_*.dbn 2>/dev/null | wc -l)
  echo "$symbol: $count files (expected: 90)"
done

# Check total size
du -sh test_data/real/databento/ml_training_90d/

Data Quality Validation:

# Test loading with DQN trainer (1 epoch)
cargo run -p ml --example train_dqn --release -- \
  --epochs 1 \
  --data-dir test_data/real/databento/ml_training_90d \
  --batch-size 32

# Expected output:
# "Successfully loaded XXXXX training samples from 360 DBN files"

Quality Checks:

1. ✅ No InvalidPrice errors (Agent 66 fix validated)
2. ✅ Total bars: 200,000-350,000 (depends on trading hours)
3. ✅ No corrupted files (size > 10 KB each)
4. ✅ Date continuity (no large gaps)

---

4. Training Data Split Strategy

Proposed Split (80/10/10)

Training Set: 80% (72 days × 4 symbols = 288 files)

• Purpose: Model weight optimization
• Date range: Days 1-72 (2024-01-02 to ~2024-04-01)
• Bars: ~267,840 bars

Validation Set: 10% (9 days × 4 symbols = 36 files)

• Purpose: Hyperparameter tuning, early stopping
• Date range: Days 73-81 (2024-04-02 to ~2024-04-15)
• Bars: ~33,480 bars

Test Set: 10% (9 days × 4 symbols = 36 files)

• Purpose: Final model evaluation (unseen data)
• Date range: Days 82-90 (2024-04-16 to ~2024-04-30)
• Bars: ~33,480 bars

Rationale:

• Time-series data: Use chronological split (NOT random) to avoid lookahead bias
• Validation set: Large enough for reliable early stopping (9 days = ~33K bars)
• Test set: Represents recent market conditions (most relevant for live trading)

Implementation in Loaders

Current Implementation (DbnSequenceLoader):

pub async fn load_sequences(
    &mut self,
    dbn_dir: P,
    train_split: f64,  // ← Single split parameter (train vs. all else)
) -> Result<(Vec<(Tensor, Tensor)>, Vec<(Tensor, Tensor)>)>

Proposed Enhancement (3-way split):

pub async fn load_sequences_with_splits(
    &mut self,
    dbn_dir: P,
    train_ratio: f64,  // 0.8 for 80%
    val_ratio: f64,    // 0.1 for 10%
    test_ratio: f64,   // 0.1 for 10%
) -> Result<(
    Vec<(Tensor, Tensor)>,  // Training
    Vec<(Tensor, Tensor)>,  // Validation
    Vec<(Tensor, Tensor)>,  // Test
)> {
    // Load all files chronologically
    let mut dbn_files = Vec::new();
    // ... (file discovery)
    dbn_files.sort();  // Chronological order

    // Split by file count (not by samples)
    let total_files = dbn_files.len();
    let train_count = (total_files as f64 * train_ratio) as usize;
    let val_count = (total_files as f64 * val_ratio) as usize;

    let train_files = &dbn_files[0..train_count];
    let val_files = &dbn_files[train_count..train_count + val_count];
    let test_files = &dbn_files[train_count + val_count..];

    // Process each subset
    let train_data = self.load_from_files(train_files).await?;
    let val_data = self.load_from_files(val_files).await?;
    let test_data = self.load_from_files(test_files).await?;

    Ok((train_data, val_data, test_data))
}

Backward Compatibility:

• Keep existing load_sequences() method for 2-way split
• Add new method load_sequences_with_splits() for 3-way split
• Update training examples to use new method:
  • train_dqn.rs
  • train_mamba2.rs
  • train_tft.rs

---

5. Training Time Impact Analysis

Baseline Performance (4-Day Dataset)

Agent 54 PPO Training (500 epochs, 1,661 bars):

• Training Time: 5.6 minutes
• Per-Epoch Time: 0.67 seconds
• Bars/Second: ~248 bars/sec

Agent 66 DQN Training (1 epoch, 7,223 bars):

• Training Time: 0.01 seconds (10 ms)
• Bars/Second: ~722,300 bars/sec (highly optimized or cached)

Realistic DQN Estimate (500 epochs, 7,223 bars):

• Assuming 10 ms/epoch (Agent 66 baseline)
• 500 epochs × 10 ms = 5 seconds total
• OR: Assuming PPO-like performance (0.67 sec/epoch)
• 500 epochs × 0.67 sec = 5.6 minutes total

Projected Performance (90-Day Dataset)

Data Scaling:

• Current: ~7,200 bars (4 days × 4 symbols)
• Target: ~334,800 bars (90 days × 4 symbols)
• Scaling Factor: 334,800 ÷ 7,200 = 46.5x more data

Training Time Projections (500 epochs):

Model	Current (4 days)	Projected (90 days, 80% train)	Notes
DQN	5.6 min	5.6 × 37.2 = 208 min = 3.5 hours	Assumes linear scaling with 80% split
PPO	5.6 min	5.6 × 37.2 = 208 min = 3.5 hours	Agent 54 baseline
MAMBA-2	10 min (est.)	10 × 37.2 = 372 min = 6.2 hours	Sequence model (slower)
TFT	42 min (est.)	42 × 37.2 = 1,562 min = 26 hours	Agent 56 estimate, attention-heavy

Conservative Estimates (with overhead):

• DQN: 3.5-5 hours
• PPO: 3.5-5 hours
• MAMBA-2: 6-8 hours
• TFT: 26-30 hours

Total Training Time (All Models): 39-48 hours (1.6-2 days)

Optimizations:

1. GPU Acceleration (RTX 3050 Ti CUDA):

   • Current: CPU-only (Agent 54 baseline)
   • Expected speedup: 5-10x for DQN/PPO, 10-20x for MAMBA-2/TFT
   • GPU Training Time: 4-10 hours total (all models)

2. Batch Size Tuning:

   • Current: 32-128 (Agent 66 validation)
   • RTX 3050 Ti 4GB: Max batch size 230 (DQN), 64 (MAMBA-2), 32 (TFT)
   • Speedup: 1.5-2x with larger batches

3. Early Stopping:

   • Monitor validation loss every 50 epochs
   • Stop if no improvement for 100 epochs
   • Expected Savings: 20-40% fewer epochs (100-300 instead of 500)

Realistic GPU-Accelerated Timeline:

• DQN: 1-2 hours (with early stopping)
• PPO: 1-2 hours (with early stopping)
• MAMBA-2: 2-4 hours (with early stopping)
• TFT: 8-12 hours (with early stopping)
• Total: 12-20 hours (0.5-0.8 days)

---

6. Infrastructure Readiness

Current Capabilities ✅

Data Loading (Agent 66 Validated):

• ✅ DbnSequenceLoader handles 360+ files efficiently
• ✅ Price scaling fixed (1e-9 factor per DBN spec)
• ✅ Symbol mapping (ES.FUT, NQ.FUT, ZN.FUT, 6E.FUT)
• ✅ Feature extraction (16 features: 5 OHLCV + 10 technical indicators + 1 log return)
• ✅ Normalization (z-score per feature)

Training Infrastructure:

• ✅ Checkpoint manager (Agent 31): Saves every 10 epochs
• ✅ S3 upload (Agent 46): MinIO integration for model archival
• ✅ Model versioning (Agent 47): Semantic versioning with metadata
• ✅ Monitoring (Agent 48): 35 Prometheus metrics
• ✅ GPU support: RTX 3050 Ti CUDA (Device::cuda_if_available)

Training Examples:

• ✅ train_dqn.rs: CLI with epochs, learning rate, batch size, output dir
• ✅ train_mamba2.rs: CLI with seq_len, d_model, train_split
• ✅ train_tft.rs: CLI with encoder_length, attention_heads, dropout
• ✅ train_ppo.rs: CLI with ent_coef, gamma, clip_epsilon

Model Trainers:

• ✅ DQN: Q-network + target network, replay buffer, epsilon-greedy
• ✅ PPO: Actor-critic, GAE, clipped surrogate loss (Agent 32 fix)
• ✅ MAMBA-2: State space model, selective scan, convolution (60-128 seq_len)
• ✅ TFT: Multi-head attention, GRN, VSN (90-day lookback)

Gaps & Required Enhancements ⚠️

Data Loader Enhancements (Estimated: 1-2 hours):

1. 3-Way Split Support:

   • Add load_sequences_with_splits() method
   • Modify load_sequences() to call new method internally
   • Update training examples to use 3-way split

2. Chronological Ordering:

   • Verify file sorting by date (currently sorts by filename)
   • Add date validation to prevent out-of-order loading

3. Memory Management:

   • Current: Loads all sequences into memory (~267K bars × 16 features × 4 bytes = ~17 MB)
   • 90-day dataset: ~267K bars × 16 features × 4 bytes = ~17 MB (acceptable)
   • No streaming needed for <100 MB datasets

Training Example Updates (Estimated: 30 minutes):

1. CLI Arguments:

   • Add --train-split, --val-split, --test-split flags
   • Add --early-stopping flag (default: 100 epochs patience)
   • Add --checkpoint-frequency flag (default: 10 epochs)

2. Validation Loop:

   • Add validation loss computation every N epochs
   • Log validation metrics to Prometheus
   • Implement early stopping based on validation loss

3. Test Evaluation:

   • Add final evaluation on test set after training
   • Generate test metrics report (accuracy, Sharpe ratio, PnL)

Monitoring Enhancements (Estimated: 30 minutes):

1. Training Metrics:

   • Add training_samples_total gauge
   • Add validation_loss_best gauge
   • Add early_stopping_triggered counter

2. Grafana Dashboards:

   • Add panel for train/val loss curves
   • Add panel for early stopping status

---

7. Cost Analysis

DataBento Pricing (Timeseries API)

Current Pricing (as of 2024):

• OHLCV-1m data: $0.01 - $0.05 per symbol per day (varies by exchange)
• GLBX.MDP3 dataset (CME Globex futures): $0.01/day/symbol (aggressive estimate)

90-Day Download Cost:

Cost = 90 days × 4 symbols × $0.0125/day/symbol
     = 90 × 4 × $0.0125
     = $4.50 (upper bound)

Alternative Estimate (conservative):

Cost = 360 files × $0.01/file
     = $3.60

Best Case (if current dataset already has 90 days):

Cost = $0 (data already downloaded)

Estimated Range: $0 - $4.50

Realistic Estimate: $1.20 - $2.50 (based on typical CME pricing)

Storage Costs

Local Storage:

• Current: 36 MB (360 files)
• 90-day: 37 MB (360 files, if date range expands)
• Cost: $0 (local disk)

S3 Storage (MinIO/AWS):

• Model checkpoints: ~150 files × 50 KB = 7.5 MB per model
• 4 models × 7.5 MB = 30 MB total
• AWS S3 Standard: $0.023/GB/month → $0.0007/month for 30 MB
• Cost: Negligible (<$0.01/month)

Total Storage Cost: <$0.01/month

Compute Costs

Local GPU Training (RTX 3050 Ti):

• Power consumption: ~130W (GPU + system)
• Training time: 12-20 hours
• Energy: 130W × 20h = 2.6 kWh
• Cost: 2.6 kWh × $0.12/kWh = $0.31

Cloud GPU Training (Alternative):

• AWS p3.2xlarge (V100 16GB): $3.06/hour
• Training time (V100): ~4-6 hours (3-4x faster than RTX 3050 Ti)
• Cost: 6h × $3.06/h = $18.36

Recommendation: Use local RTX 3050 Ti (saves $18)

Total Project Cost

Item	Cost
DataBento data download	$1.20 - $4.50
Local GPU training (electricity)	$0.31
S3 storage (1 month)	<$0.01
Total	$1.51 - $4.81

Expected Cost: ~$2.00 (data) + $0.31 (GPU) = $2.31 total

---

8. Implementation Roadmap

Phase 1: Data Acquisition (1-2 hours)

Tasks:

1. ✅ Verify current dataset coverage (10 min)

   bash verify_dataset_coverage.sh
   

2. ✅ Download missing data (30-90 min)

   cargo run -p ml --example download_training_data --release -- \
     --start-date 2024-01-02 --days 90 --output-dir test_data/real/databento/ml_training_90d
   

3. ✅ Validate downloaded files (10 min)

   cargo run -p ml --example train_dqn --release -- \
     --epochs 1 --data-dir test_data/real/databento/ml_training_90d
   

Deliverables:

• 360 DBN files (90 days × 4 symbols)
• 37 MB total data
• Validation report (bars/file, date coverage)

Phase 2: Data Loader Enhancement (1-2 hours)

Tasks:

1. ✅ Implement 3-way split in DbnSequenceLoader (45 min)

   • Add load_sequences_with_splits() method
   • Test with 80/10/10 split

2. ✅ Add chronological ordering validation (15 min)

   • Verify files are sorted by date
   • Add test case for date continuity

3. ✅ Update training examples (30 min)

   • Add CLI flags for split ratios
   • Update train_dqn.rs, train_mamba2.rs, train_tft.rs

Deliverables:

• ml/src/data_loaders/dbn_sequence_loader.rs (updated)
• Test suite for 3-way split
• Updated training examples with CLI flags

Phase 3: Training Infrastructure (30-60 min)

Tasks:

1. ✅ Add early stopping logic (20 min)

   • Monitor validation loss every 50 epochs
   • Stop if no improvement for 100 epochs
   • Log to Prometheus

2. ✅ Add validation loop to trainers (20 min)

   • Compute validation loss after each epoch
   • Log to console and Prometheus
   • Save best checkpoint based on validation loss

3. ✅ Add test evaluation (20 min)

   • Evaluate model on test set after training
   • Generate metrics report (accuracy, Sharpe, PnL)

Deliverables:

• Updated trainers with early stopping
• Validation loop in all 4 trainers
• Test evaluation script

Phase 4: Training Execution (12-48 hours)

Tasks:

1. ✅ DQN training (1-5 hours)

   cargo run -p ml --example train_dqn --release -- \
     --epochs 500 --learning-rate 0.0001 --batch-size 128 \
     --data-dir test_data/real/databento/ml_training_90d \
     --output-dir ml/trained_models/production/dqn_90d
   

2. ✅ PPO training (1-5 hours)

   cargo run -p ml --example train_ppo --release -- \
     --epochs 500 --learning-rate 0.00003 --batch-size 128 \
     --data-dir test_data/real/databento/ml_training_90d \
     --output-dir ml/trained_models/production/ppo_90d
   

3. ✅ MAMBA-2 training (2-8 hours)

   cargo run -p ml --example train_mamba2 --release -- \
     --epochs 500 --learning-rate 0.0001 --batch-size 8 --seq-len 128 \
     --dbn-dir test_data/real/databento/ml_training_90d \
     --output ml/trained_models/production/mamba2_90d
   

4. ✅ TFT training (8-30 hours)

   cargo run -p ml --example train_tft --release -- \
     --epochs 500 --learning-rate 0.001 --batch-size 32 \
     --data-dir test_data/real/databento/ml_training_90d \
     --output ml/trained_models/production/tft_90d
   

Deliverables:

• 4 trained models with 50+ checkpoints each
• Training logs with loss curves
• Validation metrics
• Test evaluation reports

Phase 5: Validation & Documentation (1-2 hours)

Tasks:

1. ✅ Validate checkpoints (30 min)

   ls -lh ml/trained_models/production/*/checkpoint_*.safetensors
   hexdump -C ml/trained_models/production/dqn_90d/checkpoint_epoch_500.safetensors | head -3
   

2. ✅ Generate training report (30 min)

   • Loss curves (train vs. validation)
   • Early stopping analysis
   • Test set metrics (Sharpe ratio, PnL, accuracy)
   • Comparison to 4-day baseline

3. ✅ Update CLAUDE.md (30 min)

   • Mark 90-day training as complete
   • Update ML status section
   • Document training timelines

Deliverables:

• Checkpoint validation report
• Training metrics report (markdown)
• Updated CLAUDE.md

---

9. Risk Analysis

Technical Risks

Risk	Probability	Impact	Mitigation
DataBento API rate limiting	Medium	Medium	Implement exponential backoff, retry logic
Insufficient GPU VRAM (4GB)	Low	High	Reduce batch size (32→16), use gradient accumulation
Training divergence (NaN loss)	Low	High	Early stopping, gradient clipping, learning rate warmup
Disk space (37 MB + 30 MB checkpoints)	Low	Low	67 MB total is negligible on modern systems
Data quality issues	Low	Medium	Validate each file after download (size > 10 KB)
Chronological data leakage	Medium	Critical	Use file-based split (not sample-based), sort by date

Operational Risks

Risk	Probability	Impact	Mitigation
Training time exceeds 48h	Medium	Medium	Use GPU acceleration, early stopping, parallel training
Download interrupted	Medium	Low	Resumable downloads (skip existing files)
API cost exceeds $5	Low	Low	Dry run first, monitor costs during download
Model overfitting	Medium	High	Use validation set for early stopping, monitor val loss
Hardware failure (RTX 3050 Ti)	Low	High	Checkpoint every 10 epochs, resume from last checkpoint

Mitigation Strategies

Data Quality:

1. Validate each file after download (size, parse first 10 records)
2. Log failed downloads for manual retry
3. Compare bar counts to expected values (400-500 bars/file)

Training Stability:

1. Gradient clipping (max_norm=1.0)
2. Learning rate warmup (first 10 epochs)
3. Early stopping (patience=100 epochs)
4. Checkpoint every 10 epochs

Resource Management:

1. Monitor GPU VRAM usage (nvidia-smi every 10 epochs)
2. Reduce batch size if OOM errors occur
3. Use gradient accumulation if batch size < 32

---

10. Success Criteria

Data Acquisition ✅

• 360 DBN files downloaded (90 days × 4 symbols)
• Total size: 35-40 MB
• All files validated (size > 10 KB, parseable)
• Date coverage: 2024-01-02 to ~2024-04-30 (90 trading days)
• No missing dates (except weekends/holidays)

Training Infrastructure ✅

• 3-way split implemented (80/10/10)
• Chronological ordering validated
• Early stopping functional (patience=100)
• Validation loop in all trainers
• Test evaluation script ready

Training Execution ✅

• DQN: 500 epochs, loss convergence, 50+ checkpoints
• PPO: 500 epochs, KL divergence > 0, 150 checkpoints
• MAMBA-2: 500 epochs, validation loss improvement, 50+ checkpoints
• TFT: 500 epochs, attention weights learned, 50+ checkpoints

Performance Targets 📊

• Training time: <48 hours total (all models)
• GPU utilization: >80% during training
• Zero NaN values throughout training
• Validation loss: <10% of initial loss
• Test set Sharpe ratio: >1.0 (at least 1 model)

Documentation ✅

• Training report with loss curves
• Checkpoint validation report
• Updated CLAUDE.md with 90-day status
• Cost breakdown (actual vs. estimated)
• Training timeline (actual vs. projected)

---

11. Recommendations

Immediate Actions (Next 1-2 hours)

1. Verify Current Dataset Coverage (10 min):

   • Run verification script to check existing date range
   • Determine if 360 files already span 90 days
   • If true: Skip download, proceed to Phase 2

2. Download Missing Data (30-90 min, if needed):

   • Run dry run first to confirm costs
   • Use resumable download script
   • Validate files as they download

3. Implement 3-Way Split (1 hour):

   • Add load_sequences_with_splits() to DbnSequenceLoader
   • Update training examples with CLI flags
   • Test with small dataset (4 days) first

Short-Term Actions (Next 2-3 days)

1. Execute Training Pipeline (12-48 hours):

   • Start with DQN (fastest model)
   • Run PPO and MAMBA-2 in parallel
   • Queue TFT last (longest training time)

2. Monitor Training Progress:

   • Check Grafana dashboards every 2-4 hours
   • Verify validation loss is decreasing
   • Watch for OOM errors or NaN values

3. Generate Training Report (1 hour):

   • Document final metrics
   • Compare to 4-day baseline
   • Identify best-performing model

Long-Term Actions (Next 1-2 weeks)

1. Model Evaluation (2-3 days):

   • Backtest on test set (9 days unseen data)
   • Calculate Sharpe ratio, max drawdown, PnL
   • Compare 4 models side-by-side

2. Hyperparameter Tuning (3-5 days):

   • Use validation set for tuning
   • Test learning rates: [1e-5, 3e-5, 1e-4, 3e-4]
   • Test batch sizes: [16, 32, 64, 128]

3. Production Deployment (1 week):

   • Package best model for live trading
   • Set up model serving (gRPC API)
   • Integrate with Trading Service

---

Appendix A: Verification Script

File: verify_dataset_coverage.sh

#!/bin/bash
# Verify current DBN dataset coverage

DATA_DIR="test_data/real/databento/ml_training"
SYMBOLS=("ES.FUT" "NQ.FUT" "ZN.FUT" "6E.FUT")

echo "========================================"
echo "DBN Dataset Coverage Verification"
echo "========================================"
echo ""

# Check total files
total_files=$(ls -1 ${DATA_DIR}/*.dbn 2>/dev/null | wc -l)
echo "Total files: ${total_files}"

# Check files per symbol
echo ""
echo "Files per symbol:"
for symbol in "${SYMBOLS[@]}"; do
  count=$(ls -1 ${DATA_DIR}/${symbol}_*.dbn 2>/dev/null | wc -l)
  echo "  ${symbol}: ${count} files"
done

# Check unique dates
echo ""
echo "Unique trading days:"
unique_dates=$(ls -1 ${DATA_DIR}/*.dbn | awk -F'_' '{print $3}' | awk -F'.' '{print $1}' | sort -u | wc -l)
echo "  Total: ${unique_dates} days"

# Check date range
echo ""
echo "Date range:"
first_date=$(ls -1 ${DATA_DIR}/*.dbn | awk -F'_' '{print $3}' | awk -F'.' '{print $1}' | sort -u | head -1)
last_date=$(ls -1 ${DATA_DIR}/*.dbn | awk -F'_' '{print $3}' | awk -F'.' '{print $1}' | sort -u | tail -1)
echo "  Start: ${first_date}"
echo "  End: ${last_date}"

# Calculate calendar days
if [[ ! -z "${first_date}" && ! -z "${last_date}" ]]; then
  start_epoch=$(date -d "${first_date}" +%s)
  end_epoch=$(date -d "${last_date}" +%s)
  calendar_days=$(( (end_epoch - start_epoch) / 86400 ))
  echo "  Calendar days: ${calendar_days}"
fi

# Check total size
echo ""
echo "Total size:"
du -sh ${DATA_DIR}/

# Sample 5 files
echo ""
echo "Sample file sizes:"
ls -lh ${DATA_DIR}/*.dbn | head -5 | awk '{print "  " $9 ": " $5}'

# Recommendation
echo ""
echo "========================================"
echo "Recommendation:"
echo "========================================"
if [ ${unique_dates} -ge 90 ]; then
  echo "✅ Dataset appears to cover 90+ trading days."
  echo "   No download needed. Proceed to Phase 2 (data loader enhancement)."
elif [ ${unique_dates} -ge 30 ]; then
  echo "⚠️  Dataset covers ${unique_dates} trading days (need 90)."
  echo "   Download remaining $((90 - unique_dates)) days."
else
  echo "❌ Dataset incomplete (only ${unique_dates} days)."
  echo "   Download full 90-day dataset."
fi

Usage:

chmod +x verify_dataset_coverage.sh
./verify_dataset_coverage.sh

---

Appendix B: Expected Training Logs

DQN Training (500 epochs, 90 days)

🚀 Starting DQN Training
Configuration:
  • Epochs: 500
  • Learning rate: 0.0001
  • Batch size: 128
  • Data directory: test_data/real/databento/ml_training_90d

✅ DQN trainer initialized

📊 Loading DBN market data...
Found 360 DBN files to load
Loading DBN files: ████████████████████ 360/360 (100%)

✅ Loaded data:
  • Training samples: 215,040 (72 days × 4 symbols × 750 bars/day)
  • Validation samples: 26,880 (9 days × 4 symbols × 750 bars/day)
  • Test samples: 26,880 (9 days × 4 symbols × 750 bars/day)

🏋️  Starting training...
Epoch 1/500 | Loss: 0.8234 | Q-value: 10.5 | Val loss: 0.8156 | Time: 12.3s
Epoch 10/500 | Loss: 0.6721 | Q-value: 15.2 | Val loss: 0.6654 | Time: 120.1s
...
Epoch 300/500 | Loss: 0.0823 | Q-value: 42.1 | Val loss: 0.0812 | Time: 3,605s
Epoch 310/500 | Loss: 0.0819 | Q-value: 42.3 | Val loss: 0.0810 | Time: 3,725s
...
⚠️  Early stopping triggered at epoch 387 (no improvement for 100 epochs)
Best validation loss: 0.0798 at epoch 287

✅ Training completed in 4,644s (1.29 hours)
  • Final training loss: 0.0805
  • Best validation loss: 0.0798
  • Checkpoints saved: 39 files

📊 Test set evaluation:
  • Test loss: 0.0812
  • Sharpe ratio: 1.42
  • Max drawdown: -8.3%
  • PnL: +$12,450 (simulated on 9 days)

✅ Model saved to ml/trained_models/production/dqn_90d/checkpoint_epoch_387.safetensors

---

Conclusion

This plan provides a comprehensive roadmap for scaling the Foxhunt ML training pipeline from a 4-day pilot dataset to a production-ready 90-day dataset. The estimated cost is $2.31 (DataBento data + GPU electricity), and the total implementation time is 14-50 hours (2-3 days including training).

Key Takeaways:

1. Data verification first: Current dataset may already contain 90 days (360 files ÷ 4 symbols = 90 files/symbol)
2. Chronological splits: Use time-series splits (80/10/10) to avoid lookahead bias
3. GPU acceleration: Local RTX 3050 Ti reduces training time by 5-10x vs. CPU
4. Early stopping: Saves 20-40% training time by stopping when validation loss plateaus
5. Cost-effective: Total cost <$5 for professional ML training dataset

Next Steps:

1. Run verify_dataset_coverage.sh to check current data coverage
2. Download missing data if needed (30-90 min)
3. Implement 3-way split in DbnSequenceLoader (1 hour)
4. Execute training pipeline (12-48 hours)
5. Generate training report and update CLAUDE.md

Status: Ready for execution. Awaiting approval to proceed with Phase 1 (data verification).