@vizzor/cli 0.13.0 → 0.14.5

package/chronovisor-engine/src/models/signal_classifier.py

@@ -0,0 +1,191 @@
+"""Random Forest signal classifier.
+
+Input: AgentSignals + derived features → buy/sell/hold classification.
+Labels derived from outcome: did price go up/down in next N hours?
+Replaces hardcoded thresholds in strategies.
+"""
+
+import os
+from pathlib import Path
+
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+# Feature keys matching FeatureVector from Node.js side
+FEATURE_KEYS = [
+    "rsi", "macdHistogram", "bollingerPercentB", "ema12", "ema26",
+    "atr", "obv", "fundingRate", "fearGreed", "priceChange24h",
+    "rsiSlope", "volumeRatio", "emaCrossoverPct", "atrPct",
+]
+
+
+class SignalClassifier:
+    def __init__(self):
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.accuracy: float | None = None
+        self.model = None
+        self.xgb_models: dict = {}  # profile → XGBClassifier
+
+    def load(self):
+        """Load trained model: prefer XGBoost > Random Forest > heuristic."""
+        # Try XGBoost direction models first (one per profile)
+        self._load_xgboost_models()
+        if self.xgb_models:
+            self.is_loaded = True
+            self.version = "0.2.0-xgboost"
+            return
+
+        # Fall back to Random Forest
+        model_path = MODEL_DIR / "signal_classifier.joblib"
+        if model_path.exists():
+            try:
+                import joblib
+                self.model = joblib.load(model_path)
+                self.is_loaded = True
+                self.last_trained = str(model_path.stat().st_mtime)
+            except Exception:
+                self._init_heuristic()
+        else:
+            self._init_heuristic()
+
+    def _load_xgboost_models(self):
+        """Load XGBoost direction models for each horizon profile."""
+        for profile in ("scalp", "standard", "position"):
+            model_path = MODEL_DIR / f"xgb_direction_{profile}.json"
+            if model_path.exists():
+                try:
+                    import xgboost as xgb
+                    m = xgb.XGBClassifier()
+                    m.load_model(str(model_path))
+                    self.xgb_models[profile] = m
+                    self.last_trained = str(model_path.stat().st_mtime)
+                except Exception:
+                    pass  # Skip this profile, fall through to RF or heuristic
+
+    def _init_heuristic(self):
+        self.is_loaded = True
+        self.version = "0.1.0-heuristic"
+
+    def predict(self, features: dict) -> dict:
+        """Classify signals into buy/sell/hold.
+
+        Returns:
+            dict with keys: direction, probability, model
+        """
+        # Prefer XGBoost when available for the given horizon profile
+        if self.xgb_models:
+            return self._predict_xgboost(features)
+        if self.model is not None:
+            return self._predict_model(features)
+        return self._predict_heuristic(features)
+
+    def _predict_xgboost(self, features: dict) -> dict:
+        """Run inference through trained XGBoost direction model."""
+        horizon = features.get("horizon", "4h")
+        # Determine profile from horizon
+        scalp = {"5m", "15m", "30m"}
+        position = {"1d", "7d"}
+        if horizon in scalp:
+            profile = "scalp"
+        elif horizon in position:
+            profile = "position"
+        else:
+            profile = "standard"
+
+        model = self.xgb_models.get(profile) or self.xgb_models.get("standard")
+        if model is None:
+            return self._predict_heuristic(features)
+
+        from ..training.train_direction import ALL_FEATURE_KEYS
+        X = np.array([[features.get(k, 0) for k in ALL_FEATURE_KEYS]])
+        proba = model.predict_proba(X)[0]
+        idx = int(np.argmax(proba))
+        direction_map = {0: "down", 1: "sideways", 2: "up"}
+        return {
+            "direction": direction_map.get(idx, "sideways"),
+            "probability": float(proba[idx]),
+            "model": f"xgb-direction-{profile}",
+        }
+
+    def _predict_model(self, features: dict) -> dict:
+        """Run inference through trained Random Forest."""
+        X = np.array([[features.get(k, 0) for k in FEATURE_KEYS]])
+        proba = self.model.predict_proba(X)[0]
+        classes = self.model.classes_
+        idx = int(np.argmax(proba))
+        direction_map = {"buy": "up", "sell": "down", "hold": "sideways"}
+        direction = direction_map.get(classes[idx], "sideways")
+        return {
+            "direction": direction,
+            "probability": float(proba[idx]),
+            "model": f"signal-classifier-{self.version}",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        """Rule-based classification until model is trained.
+
+        Conservative by design: high direction threshold (±40) and capped
+        probability (0.70) so the heuristic doesn't feed overconfident
+        directional signal into the CF algebra ensemble.
+        """
+        rsi = features.get("rsi", 50)
+        macd = features.get("macdHistogram", 0)
+        bb_pct = features.get("bollingerPercentB", 0.5)
+        funding = features.get("fundingRate", 0)
+        fg = features.get("fearGreed", 50)
+        rsi_slope = features.get("rsiSlope", 0)
+        vol_ratio = features.get("volumeRatio", 1)
+        ema_cross = features.get("emaCrossoverPct", 0)
+
+        score = 0.0
+
+        # RSI signal — only extreme values trigger
+        if rsi < 25:
+            score += 25
+        elif rsi < 35:
+            score += 10
+        elif rsi > 75:
+            score -= 25
+        elif rsi > 65:
+            score -= 10
+
+        # MACD — capped contribution to ±15
+        macd_contrib = max(-15, min(15, macd * 10))
+        score += macd_contrib
+
+        # Bollinger Bands — only extremes
+        if bb_pct < 0.1:
+            score += 12
+        elif bb_pct > 0.9:
+            score -= 12
+
+        # Funding rate (contrarian)
+        if funding > 0.0005:
+            score -= 8
+        elif funding < -0.0003:
+            score += 8
+
+        # Fear & Greed (contrarian at extremes only)
+        if fg < 15:
+            score += 8
+        elif fg > 85:
+            score -= 8
+
+        # Momentum signals — reduced contribution
+        score += rsi_slope * 1.2
+        if vol_ratio > 2.5:
+            score += 6 if score > 0 else -6
+        score += ema_cross * 3
+
+        # Flatter probability curve: divisor 300 → max ~0.70 at extreme scores
+        probability = min(0.70, max(0.3, 0.5 + abs(score) / 300))
+
+        # Higher direction threshold: ±40 → more sideways classifications
+        if score > 40:
+            return {"direction": "up", "probability": probability, "model": "rf-heuristic"}
+        elif score < -40:
+            return {"direction": "down", "probability": probability, "model": "rf-heuristic"}
+        return {"direction": "sideways", "probability": probability, "model": "rf-heuristic"}

package/chronovisor-engine/src/models/stacking_meta.py

@@ -0,0 +1,56 @@
+"""Meta-confidence model for champion/challenger promotion and filtering."""
+
+import os
+from pathlib import Path
+
+import joblib
+import numpy as np
+import pandas as pd
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class StackingMetaModel:
+    def __init__(self) -> None:
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.accuracy: float | None = None
+        self.model = None
+        self.columns: list[str] = []
+
+    def load(self) -> None:
+        path = MODEL_DIR / "meta_stacking.joblib"
+        try:
+            data = joblib.load(path)
+            self.model = data["model"]
+            self.columns = data.get("columns", [])
+            self.last_trained = data.get("trained_at")
+            self.accuracy = data.get("accuracy")
+            self.is_loaded = True
+        except Exception:
+            self.model = None
+            self.columns = []
+            self.is_loaded = True
+
+    def predict(self, features: dict) -> dict:
+        if self.model is None:
+            probability = float(features.get("probability", 0.5))
+            return {
+                "correctness_probability": round(probability, 4),
+                "verdict": "take" if probability >= 0.6 else "skip",
+                "model": "heuristic-meta-stacking",
+            }
+
+        frame = pd.DataFrame([features])
+        frame = pd.get_dummies(frame, columns=["model", "horizon"], dtype=float)
+        for column in self.columns:
+            if column not in frame:
+                frame[column] = 0.0
+        frame = frame[self.columns]
+        probability = float(self.model.predict_proba(frame)[0][1])
+        return {
+            "correctness_probability": round(probability, 4),
+            "verdict": "take" if probability >= 0.6 else "skip",
+            "model": "meta_stacking",
+        }

package/chronovisor-engine/src/models/strategy_bandit.py

@@ -0,0 +1,191 @@
+"""Strategy Bandit — Contextual bandit for trading action selection."""
+
+import os
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class StrategyBandit:
+    """Selects buy/sell/hold actions using contextual bandit or heuristic fallback."""
+
+    FEATURE_KEYS = [
+        "rsi",
+        "macd_histogram",
+        "ema12",
+        "ema26",
+        "bollinger_pct_b",
+        "atr",
+        "obv",
+        "funding_rate",
+        "fear_greed",
+        "price_change_24h",
+        "price",
+        "regime",
+    ]
+
+    REGIME_MAP = {
+        "trending_bull": 1.0,
+        "trending_bear": -1.0,
+        "ranging": 0.0,
+        "volatile": 0.5,
+        "capitulation": -2.0,
+    }
+
+    def __init__(self) -> None:
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.accuracy: float | None = None
+        self.model = None
+        self.epsilon = 0.1
+
+    def load(self) -> None:
+        model_path = MODEL_DIR / "strategy_bandit.joblib"
+        try:
+            data = joblib.load(model_path)
+            self.model = data["model"]
+            self.epsilon = data.get("epsilon", 0.1)
+            self.last_trained = data.get("trained_at")
+            self.accuracy = data.get("accuracy")
+            self.is_loaded = True
+        except Exception:
+            self.model = None
+            self.is_loaded = True  # heuristic fallback ready
+
+    def predict(self, features: dict) -> dict:
+        if self.model is not None:
+            return self._predict_model(features)
+        return self._predict_heuristic(features)
+
+    def _predict_model(self, features: dict) -> dict:
+        # Encode regime as numeric
+        regime_val = self.REGIME_MAP.get(str(features.get("regime", "ranging")), 0.0)
+        x_raw = []
+        for k in self.FEATURE_KEYS:
+            if k == "regime":
+                x_raw.append(regime_val)
+            else:
+                x_raw.append(features.get(k, 0))
+
+        x = np.array([x_raw])
+
+        # Model predicts action probabilities
+        proba = self.model.predict_proba(x)[0]
+        classes = list(self.model.classes_)
+
+        pred_idx = int(np.argmax(proba))
+        action = classes[pred_idx] if pred_idx < len(classes) else "hold"
+        confidence = float(proba[pred_idx]) * 100
+
+        # Position size based on confidence
+        position_size_pct = min(25, confidence * 0.25)
+
+        reasoning = [
+            f"ML bandit: {action} with {confidence:.0f}% confidence",
+        ]
+
+        return {
+            "action": action,
+            "confidence": round(min(100, confidence), 2),
+            "position_size_pct": round(position_size_pct, 2),
+            "reasoning": reasoning,
+            "model": "contextual-bandit",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        reasoning = []
+        score = 0
+
+        rsi = features.get("rsi", 50)
+        macd_hist = features.get("macd_histogram", 0)
+        ema12 = features.get("ema12", 0)
+        ema26 = features.get("ema26", 0)
+        bb_pct_b = features.get("bollinger_pct_b", 0.5)
+        funding = features.get("funding_rate", 0)
+        fg = features.get("fear_greed", 50)
+        pc24h = features.get("price_change_24h", 0)
+
+        # RSI with adaptive thresholds
+        if rsi < 25:
+            score += 35
+            reasoning.append(f"RSI deeply oversold ({rsi:.0f})")
+        elif rsi < 35:
+            score += 20
+            reasoning.append(f"RSI oversold zone ({rsi:.0f})")
+        elif rsi > 75:
+            score -= 35
+            reasoning.append(f"RSI deeply overbought ({rsi:.0f})")
+        elif rsi > 65:
+            score -= 20
+            reasoning.append(f"RSI overbought zone ({rsi:.0f})")
+
+        # MACD
+        if macd_hist > 0:
+            score += 15
+            reasoning.append("MACD bullish momentum")
+        elif macd_hist < 0:
+            score -= 15
+            reasoning.append("MACD bearish momentum")
+
+        # EMA crossover
+        if ema26 != 0:
+            cross_pct = ((ema12 - ema26) / ema26) * 100
+            if cross_pct > 0.5:
+                score += 20
+                reasoning.append(f"Golden cross (EMA gap {cross_pct:.2f}%)")
+            elif cross_pct < -0.5:
+                score -= 20
+                reasoning.append(f"Death cross (EMA gap {cross_pct:.2f}%)")
+
+        # Bollinger Bands
+        if bb_pct_b < 0.1:
+            score += 15
+            reasoning.append("Price at lower Bollinger Band")
+        elif bb_pct_b > 0.9:
+            score -= 15
+            reasoning.append("Price at upper Bollinger Band")
+
+        # Funding rate (contrarian)
+        if funding > 0.0005:
+            score -= 10
+            reasoning.append("High funding rate — overleveraged longs")
+        elif funding < -0.0003:
+            score += 10
+            reasoning.append("Negative funding — capitulation signal")
+
+        # Fear & Greed
+        if fg < 20:
+            score += 10
+            reasoning.append("Extreme fear — contrarian bullish")
+        elif fg > 80:
+            score -= 10
+            reasoning.append("Extreme greed — contrarian bearish")
+
+        # 24h trend
+        if pc24h > 5:
+            score += 10
+        elif pc24h < -5:
+            score -= 10
+
+        confidence = min(95, abs(score))
+        position_size_pct = min(25, confidence * 0.25)
+
+        if score > 20:
+            action = "buy"
+        elif score < -20:
+            action = "sell"
+        else:
+            action = "hold"
+            reasoning.append("Mixed signals — holding")
+
+        return {
+            "action": action,
+            "confidence": round(confidence, 2),
+            "position_size_pct": round(position_size_pct, 2),
+            "reasoning": reasoning,
+            "model": "heuristic-strategy-bandit",
+        }