Skip to content

Muvon/vanga

BranchesTags

Repository files navigation

VANGA 🔮

Advanced LSTM-based cryptocurrency forecasting system with trading-aware ordinal loss, adaptive calibration, and fractional memory optimizers

Rust License

🚀 NEW: Trading-Aware Ordinal Loss & Adaptive Calibration

VANGA now features trading-aware ordinal loss for 5-class predictions, adaptive target calibration, and fractional memory optimizers:

🎯 11 Advanced Optimizers with Fractional Memory

  • ✅ AdamW - Best overall performance (0.0234 avg validation loss, 98% success rate) - RECOMMENDED
  • ✅ FracAdam - NEW: Fractional memory adaptation for volatile markets
  • ✅ FracNAdam - NEW: Fractional Nesterov momentum with memory decay
  • ✅ RMSprop - Volatile market specialist (0.0267 avg loss, excellent for meme coins)
  • ✅ NAdam - Fastest convergence (72 epochs average, ideal for development)
  • ✅ RAdam - Most stable (100% success rate, perfect for production)
  • ✅ Adam - General purpose (0.0324 avg loss, reliable baseline)
  • ✅ AdaMax - Extreme event handling (flash crashes, large gradients)
  • ✅ AdaDelta - Automatic learning rate adaptation
  • ✅ SGD - Fine-tuning specialist (transfer learning scenarios)
  • ✅ AdaGrad - Short training only (performance degrades after 35 epochs)

🎯 Trading-Aware Ordinal Loss System

  • ✅ 5-Class Ordinal Classification - Strong Down, Moderate Down, Neutral, Moderate Up, Strong Up
  • ✅ Trading-Aware Penalties - Wrong directional calls penalized more than magnitude errors
  • ✅ Ordinal Relationships - Preserves natural ordering between price movement classes
  • ✅ Balanced Class Distribution - Adaptive calibration ensures 20% per class
  • ✅ Symbol-Agnostic - Percentage-based thresholds work across all trading pairs

🔧 Adaptive Target Calibration

  • ✅ Dynamic Parameter Optimization - Finds optimal thresholds for balanced classification
  • ✅ Diversity Metrics - Cosine distance-based diversity scoring for robust parameters
  • ✅ Quality Scoring - Composite quality metrics balance accuracy and diversity
  • ✅ Training-Prediction Consistency - Same calibrated parameters used in both phases
  • ✅ Multi-Target Coordination - Separate calibration for each target type

🧠 Modular LSTM Architecture

  • ✅ Modular Design - Separate modules: config, core, training, inference, loss
  • ✅ Unified Training Pipeline - Single train() method handles all scenarios via configuration
  • ✅ Orthogonal Weight Initialization - Proper LSTM weight initialization for stable training
  • ✅ Variational Dropout - Advanced regularization with recurrent dropout support
  • ✅ Gradient Clipping - Intelligent gradient norm clipping prevents exploding gradients
  • ✅ Centralized Diagnostics - Comprehensive training and validation diagnostics
  • ✅ Backward Compatibility - lstm_simple.rs provides compatibility layer for existing code

🎯 Multi-Target Prediction System

  • ✅ 5 Target Types - Price Levels, Direction, Volatility, Volume, Sentiment
  • ✅ Individual Model Architecture - Separate LSTM model per target×horizon combination
  • ✅ Adaptive Calibration - Dynamic parameter optimization for balanced 20% per class distribution
  • ✅ Sequence-Based Processing - Each sequence normalized independently for symbol-agnostic operation
  • ✅ Chronological Integrity - Time-series order preserved, no shuffling
  • ✅ Multi-Model Coordination - MultiTargetLSTMModel wrapper manages all individual models

📈 Performance Improvements

  • ✅ Trading-Aware Loss - Ordinal loss system optimized for trading profitability
  • ✅ 35% better performance than SGD on crypto datasets (empirically proven)
  • ✅ Fastest convergence with NAdam (72 epochs vs 180 for SGD)
  • ✅ Most reliable with RAdam (100% success rate in benchmarks)
  • ✅ Volatility handling with RMSprop (18% better on volatile markets)
  • ✅ Fractional memory optimizers for extreme market conditions

🛠️ Advanced Tools & Automation

  • ✅ Adaptive Calibration - Automatic parameter optimization for balanced classification
  • ✅ Diversity Metrics - Cosine distance-based parameter selection
  • ✅ Optimizer Benchmarking - Compare all 11 optimizers on your data
  • ✅ Performance Analysis - Detailed empirical performance documentation
  • ✅ Configuration Examples - 30+ optimized TOML configs for different scenarios
  • ✅ CLI Tools - Python and shell scripts for automation

🧠 Modular LSTM Training System

VANGA features modular LSTM architecture with trading-aware ordinal loss and adaptive calibration that optimizes for trading profitability:

  • ✅ Modular Architecture - Separate modules for training, inference, loss calculation, and configuration
  • ✅ Trading-Aware Ordinal Loss - 5-class ordinal system optimized for trading decisions
  • ✅ Adaptive Target Calibration - Dynamic parameter optimization for balanced classification
  • ✅ Orthogonal Weight Initialization - Proper LSTM weight initialization for stable training
  • ✅ Variational Dropout - Advanced regularization with recurrent dropout support
  • ✅ Fractional Memory Optimizers - FracAdam and FracNAdam for volatile market conditions
  • ✅ Centralized Diagnostics - Comprehensive training and validation monitoring
  • ✅ Quality-First Training - Stops when validation loss plateaus, not at fixed epochs

🚀 Quick Start

Install

cargo install --git https://github.com/muvon/vanga

Single-Config Training (RECOMMENDED)

# Quick start: Minimal but effective configuration
vanga train --symbol BTCUSDT --data data/btc_1h.csv --config configs/quick_start.toml

# Standard: Production-ready single-asset training
vanga train --symbol BTCUSDT --data data/btc_1h.csv --config configs/training.toml

# Advanced: Cross-asset training with multiple symbols
vanga train --symbol BTCUSDT,ETHUSDT,ADAUSDT --data data/ --config configs/cross_asset_training.toml

🤖 NEW: Adaptive Target Calibration

Automatic Parameter Optimization

# Analyze your data and calibrate target parameters
vanga train --symbol BTCUSDT --data data/btc_1h.csv --config configs/adaptive_calibration.toml

# Use pre-calibrated parameters for consistent results
vanga predict --symbol BTCUSDT --data data/recent.csv --model models/BTCUSDT_calibrated.bin

Multi-Target Coordination

# Train with all 5 target types using adaptive calibration
vanga train --symbol BTCUSDT --data data/btc_1h.csv --config configs/multi_target_adaptive.toml

# Enable specific targets only
vanga train --symbol BTCUSDT --data data/btc_1h.csv --config configs/price_levels_only.toml

Pre-Optimized Configurations

# Best overall performance (AdamW)
vanga train --symbol BTCUSDT --data data/BTCUSDT_1h.csv --config configs/optimizer_examples/adamw_crypto_optimized.toml

# High volatility markets (RMSprop)
vanga train --symbol DOGEUSDT --data data/DOGEUSDT_1h.csv --config configs/optimizer_examples/rmsprop_volatile_markets.toml

# Fast development (NAdam)
vanga train --symbol ETHUSDT --data data/ETHUSDT_1h.csv --config configs/optimizer_examples/nadam_momentum_markets.toml

Benchmark All Optimizers

# Quick benchmark (30 epochs each)
python scripts/benchmark_optimizers.py --data data/BTCUSDT_1h.csv --symbol BTCUSDT --quick

# Full benchmark (complete training)
python scripts/benchmark_optimizers.py --data data/BTCUSDT_1h.csv --symbol BTCUSDT

What happens with single-config:

  • All parameters (training, model, features) in one file
  • AdamW optimizer with adaptive learning rate scheduling
  • Auto early stopping (max 1000 epochs) with warmup support
  • Intelligent learning rate optimization (starts at 0.001, reduces when plateauing)
  • 20% validation split for monitoring
  • Stops after 50 epochs without improvement
  • 50+ technical indicators automatically generated

Make Predictions

vanga predict --symbol BTCUSDT --input data/recent_btc.csv

Configuration Templates

  • Beginner: configs/quick_start.toml - Minimal setup with AdamW optimizer
  • Standard: configs/training.toml - Production single-asset with advanced LR optimization
  • Advanced: configs/cross_asset_training.toml - Multi-asset with correlations and warmup
  • Reference: configs/example_single_asset.toml - Complete parameter guide

Getting Started

NEW: Optimizer Documentation

Technical Reference

Usage Guides

Final Implementation

Quick Reference

🎯 Architecture Overview

Core Design Principles

  • Modular LSTM Architecture: Complete modular structure in src/model/lstm/ with focused modules:
    • config.rs - LSTMConfig, OptimizerWrapper (11 optimizers), TargetFormat
    • core.rs - Model lifecycle, initialization, persistence, Xavier initialization
    • training.rs - Unified training method with ordinal loss and adaptive calibration
    • inference.rs - Prediction pipeline and forward pass
    • loss.rs - Trading-aware ordinal loss, validation metrics, gradient utilities
    • seeded_weights.rs - Reproducible weight initialization with orthogonal recurrent weights

Trading-Aware Training System

  • Ordinal Loss System: 5-class ordinal classification optimized for trading profitability
  • 11 Advanced Optimizers: AdamW, FracAdam, FracNAdam, RMSprop, NAdam, RAdam, Adam, AdaMax, AdaDelta, SGD, AdaGrad
  • Advanced Features:
    • Trading-aware ordinal loss with directional penalties
    • Adaptive target calibration with diversity metrics
    • Orthogonal weight initialization for recurrent layers
    • Variational and recurrent dropout support
    • Centralized training diagnostics and monitoring
    • Gradient clipping with intelligent norm calculation
    • Deterministic shuffling for reproducible training
    • Perfect balance validation for target consistency

Multi-Target Architecture

  • Symbol-Agnostic Design: Each trading pair gets its own specialized multi-target LSTM model
  • 5-Target Prediction System: Price levels, direction, volatility, volume, sentiment (5 classes each)
  • Adaptive Calibration: Dynamic parameter optimization for balanced 20% per class distribution
  • Individual Model Architecture: Separate LSTM model per target×horizon combination
  • Sequence-Based Processing: Each sequence normalized independently for symbol-agnostic operation

Advanced Features

  • Backward Compatibility: All existing APIs preserved through lstm_simple.rs compatibility layer
  • Hybrid Models: SmartCore backend integration, XGBoost support, and TFT (Temporal Fusion Transformer)
  • Enhanced Attention: Mixture-of-Head attention module with comprehensive dropout configurations
  • Real-time Streaming: Live prediction capabilities with streaming data support
  • Testing Architecture: All tests in separate *_test.rs files with comprehensive coverage

Required Data Format

Minimum Required Columns (OHLCV):

  • timestamp (ISO format or Unix timestamp)
  • open, high, low, close (OHLC prices)
  • volume (trading volume)

Optional Columns:

  • volume_quote (quote asset volume)
  • trades_count (number of trades)
  • buy_volume (buyer volume)
  • buy_volume_quote (buyer quote volume)
  • Any additional custom features (automatically included)

Auto-Generated Features

Technical Indicators (TA Crate Integration):

  • Moving Averages: SMA, EMA, WMA, DEMA, TEMA (multiple periods)
  • Momentum: RSI, MACD, Stochastic, Williams %R, CCI, ROC, MOM
  • Volatility: Bollinger Bands, ATR, Keltner Channels, Standard Deviation
  • Volume: OBV, Volume SMA, MFI, A/D Line, VWAP, Volume Rate of Change
  • Trend: ADX, Aroon, Parabolic SAR, Supertrend, Ichimoku components
  • Oscillators: Ultimate Oscillator, Commodity Channel Index, Detrended Price

Crypto-Specific Features:

  • Price velocity and acceleration
  • Volume-weighted average price (VWAP) deviations
  • Market microstructure indicators
  • Realized volatility (1h, 4h, 24h)
  • Regime detection indicators
  • Fractal dimension analysis

🚀 Quick Start

🚀 Training Examples

Single-Asset Training

# Quick start with minimal configuration
vanga train --symbol BTCUSDT --data ./data/btc_ohlcv.csv --config configs/quick_start.toml

# Standard production training
vanga train --symbol ETHUSDT --data ./data/eth_data.csv --config configs/training.toml

# Custom features training
vanga train --symbol BTCUSDT --data ./data/btc_data.csv --config configs/advanced_custom.toml

# Fresh training (ignore existing model)
vanga train --symbol BTCUSDT --data ./data/btc_data.csv --config configs/training.toml --fresh

# Continue training existing model with new data
vanga train --symbol BTCUSDT --data ./data/new_btc_data.csv --config configs/training.toml --continue

Cross-Asset Training

# Multi-asset training with correlation analysis
vanga train --symbol BTCUSDT,ETHUSDT,ADAUSDT --data ./data/ --config configs/cross_asset_training.toml

# Large portfolio training
vanga train --symbol BTCUSDT,ETHUSDT,ADAUSDT,DOTUSDT,LINKUSDT --data ./data/ --config configs/cross_asset_training.toml

# Cross-asset with custom configuration
vanga train --symbol BTCUSDT,ETHUSDT --data ./data/ --config configs/example_cross_asset.toml

Making Predictions

# Single prediction
vanga predict --symbol BTCUSDT --input ./data/recent_btc.csv --horizon 4h

# Multi-horizon prediction
vanga predict --symbol BTCUSDT --input ./data/recent_btc.csv --all-horizons

# Batch prediction
vanga predict --batch --input-dir ./data/current/ --output ./predictions/

# With confidence filtering
vanga predict --symbol BTCUSDT --input ./data/recent_btc.csv --min-confidence 0.8

Model Management

# List available models
vanga models list

# Evaluate model performance
vanga models evaluate --symbol BTCUSDT --test-data ./data/btc_test.csv

# Evaluate with backtesting
vanga models evaluate --symbol BTCUSDT --test-data ./data/btc_test.csv --backtest --train-split 0.8

# Compare multiple models
vanga models compare --symbols BTCUSDT,ETHUSDT --metric accuracy

# Export model for deployment
vanga models export --symbol BTCUSDT --format msgpack --output ./models/

# Create model ensemble
vanga models ensemble --symbols BTCUSDT,ETHUSDT,ADAUSDT --strategies weighted,voting --output crypto_ensemble

📊 Output Formats

Price Level Predictions

{
  "symbol": "BTCUSDT",
  "timestamp": "2024-01-15T10:30:00Z",
  "horizon": "4h",
  "current_price": 42500.0,
  "price_levels": {
    "bin_1": {"range": "< -5%", "probability": 0.05},
    "bin_2": {"range": "-5% to -3%", "probability": 0.10},
    "bin_3": {"range": "-3% to -1%", "probability": 0.15},
    "bin_4": {"range": "-1% to 1%", "probability": 0.25},
    "bin_5": {"range": "1% to 3%", "probability": 0.20},
    "bin_6": {"range": "3% to 5%", "probability": 0.15},
    "bin_7": {"range": "> 5%", "probability": 0.10}
  },
  "most_likely_range": "1% to 3%",
  "confidence": 0.82
}

5-Target Prediction System

{
  "symbol": "BTCUSDT",
  "timestamp": "2024-01-15T10:30:00Z",
  "horizon": "4h",
  "current_price": 42500.0,
  "price_levels": {
    "class_0": {"range": "Strong Down", "probability": 0.05},
    "class_1": {"range": "Moderate Down", "probability": 0.15},
    "class_2": {"range": "Neutral", "probability": 0.35},
    "class_3": {"range": "Moderate Up", "probability": 0.30},
    "class_4": {"range": "Strong Up", "probability": 0.15}
  },
  "direction": {
    "up_probability": 0.68,
    "down_probability": 0.32,
    "prediction": "UP",
    "confidence": 0.68
  },
  "volatility": {
    "class": "Medium",
    "atr_ratio": 1.25,
    "expected_change": 0.035,
    "regime": "moderate_volatility"
  },
  "sentiment": {
    "score": 0.72,
    "class": "Moderate Greed",
    "body_ratio": 0.65,
    "volume_confirmation": 0.84,
    "consistency": 0.78
  },
  "volume": {
    "class": "High",
    "log_ratio": 0.372,
    "regime": "volume_surge",
    "classification": "above_average"
  }
}

⚙️ Configuration

VANGA uses a single-config system where all parameters (training, model, features) are defined in one TOML file for maximum simplicity and consistency.

Quick Start Configurations

# Beginner: Minimal but effective setup
vanga train --symbol BTCUSDT --data data.csv --config configs/quick_start.toml

# Standard: Production-ready single-asset training
vanga train --symbol BTCUSDT --data data.csv --config configs/training.toml

# Advanced: Cross-asset training with correlation analysis
vanga train --symbol BTCUSDT,ETHUSDT,ADAUSDT --data data/ --config configs/cross_asset_training.toml

Configuration Templates

  • configs/example_single_asset.toml - Complete parameter reference with detailed explanations
  • configs/example_cross_asset.toml - Cross-asset training with correlation features
  • configs/quick_start.toml - Minimal configuration for beginners
  • configs/training.toml - Production-ready single-asset defaults
  • configs/cross_asset_training.toml - Production-ready cross-asset defaults

Key Configuration Sections

[training]
epochs = { Auto = { max_epochs = 1000 } }    # Intelligent early stopping
learning_rate = 0.001                        # Base learning rate
batch_size = { Auto = { min_size = 32, max_size = 512 } }  # Auto batch sizing
optimizer = { AdamW = { weight_decay = 0.01, beta1 = 0.9, beta2 = 0.999, eps = 1e-8 } }
validation_split = 0.2                       # 20% validation split
validation_gap = "1h"                        # Gap to prevent data leakage
early_stopping = { patience = 50, min_delta = 0.0001 }  # Early stopping config
gradient_clip = 1.0                          # Gradient clipping threshold
class_weight_strategy = "Global"             # Class weighting strategy
window_decay = 1.0                           # Learning rate decay per window
min_train_ratio = 0.4                        # Minimum training data ratio
min_increment_ratio = 0.3                    # Minimum increment ratio
seed = 42                                    # Reproducible training seed

[model]
architecture = { MultiLSTM = { layers = 2 } }  # Model architecture
sequence_length = { Auto = { min_length = 30, max_length = 120 } }  # Auto sequence length
hidden_units = { Auto = { min_units = 64, max_units = 512 } }  # Auto hidden units
dropout = { enabled = true, rate = { Fixed = 0.2 } }  # Dropout configuration
attention = { enabled = true, mechanism = "MultiHeadAttention", heads = 8 }  # Attention config

[features.technical_indicators]
enabled = true                                # Enable technical indicators
[features.technical_indicators.moving_averages]
sma_periods = [5, 10, 20, 50, 200]          # Simple moving averages
ema_periods = [5, 10, 20, 50, 200]          # Exponential moving averages

[features.cross_asset]                        # For multi-asset training only
enabled = true                                # Enable cross-asset features
required_symbols = ["BTCUSDT"]               # Require BTC for market analysis

Parameter Tuning Guidelines

For detailed parameter explanations and tuning guidance, see:

  • Single-asset: configs/example_single_asset.toml (comprehensive parameter reference)
  • Cross-asset: configs/example_cross_asset.toml (multi-asset specific guidance)

Quick tuning tips:

  • Small datasets (< 1K samples): Use configs/quick_start.toml
  • Large datasets (> 10K samples): Use configs/training.toml with optimization enabled
  • Multiple assets: Use configs/cross_asset_training.toml
  • Custom features: Start with configs/minimal_custom.toml, expand to configs/advanced_custom.toml

🏗️ Project Structure

vanga/
├── src/
│   ├── api/           # High-level training/prediction APIs
│   │   ├── trainer.rs     # Training pipeline orchestration
│   │   ├── predictor.rs   # Prediction pipeline orchestration
│   │   └── backtester.rs  # Backtesting framework
│   ├── model/         # LSTM implementations and neural networks
│   │   ├── lstm/          # Modular LSTM implementation (CORE ARCHITECTURE)
│   │   │   ├── config.rs      # LSTMConfig, OptimizerWrapper, TargetFormat
│   │   │   ├── core.rs        # Model lifecycle and initialization
│   │   │   ├── training.rs    # Unified training method (MAIN LOGIC)
│   │   │   ├── inference.rs   # Prediction and forward pass
│   │   │   ├── loss.rs        # Loss calculation with tensor broadcasting
│   │   │   ├── manual_lstm.rs # Manual LSTM cell implementation
│   │   │   ├── window_aware_lr.rs # Window-aware learning rate scheduling
│   │   │   ├── seeded_weights.rs # Reproducible weight initialization
│   │   │   ├── schedule_benchmark.rs # Learning rate schedule benchmarking
│   │   │   ├── schedule_validation.rs # Schedule validation utilities
│   │   │   ├── balance_validation_test.rs # Balance validation tests
│   │   │   ├── hidden_state_test.rs # Hidden state tests
│   │   │   ├── inference_test.rs # Inference tests
│   │   │   ├── loss_test.rs   # Loss function tests
│   │   │   ├── schedule_test.rs # Schedule tests
│   │   │   └── mod.rs         # Public API and re-exports
│   │   ├── lstm_simple.rs # Compatibility layer: `pub use crate::model::lstm::*;`
│   │   ├── multi_target.rs # Multi-target wrapper (separate models per target×horizon)
│   │   ├── attention.rs   # Multi-head attention mechanisms
│   │   ├── attention_moh.rs # Mixture-of-Head attention module
│   │   ├── attention_moh_wrapper.rs # MoH integration wrapper
│   │   ├── attention_optimizer.rs # Optimized attention implementations
│   │   ├── attention_loss.rs # Attention-specific loss functions
│   │   ├── attention_viz.rs # Attention visualization utilities
│   │   ├── tft.rs         # Temporal Fusion Transformer integration
│   │   ├── xgboost.rs     # XGBoost hybrid models
│   │   └── smartcore_backend.rs # SmartCore ML backend integration
│   ├── features/      # Feature engineering
│   │   ├── technical.rs   # 50+ technical indicators implementation
│   │   ├── cross_asset.rs # Cross-asset correlation features
│   │   └── engineering.rs # Feature engineering pipeline
│   ├── data/          # Data loading and preprocessing
│   │   ├── loader.rs      # CSV loading and validation
│   │   ├── preprocessor.rs # Feature normalization and scaling
│   │   ├── sequence.rs    # Sequence generation for LSTM
│   │   ├── schema.rs      # Data schema definitions
│   │   ├── structures.rs  # Core data structures
│   │   ├── balance.rs     # Data balancing and sampling
│   │   ├── diversity.rs   # Data diversity analysis
│   │   └── target_converter.rs # Target conversion utilities
│   ├── targets/       # Multi-target generation with adaptive parameters
│   │   ├── mod.rs         # Target orchestration and conversion
│   │   ├── price_levels.rs # VWAP-weighted 5-class price level system
│   │   ├── direction.rs   # Directional movement classification (5-class)
│   │   ├── volatility.rs  # Volatility regime classification (5-class)
│   │   ├── volume.rs      # Volume analysis targets (NEW)
│   │   ├── sentiment.rs   # Market sentiment targets (NEW)
│   │   ├── adaptive_parameters.rs # Adaptive parameter calibration (NEW)
│   │   ├── calibration.rs # Unified calibration system (NEW)
│   │   ├── generators.rs  # Target generation engines (NEW)
│   │   ├── interface.rs   # Unified target interface (NEW)
│   │   ├── registry.rs    # Target type registry (NEW)
│   │   └── sequence_reconstruction.rs # Sequence reconstruction targets
│   ├── config/        # Configuration management
│   │   ├── training.rs    # TrainingConfig with 11 optimizers (including FracAdam/FracNAdam)
│   │   ├── features.rs    # Feature configurations
│   │   ├── model.rs       # Model architecture configurations
│   │   ├── prediction.rs  # Prediction configurations
│   │   └── trading.rs     # Trading configurations
│   ├── optimization/  # Advanced optimizers and auto-optimization
│   │   ├── mod.rs         # Optimization orchestration
│   │   ├── frac_adam.rs   # Fractional Adam optimizer (NEW)
│   │   ├── frac_nadam.rs  # Fractional NAdam optimizer (NEW)
│   │   ├── fractional.rs  # Fractional derivative computation (NEW)
│   │   ├── feature_selection.rs # Feature selection algorithms
│   │   ├── hyperparameter.rs # Hyperparameter optimization
│   │   ├── objective.rs   # Optimization objectives
│   │   └── optimizer_selector.rs # Intelligent optimizer selection
│   ├── output/        # Output formatting and parsing
│   │   ├── mod.rs         # Output orchestration
│   │   ├── formatter.rs   # Prediction output formatting
│   │   ├── multi_target_parser.rs # Multi-target output parsing
│   │   ├── structures.rs  # Prediction result types
│   │   ├── metadata.rs    # Prediction metadata
│   │   ├── post_processor.rs # Post-processing utilities
│   │   └── trading_orders.rs # Trading order generation
│   ├── realtime/      # Real-time streaming prediction
│   │   ├── mod.rs         # Real-time orchestration
│   │   ├── predictor.rs   # Real-time prediction engine
│   │   ├── stream.rs      # Data streaming utilities
│   │   └── watcher.rs     # Market data watcher
│   ├── tests/         # Integration tests
│   └── utils/         # Utilities and error handling
│       ├── error.rs       # VangaError types and handling
│       ├── metrics.rs     # Evaluation metrics
│       ├── diagnostics.rs # Training diagnostics
│       ├── device.rs      # Device management (CPU/GPU/Metal)
│       ├── model_path.rs  # Model path utilities
│       ├── sequence_utils.rs # Sequence generation utilities
│       ├── file_discovery.rs # File discovery and resolution
│       ├── parser.rs      # Output parsing utilities
│       ├── market_data.rs # Market data utilities
│       ├── feature_window.rs # Feature window utilities
│       └── backtest_reporter.rs # Backtesting reporting
├── models/            # Trained model storage
├── data/              # Input data directory
├── configs/           # Configuration files (TOML templates)
│   └── optimizer_examples/ # 9 optimizer-specific configurations
├── scripts/           # Python automation scripts
├── examples/          # Usage examples and guides
└── doc/               # Comprehensive documentation (30+ guides)

🔧 Dependencies

Core ML & Neural Networks

  • candle-core: Modern Rust ML framework (GPU/Metal support)
  • candle-nn: Neural network layers and optimizers
  • candle-optimisers: 9 modern optimizers (AdamW, RMSprop, NAdam, etc.)
  • ndarray: Numerical computing and tensor operations
  • linfa: Machine learning toolkit

Data Processing & Analysis

  • polars: High-performance data processing
  • csv: CSV file handling
  • ta: Technical analysis indicators (50+ indicators)
  • statrs: Statistical functions and distributions

Configuration & CLI

  • clap: Command-line interface
  • toml: Configuration file parsing
  • serde: Serialization framework

Async & Utilities

  • tokio: Async runtime
  • anyhow: Error handling
  • chrono: Date/time processing

📈 Key Features

Automatic Optimization

  • Bayesian Hyperparameter Optimization: Finds optimal model parameters
  • Adaptive Learning Rates: Automatically adjusts during training
  • Early Stopping: Prevents overfitting
  • Auto Feature Selection: Removes redundant features

Crypto-Specific Design

  • Market Regime Detection: Adapts to trending vs ranging markets
  • Volatility Clustering: Accounts for crypto volatility patterns
  • Multi-Timeframe Analysis: 1h, 4h, 1d, 7d predictions
  • Risk-Adjusted Metrics: Sharpe ratio, max drawdown optimization

Production Ready

  • Model Persistence: Save/load trained models

  • Batch Processing: Handle multiple symbols

  • Error Handling: Robust error management

  • Logging: Comprehensive logging system

  • Production Ready: Robust error management and comprehensive logging

🤝 Support & Community

⚖️ License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Built with ❤️ by the Muvon team in Hong Kong

About

LSTM-based framework to train model and predict price movement

vanga.muvon.io

Topics

crypto bitcoin ethereum cryptocurrency trading-algorithms technical-analysis price-prediction scalping

Resources

Readme

License

Apache-2.0 license
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

1 fork
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages