@vizzor/cli 0.13.1 → 0.14.5

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

@@ -0,0 +1,341 @@
+"""TA Interpreter — Random Forest classifier for technical signal interpretation."""
+
+import os
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class TAInterpreter:
+    """Interprets technical indicators into actionable signals with learned weights."""
+
+    FEATURE_KEYS = [
+        "rsi",
+        "macd_histogram",
+        "macd_line",
+        "macd_signal",
+        "bb_percent_b",
+        "bb_bandwidth",
+        "ema12",
+        "ema26",
+        "ema_cross_pct",
+        "atr",
+        "atr_pct",
+        "obv",
+        "price_change",
+    ]
+
+    SIGNAL_NAMES = ["RSI", "MACD", "Bollinger Bands", "EMA Crossover", "ATR", "OBV"]
+
+    DEFAULT_WEIGHTS = {
+        "RSI": 20,
+        "MACD": 20,
+        "Bollinger Bands": 15,
+        "EMA Crossover": 20,
+        "ATR": 10,
+        "OBV": 15,
+    }
+
+    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
+
+    def load(self) -> None:
+        model_path = MODEL_DIR / "ta_interpreter.joblib"
+        try:
+            data = joblib.load(model_path)
+            self.model = data["model"]
+            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:
+        x = np.array([[features.get(k, 0) for k in self.FEATURE_KEYS]])
+
+        # Get probabilities for composite direction
+        proba = self.model.predict_proba(x)[0]
+        classes = list(self.model.classes_)
+
+        # Build weights from feature importances
+        weights = dict(self.DEFAULT_WEIGHTS)
+        if hasattr(self.model, "feature_importances_"):
+            imp = self.model.feature_importances_
+            # Map feature importances to signal groups
+            signal_imp = {
+                "RSI": float(imp[0]) if len(imp) > 0 else 0.2,
+                "MACD": float(np.mean(imp[1:4])) if len(imp) > 3 else 0.2,
+                "Bollinger Bands": float(np.mean(imp[4:6])) if len(imp) > 5 else 0.15,
+                "EMA Crossover": float(np.mean(imp[6:9])) if len(imp) > 8 else 0.2,
+                "ATR": float(np.mean(imp[9:11])) if len(imp) > 10 else 0.1,
+                "OBV": float(imp[11]) if len(imp) > 11 else 0.15,
+            }
+            total = sum(signal_imp.values()) or 1
+            weights = {k: round(v / total * 100, 1) for k, v in signal_imp.items()}
+
+        # Generate signals from heuristic (structure), but use ML weights/composite
+        signals = self._interpret_signals(features)
+
+        # Composite from ML
+        pred_idx = int(np.argmax(proba))
+        direction = classes[pred_idx] if pred_idx < len(classes) else "neutral"
+        confidence = float(proba[pred_idx]) * 100
+
+        # Score: positive = bullish, negative = bearish
+        bull_prob = proba[classes.index("bullish")] if "bullish" in classes else 0
+        bear_prob = proba[classes.index("bearish")] if "bearish" in classes else 0
+        score = (bull_prob - bear_prob) * 100
+
+        return {
+            "signals": signals,
+            "weights": weights,
+            "composite": {
+                "direction": direction,
+                "score": round(score, 2),
+                "confidence": round(min(100, confidence), 2),
+            },
+            "model": "rf-ta-interpreter",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        signals = self._interpret_signals(features)
+        weights = dict(self.DEFAULT_WEIGHTS)
+
+        # Composite: weighted average of signal strengths
+        total_weight = 0
+        weighted_score = 0
+        for sig in signals:
+            w = weights.get(sig["name"], 10)
+            total_weight += w
+            dir_score = (
+                sig["strength"]
+                if sig["direction"] == "bullish"
+                else -sig["strength"]
+                if sig["direction"] == "bearish"
+                else 0
+            )
+            weighted_score += dir_score * w
+
+        score = weighted_score / total_weight if total_weight > 0 else 0
+        direction = "bullish" if score > 15 else "bearish" if score < -15 else "neutral"
+
+        # Confidence from signal agreement
+        bull_count = sum(1 for s in signals if s["direction"] == "bullish")
+        bear_count = sum(1 for s in signals if s["direction"] == "bearish")
+        total_dir = bull_count + bear_count
+        agreement = max(bull_count, bear_count) / total_dir if total_dir > 0 else 0
+        confidence = agreement * 100 * (len(signals) / 6)
+
+        return {
+            "signals": signals,
+            "weights": {k: float(v) for k, v in weights.items()},
+            "composite": {
+                "direction": direction,
+                "score": round(score, 2),
+                "confidence": round(min(100, confidence), 2),
+            },
+            "model": "heuristic-ta-interpreter",
+        }
+
+    def _interpret_signals(self, features: dict) -> list[dict]:
+        signals = []
+
+        # RSI
+        rsi = features.get("rsi", 50)
+        if rsi > 70:
+            signals.append(
+                {
+                    "name": "RSI",
+                    "direction": "bearish",
+                    "strength": min(100, 50 + (rsi - 70) * 1.5),
+                    "description": f"RSI {rsi:.1f} — overbought territory",
+                }
+            )
+        elif rsi < 30:
+            signals.append(
+                {
+                    "name": "RSI",
+                    "direction": "bullish",
+                    "strength": min(100, 50 + (30 - rsi) * 1.5),
+                    "description": f"RSI {rsi:.1f} — oversold territory",
+                }
+            )
+        else:
+            direction = (
+                "bullish" if rsi > 60 else "bearish" if rsi < 40 else "neutral"
+            )
+            strength = 40 + abs(rsi - 50) if direction != "neutral" else 30
+            signals.append(
+                {
+                    "name": "RSI",
+                    "direction": direction,
+                    "strength": strength,
+                    "description": f"RSI {rsi:.1f} — {'bullish' if rsi > 60 else 'bearish' if rsi < 40 else 'neutral'} zone",
+                }
+            )
+
+        # MACD
+        histogram = features.get("macd_histogram", 0)
+        if histogram > 0:
+            signals.append(
+                {
+                    "name": "MACD",
+                    "direction": "bullish",
+                    "strength": min(90, 50 + abs(histogram) * 100),
+                    "description": f"MACD histogram positive ({histogram:.4f}) — bullish momentum",
+                }
+            )
+        elif histogram < 0:
+            signals.append(
+                {
+                    "name": "MACD",
+                    "direction": "bearish",
+                    "strength": min(90, 50 + abs(histogram) * 100),
+                    "description": f"MACD histogram negative ({histogram:.4f}) — bearish momentum",
+                }
+            )
+        else:
+            signals.append(
+                {
+                    "name": "MACD",
+                    "direction": "neutral",
+                    "strength": 30,
+                    "description": "MACD at signal line — no clear direction",
+                }
+            )
+
+        # Bollinger Bands
+        pct_b = features.get("bb_percent_b", 0.5)
+        if pct_b > 0.8:
+            signals.append(
+                {
+                    "name": "Bollinger Bands",
+                    "direction": "bearish",
+                    "strength": 55,
+                    "description": f"Price near upper band (%B: {pct_b:.2f}) — potential pullback",
+                }
+            )
+        elif pct_b < 0.2:
+            signals.append(
+                {
+                    "name": "Bollinger Bands",
+                    "direction": "bullish",
+                    "strength": 55,
+                    "description": f"Price near lower band (%B: {pct_b:.2f}) — potential bounce",
+                }
+            )
+        else:
+            signals.append(
+                {
+                    "name": "Bollinger Bands",
+                    "direction": "neutral",
+                    "strength": 30,
+                    "description": f"Price within bands (%B: {pct_b:.2f})",
+                }
+            )
+
+        # EMA Crossover
+        ema_cross = features.get("ema_cross_pct", 0)
+        if ema_cross > 0:
+            signals.append(
+                {
+                    "name": "EMA Crossover",
+                    "direction": "bullish",
+                    "strength": min(90, 50 + abs(ema_cross) * 10),
+                    "description": f"EMA(12) above EMA(26) by {ema_cross:.2f}% — bullish trend",
+                }
+            )
+        elif ema_cross < 0:
+            signals.append(
+                {
+                    "name": "EMA Crossover",
+                    "direction": "bearish",
+                    "strength": min(90, 50 + abs(ema_cross) * 10),
+                    "description": f"EMA(12) below EMA(26) by {abs(ema_cross):.2f}% — bearish trend",
+                }
+            )
+        else:
+            signals.append(
+                {
+                    "name": "EMA Crossover",
+                    "direction": "neutral",
+                    "strength": 30,
+                    "description": "EMA(12) = EMA(26) — no trend",
+                }
+            )
+
+        # ATR
+        atr_pct = features.get("atr_pct", 0)
+        if atr_pct > 5:
+            desc = f"ATR {atr_pct:.2f}% — high volatility"
+        elif atr_pct > 2:
+            desc = f"ATR {atr_pct:.2f}% — moderate volatility"
+        else:
+            desc = f"ATR {atr_pct:.2f}% — low volatility"
+        signals.append(
+            {"name": "ATR", "direction": "neutral", "strength": 40, "description": desc}
+        )
+
+        # OBV
+        obv = features.get("obv", 0)
+        price_change = features.get("price_change", 0)
+        if obv > 0 and price_change > 0:
+            signals.append(
+                {
+                    "name": "OBV",
+                    "direction": "bullish",
+                    "strength": 65,
+                    "description": "OBV positive with rising price — confirmed uptrend",
+                }
+            )
+        elif obv > 0 and price_change <= 0:
+            signals.append(
+                {
+                    "name": "OBV",
+                    "direction": "bullish",
+                    "strength": 70,
+                    "description": "OBV positive but price flat/down — accumulation",
+                }
+            )
+        elif obv < 0 and price_change < 0:
+            signals.append(
+                {
+                    "name": "OBV",
+                    "direction": "bearish",
+                    "strength": 65,
+                    "description": "OBV negative with falling price — confirmed downtrend",
+                }
+            )
+        elif obv < 0 and price_change >= 0:
+            signals.append(
+                {
+                    "name": "OBV",
+                    "direction": "bearish",
+                    "strength": 70,
+                    "description": "OBV negative but price flat/up — distribution",
+                }
+            )
+        else:
+            signals.append(
+                {
+                    "name": "OBV",
+                    "direction": "neutral",
+                    "strength": 30,
+                    "description": "OBV neutral",
+                }
+            )
+
+        return signals

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

@@ -0,0 +1,96 @@
+"""Quantile target model for price-delta forecasts."""
+
+import os
+import re
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+from ..training.train_direction import ALL_FEATURE_KEYS
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+def _horizon_to_minutes(horizon: str) -> float:
+    value = str(horizon or "4h").strip().lower()
+    total = 0.0
+    for amount, unit in re.findall(r"(\d+)(mo|y|w|d|h|m)", value):
+        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 TargetQuantileModel:
+    FEATURE_KEYS = ALL_FEATURE_KEYS + ["probability_hint", "horizon_minutes"]
+
+    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.models: dict[str, object] = {}
+
+    def load(self) -> None:
+        path = MODEL_DIR / "target_xgb_quantile.joblib"
+        try:
+            data = joblib.load(path)
+            self.models = data.get("models", {})
+            self.last_trained = data.get("trained_at")
+            self.accuracy = data.get("accuracy")
+            self.is_loaded = True
+        except Exception:
+            self.models = {}
+            self.is_loaded = True
+
+    def predict(self, features: dict) -> dict:
+        if self.models:
+            return self._predict_model(features)
+        return self._predict_heuristic(features)
+
+    def _predict_model(self, features: dict) -> dict:
+        enriched = dict(features)
+        enriched["probability_hint"] = float(features.get("probability_hint", 0.5))
+        enriched["horizon_minutes"] = _horizon_to_minutes(str(features.get("horizon", "4h")))
+        x = np.array([[enriched.get(k, 0.0) for k in self.FEATURE_KEYS]], dtype=np.float32)
+        q10 = float(self.models["q10"].predict(x)[0])
+        q50 = float(self.models["q50"].predict(x)[0])
+        q90 = float(self.models["q90"].predict(x)[0])
+        low, base, high = sorted([q10, q50, q90])
+        return {
+            "low_change_pct": round(low, 4),
+            "base_change_pct": round(base, 4),
+            "high_change_pct": round(high, 4),
+            "direction_bias": "up" if base > 0.1 else "down" if base < -0.1 else "sideways",
+            "interval_width_pct": round(high - low, 4),
+            "model": "target_xgb_quantile",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        base = (
+            float(features.get("emaCrossoverPct", 0.0)) * 0.35
+            + float(features.get("macdHistogram", 0.0)) * 2.0
+            + float(features.get("rsiSlope", 0.0)) * 0.08
+        )
+        width = max(0.35, float(features.get("atrPct", 0.5)) * 1.4)
+        low = base - width
+        high = base + width
+        return {
+            "low_change_pct": round(low, 4),
+            "base_change_pct": round(base, 4),
+            "high_change_pct": round(high, 4),
+            "direction_bias": "up" if base > 0.1 else "down" if base < -0.1 else "sideways",
+            "interval_width_pct": round(high - low, 4),
+            "model": "heuristic-target-quantile",
+        }

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

@@ -0,0 +1,107 @@
+"""Trend Scorer — XGBoost regressor for market trend strength."""
+
+import os
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class TrendScorer:
+    """Predicts trend strength (0-100) and direction from market features."""
+
+    FEATURE_KEYS = [
+        "price_change_24h",
+        "price_change_7d",
+        "volume_24h",
+        "market_cap",
+        "volume_to_mcap_ratio",
+        "rank",
+    ]
+
+    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
+
+    def load(self) -> None:
+        model_path = MODEL_DIR / "trend_scorer.joblib"
+        try:
+            data = joblib.load(model_path)
+            self.model = data["model"]
+            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:
+        x = np.array([[features.get(k, 0) for k in self.FEATURE_KEYS]])
+        score = float(np.clip(self.model.predict(x)[0], 0, 100))
+
+        # Feature importances
+        importances = {}
+        if hasattr(self.model, "feature_importances_"):
+            for key, imp in zip(self.FEATURE_KEYS, self.model.feature_importances_):
+                importances[key] = round(float(imp), 4)
+
+        direction = "bullish" if score > 60 else "bearish" if score < 40 else "neutral"
+        confidence = abs(score - 50) * 2  # 0-100 scale
+
+        return {
+            "score": round(score, 2),
+            "direction": direction,
+            "confidence": round(min(100, confidence), 2),
+            "feature_importances": importances,
+            "model": "xgboost-trend-scorer",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        score = 50.0
+
+        pc24h = features.get("price_change_24h", 0)
+        pc7d = features.get("price_change_7d", 0)
+        vol = features.get("volume_24h", 0)
+        mcap = features.get("market_cap", 0)
+
+        signals = []
+
+        if pc24h > 5:
+            score += 15
+            signals.append(f"Strong 24h gain: +{pc24h:.2f}%")
+        elif pc24h < -5:
+            score -= 15
+            signals.append(f"Significant 24h drop: {pc24h:.2f}%")
+
+        if pc7d > 10:
+            score += 20
+            signals.append(f"Bullish weekly trend: +{pc7d:.2f}%")
+        elif pc7d < -10:
+            score -= 20
+            signals.append(f"Bearish weekly trend: {pc7d:.2f}%")
+
+        if mcap > 0 and vol > mcap * 0.1:
+            score += 5
+            signals.append("High volume relative to market cap")
+
+        score = max(0, min(100, score))
+        direction = "bullish" if score > 60 else "bearish" if score < 40 else "neutral"
+        confidence = abs(score - 50) * 2
+
+        return {
+            "score": round(score, 2),
+            "direction": direction,
+            "confidence": round(min(100, confidence), 2),
+            "feature_importances": {},
+            "model": "heuristic-trend-scorer",
+        }