מודל ML לחיזוי נזילות קריפטו

Kyle (1985) הראה ש-Lambda של Kyle הוא מקדם המודד את השפעת זרימת ההזמנות על המחיר. האומדן שלו דורש ניקוי רעש מיקרו-מבני.

איך אנחנו בונים את המודל?

התהליך כולל חמישה שלבים:

1. אנליטיקה—איסוף נתונים ל-12 החודשים האחרונים: תמונות ספר הזמנות, נתוני מסחר, שיעורי מימון.
2. עיצוב—הנדסת תכונות 30+: קידודים מחזוריים של זמן, פיגורים של מרווח ועומק, ממוצעים נעים, תנודתיות, יחס Amihud.
3. יישום—אימון מודל LightGBM עם כוונון היפרפרמטרים באמצעות Optuna. קו הבסיס חוזה מרווח 4 שעות קדימה בדיוק של 85%—טוב ב-30% מ-ARIMA וב-15% מ-LSTM באותו אופק.
4. בדיקה—ולידציית walk-forward עם חלון של 6 חודשים.
5. פריסה—אינטגרציה עם מנוע המסחר באמצעות REST API או WebSocket.

import lightgbm as lgb
import pandas as pd
import numpy as np

def create_liquidity_features(df, spread_col='spread', depth_col='depth_1pct'):
    features = pd.DataFrame(index=df.index)
    # Временны́е features
    features['hour'] = df.index.hour
    features['day_of_week'] = df.index.dayofweek
    features['is_weekend'] = (features['day_of_week'] >= 5).astype(int)
    features['hour_sin'] = np.sin(2 * np.pi * features['hour'] / 24)
    features['hour_cos'] = np.cos(2 * np.pi * features['hour'] / 24)
    # Lagged ликвидность
    for lag in [1, 4, 12, 24, 48]:
        features[f'spread_lag_{lag}'] = df[spread_col].shift(lag)
        if depth_col in df.columns:
            features[f'depth_lag_{lag}'] = df[depth_col].shift(lag)
    # Rolling statistics
    for window in [12, 24, 72]:
        features[f'spread_ma_{window}'] = df[spread_col].rolling(window).mean()
        features[f'spread_std_{window}'] = df[spread_col].rolling(window).std()
    # Волатильность (прокси ликвидности)
    returns = df['close'].pct_change() if 'close' in df.columns else pd.Series(index=df.index)
    for window in [12, 24]:
        features[f'vol_{window}h'] = returns.rolling(window).std()
    # Объём
    if 'volume' in df.columns:
        features['vol_ratio'] = df['volume'] / df['volume'].rolling(24).mean()
    # Amihud ratio
    if 'close' in df.columns and 'volume' in df.columns:
        features['amihud'] = amihud_ratio(returns, df['volume'])
    return features.dropna()

def train_liquidity_model(liquidity_df, target_col='spread', horizon=4):
    """
    Предсказываем спред/ликвидность через horizon периодов
    """
    X = create_liquidity_features(liquidity_df)
    y = liquidity_df[target_col].shift(-horizon)
    # Walk-forward split
    split_idx = int(len(X) * 0.8)
    X_train, X_test = X.iloc[:split_idx], X.iloc[split_idx:]
    y_train, y_test = y.iloc[:split_idx], y.iloc[split_idx:]
    # Убираем NaN из target
    valid_mask = y_train.notna()
    model = lgb.LGBMRegressor(
        n_estimators=500,
        learning_rate=0.05,
        num_leaves=31,
        early_stopping_rounds=50
    )
    model.fit(
        X_train[valid_mask],
        y_train[valid_mask],
        eval_set=[(X_test, y_test.fillna(method='ffill'))],
        callbacks=[lgb.early_stopping(50), lgb.log_evaluation(100)]
    )
    return model

האימון רץ על GPU (NVIDIA A100) ואורך כשעתיים עבור 12 חודשי נתונים. אנחנו גם מוסיפים תכונות משווקים קשורים: שיעור מימון ועניין פתוח—הם מתאמים עם יציאות נזילות. המודל מכויל מחדש מדי שבוע כדי להתחשב בשינויי משטר.

איך חיזוי נזילות עוזר לביצוע?

לפני ביצוע הזמנה גדולה, אנחנו מעריכים את השפעת השוק שלה באמצעות מודל Almgren-Chriss. אם השפעת השוק החזויה עולה על 10 נקודות בסיס, אנחנו ממליצים על TWAP/VWAP. דוגמת קוד להערכה:

def estimate_market_impact(order_size_usd, current_depth, current_spread, lambda_estimate):
    """ Simplified Almgren-Chriss model для market impact """
    temporary_impact = lambda_estimate * np.sqrt(order_size_usd)
    permanent_impact = 0.5 * temporary_impact
    spread_cost = current_spread / 2 * order_size_usd
    total_cost = (temporary_impact + permanent_impact + spread_cost)
    total_cost_bps = total_cost / order_size_usd * 10000
    return {
        'total_impact_usd': total_cost,
        'total_impact_bps': total_cost_bps,
        'temporary': temporary_impact,
        'permanent': permanent_impact,
        'spread_cost': spread_cost,
        'optimal_execution': total_cost_bps > 10
    }

בממוצע, שימוש בחיזוי נזילות מפחית החלקה ב-35% עבור הזמנות גדולות מ-10 BTC, וחוסך עד 2% מנפח המסחר בפרויקטים עם מחזור גבוה. הניסיון שלנו מראה שאינטגרציה עם מנוע מסחר אורכת לכל היותר שבוע—אנחנו מספקים REST API מוכן עם נקודות קצה import lightgbm as lgb import pandas as pd import numpy as np def create_liquidity_features(df, spread_col='spread', depth_col='depth_1pct'): features = pd.DataFrame(index=df.index) # Временны́е features features['hour'] = df.index.hour features['day_of_week'] = df.index.dayofweek features['is_weekend'] = (features['day_of_week'] >= 5).astype(int) features['hour_sin'] = np.sin(2 * np.pi * features['hour'] / 24) features['hour_cos'] = np.cos(2 * np.pi * features['hour'] / 24) # Lagged ликвидность for lag in [1, 4, 12, 24, 48]: features[f'spread_lag_{lag}'] = df[spread_col].shift(lag) if depth_col in df.columns: features[f'depth_lag_{lag}'] = df[depth_col].shift(lag) # Rolling statistics for window in [12, 24, 72]: features[f'spread_ma_{window}'] = df[spread_col].rolling(window).mean() features[f'spread_std_{window}'] = df[spread_col].rolling(window).std() # Волатильность (прокси ликвидности) returns = df['close'].pct_change() if 'close' in df.columns else pd.Series(index=df.index) for window in [12, 24]: features[f'vol_{window}h'] = returns.rolling(window).std() # Объём if 'volume' in df.columns: features['vol_ratio'] = df['volume'] / df['volume'].rolling(24).mean() # Amihud ratio if 'close' in df.columns and 'volume' in df.columns: features['amihud'] = amihud_ratio(returns, df['volume']) return features.dropna() def train_liquidity_model(liquidity_df, target_col='spread', horizon=4): """ Предсказываем спред/ликвидность через horizon периодов """ X = create_liquidity_features(liquidity_df) y = liquidity_df[target_col].shift(-horizon) # Walk-forward split split_idx = int(len(X) * 0.8) X_train, X_test = X.iloc[:split_idx], X.iloc[split_idx:] y_train, y_test = y.iloc[:split_idx], y.iloc[split_idx:] # Убираем NaN из target valid_mask = y_train.notna() model = lgb.LGBMRegressor( n_estimators=500, learning_rate=0.05, num_leaves=31, early_stopping_rounds=50 ) model.fit( X_train[valid_mask], y_train[valid_mask], eval_set=[(X_test, y_test.fillna(method='ffill'))], callbacks=[lgb.early_stopping(50), lgb.log_evaluation(100)] ) return model ו-def estimate_market_impact(order_size_usd, current_depth, current_spread, lambda_estimate): """ Simplified Almgren-Chriss model для market impact """ temporary_impact = lambda_estimate * np.sqrt(order_size_usd) permanent_impact = 0.5 * temporary_impact spread_cost = current_spread / 2 * order_size_usd total_cost = (temporary_impact + permanent_impact + spread_cost) total_cost_bps = total_cost / order_size_usd * 10000 return { 'total_impact_usd': total_cost, 'total_impact_bps': total_cost_bps, 'temporary': temporary_impact, 'permanent': permanent_impact, 'spread_cost': spread_cost, 'optimal_execution': total_cost_bps > 10 } .

היקף העבודה

• פיתוח צינור איסוף ועיבוד נתונים (ספר הזמנות, נתוני מסחר)
• בנייה ואימון מודל החיזוי (LightGBM עם תכונות זמן)
• ולידציה על נתונים היסטוריים (walk-forward)
• אינטגרציה עם מנוע מסחר באמצעות REST API או WebSocket
• תיעוד והדרכת צוות
• חודש אחד של תמיכה לאחר השקה

לוחות זמנים משוערים

לוחות הזמנים תלויים במורכבות הנתונים ובאינטגרציה: בין 2 ל-4 שבועות. התמחור נקבע באופן אישי לאחר ביקורת. הזמינו פיתוח—התחילו בביקורת נתונים.