foxhunt/ml/src/common/mod.rs

//! Common types and utilities for ML models

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;
use std::time::SystemTime;
use uuid::Uuid;

pub use trading_engine::types::prelude::*;

pub mod config;
pub mod metrics;
pub mod performance;

pub use config::*;
pub use performance::*;

// Production ML types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelVersion {
    pub version: String,
    pub model_id: Uuid,
    pub created_at: SystemTime,
    pub commit_hash: String,
    pub model_type: String,
    pub performance_metrics: PerformanceMetrics,
    pub quantization_config: Option<QuantizationConfig>,
    pub onnx_config: Option<ONNXExportConfig>,
    pub artifacts: ModelArtifacts,
    pub validation_results: ValidationResults,
    pub tags: Vec<String>,
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetrics {
    pub avg_latency_us: f64,
    pub p99_latency_us: f64,
    pub throughput_ips: f64,
    pub memory_usage_mb: f64,
    pub accuracy: f64,
    pub energy_consumption_mj: Option<f64>,
    pub hardware_metrics: HardwareMetrics,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HardwareMetrics {
    pub cpu_utilization: f64,
    pub gpu_utilization: Option<f64>,
    pub memory_bandwidth: f64,
    pub cache_metrics: HashMap<String, f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelArtifacts {
    pub pytorch_model: PathBuf,
    pub onnx_model: Option<PathBuf>,
    pub quantized_model: Option<PathBuf>,
    pub tensorrt_engine: Option<PathBuf>,
    pub optimization_logs: Option<PathBuf>,
    pub calibration_data: Option<PathBuf>,
    pub config_file: PathBuf,
    pub benchmark_results: Option<PathBuf>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationResults {
    pub test_accuracy: f64,
    pub business_metrics: HashMap<String, f64>,
    pub latency_distribution: LatencyDistribution,
    pub stress_test_passed: bool,
    pub ab_test_results: Option<ABTestResults>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LatencyDistribution {
    pub min_us: f64,
    pub max_us: f64,
    pub mean_us: f64,
    pub median_us: f64,
    pub p95_us: f64,
    pub p99_us: f64,
    pub p999_us: f64,
    pub std_dev_us: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ABTestResults {
    pub control_accuracy: f64,
    pub treatment_accuracy: f64,
    pub statistical_significance: f64,
    pub confidence_interval: (f64, f64),
    pub sample_size: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantizationConfig {
    pub precision: String, // "int8", "int4", "fp16"
    pub calibration_samples: usize,
    pub accuracy_threshold: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ONNXExportConfig {
    pub opset_version: i64,
    pub optimization_level: String,
    pub enable_tensorrt: bool,
    pub dynamic_axes: HashMap<String, Vec<i64>>,
}

// Direct use of canonical types - no compatibility wrappers

/// `Market` data structure compatible with ML models
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// MarketData component.
pub struct MarketData {
    pub asset_id: Symbol,
    pub price: Price,
    pub volume: Volume,
    pub bid: Price,
    pub ask: Price,
    pub bid_size: Volume,
    pub ask_size: Volume,
    pub timestamp: u64, // Unix timestamp in nanoseconds
}

// Precision factor compatible with canonical Price type (8 decimal places)
/// `PRECISION_FACTOR`: component.
pub const PRECISION_FACTOR: i64 = 100_000_000; // 10^8

/// Conversion utilities for interfacing with different precision systems
pub mod conversions {
    use super::*;

    /// Convert canonical Price to liquid submodule FixedPoint (8-decimal to 6-decimal precision)
    pub fn price_to_liquid_fixed_point(price: Price) -> crate::liquid::FixedPoint {
        let liquid_precision = 1_000_000_i64; // 6 decimal places
        let canonical_precision = 100_000_000_i64; // 8 decimal places

        // Scale down from 8-decimal to 6-decimal precision
        let scaled_value = price.raw_value() as i64 / (canonical_precision / liquid_precision);
        crate::liquid::FixedPoint(scaled_value)
    }

    /// Convert liquid submodule FixedPoint to canonical Price (6-decimal to 8-decimal precision)
    pub fn liquid_fixed_point_to_price(fixed_point: crate::liquid::FixedPoint) -> Price {
        let liquid_precision = 1_000_000_i64; // 6 decimal places
        let canonical_precision = 100_000_000_i64; // 8 decimal places

        // Scale up from 6-decimal to 8-decimal precision
        let scaled_value = fixed_point.0 * (canonical_precision / liquid_precision);
        Price::from_raw(scaled_value as u64)
    }

    /// Convert `f64` to canonical Price with full 8-decimal precision
    pub fn f64_to_price(value: f64) -> Result<Price, Box<dyn std::error::Error>> {
        // error_handling::TradingError replaced
        Ok(Price::from_f64(value)?)
    }

    /// Convert canonical Price to `f64` for ML model inputs
    pub fn price_to_f64(price: Price) -> f64 {
        price.to_f64()
    }
}