Skip to content

README.md

Latest commit

 

History

History
270 lines (215 loc) · 8.65 KB

README.md

File metadata and controls

270 lines (215 loc) · 8.65 KB
Raw

Q24 Quantitative Trading System

A production-grade quantitative trading platform for the Quantiacs Q24 competition. This system provides a comprehensive ecosystem for developing, backtesting, analyzing, and managing algorithmic trading strategies across equities and cryptocurrencies.

Features

  • Multi-Strategy Portfolio Management - Run and compare 11+ strategies with individual isolation
  • Advanced Factor Library - 32+ factors across 12 categories (momentum, value, quality, etc.)
  • Professional Dashboard - 20+ analytical pages with real-time performance monitoring
  • Risk Analytics - Comprehensive risk attribution, Brinson analysis, and ex-ante risk forecasting
  • What-If Analysis - Scenario exploration with parameter surfaces
  • Smart Data Caching - TTL-based caching to optimize API usage
  • Regime Detection - Market regime classification with regime-aware metrics

Tech Stack

  • Python 3.7+
  • Streamlit - Interactive web dashboard
  • xarray - N-dimensional array computing
  • pandas / numpy - Data manipulation and numerical computing
  • Quantiacs API (qnt) - Market data access and backtesting
  • Plotly / Matplotlib - Visualization
  • scikit-learn / scipy - Machine learning and scientific computing

Project Structure

Q24_QUANT_SYSTEM/
├── src/Q24/
│   ├── strategies/           # Strategy implementations
│   │   ├── base.py           # Abstract base class
│   │   ├── registry.py       # Strategy discovery & registry
│   │   ├── ou_v1/            # Ornstein-Uhlenbeck mean-reversion
│   │   ├── glft_v1/          # Global Long-Short Tactical
│   │   ├── gtp51max/         # Optimized for max Sharpe
│   │   ├── q24_crypto_v*/    # Neural Crypto Alpha variants
│   │   └── benchmarks/       # Benchmark implementations
│   │
│   ├── strategy/             # Core strategy engine
│   │   ├── engine.py         # Execution orchestrator
│   │   ├── data_loader.py    # Market data with caching
│   │   ├── factors.py        # Factor library (32+ factors)
│   │   ├── portfolio.py      # Portfolio construction
│   │   ├── ic_weighting.py   # Information coefficient weighting
│   │   └── risk_overlays.py  # Risk management
│   │
│   ├── dashboard/            # Streamlit dashboard
│   │   ├── app.py            # Main entry point
│   │   ├── _pages/           # 20+ dashboard pages
│   │   ├── components/       # Reusable UI components
│   │   └── analytics/        # Analytics modules
│   │
│   └── shared/               # Shared utilities
│
├── outputs/                  # Strategy output directories
├── data-cache/               # Smart data caching
├── run_strategy.py           # Strategy execution entry point
├── run_dashboard.py          # Dashboard launcher
├── Run_Q24.command           # macOS combined runner
└── .env                      # Configuration

Getting Started

Prerequisites

  • Python 3.7+
  • Quantiacs API key (obtain from Quantiacs)
  • Conda (recommended) or pip

Installation

  1. Clone the repository:

    git clone <repository-url>
cd Q24_QUANT_SYSTEM

  2. Create and activate environment:

    conda create -n q24 python=3.10
conda activate q24

  3. Install dependencies:

    pip install streamlit pandas numpy xarray plotly matplotlib scikit-learn scipy
pip install qnt  # Quantiacs toolbox

  4. Configure environment variables in .env:

    API_KEY=your-quantiacs-api-key
Q24_TAG=2025-12-22          # Optional: tag for outputs
Q24_FORCE_RERUN=false       # Force re-run regardless of freshness
Q24_AUTO_RUN_BENCHMARKS=true

Usage

Running Strategies

Execute all enabled strategies:

python run_strategy.py

This will:

  • Load enabled strategies from enabled_strategies.json
  • Skip strategies already run today (unless Q24_FORCE_RERUN=true)
  • Execute each strategy and save results to outputs/<strategy_id>/
  • Auto-run benchmark strategies after regular strategies

Launching Dashboard

Start the interactive portfolio management dashboard:

python run_dashboard.py

The dashboard provides:

  • Overview - KPI dashboard with performance charts
  • Performance - Sharpe, Sortino, Calmar, drawdown metrics
  • Weights - Portfolio composition over time
  • Factors - Factor IC analysis and contribution
  • Attribution - Factor and stock attribution
  • Risk Analytics - Risk decomposition and ex-ante forecasting
  • Elite Analytics - Regime, tail risk, convexity analysis
  • Strategy Comparison - Multi-strategy performance comparison
  • What-If Analysis - Scenario exploration

Combined Runner (macOS)

./Run_Q24.command

Runs diagnostics, executes strategies, and launches the dashboard.

Strategy Framework

Creating a New Strategy

  1. Create a new directory in src/Q24/strategies/:

    src/Q24/strategies/my_strategy/
├── __init__.py
├── config.py      # Strategy configuration
├── engine.py      # Strategy implementation
└── factors.py     # Custom factors (optional)

  2. Implement the strategy by inheriting from StrategyBase:

    from src.Q24.strategies.base import StrategyBase, StrategyConfig
from src.Q24.strategies.registry import StrategyRegistry

@StrategyRegistry.register
class MyStrategy(StrategyBase):
    @classmethod
    def get_id(cls) -> str:
        return "my_strategy"

    @classmethod
    def get_display_name(cls) -> str:
        return "My Custom Strategy"

    def run(self):
        # Strategy implementation
        pass

  3. Enable the strategy in enabled_strategies.json:

    {
  "enabled": {
    "my_strategy": true
  }
}

Available Strategies

Strategy Type Description
ou_v1 Mean-Reversion Ornstein-Uhlenbeck process with 24 factors
glft_v1 Tactical Global Long-Short Tactical
gtp51max Optimized Maximum Sharpe optimization
q24_crypto_v5 Crypto Neural Crypto Alpha (28 factors)
q24_crypto_v10x Crypto Neural Crypto Alpha (12 factors)
q24_crypto_v11x Crypto Neural Crypto Alpha (10 curated factors)
q23_composer_v1 Ensemble 32-factor ensemble strategy
benchmarks/* Benchmark Equal-weight and market-cap benchmarks

Configuration

Environment Variables

Variable Description Default
API_KEY Quantiacs API key Required
Q24_TAG Tag for output directories Current date
Q24_FORCE_RERUN Force re-run all strategies false
Q24_AUTO_RUN_BENCHMARKS Auto-run benchmarks after strategies true
Q24_SKIP_BENCHMARKS Skip benchmark execution false
Q24_DEBUG_RUNS Enable debug mode false

Strategy Configuration

Configure which strategies to run in src/Q24/strategies/enabled_strategies.json:

{
  "enabled": {
    "ou_v1": true,
    "glft_v1": false,
    "benchmark_nas_ew": true
  }
}

Dashboard Pages

Core Analytics

  • Overview - KPI dashboard with portfolio snapshot
  • Performance - Comprehensive performance metrics
  • Weights - Long/short portfolio composition
  • Factors - Factor IC analysis
  • Attribution - Factor/stock attribution

Elite Analytics

  • Regime Analysis - Market regime detection
  • Tail Risk - CVaR clustering and extreme risk
  • Convexity - Gain decomposition analysis
  • Alpha Decay - Signal freshness estimation
  • Capacity - Portfolio scalability analysis

Risk Analytics

  • Risk Attribution - Factor risk contribution
  • Brinson Attribution - Active return decomposition
  • Ex-Ante Risk - Forward risk projection
  • Correlation Analysis - Rolling correlations

Management

  • Strategy Warehouse - Enable/disable strategies
  • Strategy Comparison - Multi-strategy comparison
  • What-If Analysis - Scenario exploration
  • Diagnostics - System health monitoring

Output Structure

Strategy results are saved to outputs/<strategy_id>/:

outputs/ou_v1/
├── _wide_weights_2025-12-22.csv    # Portfolio weights
├── _ic_2025-12-22.csv              # Information coefficients
├── _factor_weights_2025-12-22.csv  # Factor contributions
└── diagnostics.json                # Performance metrics

License

Proprietary - All rights reserved.

Support

For issues and feature requests, please open an issue in the repository.