@vizzor/cli 0.13.0 → 0.14.5

package/chronovisor-engine/src/training/pipeline.py

@@ -0,0 +1,130 @@
+"""
+Training Pipeline — pulls data, generates labels, trains models, saves artifacts.
+"""
+
+import os
+import json
+import time
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+ARTIFACT_DIR = Path(os.getenv("MODEL_ARTIFACT_DIR", "models"))
+
+
+class TrainingPipeline:
+    """Base training pipeline for all ML models."""
+
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+        self.artifact_dir = ARTIFACT_DIR / model_name
+        self.artifact_dir.mkdir(parents=True, exist_ok=True)
+
+    def load_data(self) -> Any:
+        """Override in subclass to load training data."""
+        raise NotImplementedError
+
+    def preprocess(self, data: Any) -> tuple:
+        """Override to split and preprocess data. Returns (X_train, X_val, X_test, y_train, y_val, y_test)."""
+        raise NotImplementedError
+
+    def train(self, X_train: Any, y_train: Any, X_val: Any, y_val: Any) -> Any:
+        """Override to train the model. Returns trained model."""
+        raise NotImplementedError
+
+    def evaluate(self, model: Any, X_test: Any, y_test: Any) -> dict:
+        """Override to evaluate the model. Returns metrics dict."""
+        raise NotImplementedError
+
+    def fit_scaler(self, X: np.ndarray) -> Any:
+        """Fit a StandardScaler on training features and save it.
+
+        Call this in preprocess() after splitting data, before training.
+        The scaler is saved as {model_name}_scaler.joblib for inference use.
+        """
+        from sklearn.preprocessing import StandardScaler
+        import joblib
+
+        scaler = StandardScaler()
+        scaler.fit(X)
+
+        scaler_path = self.artifact_dir / f"{self.model_name}_scaler.joblib"
+        joblib.dump(scaler, scaler_path)
+        logger.info(f"Scaler saved to {scaler_path}")
+
+        self._scaler = scaler
+        return scaler
+
+    def transform_features(self, X: np.ndarray, scaler: Any = None) -> np.ndarray:
+        """Apply a fitted StandardScaler to features.
+
+        Uses the internally stored scaler if none provided.
+        """
+        s = scaler or getattr(self, "_scaler", None)
+        if s is None:
+            logger.warning("No scaler available — returning raw features")
+            return X
+        return s.transform(X).astype(np.float32)
+
+    @staticmethod
+    def load_scaler(model_name: str) -> Any:
+        """Load a previously saved scaler for inference."""
+        import joblib
+
+        scaler_path = ARTIFACT_DIR / model_name / f"{model_name}_scaler.joblib"
+        if scaler_path.exists():
+            return joblib.load(scaler_path)
+        # Fallback: check flat models/ directory
+        flat_path = ARTIFACT_DIR / f"{model_name}_scaler.joblib"
+        if flat_path.exists():
+            return joblib.load(flat_path)
+        return None
+
+    def save(self, model: Any, metrics: dict) -> str:
+        """Save model artifact and metrics."""
+        timestamp = int(time.time())
+        artifact_path = self.artifact_dir / f"{self.model_name}_{timestamp}.pkl"
+
+        # Save metrics
+        metrics_path = self.artifact_dir / f"metrics_{timestamp}.json"
+        with open(metrics_path, "w") as f:
+            json.dump(metrics, f, indent=2)
+
+        logger.info(f"Model saved to {artifact_path}")
+        return str(artifact_path)
+
+    def run(self) -> dict:
+        """Execute the full training pipeline."""
+        start = time.time()
+        logger.info(f"Starting training pipeline for {self.model_name}")
+
+        try:
+            data = self.load_data()
+            splits = self.preprocess(data)
+            X_train, X_val, X_test, y_train, y_val, y_test = splits
+
+            model = self.train(X_train, y_train, X_val, y_val)
+            metrics = self.evaluate(model, X_test, y_test)
+            artifact_path = self.save(model, metrics)
+
+            duration = time.time() - start
+            return {
+                "model": self.model_name,
+                "status": "success",
+                "metrics": metrics,
+                "duration_seconds": round(duration, 2),
+                "artifact_path": artifact_path,
+            }
+        except Exception as e:
+            logger.error(f"Training failed for {self.model_name}: {e}")
+            return {
+                "model": self.model_name,
+                "status": "failed",
+                "error": str(e),
+                "duration_seconds": round(time.time() - start, 2),
+                "artifact_path": "",
+            }

package/chronovisor-engine/src/training/train_catalyst.py

@@ -0,0 +1,169 @@
+"""Event-aware catalyst trainer for 1d+ direction forecasts."""
+
+import time
+from pathlib import Path
+
+import joblib
+import numpy as np
+import pandas as pd
+from sklearn.metrics import accuracy_score, f1_score
+
+from .data_loader import build_feature_frame, get_training_symbols
+
+HIGH_IMPACT_EVENTS = [
+    ("2025-12-17", "fomc"),
+    ("2026-01-14", "cpi"),
+    ("2026-01-28", "fomc"),
+    ("2026-02-06", "nfp"),
+    ("2026-02-11", "cpi"),
+    ("2026-03-06", "nfp"),
+    ("2026-03-18", "fomc"),
+    ("2026-04-03", "nfp"),
+    ("2026-05-06", "fomc"),
+    ("2026-06-05", "nfp"),
+]
+
+
+def _event_features(timestamp) -> dict[str, float]:
+    event_times = [
+        (abs((timestamp - pd.Timestamp(date, tz="UTC")) / np.timedelta64(1, "D")), kind)
+        for date, kind in HIGH_IMPACT_EVENTS
+    ]
+    if not event_times:
+        return {
+            "days_to_event": 30.0,
+            "event_risk": 0.0,
+            "within_24h": 0.0,
+            "within_72h": 0.0,
+            "within_7d": 0.0,
+            "is_fomc": 0.0,
+            "is_cpi": 0.0,
+            "is_nfp": 0.0,
+        }
+    days_to_event, kind = sorted(event_times, key=lambda item: item[0])[0]
+    return {
+        "days_to_event": float(days_to_event),
+        "event_risk": float(max(0.0, 1.0 - min(days_to_event, 14.0) / 14.0)),
+        "within_24h": float(days_to_event <= 1.0),
+        "within_72h": float(days_to_event <= 3.0),
+        "within_7d": float(days_to_event <= 7.0),
+        "is_fomc": float(kind == "fomc"),
+        "is_cpi": float(kind == "cpi"),
+        "is_nfp": float(kind == "nfp"),
+    }
+
+
+class CatalystTrainer:
+    model_name = "catalyst_event"
+    artifact_path = Path("models") / "catalyst_event.joblib"
+    feature_keys = [
+        "days_to_event",
+        "event_risk",
+        "within_24h",
+        "within_72h",
+        "within_7d",
+        "is_fomc",
+        "is_cpi",
+        "is_nfp",
+        "returns_1d",
+        "returns_7d",
+        "volatility_14d",
+        "fear_greed",
+        "funding_rate",
+    ]
+
+    def run(self, days: int = 365) -> dict:
+        start = time.time()
+        rows = []
+        for symbol in get_training_symbols():
+            frame = build_feature_frame(symbol, timeframe="4h", days=days)
+            if frame.empty or len(frame) < 120:
+                continue
+            future = frame["future_return_1d"]
+            labels = np.where(future > 1.0, 2, np.where(future < -1.0, 0, 1))
+            event_rows = frame["time"].apply(_event_features)
+            event_frame = pd.DataFrame(list(event_rows))
+            merged = pd.concat(
+                [
+                    event_frame.reset_index(drop=True),
+                    frame[["returns_1d", "returns_7d", "volatility_14d", "fear_greed", "funding_rate"]].reset_index(drop=True),
+                ],
+                axis=1,
+            )
+            merged["y"] = labels
+            rows.append(merged)
+
+        if not rows:
+            return {
+                "model": self.model_name,
+                "status": "skipped",
+                "metrics": {"samples": 0},
+                "duration_seconds": round(time.time() - start, 2),
+                "artifact_path": "",
+                "error": "No catalyst training data available",
+            }
+
+        frame = pd.concat(rows, ignore_index=True).fillna(0.0)
+        X = frame[self.feature_keys].astype(np.float32).values
+        y = frame["y"].astype(np.int64).values
+        n = len(X)
+        split = int(n * 0.80)
+        X_train, X_test = X[:split], X[split:]
+        y_train, y_test = y[:split], y[split:]
+
+        try:
+            import xgboost as xgb
+
+            model = xgb.XGBClassifier(
+                n_estimators=220,
+                max_depth=4,
+                learning_rate=0.05,
+                subsample=0.85,
+                colsample_bytree=0.85,
+                objective="multi:softprob",
+                num_class=3,
+                eval_metric="mlogloss",
+                random_state=42,
+            )
+            model.fit(X_train, y_train)
+            engine = "xgboost"
+        except Exception:
+            from sklearn.ensemble import RandomForestClassifier
+
+            model = RandomForestClassifier(
+                n_estimators=250,
+                max_depth=10,
+                class_weight="balanced_subsample",
+                random_state=42,
+                n_jobs=-1,
+            )
+            model.fit(X_train, y_train)
+            engine = "random_forest"
+
+        preds = model.predict(X_test)
+        accuracy = float(accuracy_score(y_test, preds))
+        f1 = float(f1_score(y_test, preds, average="weighted", zero_division=0))
+
+        self.artifact_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(
+            {
+                "model": model,
+                "engine": engine,
+                "feature_keys": self.feature_keys,
+                "trained_at": str(int(time.time())),
+                "accuracy": accuracy,
+            },
+            self.artifact_path,
+        )
+
+        return {
+            "model": self.model_name,
+            "status": "success",
+            "metrics": {
+                "accuracy": accuracy,
+                "f1": f1,
+                "test_samples": len(X_test),
+            },
+            "duration_seconds": round(time.time() - start, 2),
+            "artifact_path": str(self.artifact_path),
+        }

package/chronovisor-engine/src/training/train_classifier.py

@@ -0,0 +1,159 @@
+"""Training script for the Random Forest signal classifier."""
+
+import os
+from pathlib import Path
+
+import numpy as np
+import joblib
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report
+
+from .data_loader import get_training_symbols, load_ohlcv
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+# Simple TA feature computation from raw OHLCV
+def compute_features(df):
+    """Compute TA features from OHLCV DataFrame for classifier training."""
+    closes = df["close"].values
+    highs = df["high"].values
+    lows = df["low"].values
+    volumes = df["volume"].values
+
+    features, labels = [], []
+
+    for i in range(50, len(closes) - 4):
+        window = closes[i - 50 : i]
+
+        # RSI(14)
+        deltas = np.diff(window[-15:])
+        gains = np.maximum(deltas, 0)
+        losses = np.abs(np.minimum(deltas, 0))
+        avg_gain = np.mean(gains) if len(gains) > 0 else 0
+        avg_loss = np.mean(losses) if len(losses) > 0 else 1e-10
+        rs = avg_gain / avg_loss
+        rsi = 100 - (100 / (1 + rs))
+
+        # EMA12, EMA26
+        ema12 = np.mean(window[-12:])
+        ema26 = np.mean(window[-26:])
+
+        # MACD histogram proxy
+        macd_hist = ema12 - ema26
+
+        # ATR(14)
+        atr_vals = []
+        for j in range(i - 14, i):
+            tr = max(
+                highs[j] - lows[j],
+                abs(highs[j] - closes[j - 1]),
+                abs(lows[j] - closes[j - 1]),
+            )
+            atr_vals.append(tr)
+        atr = np.mean(atr_vals)
+
+        # Volume ratio
+        vol_avg = np.mean(volumes[i - 20 : i])
+        vol_ratio = volumes[i] / vol_avg if vol_avg > 0 else 1
+
+        # Bollinger %B
+        sma20 = np.mean(window[-20:])
+        std20 = np.std(window[-20:])
+        upper = sma20 + 2 * std20
+        lower = sma20 - 2 * std20
+        bb_pctb = (closes[i] - lower) / (upper - lower) if (upper - lower) > 0 else 0.5
+
+        # Price as base
+        price = closes[i]
+        ema_cross_pct = ((ema12 - ema26) / price * 100) if price > 0 else 0
+        atr_pct = (atr / price * 100) if price > 0 else 0
+
+        # RSI slope (3 periods)
+        if i >= 53:
+            older_window = closes[i - 53 : i - 3]
+            older_deltas = np.diff(older_window[-15:])
+            older_gains = np.maximum(older_deltas, 0)
+            older_losses = np.abs(np.minimum(older_deltas, 0))
+            older_rs = np.mean(older_gains) / (np.mean(older_losses) + 1e-10)
+            older_rsi = 100 - (100 / (1 + older_rs))
+            rsi_slope = rsi - older_rsi
+        else:
+            rsi_slope = 0
+
+        feat = [
+            rsi, macd_hist, bb_pctb, ema12, ema26,
+            atr, 0,  # OBV placeholder
+            0,  # funding rate placeholder
+            50,  # fear/greed placeholder
+            0,  # price change 24h placeholder
+            rsi_slope, vol_ratio, ema_cross_pct, atr_pct,
+        ]
+        features.append(feat)
+
+        # Label: 4-candle forward return
+        future_close = closes[i + 4]
+        pct = (future_close - price) / price * 100
+        if pct > 1.0:
+            labels.append("buy")
+        elif pct < -1.0:
+            labels.append("sell")
+        else:
+            labels.append("hold")
+
+    return np.array(features, dtype=np.float32), np.array(labels)
+
+
+def train(days: int = 90):
+    """Train Random Forest classifier on historical data."""
+    print(f"Loading data ({days} days)...")
+
+    all_X, all_y = [], []
+    for symbol in get_training_symbols():
+        try:
+            df = load_ohlcv(symbol, "4h", days)
+            if len(df) < 100:
+                print(f"  {symbol}: insufficient data ({len(df)} rows), skipping")
+                continue
+            X, y = compute_features(df)
+            all_X.append(X)
+            all_y.append(y)
+            print(f"  {symbol}: {len(X)} samples")
+        except Exception as e:
+            print(f"  {symbol}: error — {e}")
+
+    if not all_X:
+        print("No training data available.")
+        return
+
+    X = np.concatenate(all_X)
+    y = np.concatenate(all_y)
+    unique, counts = np.unique(y, return_counts=True)
+    print(f"Total: {len(X)} samples, classes: {dict(zip(unique, counts))}")
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    clf = RandomForestClassifier(
+        n_estimators=200,
+        max_depth=12,
+        min_samples_split=10,
+        class_weight="balanced",
+        random_state=42,
+        n_jobs=-1,
+    )
+    clf.fit(X_train, y_train)
+
+    y_pred = clf.predict(X_test)
+    print("\nClassification Report:")
+    print(classification_report(y_test, y_pred))
+
+    accuracy = (y_pred == y_test).mean()
+    print(f"Test accuracy: {accuracy:.3f}")
+
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    joblib.dump(clf, MODEL_DIR / "signal_classifier.joblib")
+    print(f"Model saved to {MODEL_DIR / 'signal_classifier.joblib'}")
+
+
+if __name__ == "__main__":
+    train()

package/chronovisor-engine/src/training/train_conformal.py

@@ -0,0 +1,106 @@
+"""Conformal interval trainer for target-delta forecasts."""
+
+import re
+import time
+from pathlib import Path
+
+import joblib
+import numpy as np
+from sklearn.ensemble import GradientBoostingRegressor
+
+from .data_loader import load_target_outcomes
+from .train_direction import ALL_FEATURE_KEYS
+
+
+def _horizon_to_minutes(horizon: str) -> float:
+    total = 0.0
+    for amount, unit in re.findall(r"(\d+)(mo|y|w|d|h|m)", str(horizon or "").strip().lower()):
+        quantity = float(amount or 0)
+        if unit == "m":
+            total += quantity
+        elif unit == "h":
+            total += quantity * 60
+        elif unit == "d":
+            total += quantity * 1440
+        elif unit == "w":
+            total += quantity * 10080
+        elif unit == "mo":
+            total += quantity * 43200
+        elif unit == "y":
+            total += quantity * 525600
+    return total if total > 0 else 240.0
+
+
+class ConformalIntervalTrainer:
+    model_name = "interval_conformal_calibrator"
+    artifact_path = Path("models") / "interval_conformal_calibrator.joblib"
+
+    def run(self, days: int = 180) -> dict:
+        start = time.time()
+        outcomes = load_target_outcomes(days)
+        if len(outcomes) < 60:
+            return {
+                "model": self.model_name,
+                "status": "skipped",
+                "metrics": {"samples": len(outcomes)},
+                "duration_seconds": round(time.time() - start, 2),
+                "artifact_path": "",
+                "error": f"Need at least 60 samples, got {len(outcomes)}",
+            }
+
+        rows = []
+        for outcome in outcomes:
+            features = dict(outcome["features"])
+            features["probability_hint"] = float(outcome.get("probability", 0.5))
+            features["horizon_minutes"] = _horizon_to_minutes(str(outcome.get("horizon", "4h")))
+            rows.append(features)
+
+        feature_keys = ALL_FEATURE_KEYS + ["probability_hint", "horizon_minutes"]
+        X = np.array([[row.get(key, 0.0) for key in feature_keys] for row in rows], dtype=np.float32)
+        y = np.array([float(outcome["changePct"]) for outcome in outcomes], dtype=np.float32)
+
+        n = len(X)
+        train_end = int(n * 0.70)
+        cal_end = int(n * 0.85)
+        X_train, X_cal = X[:train_end], X[train_end:cal_end]
+        y_train, y_cal = y[:train_end], y[train_end:cal_end]
+        X_test, y_test = X[cal_end:], y[cal_end:]
+
+        base = GradientBoostingRegressor(
+            loss="absolute_error", n_estimators=250, max_depth=3, random_state=42
+        )
+        base.fit(X_train, y_train)
+
+        cal_preds = base.predict(X_cal)
+        residuals = y_cal - cal_preds
+        lower = float(np.quantile(residuals, 0.10))
+        upper = float(np.quantile(residuals, 0.90))
+
+        test_preds = base.predict(X_test)
+        coverage = float(np.mean((y_test >= test_preds + lower) & (y_test <= test_preds + upper)))
+
+        self.artifact_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(
+            {
+                "lower_residual_pct": lower,
+                "upper_residual_pct": upper,
+                "coverage": coverage,
+                "trained_at": str(int(time.time())),
+            },
+            self.artifact_path,
+        )
+
+        return {
+            "model": self.model_name,
+            "status": "success",
+            "metrics": {
+                "lower_residual_pct": lower,
+                "upper_residual_pct": upper,
+                "coverage": coverage,
+                "train_samples": len(X_train),
+                "calibration_samples": len(X_cal),
+                "test_samples": len(X_test),
+            },
+            "duration_seconds": round(time.time() - start, 2),
+            "artifact_path": str(self.artifact_path),
+        }