@vizzor/cli 0.13.0 → 0.14.5

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

@@ -0,0 +1,168 @@
+"""Training pipeline for narrative detection model."""
+
+import logging
+
+import numpy as np
+
+from .pipeline import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+# Sample narrative corpus for pipeline testing
+SAMPLE_NARRATIVES = {
+    "ai_crypto": [
+        "AI agents are revolutionizing crypto trading with new inference tokens",
+        "Decentralized AI compute networks see massive growth in TVL",
+        "New LLM-powered trading bots leverage on-chain data for alpha",
+    ],
+    "rwa": [
+        "Tokenized treasury bills gain institutional adoption as yields rise",
+        "Real world asset protocols see record inflows from TradFi",
+        "Ondo Finance launches new tokenized bond product on Ethereum",
+    ],
+    "depin": [
+        "DePIN networks expand hardware infrastructure with new sensor deployments",
+        "Helium and Hivemapper lead physical infrastructure narrative growth",
+        "Render Network compute demand surges amid AI training requirements",
+    ],
+    "meme": [
+        "Memecoin season returns as PEPE and WIF hit new highs on Solana",
+        "Pump.fun launches see degen traders ape into new fair launch tokens",
+        "Community-driven meme tokens dominate social media sentiment",
+    ],
+    "defi_revival": [
+        "DeFi TVL crosses $100B as Aave and Uniswap report record volumes",
+        "Lending protocols see yield compression as liquidity floods back",
+        "Perpetual DEX volumes surpass centralized exchange competitors",
+    ],
+}
+
+
+def build_narrative_corpus() -> dict[str, np.ndarray]:
+    """Build training corpus from crypto news sources.
+
+    Generates TF-IDF feature vectors from narrative text samples.
+    """
+    logger.info("Building narrative detection corpus...")
+
+    texts: list[str] = []
+    labels: list[int] = []
+    label_map = list(SAMPLE_NARRATIVES.keys())
+
+    for label_idx, (narrative, samples) in enumerate(SAMPLE_NARRATIVES.items()):
+        # Augment each sample with slight variations
+        for sample in samples:
+            texts.append(sample)
+            labels.append(label_idx)
+            # Simple augmentation: shuffle words
+            words = sample.split()
+            for _ in range(3):
+                np.random.shuffle(words)
+                texts.append(" ".join(words))
+                labels.append(label_idx)
+
+    # Convert to simple bag-of-words features for pipeline compatibility
+    all_words = set()
+    for text in texts:
+        all_words.update(text.lower().split())
+    vocab = sorted(all_words)
+    word_to_idx = {w: i for i, w in enumerate(vocab)}
+
+    n_samples = len(texts)
+    n_features = len(vocab)
+    X = np.zeros((n_samples, min(n_features, 200)), dtype=np.float32)
+
+    for i, text in enumerate(texts):
+        words = text.lower().split()
+        for word in words:
+            idx = word_to_idx.get(word, -1)
+            if 0 <= idx < X.shape[1]:
+                X[i, idx] += 1.0
+
+    y = np.array(labels, dtype=np.int32)
+    return {"X": X, "y": y, "label_map": label_map}
+
+
+class NarrativeTrainer(TrainingPipeline):
+    """Training pipeline for narrative detection."""
+
+    def __init__(self) -> None:
+        super().__init__("narrative_detector")
+
+    def load_data(self) -> dict:
+        logger.info("Loading narrative detection training data...")
+        return build_narrative_corpus()
+
+    def preprocess(self, data: dict) -> tuple:
+        X, y = data["X"], data["y"]
+        n = len(X)
+        train_end = int(n * 0.7)
+        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: np.ndarray,
+        y_train: np.ndarray,
+        X_val: np.ndarray,
+        y_val: np.ndarray,
+    ):
+        from sklearn.ensemble import RandomForestClassifier
+
+        model = RandomForestClassifier(
+            n_estimators=100, max_depth=10, random_state=42
+        )
+        model.fit(X_train, y_train)
+        val_acc = model.score(X_val, y_val)
+        logger.info(f"Narrative detector validation accuracy: {val_acc:.4f}")
+        return model
+
+    def evaluate(self, model, X_test: np.ndarray, y_test: np.ndarray) -> dict:
+        from sklearn.metrics import (
+            accuracy_score,
+            f1_score,
+            precision_score,
+            recall_score,
+        )
+
+        preds = model.predict(X_test)
+        return {
+            "accuracy": float(accuracy_score(y_test, preds)),
+            "precision": float(
+                precision_score(y_test, preds, average="weighted", zero_division=0)
+            ),
+            "recall": float(
+                recall_score(y_test, preds, average="weighted", zero_division=0)
+            ),
+            "f1": float(
+                f1_score(y_test, preds, average="weighted", zero_division=0)
+            ),
+            "test_samples": len(y_test),
+        }
+
+    def save(self, model, metrics: dict) -> str:
+        import joblib
+
+        path = super().save(model, metrics)
+        artifact_path = path.replace(".pkl", "_model.pkl")
+        joblib.dump(model, artifact_path)
+        return artifact_path
+
+
+def train_narrative_detector(
+    data_dir: str = "data/narrative", output_dir: str = "models/"
+) -> dict:
+    """Train narrative detection model."""
+    trainer = NarrativeTrainer()
+    return trainer.run()
+
+
+if __name__ == "__main__":
+    train_narrative_detector()

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

@@ -0,0 +1,109 @@
+"""Training pipeline for pump detection using real microstructure history."""
+
+import logging
+import time
+
+import numpy as np
+
+from .data_loader import load_pump_training_frame
+from .pipeline import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+
+class PumpTrainer(TrainingPipeline):
+    """Train a classifier over short-horizon pump/dump microstructure features."""
+
+    FEATURE_KEYS = ["return_1", "volume_ratio", "cusum_up", "cusum_down", "volatility_5"]
+
+    def __init__(self) -> None:
+        super().__init__("pump_detector")
+
+    def load_data(self):
+        logger.info("Loading real pump/dump training data from 1m OHLCV history...")
+        frame = load_pump_training_frame(days=30, timeframe="1m")
+        if frame.empty:
+            raise RuntimeError("No historical pump training data available")
+        return frame
+
+    def preprocess(self, data):
+        X = data[self.FEATURE_KEYS].fillna(0.0).astype(np.float32).values
+        y = data["y"].astype(np.int64).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.XGBClassifier(
+                n_estimators=250,
+                max_depth=4,
+                learning_rate=0.05,
+                subsample=0.85,
+                colsample_bytree=0.85,
+                objective="multi:softprob",
+                num_class=3,
+                eval_metric="mlogloss",
+                early_stopping_rounds=20,
+                random_state=42,
+            )
+            model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False)
+            return {"model": model, "engine": "xgboost"}
+        except Exception:
+            from sklearn.ensemble import GradientBoostingClassifier
+
+            model = GradientBoostingClassifier(n_estimators=180, max_depth=4, random_state=42)
+            model.fit(X_train, y_train)
+            return {"model": model, "engine": "gradient_boosting"}
+
+    def evaluate(self, trained, X_test, y_test):
+        from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+
+        model = trained["model"]
+        preds = model.predict(X_test)
+        return {
+            "accuracy": float(accuracy_score(y_test, preds)),
+            "precision": float(
+                precision_score(y_test, preds, average="weighted", zero_division=0)
+            ),
+            "recall": float(recall_score(y_test, preds, average="weighted", zero_division=0)),
+            "f1": float(f1_score(y_test, preds, average="weighted", zero_division=0)),
+            "engine": trained["engine"],
+            "test_samples": len(y_test),
+        }
+
+    def save(self, trained, metrics):
+        import joblib
+
+        super().save(trained, metrics)
+        artifact_path = self.artifact_dir.parent / "pump_detector.joblib"
+        joblib.dump(
+            {
+                "model": trained["model"],
+                "engine": trained["engine"],
+                "trained_at": str(int(time.time())),
+                "accuracy": metrics.get("accuracy"),
+                "feature_keys": self.FEATURE_KEYS,
+            },
+            artifact_path,
+        )
+        return str(artifact_path)
+
+
+def train_pump_detector() -> dict:
+    trainer = PumpTrainer()
+    return trainer.run()
+
+
+if __name__ == "__main__":
+    train_pump_detector()

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

@@ -0,0 +1,116 @@
+"""Regime detector training on real historical market-state features."""
+
+import logging
+import time
+
+import numpy as np
+
+from .data_loader import load_regime_training_frame
+from .pipeline import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+REGIMES = ["trending_bull", "trending_bear", "ranging", "volatile", "capitulation"]
+
+
+class RegimeTrainer(TrainingPipeline):
+    FEATURE_KEYS = [
+        "returns_1d",
+        "returns_7d",
+        "volatility_14d",
+        "volume_ratio",
+        "rsi",
+        "bb_width",
+        "fear_greed",
+        "funding_rate",
+        "price_vs_sma200",
+    ]
+
+    def __init__(self):
+        super().__init__("regime_detector")
+
+    def load_data(self):
+        logger.info("Loading real regime training data from OHLCV history...")
+        frame = load_regime_training_frame(days=300, timeframe="4h")
+        if frame.empty:
+            raise RuntimeError("No historical regime 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"].map({name: idx for idx, name in enumerate(REGIMES)}).astype(np.int64).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.XGBClassifier(
+                n_estimators=250,
+                max_depth=4,
+                learning_rate=0.05,
+                subsample=0.85,
+                colsample_bytree=0.85,
+                min_child_weight=3,
+                objective="multi:softprob",
+                num_class=len(REGIMES),
+                eval_metric="mlogloss",
+                early_stopping_rounds=25,
+                random_state=42,
+            )
+            model.fit(X_train, y_train, eval_set=[(X_val, y_val)], verbose=False)
+            return {"model": model, "engine": "xgboost"}
+        except Exception:
+            from sklearn.ensemble import RandomForestClassifier
+
+            model = RandomForestClassifier(
+                n_estimators=250,
+                max_depth=10,
+                min_samples_leaf=4,
+                class_weight="balanced_subsample",
+                random_state=42,
+                n_jobs=-1,
+            )
+            model.fit(X_train, y_train)
+            return {"model": model, "engine": "random_forest"}
+
+    def evaluate(self, trained, X_test, y_test):
+        from sklearn.metrics import accuracy_score, classification_report
+
+        model = trained["model"]
+        preds = model.predict(X_test)
+        report = classification_report(
+            y_test,
+            preds,
+            target_names=REGIMES,
+            output_dict=True,
+            zero_division=0,
+        )
+        return {
+            "accuracy": float(accuracy_score(y_test, preds)),
+            "per_class": {k: v for k, v in report.items() if k in REGIMES},
+            "engine": trained["engine"],
+            "test_samples": len(y_test),
+        }
+
+    def save(self, trained, metrics):
+        import joblib
+
+        super().save(trained, metrics)
+        artifact_path = self.artifact_dir.parent / "regime_detector.joblib"
+        joblib.dump(
+            {
+                "model": trained["model"],
+                "engine": trained["engine"],
+                "trained_at": str(int(time.time())),
+                "accuracy": metrics.get("accuracy"),
+                "feature_keys": self.FEATURE_KEYS,
+            },
+            artifact_path,
+        )
+        return str(artifact_path)

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

@@ -0,0 +1,58 @@
+"""Rug detection model training script."""
+
+import logging
+import numpy as np
+from .pipeline import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+
+class RugTrainer(TrainingPipeline):
+    def __init__(self):
+        super().__init__("rug_detector")
+
+    def load_data(self):
+        # Load from feature store / CSV / database
+        logger.info("Loading rug detection training data...")
+        # Placeholder: generate synthetic data for pipeline testing
+        n = 1000
+        X = np.random.randn(n, 15).astype(np.float32)
+        y = (X[:, 0] + X[:, 2] + X[:, 4] > 1.5).astype(np.int32)
+        return {"X": X, "y": y}
+
+    def preprocess(self, data):
+        X, y = data["X"], data["y"]
+        n = len(X)
+        train_end = int(n * 0.7)
+        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):
+        from sklearn.ensemble import GradientBoostingClassifier
+        model = GradientBoostingClassifier(n_estimators=100, max_depth=5, random_state=42)
+        model.fit(X_train, y_train)
+        val_acc = model.score(X_val, y_val)
+        logger.info(f"Validation accuracy: {val_acc:.4f}")
+        return model
+
+    def evaluate(self, model, X_test, y_test):
+        from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+        preds = model.predict(X_test)
+        return {
+            "accuracy": float(accuracy_score(y_test, preds)),
+            "precision": float(precision_score(y_test, preds, zero_division=0)),
+            "recall": float(recall_score(y_test, preds, zero_division=0)),
+            "f1": float(f1_score(y_test, preds, zero_division=0)),
+            "test_samples": len(y_test),
+        }
+
+    def save(self, model, metrics):
+        import joblib
+
+        super().save(model, metrics)
+        artifact_path = self.artifact_dir.parent / "rug_detector.joblib"
+        joblib.dump(model, artifact_path)
+        return str(artifact_path)

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

@@ -0,0 +1,63 @@
+"""Sentiment NLP model training script."""
+
+import logging
+import time
+import numpy as np
+from .pipeline import TrainingPipeline
+
+logger = logging.getLogger(__name__)
+
+
+class SentimentTrainer(TrainingPipeline):
+    def __init__(self):
+        super().__init__("sentiment_nlp")
+
+    def load_data(self):
+        logger.info("Loading sentiment training data...")
+        n = 500
+        X = [f"Headline {i} about crypto" for i in range(n)]
+        y = np.random.choice(["bullish", "bearish", "neutral"], size=n)
+        return {"X": X, "y": y}
+
+    def preprocess(self, data):
+        X, y = data["X"], data["y"]
+        n = len(X)
+        t1, t2 = int(n * 0.7), int(n * 0.85)
+        return X[:t1], X[t1:t2], X[t2:], y[:t1], y[t1:t2], y[t2:]
+
+    def train(self, X_train, y_train, X_val, y_val):
+        from sklearn.feature_extraction.text import TfidfVectorizer
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.pipeline import Pipeline
+
+        model = Pipeline([
+            ("tfidf", TfidfVectorizer(max_features=5000)),
+            ("clf", LogisticRegression(max_iter=1000)),
+        ])
+        model.fit(X_train, y_train)
+        val_acc = model.score(X_val, y_val)
+        logger.info(f"Validation accuracy: {val_acc:.4f}")
+        return model
+
+    def evaluate(self, model, X_test, y_test):
+        from sklearn.metrics import accuracy_score, classification_report
+        preds = model.predict(X_test)
+        return {
+            "accuracy": float(accuracy_score(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 / "sentiment_nlp.joblib"
+        joblib.dump(
+            {
+                "model": model,
+                "trained_at": str(int(time.time())),
+                "accuracy": metrics.get("accuracy"),
+            },
+            artifact_path,
+        )
+        return str(artifact_path)

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

@@ -0,0 +1,74 @@
+"""Stacking meta-confidence trainer from resolved prediction history."""
+
+import time
+from pathlib import Path
+
+import joblib
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, roc_auc_score
+
+from .data_loader import load_meta_prediction_frame
+
+
+class StackingMetaTrainer:
+    model_name = "meta_stacking"
+    artifact_path = Path("models") / "meta_stacking.joblib"
+
+    def run(self, days: int = 180) -> dict:
+        start = time.time()
+        frame = load_meta_prediction_frame(days)
+        if frame.empty or len(frame) < 50:
+            return {
+                "model": self.model_name,
+                "status": "skipped",
+                "metrics": {"samples": len(frame)},
+                "duration_seconds": round(time.time() - start, 2),
+                "artifact_path": "",
+                "error": "Need at least 50 resolved predictions",
+            }
+
+        encoded = frame.copy()
+        y = encoded.pop("was_correct").astype(int)
+        encoded = encoded.drop(columns=["actual_change_pct"])
+        encoded = encoded.fillna(0.0)
+        encoded = encoded.astype({"model": "string", "horizon": "string"})
+        encoded = pd.get_dummies(encoded, columns=["model", "horizon"], dtype=float)
+
+        n = len(encoded)
+        split = int(n * 0.80)
+        X_train, X_test = encoded.iloc[:split], encoded.iloc[split:]
+        y_train, y_test = y.iloc[:split], y.iloc[split:]
+
+        model = LogisticRegression(max_iter=1000, class_weight="balanced", random_state=42)
+        model.fit(X_train, y_train)
+
+        proba = model.predict_proba(X_test)[:, 1]
+        pred = (proba >= 0.5).astype(int)
+        accuracy = float(accuracy_score(y_test, pred))
+        auc = float(roc_auc_score(y_test, proba)) if len(set(y_test)) > 1 else 0.5
+
+        self.artifact_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(
+            {
+                "model": model,
+                "columns": list(X_train.columns),
+                "trained_at": str(int(time.time())),
+                "accuracy": accuracy,
+                "auc": auc,
+            },
+            self.artifact_path,
+        )
+
+        return {
+            "model": self.model_name,
+            "status": "success",
+            "metrics": {
+                "accuracy": accuracy,
+                "auc": auc,
+                "train_samples": len(X_train),
+                "test_samples": len(X_test),
+            },
+            "duration_seconds": round(time.time() - start, 2),
+            "artifact_path": str(self.artifact_path),
+        }