foxhunt/crates/ml-alpha/examples/phase1a.rs

//! Phase 1a entry-point binary.
//!
//! Loads local fxcache, runs purged walk-forward split, trains a 2-layer MLP
//! on binary direction labels, evaluates validation accuracy, prints the gate
//! verdict.
//!
//! ## Usage
//!
//! Defaults to the local Phase 1a test fxcache:
//! ```
//! cargo run -p ml-alpha --example phase1a --release
//! ```
//!
//! Override config via CLI:
//! ```
//! cargo run -p ml-alpha --example phase1a --release -- \
//!   --fxcache-path /path/to/file.fxcache \
//!   --horizon 60 \
//!   --epochs 5
//! ```
//!
//! Or via TOML config:
//! ```
//! cargo run -p ml-alpha --example phase1a --release -- --config config/foxhuntq-phase1a.toml
//! ```

use std::sync::Arc;

use anyhow::Result;
use clap::Parser;
use cudarc::driver::CudaContext;
use tracing_subscriber::EnvFilter;

use ml_alpha::training::{Phase1aConfig, Phase1aTrainer};

#[derive(Debug, Parser)]
#[command(name = "phase1a", about = "FoxhuntQ-Δ Phase 1a falsification smoke")]
struct Cli {
    /// Override fxcache path. Defaults to local test_data fxcache.
    #[arg(long)]
    fxcache_path: Option<String>,

    /// Number of training epochs.
    #[arg(long, default_value_t = 5)]
    epochs: usize,

    /// Batch size for training.
    #[arg(long, default_value_t = 1024)]
    batch_size: usize,

    /// Adam learning rate.
    #[arg(long, default_value_t = 1e-3)]
    learning_rate: f32,

    /// Label horizon in bars (`sign(price[t+H] − price[t])`).
    #[arg(long, default_value_t = 60)]
    horizon: usize,

    /// Train fraction for the purged walk-forward split.
    #[arg(long, default_value_t = 0.8)]
    train_frac: f32,

    /// Additional embargo bars beyond `horizon` (Lopez de Prado embargo).
    #[arg(long, default_value_t = 0)]
    embargo_bars: usize,

    /// Hidden dim of the 2-layer MLP.
    #[arg(long, default_value_t = 256)]
    hidden_dim: usize,

    /// Deterministic RNG seed.
    #[arg(long, default_value_t = 42)]
    seed: u64,

    /// Path to a TOML config file (overrides individual flags).
    #[arg(long)]
    config: Option<String>,
}

fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")))
        .init();

    let cli = Cli::parse();

    if cli.config.is_some() {
        // TOML config support deferred to step 3; skeleton uses CLI defaults only.
        anyhow::bail!("--config (TOML) not yet supported; use CLI flags");
    }
    let mut config = Phase1aConfig::default();

    // Apply CLI overrides over the loaded / default config.
    if let Some(p) = cli.fxcache_path { config.fxcache_path = p; }
    config.epochs = cli.epochs;
    config.batch_size = cli.batch_size;
    config.learning_rate = cli.learning_rate;
    config.horizon = cli.horizon;
    config.train_frac = cli.train_frac;
    config.embargo_bars = cli.embargo_bars;
    config.mlp.hidden_dim = cli.hidden_dim;
    config.seed = cli.seed;

    tracing::info!(?config, "Phase 1a config resolved");

    // Initialize CUDA context + stream. RTX 3050 Ti on local; H100/L40S on
    // Argo (compute-cap auto-derived by the workflow).
    let ctx = CudaContext::new(0)
        .map_err(|e| anyhow::anyhow!("CUDA context init: {e}"))?;
    let stream = ctx.new_stream()
        .map_err(|e| anyhow::anyhow!("CUDA stream init: {e}"))?;
    let stream = Arc::new(stream);

    let mut trainer = Phase1aTrainer::from_config(config, Arc::clone(&stream))?;
    let report = trainer.run()?;

    tracing::info!(
        accuracy = report.accuracy,
        auc = report.auc,
        n_samples = report.n_samples,
        up_fraction = report.up_fraction,
        tied_fraction = report.tied_fraction,
        "Phase 1a evaluation complete"
    );
    println!();
    println!("{}", report.verdict_line());

    Ok(())
}