@vizzor/cli 0.13.1 → 0.14.5

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

@@ -0,0 +1,215 @@
+"""XGBoost direction classifier with walk-forward temporal validation.
+
+Trains horizon-specific models (scalp/standard/position) to predict
+price direction (up/down/sideways) from technical + on-chain features.
+Uses proper time-based splits to avoid look-ahead bias.
+"""
+
+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 + engineered features
+BASE_FEATURE_KEYS = [
+    "rsi", "macdHistogram", "bollingerPercentB", "ema12", "ema26",
+    "atr", "obv", "fundingRate", "fearGreed", "priceChange24h",
+    "rsiSlope", "volumeRatio", "emaCrossoverPct", "atrPct",
+]
+
+# Engineered features added during preprocessing
+ENGINEERED_KEYS = [
+    "lagReturn1", "lagReturn3", "lagReturn5",
+    "rollingVolatility5", "rollingVolatility10",
+    "priceVsSMA20",
+]
+
+ALL_FEATURE_KEYS = BASE_FEATURE_KEYS + ENGINEERED_KEYS
+
+# Horizon profiles and their direction thresholds (% move to label up/down)
+HORIZON_PROFILES = {
+    "scalp": {"horizons": ["5m", "15m", "30m"], "threshold": 0.15},
+    "standard": {"horizons": ["1h", "4h"], "threshold": 0.35},
+    "position": {"horizons": ["1d", "7d"], "threshold": 0.75},
+}
+
+
+def engineer_features(features: dict, history: list[dict] | None = None) -> dict:
+    """Add lagged returns, rolling volatility, price vs SMA to raw features."""
+    result = dict(features)
+
+    if history and len(history) >= 5:
+        prices = [h.get("price", 0) for h in history[-20:]]
+        if len(prices) >= 2 and prices[-1] > 0:
+            result["lagReturn1"] = (prices[-1] - prices[-2]) / prices[-1] * 100 if prices[-2] > 0 else 0
+        else:
+            result["lagReturn1"] = 0
+
+        if len(prices) >= 4 and prices[-1] > 0:
+            result["lagReturn3"] = (prices[-1] - prices[-4]) / prices[-1] * 100 if prices[-4] > 0 else 0
+        else:
+            result["lagReturn3"] = 0
+
+        if len(prices) >= 6 and prices[-1] > 0:
+            result["lagReturn5"] = (prices[-1] - prices[-6]) / prices[-1] * 100 if prices[-6] > 0 else 0
+        else:
+            result["lagReturn5"] = 0
+
+        if len(prices) >= 5:
+            returns = [
+                (prices[i] - prices[i - 1]) / prices[i - 1] * 100
+                for i in range(1, len(prices))
+                if prices[i - 1] > 0
+            ]
+            result["rollingVolatility5"] = float(np.std(returns[-5:])) if len(returns) >= 5 else 0
+            result["rollingVolatility10"] = float(np.std(returns[-10:])) if len(returns) >= 10 else 0
+        else:
+            result["rollingVolatility5"] = 0
+            result["rollingVolatility10"] = 0
+
+        if len(prices) >= 20:
+            sma20 = np.mean(prices[-20:])
+            result["priceVsSMA20"] = (prices[-1] - sma20) / sma20 * 100 if sma20 > 0 else 0
+        else:
+            result["priceVsSMA20"] = 0
+    else:
+        for key in ENGINEERED_KEYS:
+            result.setdefault(key, 0)
+
+    return result
+
+
+class DirectionTrainer:
+    """Walk-forward XGBoost trainer for direction prediction."""
+
+    def __init__(self, profile: str = "standard"):
+        if profile not in HORIZON_PROFILES:
+            raise ValueError(f"Unknown profile: {profile}. Use: {list(HORIZON_PROFILES.keys())}")
+        self.profile = profile
+        self.threshold = HORIZON_PROFILES[profile]["threshold"]
+
+    def label_direction(self, change_pct: float) -> int:
+        """Convert price change to direction label: 0=down, 1=sideways, 2=up."""
+        if change_pct > self.threshold:
+            return 2  # up
+        elif change_pct < -self.threshold:
+            return 0  # down
+        return 1  # sideways
+
+    def run(self, outcomes: list[dict] | None = None) -> dict:
+        """Train XGBoost model from prediction outcomes.
+
+        Each outcome should have:
+          - features: dict of feature values
+          - changePct: actual price change percentage
+          - horizon: string horizon label
+
+        Returns training result dict.
+        """
+        import time
+        start = time.time()
+
+        if not outcomes or len(outcomes) < 30:
+            return {
+                "model": f"xgb-direction-{self.profile}",
+                "status": "skipped",
+                "metrics": None,
+                "duration_seconds": time.time() - start,
+                "artifact_path": "",
+                "error": f"Need at least 30 samples, got {len(outcomes) if outcomes else 0}",
+            }
+
+        try:
+            import xgboost as xgb
+            from sklearn.metrics import accuracy_score, classification_report
+        except ImportError:
+            return {
+                "model": f"xgb-direction-{self.profile}",
+                "status": "failed",
+                "metrics": None,
+                "duration_seconds": time.time() - start,
+                "artifact_path": "",
+                "error": "xgboost not installed",
+            }
+
+        # Filter outcomes for this profile's horizons
+        valid_horizons = set(HORIZON_PROFILES[self.profile]["horizons"])
+        filtered = [o for o in outcomes if o.get("horizon") in valid_horizons]
+        if len(filtered) < 30:
+            filtered = outcomes  # Fall back to all outcomes if not enough per-profile
+
+        # Build feature matrix and labels
+        X = np.array([
+            [o.get("features", {}).get(k, 0) for k in ALL_FEATURE_KEYS]
+            for o in filtered
+        ])
+        y = np.array([self.label_direction(o.get("changePct", 0)) for o in filtered])
+
+        # Walk-forward temporal split: 70% train, 15% val, 15% test
+        n = len(X)
+        train_end = int(n * 0.70)
+        val_end = int(n * 0.85)
+
+        X_train, y_train = X[:train_end], y[:train_end]
+        X_val, y_val = X[train_end:val_end], y[train_end:val_end]
+        X_test, y_test = X[val_end:], y[val_end:]
+
+        if len(X_test) < 5:
+            return {
+                "model": f"xgb-direction-{self.profile}",
+                "status": "skipped",
+                "metrics": None,
+                "duration_seconds": time.time() - start,
+                "artifact_path": "",
+                "error": "Not enough data for temporal split",
+            }
+
+        # Train XGBoost with early stopping
+        model = xgb.XGBClassifier(
+            n_estimators=200,
+            max_depth=4,
+            learning_rate=0.05,
+            subsample=0.8,
+            colsample_bytree=0.8,
+            min_child_weight=3,
+            reg_alpha=0.1,
+            reg_lambda=1.0,
+            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,
+        )
+
+        # Evaluate on test set
+        y_pred = model.predict(X_test)
+        accuracy = float(accuracy_score(y_test, y_pred))
+
+        # Save model
+        MODEL_DIR.mkdir(parents=True, exist_ok=True)
+        model_path = MODEL_DIR / f"xgb_direction_{self.profile}.json"
+        model.save_model(str(model_path))
+
+        duration = time.time() - start
+
+        return {
+            "model": f"xgb-direction-{self.profile}",
+            "status": "success",
+            "metrics": {
+                "accuracy": round(accuracy, 4),
+                "train_samples": len(X_train),
+                "val_samples": len(X_val),
+                "test_samples": len(X_test),
+                "best_iteration": model.best_iteration if hasattr(model, "best_iteration") else None,
+            },
+            "duration_seconds": round(duration, 2),
+            "artifact_path": str(model_path),
+        }

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

@@ -0,0 +1,57 @@
+"""Baseline feature-distribution trainer for drift monitoring."""
+
+import time
+from pathlib import Path
+
+import joblib
+
+from .data_loader import load_meta_prediction_frame
+
+
+class DriftMonitorTrainer:
+    model_name = "meta_drift_detector"
+    artifact_path = Path("models") / "meta_drift_detector.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",
+            }
+
+        numeric = frame.drop(columns=["model", "horizon", "was_correct"]).fillna(0.0)
+        baseline = {
+            column: {
+                "mean": float(numeric[column].mean()),
+                "std": float(max(numeric[column].std(), 1e-6)),
+                "p10": float(numeric[column].quantile(0.10)),
+                "p90": float(numeric[column].quantile(0.90)),
+            }
+            for column in numeric.columns
+        }
+
+        self.artifact_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(
+            {
+                "baseline": baseline,
+                "trained_at": str(int(time.time())),
+            },
+            self.artifact_path,
+        )
+
+        return {
+            "model": self.model_name,
+            "status": "success",
+            "metrics": {
+                "features": len(baseline),
+                "samples": len(numeric),
+            },
+            "duration_seconds": round(time.time() - start, 2),
+            "artifact_path": str(self.artifact_path),
+        }

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

@@ -0,0 +1,58 @@
+"""Isotonic probability calibration trainer from resolved prediction history."""
+
+import time
+from pathlib import Path
+
+import joblib
+import numpy as np
+from sklearn.isotonic import IsotonicRegression
+
+from .data_loader import load_meta_prediction_frame
+
+
+class IsotonicTrainer:
+    model_name = "meta_isotonic"
+    artifact_path = Path("models") / "meta_isotonic.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",
+            }
+
+        predicted = frame["probability"].astype(float).to_numpy()
+        actual = frame["was_correct"].astype(float).to_numpy()
+
+        model = IsotonicRegression(y_min=0.05, y_max=0.95, out_of_bounds="clip")
+        model.fit(predicted, actual)
+        calibrated = model.predict(predicted)
+        mae = float(np.mean(np.abs(calibrated - actual)))
+
+        self.artifact_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(
+            {
+                "model": model,
+                "trained_at": str(int(time.time())),
+                "accuracy": 1.0 - mae,
+                "samples": len(predicted),
+            },
+            self.artifact_path,
+        )
+
+        return {
+            "model": self.model_name,
+            "status": "success",
+            "metrics": {
+                "mae": mae,
+                "samples": len(predicted),
+            },
+            "duration_seconds": round(time.time() - start, 2),
+            "artifact_path": str(self.artifact_path),
+        }

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

@@ -0,0 +1,217 @@
+"""Training script for the LSTM price direction predictor.
+
+Updated to produce proper (batch, T=100, F=8) shaped input instead of
+the incorrect (batch, 1, N) that treated all features as a single timestep.
+
+Per-candle features (8): close, rsi, macdHist, bbPercentB, atr, obv, funding, fearGreed
+"""
+
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
+
+from .data_loader import create_sequences, get_training_symbols, load_ohlcv
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+# Per-candle features: matches lstm_predictor.py PER_CANDLE_FEATURES
+NUM_FEATURES = 8
+SEQUENCE_LENGTH = 100
+
+
+class PriceLSTM(nn.Module):
+    """LSTM model for price direction classification.
+
+    Input shape: (batch, T=100, F=8)
+    Output: 3-class logits (down, sideways, up)
+    """
+
+    def __init__(self, input_size: int = NUM_FEATURES, hidden_size: int = 64, num_layers: int = 2):
+        super().__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=0.2)
+        self.fc = nn.Sequential(
+            nn.Linear(hidden_size, 32),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(32, 3),  # 3 classes: down, sideways, up
+        )
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        last_hidden = lstm_out[:, -1, :]
+        return self.fc(last_hidden)
+
+
+def create_enriched_sequences(
+    df, window: int = SEQUENCE_LENGTH, horizon: int = 4
+) -> tuple[np.ndarray, np.ndarray]:
+    """Create training sequences with per-candle TA features.
+
+    Instead of just OHLCV (5 features), each candle gets 8 features:
+    close, rsi, macdHist, bbPercentB, atr, obv, funding, fearGreed.
+
+    Falls back to create_sequences() if TA columns are missing (legacy data).
+    """
+    required_cols = ["close", "rsi", "macd_hist", "bb_percent_b", "atr", "obv"]
+    has_ta = all(col in df.columns for col in required_cols)
+
+    if not has_ta:
+        # Legacy path: use raw OHLCV from data_loader
+        return create_sequences(df, window, horizon)
+
+    feature_cols = [
+        "close", "rsi", "macd_hist", "bb_percent_b", "atr", "obv",
+        "funding_rate", "fear_greed",
+    ]
+    # Fill missing optional columns with defaults
+    if "funding_rate" not in df.columns:
+        df = df.copy()
+        df["funding_rate"] = 0.0
+    if "fear_greed" not in df.columns:
+        df = df.copy()
+        df["fear_greed"] = 50.0
+
+    data = df[feature_cols].values
+    closes = df["close"].values
+
+    X, y = [], []
+    for i in range(window, len(data) - horizon):
+        window_data = data[i - window: i].copy()
+
+        # Normalize close prices by first close in window
+        base_price = window_data[0, 0]
+        if base_price == 0:
+            continue
+        window_data[:, 0] /= base_price
+
+        X.append(window_data)
+
+        # Label from future price change
+        future_close = closes[i + horizon - 1]
+        current_close = closes[i - 1]
+        pct_change = (future_close - current_close) / current_close * 100
+
+        if pct_change > 1.0:
+            y.append(2)  # up
+        elif pct_change < -1.0:
+            y.append(0)  # down
+        else:
+            y.append(1)  # sideways
+
+    return np.array(X, dtype=np.float32), np.array(y, dtype=np.int64)
+
+
+def fit_scaler(X: np.ndarray):
+    """Fit a StandardScaler on training data and return it.
+
+    Reshapes (N, T, F) → (N*T, F) for fitting, then back.
+    """
+    from sklearn.preprocessing import StandardScaler
+
+    n_samples, seq_len, n_features = X.shape
+    flat = X.reshape(-1, n_features)
+    scaler = StandardScaler()
+    scaler.fit(flat)
+    return scaler
+
+
+def apply_scaler(X: np.ndarray, scaler) -> np.ndarray:
+    """Apply a fitted StandardScaler to sequence data."""
+    n_samples, seq_len, n_features = X.shape
+    flat = X.reshape(-1, n_features)
+    scaled = scaler.transform(flat)
+    return scaled.reshape(n_samples, seq_len, n_features).astype(np.float32)
+
+
+def train(days: int = 90, epochs: int = 50, batch_size: int = 32, lr: float = 1e-3):
+    """Train LSTM on historical OHLCV data from the available symbol universe."""
+    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) < 200:
+                print(f"  {symbol}: insufficient data ({len(df)} rows), skipping")
+                continue
+            X, y = create_enriched_sequences(df, window=SEQUENCE_LENGTH, horizon=4)
+            all_X.append(X)
+            all_y.append(y)
+            print(f"  {symbol}: {len(X)} sequences, shape {X.shape}")
+        except Exception as e:
+            print(f"  {symbol}: error — {e}")
+
+    if not all_X:
+        print("No training data available. Ensure data collector has run.")
+        return
+
+    X = np.concatenate(all_X)
+    y = np.concatenate(all_y)
+    print(f"Total: {len(X)} sequences (shape {X.shape}), class distribution: {np.bincount(y)}")
+
+    # Fit and save scaler for inference normalization
+    scaler = fit_scaler(X)
+    X = apply_scaler(X, scaler)
+
+    MODEL_DIR.mkdir(parents=True, exist_ok=True)
+    import joblib
+    scaler_path = MODEL_DIR / "lstm_predictor_scaler.joblib"
+    joblib.dump(scaler, scaler_path)
+    print(f"Scaler saved to {scaler_path}")
+
+    # Split 80/20
+    split = int(len(X) * 0.8)
+    X_train, X_val = X[:split], X[split:]
+    y_train, y_val = y[:split], y[split:]
+
+    train_ds = TensorDataset(torch.tensor(X_train), torch.tensor(y_train))
+    val_ds = TensorDataset(torch.tensor(X_val), torch.tensor(y_val))
+    train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
+    val_dl = DataLoader(val_ds, batch_size=batch_size)
+
+    model = PriceLSTM(input_size=NUM_FEATURES)
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    criterion = nn.CrossEntropyLoss()
+
+    best_val_acc = 0.0
+    for epoch in range(epochs):
+        model.train()
+        total_loss = 0
+        for X_batch, y_batch in train_dl:
+            optimizer.zero_grad()
+            output = model(X_batch)
+            loss = criterion(output, y_batch)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+
+        # Validation
+        model.eval()
+        correct, total = 0, 0
+        with torch.no_grad():
+            for X_batch, y_batch in val_dl:
+                output = model(X_batch)
+                preds = output.argmax(dim=-1)
+                correct += (preds == y_batch).sum().item()
+                total += len(y_batch)
+
+        val_acc = correct / max(1, total)
+        avg_loss = total_loss / len(train_dl)
+
+        if (epoch + 1) % 10 == 0:
+            print(f"Epoch {epoch + 1}/{epochs} — loss: {avg_loss:.4f}, val_acc: {val_acc:.3f}")
+
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            torch.save(model, MODEL_DIR / "lstm_predictor.pt")
+
+    print(f"Training complete. Best validation accuracy: {best_val_acc:.3f}")
+    print(f"Model saved to {MODEL_DIR / 'lstm_predictor.pt'}")
+
+
+if __name__ == "__main__":
+    train()

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

@@ -0,0 +1,102 @@
+"""Short-horizon microstructure specialist trainer."""
+
+import time
+from pathlib import Path
+
+import joblib
+import numpy as np
+from sklearn.metrics import accuracy_score, f1_score
+
+from .data_loader import load_microstructure_training_frame
+
+
+class MicrostructureTrainer:
+    model_name = "microstructure_specialist"
+    artifact_path = Path("models") / "microstructure_specialist.joblib"
+    feature_keys = [
+        "return_1",
+        "volume_ratio",
+        "range_pct",
+        "wick_imbalance",
+        "trade_intensity",
+        "price_vs_sma20",
+        "volatility_5",
+    ]
+
+    def run(self, days: int = 30) -> dict:
+        start = time.time()
+        frame = load_microstructure_training_frame(days=days, timeframe="1m")
+        if frame.empty or len(frame) < 80:
+            return {
+                "model": self.model_name,
+                "status": "skipped",
+                "metrics": {"samples": len(frame)},
+                "duration_seconds": round(time.time() - start, 2),
+                "artifact_path": "",
+                "error": "Need at least 80 microstructure samples",
+            }
+
+        X = frame[self.feature_keys].fillna(0.0).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,
+                min_samples_leaf=4,
+                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),
+        }