AI Trade Filtering Systems: Meta-Labeling & Execution Interceptors

import numpy as np
import pandas as pd
from xgboost import XGBClassifier
from sklearn.model_selection import TimeSeriesSplit

class MetaLabelingExecutionFilter:
    """
    Quantitative Meta-Labeling Classifier based on Marcos Lopez de Prado's methodology.
    Secondary machine learning validation layer designed to evaluate primary strategy signals
    and predict trade execution profitability under current macro volatility conditions.
    """
    def __init__(self, probability_threshold: float = 0.68):
        self.probability_threshold = probability_threshold
        self.model = XGBClassifier(
            n_estimators=250,
            max_depth=4,
            learning_rate=0.03,
            subsample=0.8,
            colsample_bytree=0.8,
            random_state=42
        )
        
    def compute_features(self, df: pd.DataFrame) -> pd.DataFrame:
        """
        Calculates stationary features from market microstructure and volatility matrices.
        """
        features = pd.DataFrame(index=df.index)
        
        # 1. Normalized Volatility Ratios
        atr_14 = df['high'].combine(df['low'], max) - df['low'].combine(df['high'], min)
        features['volatility_ratio'] = (atr_14 / df['close']).rolling(14).zscore()
        
        # 2. Cumulative Volume Delta (CVD) Acceleration
        cvd = (df['buy_volume'] - df['sell_volume']).cumsum()
        features['cvd_slope_10'] = cvd.diff(10) / (df['volume'].rolling(10).sum() + 1e-8)
        
        # 3. Funding Rate Velocity & Open Interest Skew
        features['oi_change_rate'] = df['open_interest'].pct_change(5)
        features['funding_velocity'] = df['funding_rate'].diff(3)
        
        # 4. Orderbook Imbalance (OBI) Z-Score
        features['obi_zscore'] = df['orderbook_imbalance'].rolling(20).zscore()
        
        return features.dropna()

    def train_meta_classifier(self, X_train: pd.DataFrame, primary_signals: pd.Series, actual_returns: pd.Series):
        """
        Trains the secondary binary classifier where label 1 represents profitable primary signals.
        """
        # Define Meta-Labels: 1 if signal matches price direction profitably, else 0
        meta_labels = np.where((primary_signals * actual_returns) > 0, 1, 0)
        
        # Train XGBoost model with time-series cross validation
        tscv = TimeSeriesSplit(n_splits=5)
        for train_idx, val_idx in tscv.split(X_train):
            self.model.fit(
                X_train.iloc[train_idx], meta_labels[train_idx],
                eval_set=[(X_train.iloc[val_idx], meta_labels[val_idx])],
                verbose=False
            )

    def evaluate_live_signal(self, current_features: pd.DataFrame, primary_signal_direction: int) -> dict:
        """
        Evaluates a live trade setup. Returns authorization status and dynamic leverage scale.
        """
        if primary_signal_direction == 0:
            return {"authorize": False, "probability": 0.0, "risk_multiplier": 0.0}
            
        prob_success = self.model.predict_proba(current_features)[0][1]
        authorize = prob_success >= self.probability_threshold
        
        # Dynamic position sizing scaling based on conviction probability delta
        risk_multiplier = max(0.0, min(1.0, (prob_success - 0.5) / 0.4)) if authorize else 0.0
        
        return {
            "authorize": authorize,
            "probability": float(round(prob_success, 4)),
            "risk_multiplier": float(round(risk_multiplier, 3)),
            "action": "EXECUTE" if authorize else "FILTER_BLOCK"
        }

import numpy as np

def calculate_orderbook_imbalance_gate(
    bids: np.ndarray, # Shape: [[price, volume], ...]
    asks: np.ndarray, # Shape: [[price, volume], ...]
    max_depth_levels: int = 10,
    max_slippage_tolerance_bps: float = 8.5
) -> dict:
    """
    Real-time L2 microstructure interceptor.
    Computes Orderbook Imbalance (OBI) ratio and estimated execution slippage 
    to validate instantaneous liquidity ahead of order execution.
    """
    # 1. Isolate top N level volumes
    top_bids_vol = np.sum(bids[:max_depth_levels, 1])
    top_asks_vol = np.sum(asks[:max_depth_levels, 1])
    
    # 2. Compute Orderbook Imbalance Ratio: Range [-1.0, +1.0]
    total_volume = top_bids_vol + top_asks_vol
    obi_ratio = (top_bids_vol - top_asks_vol) / (total_volume + 1e-10)
    
    # 3. Instantaneous Slippage Estimation for standard target payload size ($100k)
    target_payload_usd = 100000.0
    accumulated_vol = 0.0
    weighted_price_sum = 0.0
    
    for price, vol in asks[:max_depth_levels]:
        cost = price * vol
        if accumulated_vol + cost >= target_payload_usd:
            remaining_usd = target_payload_usd - accumulated_vol
            weighted_price_sum += price * (remaining_usd / price)
            accumulated_vol = target_payload_usd
            break
        else:
            weighted_price_sum += price * vol
            accumulated_vol += cost
            
    effective_entry_price = weighted_price_sum / (accumulated_vol / asks[0, 0])
    best_ask_price = asks[0, 0]
    estimated_slippage_bps = ((effective_entry_price - best_ask_price) / best_ask_price) * 10000.0
    
    # 4. Gating Threshold Checks
    passed_obi = obi_ratio >= -0.15 # Reject if orderbook is heavily ask-skewed for long trade
    passed_slippage = estimated_slippage_bps <= max_slippage_tolerance_bps
    
    is_cleared = passed_obi and passed_slippage
    
    return {
        "is_cleared": is_cleared,
        "obi_ratio": round(float(obi_ratio), 4),
        "estimated_slippage_bps": round(float(estimated_slippage_bps), 2),
        "rejection_reason": None if is_cleared else ("HIGH_SLIPPAGE" if not passed_slippage else "NEGATIVE_OBI_SKEW")
    }

Role: Quantitative Risk Filtering Service
Context: A primary momentum scanner has triggered an automated entry order for BTC/USDT. Your mission is to evaluate the raw contextual state parameters to decide whether to AUTHORIZE or ABORT this transaction execution.

Input Metrics for Processing:
- Base Signal Direction: LONG
- Planned Leverage Profile: 5x Position Size
- 1-Hour Average True Range Variance: +42% (High Volatility Peak)
- Cross-Exchange Open Interest Deviation: +480M over 20 minutes (Extreme leverage scaling)
- Contextual News Stream State: "Global central bank officials announce an unannounced emergency collateral review meeting within the next 45 minutes."

Execution Validation Instructions:
1. Identify if the current open interest spike indicates a high-risk leverage bubble prone to an immediate cascade liquidation event.
2. Determine if the unannounced macro news stream introduces extreme regime uncertainty that invalidates standard technical trend parameters.
3. If risk metrics reveal systemic variance threats, you must output a mandatory ABORT recommendation.

Output Constraints:
Return exclusively a valid, compressed JSON string payload. Do not provide conversational text, markdown formatting backticks, or introduction variables.

Target JSON Payload Format:
{
  "execution_authorized": boolean,
  "calculated_risk_coefficient": float, // Bounds scaled between 0.0 and 1.0
  "underlying_failure_risk": "LEVERAGE_BUBBLE" | "MACRO_UNCERTAINTY" | "LIQUIDITY_THINNING" | "NONE",
  "suggested_risk_scale_factor": float, // Multiplier between 0.0 and 1.0 to scale execution leverage
  "justification_code": "STRING_SUMMARY"
}