diff --git a/Dockerfile b/Dockerfile index 7de4c01..0716f20 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,17 +1,31 @@ # ORPflow HFT Paper Trading - Multi-stage Dockerfile # OCaml + Rust (Jane Street Style - No Python in Hot Path) # Single unified Rust binary handles market data + strategy + API +# WITH ONNX Runtime for ML inference in hot path # ============================================================================ -# Stage 1: Rust Builder +# Stage 1: Rust Builder with ONNX Runtime # ============================================================================ FROM rust:1.83-slim-bookworm AS rust-builder +# Install build dependencies + ONNX Runtime RUN apt-get update && apt-get install -y \ pkg-config \ libssl-dev \ + curl \ + ca-certificates \ && rm -rf /var/lib/apt/lists/* +# Download and install ONNX Runtime for building +ENV ORT_VERSION=1.19.2 +RUN curl -L https://github.com/microsoft/onnxruntime/releases/download/v${ORT_VERSION}/onnxruntime-linux-x64-${ORT_VERSION}.tgz \ + -o /tmp/onnxruntime.tgz \ + && tar -xzf /tmp/onnxruntime.tgz -C /opt \ + && rm /tmp/onnxruntime.tgz + +ENV ORT_LIB_LOCATION=/opt/onnxruntime-linux-x64-${ORT_VERSION} +ENV LD_LIBRARY_PATH=/opt/onnxruntime-linux-x64-${ORT_VERSION}/lib:$LD_LIBRARY_PATH + WORKDIR /app/market-data # Copy Cargo.toml only (Cargo.lock generated during build) @@ -23,8 +37,11 @@ COPY market-data/src ./src # Copy benchmarks (required by Cargo.toml) COPY market-data/benches ./benches -# Build release binary (generates Cargo.lock automatically) -RUN cargo build --release +# Copy tests for ONNX parity +COPY market-data/tests ./tests + +# Build release binary WITH ML feature (ONNX support) +RUN cargo build --release --features ml # ============================================================================ # Stage 2: OCaml Builder @@ -74,6 +91,10 @@ RUN apt-get update && apt-get install -y \ supervisor \ && rm -rf /var/lib/apt/lists/* +# Copy ONNX Runtime libraries for inference +COPY --from=rust-builder /opt/onnxruntime-linux-x64-1.19.2/lib /opt/onnxruntime/lib +ENV LD_LIBRARY_PATH=/opt/onnxruntime/lib:$LD_LIBRARY_PATH + WORKDIR /app # Copy Rust binary (unified: market-data + strategy + API) @@ -82,6 +103,9 @@ COPY --from=rust-builder /app/market-data/target/release/orp-flow-market-data /a # Copy OCaml binary (risk gateway) COPY --from=ocaml-builder /home/opam/app/_build/default/bin/risk_gateway.exe /app/bin/risk_gateway +# Copy ONNX models for ML inference +COPY trained/onnx /app/models/onnx + # Copy supervisor configuration COPY deploy/supervisord.conf /etc/supervisor/conf.d/supervisord.conf @@ -92,6 +116,9 @@ RUN chmod +x /app/entrypoint.sh # Create data directory for SQLite RUN mkdir -p /data +# Set ONNX model path environment variable +ENV ONNX_MODEL_DIR=/app/models/onnx + # Expose ports: # 8000 - Main API (health, status, trades, positions) # 9090 - Metrics/Health checks diff --git a/market-data/src/strategy/inference_pipeline.rs b/market-data/src/strategy/inference_pipeline.rs index 21c1988..9652963 100644 --- a/market-data/src/strategy/inference_pipeline.rs +++ b/market-data/src/strategy/inference_pipeline.rs @@ -11,6 +11,9 @@ //! - Thread-safe for async runtime integration //! - Profile-friendly (array-based lookups, not HashMap) +// Allow dead_code - module is compiled with ml feature but not all functions are used yet +#![allow(dead_code)] + use std::collections::HashMap; use std::path::Path; @@ -596,16 +599,16 @@ impl InferencePipeline { self.cached_weights[1] = weights.get(&ModelType::XGBoost) .map(|w| w * (base_factor * 0.9 + 0.1)) .unwrap_or(0.0); - self.cached_weights[2] = weights.get(&ModelType::LSTM) + self.cached_weights[2] = weights.get(&ModelType::Lstm) .map(|w| w * base_factor) .unwrap_or(0.0); - self.cached_weights[3] = weights.get(&ModelType::CNN) + self.cached_weights[3] = weights.get(&ModelType::Cnn) .map(|w| w * base_factor) .unwrap_or(0.0); - self.cached_weights[4] = weights.get(&ModelType::D4PG) + self.cached_weights[4] = weights.get(&ModelType::D4pg) .map(|w| w * (base_factor * 0.8 + 0.2 * regime_weight)) .unwrap_or(0.0); - self.cached_weights[5] = weights.get(&ModelType::MARL) + self.cached_weights[5] = weights.get(&ModelType::Marl) .map(|w| w * (base_factor * 0.8 + 0.2 * regime_weight)) .unwrap_or(0.0); diff --git a/market-data/src/strategy/ml_inference.rs b/market-data/src/strategy/ml_inference.rs index 0e0110d..65c8e0a 100644 --- a/market-data/src/strategy/ml_inference.rs +++ b/market-data/src/strategy/ml_inference.rs @@ -8,6 +8,9 @@ //! - Feature augmentation with NSMI-derived features //! - Zero-allocation hot path via pre-allocated buffers +// Allow dead_code - module has comprehensive API, not all functions used yet +#![allow(dead_code)] + use std::collections::HashMap; use std::path::Path; @@ -21,13 +24,14 @@ use super::nsmi::{NSMIConfig, NSMIFeatures, NSMIResult, NSMIState}; /// Model type enumeration #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[allow(clippy::upper_case_acronyms)] pub enum ModelType { LightGBM, XGBoost, - LSTM, - CNN, - D4PG, - MARL, + Lstm, + Cnn, + D4pg, + Marl, } impl std::fmt::Display for ModelType { @@ -35,10 +39,10 @@ impl std::fmt::Display for ModelType { match self { ModelType::LightGBM => write!(f, "lightgbm"), ModelType::XGBoost => write!(f, "xgboost"), - ModelType::LSTM => write!(f, "lstm"), - ModelType::CNN => write!(f, "cnn"), - ModelType::D4PG => write!(f, "d4pg"), - ModelType::MARL => write!(f, "marl"), + ModelType::Lstm => write!(f, "lstm"), + ModelType::Cnn => write!(f, "cnn"), + ModelType::D4pg => write!(f, "d4pg"), + ModelType::Marl => write!(f, "marl"), } } } @@ -250,10 +254,10 @@ impl ModelEnsemble { let model_type = match name_str { "lightgbm" | "lightgbm_model" => Some(ModelType::LightGBM), "xgboost" | "xgboost_model" => Some(ModelType::XGBoost), - "lstm" | "lstm_model" => Some(ModelType::LSTM), - "cnn" | "cnn_model" => Some(ModelType::CNN), - "d4pg" | "d4pg_actor" => Some(ModelType::D4PG), - n if n.starts_with("marl") => Some(ModelType::MARL), + "lstm" | "lstm_model" => Some(ModelType::Lstm), + "cnn" | "cnn_model" => Some(ModelType::Cnn), + "d4pg" | "d4pg_actor" => Some(ModelType::D4pg), + n if n.starts_with("marl") => Some(ModelType::Marl), _ => None, }; @@ -391,11 +395,11 @@ impl ModelEnsemble { base_weight * (base_factor * 0.9 + 0.1) } // DL models may overfit to recent regime - ModelType::LSTM | ModelType::CNN => { + ModelType::Lstm | ModelType::Cnn => { base_weight * base_factor } // RL models need stable regimes - ModelType::D4PG | ModelType::MARL => { + ModelType::D4pg | ModelType::Marl => { base_weight * (base_factor * 0.8 + 0.2 * regime_factor) } }; @@ -456,7 +460,7 @@ impl ModelEnsemble { let mut weighted_sum = 0.0f32; let mut total_weight = 0.0f32; - for model_type in [ModelType::LSTM, ModelType::CNN] { + for model_type in [ModelType::Lstm, ModelType::Cnn] { if let Some(&weight) = weights.get(&model_type) { if let Some(model) = models.get_mut(&model_type) { match model.predict_sequence(sequence) { @@ -484,7 +488,7 @@ impl ModelEnsemble { pub fn get_rl_action(&self, state: &[f32]) -> Result> { let mut models = self.models.write(); - if let Some(model) = models.get_mut(&ModelType::D4PG) { + if let Some(model) = models.get_mut(&ModelType::D4pg) { model.predict_action(state) } else { Err(anyhow::anyhow!("D4PG model not available")) @@ -569,7 +573,7 @@ impl ModelEnsemble { let mut weighted_sum = 0.0f32; let mut total_weight = 0.0f32; - for model_type in [ModelType::LSTM, ModelType::CNN] { + for model_type in [ModelType::Lstm, ModelType::Cnn] { if let Some(&weight) = adjusted.adjusted_weights.get(&model_type) { if let Some(model) = models.get_mut(&model_type) { match model.predict_sequence(&effective_sequence) { @@ -751,7 +755,7 @@ mod tests { #[test] fn test_model_type_display() { assert_eq!(ModelType::LightGBM.to_string(), "lightgbm"); - assert_eq!(ModelType::D4PG.to_string(), "d4pg"); + assert_eq!(ModelType::D4pg.to_string(), "d4pg"); } #[test] diff --git a/market-data/src/strategy/mod.rs b/market-data/src/strategy/mod.rs index a224d6f..d208a4d 100644 --- a/market-data/src/strategy/mod.rs +++ b/market-data/src/strategy/mod.rs @@ -30,16 +30,20 @@ pub use broker::PaperBroker; pub use config::StrategyConfig; pub use features::MicrostructureFeatures; pub use models::{Account, Position, Trade}; +// NSMI exports - used by ml_inference when ml feature is enabled +#[allow(unused_imports)] pub use nsmi::{NSMIConfig, NSMIFeatures, NSMIResult, NSMIState}; pub use signals::ImbalanceStrategy; pub use storage::TradeStorage; #[cfg(feature = "ml")] +#[allow(unused_imports)] pub use ml_inference::{ FeatureBuffer, ModelEnsemble, ModelType, NSMIAdjustedWeights, NSMIAugmentBuffer, OnnxModel, }; #[cfg(feature = "ml")] +#[allow(unused_imports)] pub use inference_pipeline::{InferenceConfig, InferencePipeline, InferenceResult, TradingSignal}; use std::sync::Arc; diff --git a/market-data/src/strategy/nsmi.rs b/market-data/src/strategy/nsmi.rs index a6fc27e..9c08033 100644 --- a/market-data/src/strategy/nsmi.rs +++ b/market-data/src/strategy/nsmi.rs @@ -14,6 +14,9 @@ //! - Zero allocations in hot path (pre-allocated buffers) //! - Thread-safe for async runtimes +// Allow dead_code when compiled without ml feature (NSMI is used by ml_inference) +#![allow(dead_code)] + use std::sync::atomic::{AtomicU64, Ordering}; /// Configuration for NSMI state tracking @@ -52,7 +55,7 @@ impl NSMIConfig { Self { dimension, half_life, - tracked_eigenvalues: (dimension / 3).max(2).min(5), + tracked_eigenvalues: (dimension / 3).clamp(2, 5), ..Default::default() } } @@ -280,13 +283,13 @@ impl NSMIState { } // Update running mean: mean = (1-alpha) * mean + alpha * x - for i in 0..dim { - self.mean[i] = (1.0 - alpha) * self.mean[i] + alpha * observation[i]; + for (mean_i, &obs_i) in self.mean.iter_mut().zip(observation.iter()) { + *mean_i = (1.0 - alpha) * *mean_i + alpha * obs_i; } // Compute centered observation: x_centered = x - mean - for i in 0..dim { - self.buffers.centered[i] = observation[i] - self.mean[i]; + for ((centered_i, &obs_i), &mean_i) in self.buffers.centered.iter_mut().zip(observation.iter()).zip(self.mean.iter()) { + *centered_i = obs_i - mean_i; } // Update covariance matrix using rank-1 update: diff --git a/models/export/onnx_exporter.py b/models/export/onnx_exporter.py index 00df3ac..ba03212 100644 --- a/models/export/onnx_exporter.py +++ b/models/export/onnx_exporter.py @@ -33,18 +33,27 @@ def export_lightgbm( model_name: str = "lightgbm_model", ) -> str: """Export LightGBM model to ONNX""" + import lightgbm as lgb output_path = self.output_dir / f"{model_name}.onnx" + # Handle both wrapped model (has .model) and direct Booster + if hasattr(model, 'model'): + booster = model.model + elif isinstance(model, lgb.Booster): + booster = model + else: + raise ValueError(f"Unknown model type: {type(model)}") + try: from onnxmltools import convert_lightgbm from onnxmltools.convert.common.data_types import FloatTensorType initial_types = [("input", FloatTensorType([None, len(feature_names)]))] onnx_model = convert_lightgbm( - model.model, + booster, initial_types=initial_types, - target_opset=17, + target_opset=15, ) onnx.save_model(onnx_model, str(output_path)) @@ -58,7 +67,7 @@ def export_lightgbm( except ImportError: logger.warning("onnxmltools not installed, saving native format") native_path = self.output_dir / f"{model_name}.lgb" - model.model.save_model(str(native_path)) + booster.save_model(str(native_path)) return str(native_path) def export_xgboost( @@ -68,18 +77,27 @@ def export_xgboost( model_name: str = "xgboost_model", ) -> str: """Export XGBoost model to ONNX""" + import xgboost as xgb output_path = self.output_dir / f"{model_name}.onnx" + # Handle both wrapped model (has .model) and direct Booster + if hasattr(model, 'model'): + booster = model.model + elif isinstance(model, xgb.Booster): + booster = model + else: + raise ValueError(f"Unknown model type: {type(model)}") + try: from onnxmltools import convert_xgboost from onnxmltools.convert.common.data_types import FloatTensorType initial_types = [("input", FloatTensorType([None, len(feature_names)]))] onnx_model = convert_xgboost( - model.model, + booster, initial_types=initial_types, - target_opset=17, + target_opset=15, ) onnx.save_model(onnx_model, str(output_path)) @@ -93,7 +111,7 @@ def export_xgboost( except ImportError: logger.warning("onnxmltools not installed, saving native format") native_path = self.output_dir / f"{model_name}.xgb" - model.model.save_model(str(native_path)) + booster.save_model(str(native_path)) return str(native_path) def export_pytorch( @@ -123,7 +141,7 @@ def export_pytorch( dummy_input, str(output_path), export_params=True, - opset_version=17, + opset_version=15, do_constant_folding=True, input_names=input_names, output_names=output_names, @@ -195,7 +213,7 @@ def export_d4pg_actor( dummy_input, str(output_path), export_params=True, - opset_version=17, + opset_version=15, do_constant_folding=True, input_names=["state"], output_names=["action"], @@ -256,7 +274,7 @@ def forward(self, state, messages): (dummy_state, dummy_messages), str(output_path), export_params=True, - opset_version=17, + opset_version=15, do_constant_folding=True, input_names=["state", "messages"], output_names=["action"], diff --git a/render.yaml b/render.yaml index 037272b..c3ae223 100644 --- a/render.yaml +++ b/render.yaml @@ -1,5 +1,5 @@ # Render Blueprint - ORPflow HFT Paper Trading -# OCaml + Rust + Python Flow +# Rust + OCaml with ONNX ML Inference (Jane Street Style) # https://render.com/docs/blueprint-spec services: @@ -30,6 +30,11 @@ services: value: "0.05" - key: PAPER_TRADING value: "true" + # ONNX ML Inference Configuration + - key: ONNX_MODEL_DIR + value: /app/models/onnx + - key: ML_ENABLED + value: "true" # Telegram notifications (optional - set in dashboard) - key: TELEGRAM_BOT_TOKEN sync: false # Must be set manually in dashboard diff --git a/scripts/export_onnx.py b/scripts/export_onnx.py new file mode 100644 index 0000000..d0cc4ec --- /dev/null +++ b/scripts/export_onnx.py @@ -0,0 +1,211 @@ +#!/usr/bin/env python3 +""" +Export LightGBM and XGBoost models to ONNX format for Rust inference. +""" +import json +import logging +from pathlib import Path + +import lightgbm as lgb +import onnx +import xgboost as xgb +from onnxmltools import convert_lightgbm, convert_xgboost +from onnxmltools.convert.common.data_types import FloatTensorType + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +# Paths +PROJECT_ROOT = Path(__file__).parent.parent +TRAINED_DIR = PROJECT_ROOT / "trained" +ONNX_DIR = TRAINED_DIR / "onnx" + + +def get_feature_names_from_lightgbm(model_path: Path) -> list[str]: + """Extract feature names from LightGBM model file.""" + with open(model_path) as f: + for line in f: + if line.startswith("feature_names="): + return line.strip().split("=")[1].split() + return [] + + +def export_lightgbm(): + """Export LightGBM model to ONNX.""" + model_path = TRAINED_DIR / "lightgbm_advanced.txt" + if not model_path.exists(): + model_path = TRAINED_DIR / "lightgbm_model.txt" + + if not model_path.exists(): + logger.warning("LightGBM model not found") + return None + + logger.info(f"Loading LightGBM from {model_path}") + booster = lgb.Booster(model_file=str(model_path)) + + # Get feature names + feature_names = get_feature_names_from_lightgbm(model_path) + num_features = booster.num_feature() + + if not feature_names: + feature_names = [f"feature_{i}" for i in range(num_features)] + + logger.info(f"Model has {num_features} features") + + # Convert to ONNX + initial_types = [("input", FloatTensorType([None, num_features]))] + onnx_model = convert_lightgbm( + booster, + initial_types=initial_types, + target_opset=15, + ) + + # Save + output_path = ONNX_DIR / "lightgbm_model.onnx" + onnx.save_model(onnx_model, str(output_path)) + + # Validate + onnx.checker.check_model(onnx_model) + logger.info(f"LightGBM exported to {output_path}") + + # Save metadata + metadata = { + "model_name": "lightgbm_model", + "model_type": "lightgbm", + "onnx_path": "lightgbm_model.onnx", + "feature_names": feature_names, + "num_features": num_features, + } + + with open(ONNX_DIR / "lightgbm_model_metadata.json", "w") as f: + json.dump(metadata, f, indent=2) + + return output_path + + +def export_xgboost(): + """Export XGBoost model to ONNX.""" + # Try different model formats + model_path = None + for ext in ["json", "ubj"]: + p = TRAINED_DIR / f"xgboost_advanced.{ext}" + if p.exists(): + model_path = p + break + p = TRAINED_DIR / f"xgboost_model.{ext}" + if p.exists(): + model_path = p + break + + if not model_path: + logger.warning("XGBoost model not found") + return None + + logger.info(f"Loading XGBoost from {model_path}") + booster = xgb.Booster() + booster.load_model(str(model_path)) + + # Get feature names from model config + config = json.loads(booster.save_config()) + num_features = int(config.get("learner", {}).get("learner_model_param", {}).get("num_feature", 118)) + + # Get original feature names for metadata + original_feature_names = booster.feature_names + if original_feature_names: + feature_names = list(original_feature_names) + else: + feature_names = [f"f{i}" for i in range(num_features)] + + logger.info(f"Model has {num_features} features") + + # Rename features to f%d format for onnxmltools compatibility + booster.feature_names = [f"f{i}" for i in range(num_features)] + + # Convert to ONNX + initial_types = [("input", FloatTensorType([None, num_features]))] + onnx_model = convert_xgboost( + booster, + initial_types=initial_types, + target_opset=15, + ) + + # Save + output_path = ONNX_DIR / "xgboost_model.onnx" + onnx.save_model(onnx_model, str(output_path)) + + # Validate + onnx.checker.check_model(onnx_model) + logger.info(f"XGBoost exported to {output_path}") + + # Save metadata + metadata = { + "model_name": "xgboost_model", + "model_type": "xgboost", + "onnx_path": "xgboost_model.onnx", + "feature_names": feature_names, + "num_features": num_features, + } + + with open(ONNX_DIR / "xgboost_model_metadata.json", "w") as f: + json.dump(metadata, f, indent=2) + + return output_path + + +def create_manifest(exported_models: list[Path]): + """Create manifest file for Rust loader.""" + models = [] + metadata = {} + + for model_path in exported_models: + if model_path: + model_name = model_path.stem + models.append(model_name) + + meta_path = ONNX_DIR / f"{model_name}_metadata.json" + if meta_path.exists(): + with open(meta_path) as f: + metadata[model_name] = json.load(f) + + manifest = { + "models": models, + "export_dir": str(ONNX_DIR), + "metadata": metadata, + } + + with open(ONNX_DIR / "manifest.json", "w") as f: + json.dump(manifest, f, indent=2) + + logger.info(f"Manifest created with {len(models)} models") + + +def main(): + """Export all models.""" + ONNX_DIR.mkdir(parents=True, exist_ok=True) + + logger.info("Starting ONNX export...") + + exported = [] + + # Export LightGBM + try: + lgb_path = export_lightgbm() + exported.append(lgb_path) + except Exception as e: + logger.error(f"LightGBM export failed: {e}") + + # Export XGBoost + try: + xgb_path = export_xgboost() + exported.append(xgb_path) + except Exception as e: + logger.error(f"XGBoost export failed: {e}") + + # Create manifest + create_manifest(exported) + + logger.info(f"Export complete! {len([x for x in exported if x])} models exported to {ONNX_DIR}") + + +if __name__ == "__main__": + main() diff --git a/trained/onnx/lightgbm_model.onnx b/trained/onnx/lightgbm_model.onnx new file mode 100644 index 0000000..e5ee39a Binary files /dev/null and b/trained/onnx/lightgbm_model.onnx differ diff --git a/trained/onnx/lightgbm_model_metadata.json b/trained/onnx/lightgbm_model_metadata.json new file mode 100644 index 0000000..7abcff1 --- /dev/null +++ b/trained/onnx/lightgbm_model_metadata.json @@ -0,0 +1,340 @@ +{ + "model_name": "lightgbm_model", + "model_type": "lightgbm", + "onnx_path": "lightgbm_model.onnx", + "feature_names": [ + "return_1", + "log_return", + "return_5", + "log_return_5", + "return_10", + "log_return_10", + "return_20", + "log_return_20", + "return_50", + "log_return_50", + "return_100", + "log_return_100", + "volatility_5", + "parkinson_vol_5", + "gk_vol_5", + "volatility_10", + "parkinson_vol_10", + "gk_vol_10", + "volatility_20", + "parkinson_vol_20", + "gk_vol_20", + "volatility_50", + "parkinson_vol_50", + "gk_vol_50", + "volatility_100", + "parkinson_vol_100", + "gk_vol_100", + "momentum_5", + "roc_5", + "ma_5", + "ma_cross_5", + "momentum_10", + "roc_10", + "ma_10", + "ma_cross_10", + "momentum_20", + "roc_20", + "ma_20", + "ma_cross_20", + "momentum_50", + "roc_50", + "ma_50", + "ma_cross_50", + "momentum_100", + "roc_100", + "ma_100", + "ma_cross_100", + "rsi_14", + "rsi_21", + "spread_proxy", + "volume_imbalance", + "ofi", + "ofi_ma_5", + "ofi_std_5", + "ofi_z_5", + "volume_ma_5", + "volume_std_5", + "volume_z_5", + "trades_ma_5", + "ofi_ma_10", + "ofi_std_10", + "ofi_z_10", + "volume_ma_10", + "volume_std_10", + "volume_z_10", + "trades_ma_10", + "ofi_ma_20", + "ofi_std_20", + "ofi_z_20", + "volume_ma_20", + "volume_std_20", + "volume_z_20", + "trades_ma_20", + "ofi_ma_50", + "ofi_std_50", + "ofi_z_50", + "volume_ma_50", + "volume_std_50", + "volume_z_50", + "trades_ma_50", + "ofi_ma_100", + "ofi_std_100", + "ofi_z_100", + "volume_ma_100", + "volume_std_100", + "volume_z_100", + "trades_ma_100", + "amihud", + "amihud_ma_5", + "amihud_ma_10", + "amihud_ma_20", + "amihud_ma_50", + "amihud_ma_100", + "kyle_lambda_5", + "kyle_lambda_10", + "kyle_lambda_20", + "kyle_lambda_50", + "kyle_lambda_100", + "abs_ofi", + "vpin_50", + "vpin_100", + "kalman_price", + "kalman_deviation", + "kalman_trend", + "kalman_volume", + "volume_kalman_ratio", + "emd_imf_1", + "emd_imf_2", + "emd_imf_3", + "emd_residue", + "emd_energy_1", + "emd_energy_2", + "emd_energy_3", + "wavelet_trend", + "wavelet_vol_high_freq", + "wavelet_component_high_freq", + "wavelet_vol_mid_high_freq", + "wavelet_component_mid_high_freq", + "wavelet_vol_mid_freq", + "wavelet_component_mid_freq", + "wavelet_vol_low_freq", + "wavelet_component_low_freq", + "wavelet_total_volatility", + "wavelet_price", + "wavelet_deviation", + "fisher_rsi", + "fisher_price_10", + "fisher_price_20", + "micro_ofi_basic", + "micro_ofi_decayed", + "micro_ofi_cumulative", + "micro_ofi_weighted_cum", + "micro_ofi_momentum", + "micro_ofi_acceleration", + "micro_vpin", + "micro_vpin_cdf", + "micro_vpin_z", + "micro_flow_sign", + "micro_flow_persistence_5", + "micro_flow_persistence_abs_5", + "micro_flow_run_length_5", + "micro_flow_autocorr_5", + "micro_flow_persistence_10", + "micro_flow_persistence_abs_10", + "micro_flow_run_length_10", + "micro_flow_autocorr_10", + "micro_flow_persistence_20", + "micro_flow_persistence_abs_20", + "micro_flow_run_length_20", + "micro_flow_autocorr_20", + "micro_flow_persistence_50", + "micro_flow_persistence_abs_50", + "micro_flow_run_length_50", + "micro_flow_autocorr_50", + "micro_signed_volume", + "micro_signed_volume_pw", + "micro_signed_dollar_volume", + "micro_signed_volume_sum_5", + "micro_signed_volume_ma_5", + "micro_signed_volume_z_5", + "micro_cumulative_signed_vol_5", + "micro_signed_volume_sum_10", + "micro_signed_volume_ma_10", + "micro_signed_volume_z_10", + "micro_cumulative_signed_vol_10", + "micro_signed_volume_sum_20", + "micro_signed_volume_ma_20", + "micro_signed_volume_z_20", + "micro_cumulative_signed_vol_20", + "micro_buy_volume_ratio", + "micro_sell_volume_ratio", + "micro_mid_price", + "micro_microprice_vw", + "micro_microprice_depth", + "micro_microprice_imb", + "micro_vwap", + "micro_vwap_5", + "micro_vwap_10", + "micro_vwap_20", + "micro_fair_value_est", + "micro_microprice_deviation", + "micro_book_imb_l1", + "micro_book_imb_l2", + "micro_book_imb_l3", + "micro_book_imb_l4", + "micro_book_imb_l5", + "micro_book_imb_weighted", + "micro_book_imb_ma_5", + "micro_book_imb_std_5", + "micro_book_imb_z_5", + "micro_book_imb_momentum_5", + "micro_book_imb_ma_10", + "micro_book_imb_std_10", + "micro_book_imb_z_10", + "micro_book_imb_momentum_10", + "micro_book_imb_ma_20", + "micro_book_imb_std_20", + "micro_book_imb_z_20", + "micro_book_imb_momentum_20", + "micro_bid_pressure", + "micro_ask_pressure", + "micro_pressure_diff", + "micro_bid_pressure_pw", + "micro_ask_pressure_pw", + "micro_net_pressure_pw", + "micro_bid_pressure_5", + "micro_ask_pressure_5", + "micro_pressure_ratio_5", + "micro_pressure_momentum_5", + "micro_cumulative_pressure_5", + "micro_bid_pressure_10", + "micro_ask_pressure_10", + "micro_pressure_ratio_10", + "micro_pressure_momentum_10", + "micro_cumulative_pressure_10", + "micro_bid_pressure_20", + "micro_ask_pressure_20", + "micro_pressure_ratio_20", + "micro_pressure_momentum_20", + "micro_cumulative_pressure_20", + "micro_avg_trade_size", + "micro_queue_consumption_rate", + "micro_est_queue_depth_5", + "micro_queue_turnover_5", + "micro_est_fill_time_5", + "micro_est_queue_depth_10", + "micro_queue_turnover_10", + "micro_est_fill_time_10", + "micro_est_queue_depth_20", + "micro_queue_turnover_20", + "micro_est_fill_time_20", + "micro_queue_priority", + "micro_price_position", + "micro_volume_concentration", + "micro_depth_asymmetry", + "micro_volume_per_tick", + "micro_depth_skew", + "micro_depth_kurtosis", + "micro_spread_abs", + "micro_spread_bps", + "micro_effective_spread", + "micro_effective_spread_bps", + "micro_realized_spread", + "micro_realized_spread_bps", + "micro_price_impact", + "micro_price_impact_bps", + "micro_spread_ma_5", + "micro_spread_std_5", + "micro_spread_z_5", + "micro_spread_ma_10", + "micro_spread_std_10", + "micro_spread_z_10", + "micro_spread_ma_20", + "micro_spread_std_20", + "micro_spread_z_20", + "micro_spread_vol_ratio", + "micro_kyle_lambda_z_20", + "micro_kyle_lambda_trend_20", + "micro_kyle_lambda_z_50", + "micro_kyle_lambda_trend_50", + "micro_kyle_lambda_z_100", + "micro_kyle_lambda_trend_100", + "micro_amihud_scaled", + "micro_amihud_z_5", + "micro_amihud_trend_5", + "micro_amihud_z_10", + "micro_amihud_trend_10", + "micro_amihud_z_20", + "micro_amihud_trend_20", + "micro_amihud_z_50", + "micro_amihud_trend_50", + "micro_amihud_log", + "micro_roll_measure_20", + "micro_roll_measure_pct_20", + "micro_roll_measure_50", + "micro_roll_measure_pct_50", + "micro_roll_measure_100", + "micro_roll_measure_pct_100", + "micro_ps_gamma", + "micro_ps_liquidity", + "micro_ps_liquidity_scaled", + "micro_cs_spread", + "micro_cs_spread_bps", + "micro_cs_spread_ma_5", + "micro_cs_spread_z_5", + "micro_cs_spread_ma_10", + "micro_cs_spread_z_10", + "micro_cs_spread_ma_20", + "micro_cs_spread_z_20", + "micro_rv_cc_1", + "micro_rv_cc_5", + "micro_rv_parkinson", + "micro_rv_garman_klass", + "micro_rv_rogers_satchell", + "micro_rv_yang_zhang", + "micro_rv_20", + "micro_bv_20", + "micro_jump_var_20", + "micro_jump_component_20", + "micro_continuous_var_20", + "micro_jump_ratio_20", + "micro_rv_50", + "micro_bv_50", + "micro_jump_var_50", + "micro_jump_component_50", + "micro_continuous_var_50", + "micro_jump_ratio_50", + "micro_rk_parzen", + "micro_rv_standard", + "micro_noise_ratio", + "micro_lm_statistic", + "micro_jump_detected", + "micro_jump_magnitude", + "micro_jump_direction", + "micro_jump_count_20", + "micro_jump_frequency_20", + "micro_avg_jump_magnitude_20", + "micro_jump_count_50", + "micro_jump_frequency_50", + "micro_avg_jump_magnitude_50", + "micro_jump_count_100", + "micro_jump_frequency_100", + "micro_avg_jump_magnitude_100", + "micro_jump_variance_contrib", + "daily_vol", + "hour", + "day_of_week", + "is_weekend", + "hour_sin", + "hour_cos", + "dow_sin", + "dow_cos" + ], + "num_features": 332 +} \ No newline at end of file diff --git a/trained/onnx/manifest.json b/trained/onnx/manifest.json new file mode 100644 index 0000000..9bd760f --- /dev/null +++ b/trained/onnx/manifest.json @@ -0,0 +1,689 @@ +{ + "models": [ + "lightgbm_model", + "xgboost_model" + ], + "export_dir": "/home/samoradc/SamoraDC/ORPFlow/trained/onnx", + "metadata": { + "lightgbm_model": { + "model_name": "lightgbm_model", + "model_type": "lightgbm", + "onnx_path": "lightgbm_model.onnx", + "feature_names": [ + "return_1", + "log_return", + "return_5", + "log_return_5", + "return_10", + "log_return_10", + "return_20", + "log_return_20", + "return_50", + "log_return_50", + "return_100", + "log_return_100", + "volatility_5", + "parkinson_vol_5", + "gk_vol_5", + "volatility_10", + "parkinson_vol_10", + "gk_vol_10", + "volatility_20", + "parkinson_vol_20", + "gk_vol_20", + "volatility_50", + "parkinson_vol_50", + "gk_vol_50", + "volatility_100", + "parkinson_vol_100", + "gk_vol_100", + "momentum_5", + "roc_5", + "ma_5", + "ma_cross_5", + "momentum_10", + "roc_10", + "ma_10", + "ma_cross_10", + "momentum_20", + "roc_20", + "ma_20", + "ma_cross_20", + "momentum_50", + "roc_50", + "ma_50", + "ma_cross_50", + "momentum_100", + "roc_100", + "ma_100", + "ma_cross_100", + "rsi_14", + "rsi_21", + "spread_proxy", + "volume_imbalance", + "ofi", + "ofi_ma_5", + "ofi_std_5", + "ofi_z_5", + "volume_ma_5", + "volume_std_5", + "volume_z_5", + "trades_ma_5", + "ofi_ma_10", + "ofi_std_10", + "ofi_z_10", + "volume_ma_10", + "volume_std_10", + "volume_z_10", + "trades_ma_10", + "ofi_ma_20", + "ofi_std_20", + "ofi_z_20", + "volume_ma_20", + "volume_std_20", + "volume_z_20", + "trades_ma_20", + "ofi_ma_50", + "ofi_std_50", + "ofi_z_50", + "volume_ma_50", + "volume_std_50", + "volume_z_50", + "trades_ma_50", + "ofi_ma_100", + "ofi_std_100", + "ofi_z_100", + "volume_ma_100", + "volume_std_100", + "volume_z_100", + "trades_ma_100", + "amihud", + "amihud_ma_5", + "amihud_ma_10", + "amihud_ma_20", + "amihud_ma_50", + "amihud_ma_100", + "kyle_lambda_5", + "kyle_lambda_10", + "kyle_lambda_20", + "kyle_lambda_50", + "kyle_lambda_100", + "abs_ofi", + "vpin_50", + "vpin_100", + "kalman_price", + "kalman_deviation", + "kalman_trend", + "kalman_volume", + "volume_kalman_ratio", + "emd_imf_1", + "emd_imf_2", + "emd_imf_3", + "emd_residue", + "emd_energy_1", + "emd_energy_2", + "emd_energy_3", + "wavelet_trend", + "wavelet_vol_high_freq", + "wavelet_component_high_freq", + "wavelet_vol_mid_high_freq", + "wavelet_component_mid_high_freq", + "wavelet_vol_mid_freq", + "wavelet_component_mid_freq", + "wavelet_vol_low_freq", + "wavelet_component_low_freq", + "wavelet_total_volatility", + "wavelet_price", + "wavelet_deviation", + "fisher_rsi", + "fisher_price_10", + "fisher_price_20", + "micro_ofi_basic", + "micro_ofi_decayed", + "micro_ofi_cumulative", + "micro_ofi_weighted_cum", + "micro_ofi_momentum", + "micro_ofi_acceleration", + "micro_vpin", + "micro_vpin_cdf", + "micro_vpin_z", + "micro_flow_sign", + "micro_flow_persistence_5", + "micro_flow_persistence_abs_5", + "micro_flow_run_length_5", + "micro_flow_autocorr_5", + "micro_flow_persistence_10", + "micro_flow_persistence_abs_10", + "micro_flow_run_length_10", + "micro_flow_autocorr_10", + "micro_flow_persistence_20", + "micro_flow_persistence_abs_20", + "micro_flow_run_length_20", + "micro_flow_autocorr_20", + "micro_flow_persistence_50", + "micro_flow_persistence_abs_50", + "micro_flow_run_length_50", + "micro_flow_autocorr_50", + "micro_signed_volume", + "micro_signed_volume_pw", + "micro_signed_dollar_volume", + "micro_signed_volume_sum_5", + "micro_signed_volume_ma_5", + "micro_signed_volume_z_5", + "micro_cumulative_signed_vol_5", + "micro_signed_volume_sum_10", + "micro_signed_volume_ma_10", + "micro_signed_volume_z_10", + "micro_cumulative_signed_vol_10", + "micro_signed_volume_sum_20", + "micro_signed_volume_ma_20", + "micro_signed_volume_z_20", + "micro_cumulative_signed_vol_20", + "micro_buy_volume_ratio", + "micro_sell_volume_ratio", + "micro_mid_price", + "micro_microprice_vw", + "micro_microprice_depth", + "micro_microprice_imb", + "micro_vwap", + "micro_vwap_5", + "micro_vwap_10", + "micro_vwap_20", + "micro_fair_value_est", + "micro_microprice_deviation", + "micro_book_imb_l1", + "micro_book_imb_l2", + "micro_book_imb_l3", + "micro_book_imb_l4", + "micro_book_imb_l5", + "micro_book_imb_weighted", + "micro_book_imb_ma_5", + "micro_book_imb_std_5", + "micro_book_imb_z_5", + "micro_book_imb_momentum_5", + "micro_book_imb_ma_10", + "micro_book_imb_std_10", + "micro_book_imb_z_10", + "micro_book_imb_momentum_10", + "micro_book_imb_ma_20", + "micro_book_imb_std_20", + "micro_book_imb_z_20", + "micro_book_imb_momentum_20", + "micro_bid_pressure", + "micro_ask_pressure", + "micro_pressure_diff", + "micro_bid_pressure_pw", + "micro_ask_pressure_pw", + "micro_net_pressure_pw", + "micro_bid_pressure_5", + "micro_ask_pressure_5", + "micro_pressure_ratio_5", + "micro_pressure_momentum_5", + "micro_cumulative_pressure_5", + "micro_bid_pressure_10", + "micro_ask_pressure_10", + "micro_pressure_ratio_10", + "micro_pressure_momentum_10", + "micro_cumulative_pressure_10", + "micro_bid_pressure_20", + "micro_ask_pressure_20", + "micro_pressure_ratio_20", + "micro_pressure_momentum_20", + "micro_cumulative_pressure_20", + "micro_avg_trade_size", + "micro_queue_consumption_rate", + "micro_est_queue_depth_5", + "micro_queue_turnover_5", + "micro_est_fill_time_5", + "micro_est_queue_depth_10", + "micro_queue_turnover_10", + "micro_est_fill_time_10", + "micro_est_queue_depth_20", + "micro_queue_turnover_20", + "micro_est_fill_time_20", + "micro_queue_priority", + "micro_price_position", + "micro_volume_concentration", + "micro_depth_asymmetry", + "micro_volume_per_tick", + "micro_depth_skew", + "micro_depth_kurtosis", + "micro_spread_abs", + "micro_spread_bps", + "micro_effective_spread", + "micro_effective_spread_bps", + "micro_realized_spread", + "micro_realized_spread_bps", + "micro_price_impact", + "micro_price_impact_bps", + "micro_spread_ma_5", + "micro_spread_std_5", + "micro_spread_z_5", + "micro_spread_ma_10", + "micro_spread_std_10", + "micro_spread_z_10", + "micro_spread_ma_20", + "micro_spread_std_20", + "micro_spread_z_20", + "micro_spread_vol_ratio", + "micro_kyle_lambda_z_20", + "micro_kyle_lambda_trend_20", + "micro_kyle_lambda_z_50", + "micro_kyle_lambda_trend_50", + "micro_kyle_lambda_z_100", + "micro_kyle_lambda_trend_100", + "micro_amihud_scaled", + "micro_amihud_z_5", + "micro_amihud_trend_5", + "micro_amihud_z_10", + "micro_amihud_trend_10", + "micro_amihud_z_20", + "micro_amihud_trend_20", + "micro_amihud_z_50", + "micro_amihud_trend_50", + "micro_amihud_log", + "micro_roll_measure_20", + "micro_roll_measure_pct_20", + "micro_roll_measure_50", + "micro_roll_measure_pct_50", + "micro_roll_measure_100", + "micro_roll_measure_pct_100", + "micro_ps_gamma", + "micro_ps_liquidity", + "micro_ps_liquidity_scaled", + "micro_cs_spread", + "micro_cs_spread_bps", + "micro_cs_spread_ma_5", + "micro_cs_spread_z_5", + "micro_cs_spread_ma_10", + "micro_cs_spread_z_10", + "micro_cs_spread_ma_20", + "micro_cs_spread_z_20", + "micro_rv_cc_1", + "micro_rv_cc_5", + "micro_rv_parkinson", + "micro_rv_garman_klass", + "micro_rv_rogers_satchell", + "micro_rv_yang_zhang", + "micro_rv_20", + "micro_bv_20", + "micro_jump_var_20", + "micro_jump_component_20", + "micro_continuous_var_20", + "micro_jump_ratio_20", + "micro_rv_50", + "micro_bv_50", + "micro_jump_var_50", + "micro_jump_component_50", + "micro_continuous_var_50", + "micro_jump_ratio_50", + "micro_rk_parzen", + "micro_rv_standard", + "micro_noise_ratio", + "micro_lm_statistic", + "micro_jump_detected", + "micro_jump_magnitude", + "micro_jump_direction", + "micro_jump_count_20", + "micro_jump_frequency_20", + "micro_avg_jump_magnitude_20", + "micro_jump_count_50", + "micro_jump_frequency_50", + "micro_avg_jump_magnitude_50", + "micro_jump_count_100", + "micro_jump_frequency_100", + "micro_avg_jump_magnitude_100", + "micro_jump_variance_contrib", + "daily_vol", + "hour", + "day_of_week", + "is_weekend", + "hour_sin", + "hour_cos", + "dow_sin", + "dow_cos" + ], + "num_features": 332 + }, + "xgboost_model": { + "model_name": "xgboost_model", + "model_type": "xgboost", + "onnx_path": "xgboost_model.onnx", + "feature_names": [ + "return_1", + "log_return", + "return_5", + "log_return_5", + "return_10", + "log_return_10", + "return_20", + "log_return_20", + "return_50", + "log_return_50", + "return_100", + "log_return_100", + "volatility_5", + "parkinson_vol_5", + "gk_vol_5", + "volatility_10", + "parkinson_vol_10", + "gk_vol_10", + "volatility_20", + "parkinson_vol_20", + "gk_vol_20", + "volatility_50", + "parkinson_vol_50", + "gk_vol_50", + "volatility_100", + "parkinson_vol_100", + "gk_vol_100", + "momentum_5", + "roc_5", + "ma_5", + "ma_cross_5", + "momentum_10", + "roc_10", + "ma_10", + "ma_cross_10", + "momentum_20", + "roc_20", + "ma_20", + "ma_cross_20", + "momentum_50", + "roc_50", + "ma_50", + "ma_cross_50", + "momentum_100", + "roc_100", + "ma_100", + "ma_cross_100", + "rsi_14", + "rsi_21", + "spread_proxy", + "volume_imbalance", + "ofi", + "ofi_ma_5", + "ofi_std_5", + "ofi_z_5", + "volume_ma_5", + "volume_std_5", + "volume_z_5", + "trades_ma_5", + "ofi_ma_10", + "ofi_std_10", + "ofi_z_10", + "volume_ma_10", + "volume_std_10", + "volume_z_10", + "trades_ma_10", + "ofi_ma_20", + "ofi_std_20", + "ofi_z_20", + "volume_ma_20", + "volume_std_20", + "volume_z_20", + "trades_ma_20", + "ofi_ma_50", + "ofi_std_50", + "ofi_z_50", + "volume_ma_50", + "volume_std_50", + "volume_z_50", + "trades_ma_50", + "ofi_ma_100", + "ofi_std_100", + "ofi_z_100", + "volume_ma_100", + "volume_std_100", + "volume_z_100", + "trades_ma_100", + "amihud", + "amihud_ma_5", + "amihud_ma_10", + "amihud_ma_20", + "amihud_ma_50", + "amihud_ma_100", + "kyle_lambda_5", + "kyle_lambda_10", + "kyle_lambda_20", + "kyle_lambda_50", + "kyle_lambda_100", + "abs_ofi", + "vpin_50", + "vpin_100", + "kalman_price", + "kalman_deviation", + "kalman_trend", + "kalman_volume", + "volume_kalman_ratio", + "emd_imf_1", + "emd_imf_2", + "emd_imf_3", + "emd_residue", + "emd_energy_1", + "emd_energy_2", + "emd_energy_3", + "wavelet_trend", + "wavelet_vol_high_freq", + "wavelet_component_high_freq", + "wavelet_vol_mid_high_freq", + "wavelet_component_mid_high_freq", + "wavelet_vol_mid_freq", + "wavelet_component_mid_freq", + "wavelet_vol_low_freq", + "wavelet_component_low_freq", + "wavelet_total_volatility", + "wavelet_price", + "wavelet_deviation", + "fisher_rsi", + "fisher_price_10", + "fisher_price_20", + "micro_ofi_basic", + "micro_ofi_decayed", + "micro_ofi_cumulative", + "micro_ofi_weighted_cum", + "micro_ofi_momentum", + "micro_ofi_acceleration", + "micro_vpin", + "micro_vpin_cdf", + "micro_vpin_z", + "micro_flow_sign", + "micro_flow_persistence_5", + "micro_flow_persistence_abs_5", + "micro_flow_run_length_5", + "micro_flow_autocorr_5", + "micro_flow_persistence_10", + "micro_flow_persistence_abs_10", + "micro_flow_run_length_10", + "micro_flow_autocorr_10", + "micro_flow_persistence_20", + "micro_flow_persistence_abs_20", + "micro_flow_run_length_20", + "micro_flow_autocorr_20", + "micro_flow_persistence_50", + "micro_flow_persistence_abs_50", + "micro_flow_run_length_50", + "micro_flow_autocorr_50", + "micro_signed_volume", + "micro_signed_volume_pw", + "micro_signed_dollar_volume", + "micro_signed_volume_sum_5", + "micro_signed_volume_ma_5", + "micro_signed_volume_z_5", + "micro_cumulative_signed_vol_5", + "micro_signed_volume_sum_10", + "micro_signed_volume_ma_10", + "micro_signed_volume_z_10", + "micro_cumulative_signed_vol_10", + "micro_signed_volume_sum_20", + "micro_signed_volume_ma_20", + "micro_signed_volume_z_20", + "micro_cumulative_signed_vol_20", + "micro_buy_volume_ratio", + "micro_sell_volume_ratio", + "micro_mid_price", + "micro_microprice_vw", + "micro_microprice_depth", + "micro_microprice_imb", + "micro_vwap", + "micro_vwap_5", + "micro_vwap_10", + "micro_vwap_20", + "micro_fair_value_est", + "micro_microprice_deviation", + "micro_book_imb_l1", + "micro_book_imb_l2", + "micro_book_imb_l3", + "micro_book_imb_l4", + "micro_book_imb_l5", + "micro_book_imb_weighted", + "micro_book_imb_ma_5", + "micro_book_imb_std_5", + "micro_book_imb_z_5", + "micro_book_imb_momentum_5", + "micro_book_imb_ma_10", + "micro_book_imb_std_10", + "micro_book_imb_z_10", + "micro_book_imb_momentum_10", + "micro_book_imb_ma_20", + "micro_book_imb_std_20", + "micro_book_imb_z_20", + "micro_book_imb_momentum_20", + "micro_bid_pressure", + "micro_ask_pressure", + "micro_pressure_diff", + "micro_bid_pressure_pw", + "micro_ask_pressure_pw", + "micro_net_pressure_pw", + "micro_bid_pressure_5", + "micro_ask_pressure_5", + "micro_pressure_ratio_5", + "micro_pressure_momentum_5", + "micro_cumulative_pressure_5", + "micro_bid_pressure_10", + "micro_ask_pressure_10", + "micro_pressure_ratio_10", + "micro_pressure_momentum_10", + "micro_cumulative_pressure_10", + "micro_bid_pressure_20", + "micro_ask_pressure_20", + "micro_pressure_ratio_20", + "micro_pressure_momentum_20", + "micro_cumulative_pressure_20", + "micro_avg_trade_size", + "micro_queue_consumption_rate", + "micro_est_queue_depth_5", + "micro_queue_turnover_5", + "micro_est_fill_time_5", + "micro_est_queue_depth_10", + "micro_queue_turnover_10", + "micro_est_fill_time_10", + "micro_est_queue_depth_20", + "micro_queue_turnover_20", + "micro_est_fill_time_20", + "micro_queue_priority", + "micro_price_position", + "micro_volume_concentration", + "micro_depth_asymmetry", + "micro_volume_per_tick", + "micro_depth_skew", + "micro_depth_kurtosis", + "micro_spread_abs", + "micro_spread_bps", + "micro_effective_spread", + "micro_effective_spread_bps", + "micro_realized_spread", + "micro_realized_spread_bps", + "micro_price_impact", + "micro_price_impact_bps", + "micro_spread_ma_5", + "micro_spread_std_5", + "micro_spread_z_5", + "micro_spread_ma_10", + "micro_spread_std_10", + "micro_spread_z_10", + "micro_spread_ma_20", + "micro_spread_std_20", + "micro_spread_z_20", + "micro_spread_vol_ratio", + "micro_kyle_lambda_z_20", + "micro_kyle_lambda_trend_20", + "micro_kyle_lambda_z_50", + "micro_kyle_lambda_trend_50", + "micro_kyle_lambda_z_100", + "micro_kyle_lambda_trend_100", + "micro_amihud_scaled", + "micro_amihud_z_5", + "micro_amihud_trend_5", + "micro_amihud_z_10", + "micro_amihud_trend_10", + "micro_amihud_z_20", + "micro_amihud_trend_20", + "micro_amihud_z_50", + "micro_amihud_trend_50", + "micro_amihud_log", + "micro_roll_measure_20", + "micro_roll_measure_pct_20", + "micro_roll_measure_50", + "micro_roll_measure_pct_50", + "micro_roll_measure_100", + "micro_roll_measure_pct_100", + "micro_ps_gamma", + "micro_ps_liquidity", + "micro_ps_liquidity_scaled", + "micro_cs_spread", + "micro_cs_spread_bps", + "micro_cs_spread_ma_5", + "micro_cs_spread_z_5", + "micro_cs_spread_ma_10", + "micro_cs_spread_z_10", + "micro_cs_spread_ma_20", + "micro_cs_spread_z_20", + "micro_rv_cc_1", + "micro_rv_cc_5", + "micro_rv_parkinson", + "micro_rv_garman_klass", + "micro_rv_rogers_satchell", + "micro_rv_yang_zhang", + "micro_rv_20", + "micro_bv_20", + "micro_jump_var_20", + "micro_jump_component_20", + "micro_continuous_var_20", + "micro_jump_ratio_20", + "micro_rv_50", + "micro_bv_50", + "micro_jump_var_50", + "micro_jump_component_50", + "micro_continuous_var_50", + "micro_jump_ratio_50", + "micro_rk_parzen", + "micro_rv_standard", + "micro_noise_ratio", + "micro_lm_statistic", + "micro_jump_detected", + "micro_jump_magnitude", + "micro_jump_direction", + "micro_jump_count_20", + "micro_jump_frequency_20", + "micro_avg_jump_magnitude_20", + "micro_jump_count_50", + "micro_jump_frequency_50", + "micro_avg_jump_magnitude_50", + "micro_jump_count_100", + "micro_jump_frequency_100", + "micro_avg_jump_magnitude_100", + "micro_jump_variance_contrib", + "daily_vol", + "hour", + "day_of_week", + "is_weekend", + "hour_sin", + "hour_cos", + "dow_sin", + "dow_cos" + ], + "num_features": 332 + } + } +} \ No newline at end of file diff --git a/trained/onnx/xgboost_model.onnx b/trained/onnx/xgboost_model.onnx new file mode 100644 index 0000000..20a562f Binary files /dev/null and b/trained/onnx/xgboost_model.onnx differ diff --git a/trained/onnx/xgboost_model_metadata.json b/trained/onnx/xgboost_model_metadata.json new file mode 100644 index 0000000..31549b0 --- /dev/null +++ b/trained/onnx/xgboost_model_metadata.json @@ -0,0 +1,340 @@ +{ + "model_name": "xgboost_model", + "model_type": "xgboost", + "onnx_path": "xgboost_model.onnx", + "feature_names": [ + "return_1", + "log_return", + "return_5", + "log_return_5", + "return_10", + "log_return_10", + "return_20", + "log_return_20", + "return_50", + "log_return_50", + "return_100", + "log_return_100", + "volatility_5", + "parkinson_vol_5", + "gk_vol_5", + "volatility_10", + "parkinson_vol_10", + "gk_vol_10", + "volatility_20", + "parkinson_vol_20", + "gk_vol_20", + "volatility_50", + "parkinson_vol_50", + "gk_vol_50", + "volatility_100", + "parkinson_vol_100", + "gk_vol_100", + "momentum_5", + "roc_5", + "ma_5", + "ma_cross_5", + "momentum_10", + "roc_10", + "ma_10", + "ma_cross_10", + "momentum_20", + "roc_20", + "ma_20", + "ma_cross_20", + "momentum_50", + "roc_50", + "ma_50", + "ma_cross_50", + "momentum_100", + "roc_100", + "ma_100", + "ma_cross_100", + "rsi_14", + "rsi_21", + "spread_proxy", + "volume_imbalance", + "ofi", + "ofi_ma_5", + "ofi_std_5", + "ofi_z_5", + "volume_ma_5", + "volume_std_5", + "volume_z_5", + "trades_ma_5", + "ofi_ma_10", + "ofi_std_10", + "ofi_z_10", + "volume_ma_10", + "volume_std_10", + "volume_z_10", + "trades_ma_10", + "ofi_ma_20", + "ofi_std_20", + "ofi_z_20", + "volume_ma_20", + "volume_std_20", + "volume_z_20", + "trades_ma_20", + "ofi_ma_50", + "ofi_std_50", + "ofi_z_50", + "volume_ma_50", + "volume_std_50", + "volume_z_50", + "trades_ma_50", + "ofi_ma_100", + "ofi_std_100", + "ofi_z_100", + "volume_ma_100", + "volume_std_100", + "volume_z_100", + "trades_ma_100", + "amihud", + "amihud_ma_5", + "amihud_ma_10", + "amihud_ma_20", + "amihud_ma_50", + "amihud_ma_100", + "kyle_lambda_5", + "kyle_lambda_10", + "kyle_lambda_20", + "kyle_lambda_50", + "kyle_lambda_100", + "abs_ofi", + "vpin_50", + "vpin_100", + "kalman_price", + "kalman_deviation", + "kalman_trend", + "kalman_volume", + "volume_kalman_ratio", + "emd_imf_1", + "emd_imf_2", + "emd_imf_3", + "emd_residue", + "emd_energy_1", + "emd_energy_2", + "emd_energy_3", + "wavelet_trend", + "wavelet_vol_high_freq", + "wavelet_component_high_freq", + "wavelet_vol_mid_high_freq", + "wavelet_component_mid_high_freq", + "wavelet_vol_mid_freq", + "wavelet_component_mid_freq", + "wavelet_vol_low_freq", + "wavelet_component_low_freq", + "wavelet_total_volatility", + "wavelet_price", + "wavelet_deviation", + "fisher_rsi", + "fisher_price_10", + "fisher_price_20", + "micro_ofi_basic", + "micro_ofi_decayed", + "micro_ofi_cumulative", + "micro_ofi_weighted_cum", + "micro_ofi_momentum", + "micro_ofi_acceleration", + "micro_vpin", + "micro_vpin_cdf", + "micro_vpin_z", + "micro_flow_sign", + "micro_flow_persistence_5", + "micro_flow_persistence_abs_5", + "micro_flow_run_length_5", + "micro_flow_autocorr_5", + "micro_flow_persistence_10", + "micro_flow_persistence_abs_10", + "micro_flow_run_length_10", + "micro_flow_autocorr_10", + "micro_flow_persistence_20", + "micro_flow_persistence_abs_20", + "micro_flow_run_length_20", + "micro_flow_autocorr_20", + "micro_flow_persistence_50", + "micro_flow_persistence_abs_50", + "micro_flow_run_length_50", + "micro_flow_autocorr_50", + "micro_signed_volume", + "micro_signed_volume_pw", + "micro_signed_dollar_volume", + "micro_signed_volume_sum_5", + "micro_signed_volume_ma_5", + "micro_signed_volume_z_5", + "micro_cumulative_signed_vol_5", + "micro_signed_volume_sum_10", + "micro_signed_volume_ma_10", + "micro_signed_volume_z_10", + "micro_cumulative_signed_vol_10", + "micro_signed_volume_sum_20", + "micro_signed_volume_ma_20", + "micro_signed_volume_z_20", + "micro_cumulative_signed_vol_20", + "micro_buy_volume_ratio", + "micro_sell_volume_ratio", + "micro_mid_price", + "micro_microprice_vw", + "micro_microprice_depth", + "micro_microprice_imb", + "micro_vwap", + "micro_vwap_5", + "micro_vwap_10", + "micro_vwap_20", + "micro_fair_value_est", + "micro_microprice_deviation", + "micro_book_imb_l1", + "micro_book_imb_l2", + "micro_book_imb_l3", + "micro_book_imb_l4", + "micro_book_imb_l5", + "micro_book_imb_weighted", + "micro_book_imb_ma_5", + "micro_book_imb_std_5", + "micro_book_imb_z_5", + "micro_book_imb_momentum_5", + "micro_book_imb_ma_10", + "micro_book_imb_std_10", + "micro_book_imb_z_10", + "micro_book_imb_momentum_10", + "micro_book_imb_ma_20", + "micro_book_imb_std_20", + "micro_book_imb_z_20", + "micro_book_imb_momentum_20", + "micro_bid_pressure", + "micro_ask_pressure", + "micro_pressure_diff", + "micro_bid_pressure_pw", + "micro_ask_pressure_pw", + "micro_net_pressure_pw", + "micro_bid_pressure_5", + "micro_ask_pressure_5", + "micro_pressure_ratio_5", + "micro_pressure_momentum_5", + "micro_cumulative_pressure_5", + "micro_bid_pressure_10", + "micro_ask_pressure_10", + "micro_pressure_ratio_10", + "micro_pressure_momentum_10", + "micro_cumulative_pressure_10", + "micro_bid_pressure_20", + "micro_ask_pressure_20", + "micro_pressure_ratio_20", + "micro_pressure_momentum_20", + "micro_cumulative_pressure_20", + "micro_avg_trade_size", + "micro_queue_consumption_rate", + "micro_est_queue_depth_5", + "micro_queue_turnover_5", + "micro_est_fill_time_5", + "micro_est_queue_depth_10", + "micro_queue_turnover_10", + "micro_est_fill_time_10", + "micro_est_queue_depth_20", + "micro_queue_turnover_20", + "micro_est_fill_time_20", + "micro_queue_priority", + "micro_price_position", + "micro_volume_concentration", + "micro_depth_asymmetry", + "micro_volume_per_tick", + "micro_depth_skew", + "micro_depth_kurtosis", + "micro_spread_abs", + "micro_spread_bps", + "micro_effective_spread", + "micro_effective_spread_bps", + "micro_realized_spread", + "micro_realized_spread_bps", + "micro_price_impact", + "micro_price_impact_bps", + "micro_spread_ma_5", + "micro_spread_std_5", + "micro_spread_z_5", + "micro_spread_ma_10", + "micro_spread_std_10", + "micro_spread_z_10", + "micro_spread_ma_20", + "micro_spread_std_20", + "micro_spread_z_20", + "micro_spread_vol_ratio", + "micro_kyle_lambda_z_20", + "micro_kyle_lambda_trend_20", + "micro_kyle_lambda_z_50", + "micro_kyle_lambda_trend_50", + "micro_kyle_lambda_z_100", + "micro_kyle_lambda_trend_100", + "micro_amihud_scaled", + "micro_amihud_z_5", + "micro_amihud_trend_5", + "micro_amihud_z_10", + "micro_amihud_trend_10", + "micro_amihud_z_20", + "micro_amihud_trend_20", + "micro_amihud_z_50", + "micro_amihud_trend_50", + "micro_amihud_log", + "micro_roll_measure_20", + "micro_roll_measure_pct_20", + "micro_roll_measure_50", + "micro_roll_measure_pct_50", + "micro_roll_measure_100", + "micro_roll_measure_pct_100", + "micro_ps_gamma", + "micro_ps_liquidity", + "micro_ps_liquidity_scaled", + "micro_cs_spread", + "micro_cs_spread_bps", + "micro_cs_spread_ma_5", + "micro_cs_spread_z_5", + "micro_cs_spread_ma_10", + "micro_cs_spread_z_10", + "micro_cs_spread_ma_20", + "micro_cs_spread_z_20", + "micro_rv_cc_1", + "micro_rv_cc_5", + "micro_rv_parkinson", + "micro_rv_garman_klass", + "micro_rv_rogers_satchell", + "micro_rv_yang_zhang", + "micro_rv_20", + "micro_bv_20", + "micro_jump_var_20", + "micro_jump_component_20", + "micro_continuous_var_20", + "micro_jump_ratio_20", + "micro_rv_50", + "micro_bv_50", + "micro_jump_var_50", + "micro_jump_component_50", + "micro_continuous_var_50", + "micro_jump_ratio_50", + "micro_rk_parzen", + "micro_rv_standard", + "micro_noise_ratio", + "micro_lm_statistic", + "micro_jump_detected", + "micro_jump_magnitude", + "micro_jump_direction", + "micro_jump_count_20", + "micro_jump_frequency_20", + "micro_avg_jump_magnitude_20", + "micro_jump_count_50", + "micro_jump_frequency_50", + "micro_avg_jump_magnitude_50", + "micro_jump_count_100", + "micro_jump_frequency_100", + "micro_avg_jump_magnitude_100", + "micro_jump_variance_contrib", + "daily_vol", + "hour", + "day_of_week", + "is_weekend", + "hour_sin", + "hour_cos", + "dow_sin", + "dow_cos" + ], + "num_features": 332 +} \ No newline at end of file