@vizzor/cli 0.13.1 → 0.14.5

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

@@ -0,0 +1,115 @@
+"""Target quantile trainer for bull/base/bear price-delta forecasts."""
+
+import re
+import time
+from pathlib import Path
+
+import joblib
+import numpy as np
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.metrics import mean_absolute_error
+
+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 TargetQuantileTrainer:
+    model_name = "target_xgb_quantile"
+    artifact_path = Path("models") / "target_xgb_quantile.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)
+        val_end = int(n * 0.85)
+        X_train, X_val, X_test = X[:train_end], X[train_end:val_end], X[val_end:]
+        y_train, y_val, y_test = y[:train_end], y[train_end:val_end], y[val_end:]
+
+        models = {
+            "q10": GradientBoostingRegressor(
+                loss="quantile", alpha=0.10, n_estimators=250, max_depth=3, random_state=42
+            ),
+            "q50": GradientBoostingRegressor(
+                loss="absolute_error", n_estimators=250, max_depth=3, random_state=42
+            ),
+            "q90": GradientBoostingRegressor(
+                loss="quantile", alpha=0.90, n_estimators=250, max_depth=3, random_state=42
+            ),
+        }
+
+        for model in models.values():
+            model.fit(X_train, y_train)
+
+        low = models["q10"].predict(X_test)
+        base = models["q50"].predict(X_test)
+        high = models["q90"].predict(X_test)
+        coverage = float(np.mean((y_test >= low) & (y_test <= high)))
+        mae = float(mean_absolute_error(y_test, base))
+
+        self.artifact_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(
+            {
+                "models": models,
+                "feature_keys": feature_keys,
+                "trained_at": str(int(time.time())),
+                "accuracy": 1.0 / (1.0 + mae),
+                "mae": mae,
+                "coverage": coverage,
+            },
+            self.artifact_path,
+        )
+
+        return {
+            "model": self.model_name,
+            "status": "success",
+            "metrics": {
+                "mae": mae,
+                "coverage": coverage,
+                "train_samples": len(X_train),
+                "val_samples": len(X_val),
+                "test_samples": len(X_test),
+            },
+            "duration_seconds": round(time.time() - start, 2),
+            "artifact_path": str(self.artifact_path),
+        }

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

@@ -0,0 +1,101 @@
+"""Trend scorer training on real historical OHLCV and snapshot-derived features."""
+
+import logging
+import time
+
+import numpy as np
+
+from .data_loader import load_trend_training_frame
+from .pipeline import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+
+class TrendTrainer(TrainingPipeline):
+    FEATURE_KEYS = [
+        "price_change_24h",
+        "price_change_7d",
+        "volume_24h",
+        "market_cap",
+        "volume_to_mcap_ratio",
+        "rank",
+    ]
+
+    def __init__(self):
+        super().__init__("trend_scorer")
+
+    def load_data(self):
+        logger.info("Loading real trend scoring data from OHLCV history...")
+        frame = load_trend_training_frame(days=240, timeframe="4h")
+        if frame.empty:
+            raise RuntimeError("No historical trend training data available")
+        return frame
+
+    def preprocess(self, data):
+        data = data.sort_index().reset_index(drop=True)
+        X = data[self.FEATURE_KEYS].fillna(0.0).astype(np.float32).values
+        y = data["y"].astype(np.float32).values
+
+        n = len(X)
+        train_end = int(n * 0.70)
+        val_end = int(n * 0.85)
+
+        return X[:train_end], X[train_end:val_end], X[val_end:], y[:train_end], y[train_end:val_end], y[val_end:]
+
+    def train(self, X_train, y_train, X_val, y_val):
+        try:
+            import xgboost as xgb
+
+            model = xgb.XGBRegressor(
+                n_estimators=300,
+                max_depth=4,
+                learning_rate=0.05,
+                subsample=0.85,
+                colsample_bytree=0.85,
+                reg_alpha=0.05,
+                reg_lambda=1.0,
+                objective="reg:squarederror",
+                eval_metric="rmse",
+                early_stopping_rounds=25,
+                random_state=42,
+            )
+            model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False)
+            return model
+        except Exception:
+            from sklearn.ensemble import RandomForestRegressor
+
+            model = RandomForestRegressor(
+                n_estimators=250,
+                max_depth=10,
+                min_samples_leaf=5,
+                random_state=42,
+                n_jobs=-1,
+            )
+            model.fit(X_train, y_train)
+            return model
+
+    def evaluate(self, model, X_test, y_test):
+        from sklearn.metrics import mean_absolute_error, r2_score
+
+        preds = np.clip(model.predict(X_test), 0, 100)
+        return {
+            "r2": float(r2_score(y_test, preds)),
+            "mae": float(mean_absolute_error(y_test, preds)),
+            "test_samples": len(y_test),
+        }
+
+    def save(self, model, metrics):
+        import joblib
+
+        super().save(model, metrics)
+        artifact_path = self.artifact_dir.parent / "trend_scorer.joblib"
+        joblib.dump(
+            {
+                "model": model,
+                "trained_at": str(int(time.time())),
+                "accuracy": metrics.get("r2"),
+                "feature_keys": self.FEATURE_KEYS,
+            },
+            artifact_path,
+        )
+        return str(artifact_path)