מודל קיבוץ התנהגותי למטבעות קריפטו

קיבוץ מאות מטבעות קריפטוגרפיים לפי התנהגות באופן ידני מוביל לבלבול — לנכסים עם תנודתיות דומה עשויה להיות מתאם שונה עם BTC, ונפחי המסחר משתנים באופן בלתי צפוי. מודל הקיבוץ שלנו מנצל ניתוח מתאם ותנודתיות של מטבעות קריפטוגרפיים כדי לזהות קבוצות נסתרות. המהנדסים שלנו, עם ניסיון של 5+ שנים בשוק, 7 שנות ניסיון ב-ML ו-50+ פרויקטים של ניתוח שוק קריפטו שהושלמו, הופכים תהליך זה לאוטומטי. המודל מזהה קבוצות נסתרות על בסיס 15+ מדדים: תשואה שנתית, תנודתיות, יחס שארפ, הטיה, קורטוזיס, VaR 95%, CVaR 95%, משיכה מקסימלית, מתאם עם BTC, מומנטום של 30 יום, נפח מסחר יומי ממוצע. זה לא סיווג — אנחנו לא מקצים תוויות, אנחנו מוצאים קבוצות טבעיות על ידי שילוב נכסים עם דפוסי התנהגות דומים.

קיבוץ כזה מאפשר פיזור תיק על ידי בחירת 1-2 נכסים מכל אשכול, הפחתת מתאם. זה גם תומך באסטרטגיות רוטציה: כאשר נכס אחד באשכול מזנק, אנחנו מחפשים נכסים מפגרים באותו אשכול. לבסוף, זה עוזר להבין את מבנה השוק, לזהות קבוצות כמו "בלו צ'יפים", "אלטקוינס עם ביתא גבוהה", ו"נכסים ללא מתאם".

איך אנחנו בונים תכונות לקיבוץ

הנדסת תכונות היא השלב המרכזי. אנחנו לוקחים מחירי סגירה שעתיים ל-90 הימים האחרונים. עבור כל נכס, אנחנו מחשבים:

• תשואה שנתית ותנודתיות,
• יחס שארפ (יחס תשואה לסיכון),
• מומנטום של 30 יום,
• משיכה מקסימלית,
• מתאם עם BTC (אם זמין),
• נפח מסחר יומי ממוצע בדולרים.

קוד ליצירת תכונות:

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler

def create_behavioral_features(prices_dict, lookback_days=90):
    features = {}
    for symbol, price_series in prices_dict.items():
        returns = price_series.pct_change().dropna()
        if len(returns) < lookback_days * 24:  # hourly data
            continue
        recent_returns = returns.iloc[-lookback_days*24:]
        features[symbol] = {
            # Return characteristics
            'annualized_return': recent_returns.mean() * 365 * 24,
            'annualized_vol': recent_returns.std() * np.sqrt(365 * 24),
            'sharpe': recent_returns.mean() / (recent_returns.std() + 1e-8) * np.sqrt(365*24),
            # Distribution shape
            'skewness': recent_returns.skew(),
            'kurtosis': recent_returns.kurt(),
            # Tail risk
            'var_95': np.percentile(recent_returns, 5),
            'cvar_95': recent_returns[recent_returns <= np.percentile(recent_returns, 5)].mean(),
            # Trend characteristics
            'momentum_30d': price_series.iloc[-720:].pct_change(720).iloc[-1],  # 30d return
            'trend_strength': abs(recent_returns.mean()) / (recent_returns.std() + 1e-8),
            # Drawdown
            'max_drawdown': calculate_max_drawdown(price_series.iloc[-lookback_days*24:]),
            # Correlation with BTC (if available)
            'btc_corr': recent_returns.corr(prices_dict.get('BTC', pd.Series()).pct_change().dropna()),
            # Volume-based (если доступны volume данные)
            'avg_daily_volume_usd': get_avg_daily_volume(symbol),
        }
    return pd.DataFrame(features).T

בפרויקט אחד עבור קרן גידור, קיבצנו 150 מטבעות קריפטוגרפיים תוך שבועיים בעלות של $5,000. כתוצאה מכך, הלקוח בנה תיק עם מתאם של 0.35 בין נכסים מאשכולות שונים, והפחית את סיכון המשיכה ב-40%. זה חסך למעלה מ-200 שעות של ניתוח ידני בשנה, והניב ROI של פי 10.

מדדים מרכזיים לקיבוץ

לא כל המדדים שימושיים באותה מידה. מתאם עם BTC ותנודתיות לרוב שולטים, אבל הוספת מומנטום ומשיכה משפרת את ההפרדה של נכסים ספקולטיביים. אנחנו מיישמים PCA לניתוח חשיבות תכונות ומסירים תכונות עם מולטי-קוליניאריות.

השוואת אלגוריתמי קיבוץ

אנחנו משתמשים בשלוש גישות — לכל אחת יש את החוזקות שלה.

K-Means — קלאסי: מהיר (פי 3 יותר מהיר מ-DBSCAN על 500+ אובייקטים), אבל מניח אשכולות כדוריים בגודל שווה. מתאים לחלוקה ראשונית.

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

def kmeans_clustering(features_df, n_clusters=6, seed=42):
    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features_df.fillna(0))
    inertias = []
    k_range = range(2, 15)
    for k in k_range:
        km = KMeans(n_clusters=k, random_state=seed, n_init=10)
        km.fit(features_scaled)
        inertias.append(km.inertia_)
    best_k = find_elbow(inertias, k_range)
    km = KMeans(n_clusters=best_k, random_state=seed, n_init=10)
    labels = km.fit_predict(features_scaled)
    return labels, km, scaler

DBSCAN — אינו דורש ציון מספר האשכולות, מזהה חריגים (נקודות רעש). טוב כאשר לאשכולות יש צורות מורכבות.

from sklearn.cluster import DBSCAN

def dbscan_clustering(features_scaled, eps=0.5, min_samples=3):
    db = DBSCAN(eps=eps, min_samples=min_samples, metric='euclidean')
    labels = db.fit_predict(features_scaled)
    n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
    n_noise = (labels == -1).sum()
    return labels, n_clusters, n_noise

קיבוץ היררכי — בונה דנדרוגרמה, מציג היררכיה ויזואלית. אנחנו משתמשים בו לניתוח ויזואלי כאשר צריך לראות אשכולות מקוננים.

UMAP עדיף על PCA להמחשת אשכולות

כדי להמחיש נתונים רב-ממדיים, אנחנו מפחיתים ממדים ל-2D. UMAP (Uniform Manifold Approximation and Projection), בניגוד ל-PCA ליניארי, משמר טוב יותר מבנה גלובלי ומקומי. בפועל, UMAP מייצר אשכולות קומפקטיים ומופרדים יותר, במיוחד עבור נתונים עם תלות לא-ליניארית. UMAP מתואר בעבודה של McInnes et al. (ראה ויקיפדיה).

from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import umap

def reduce_dimensions(features_scaled, method='umap', n_components=2):
    if method == 'pca':
        reducer = PCA(n_components=n_components, random_state=42)
    elif method == 'tsne':
        reducer = TSNE(n_components=n_components, random_state=42, perplexity=min(30, len(features_scaled)//4))
    elif method == 'umap':
        reducer = umap.UMAP(n_components=n_components, random_state=42, n_neighbors=min(15, len(features_scaled)//3))
    embedding = reducer.fit_transform(features_scaled)
    return embedding

לאחר ההפחתה, אנחנו יוצרים תרשים פיזור עם קידוד צבע לפי אשכול — ההמחשה המרכזית של התוצאות.

פירוש אשכולות

לאחר הקיבוץ, אנחנו מנתחים את הערכים הממוצעים של המדדים לכל אשכול. לדוגמה:

קוד לפירוש אוטומטי:

def describe_clusters(features_df, labels):
    features_df['cluster'] = labels
    cluster_stats = features_df.groupby('cluster').agg({
        'annualized_return': 'mean',
        'annualized_vol': 'mean',
        'sharpe': 'mean',
        'btc_corr': 'mean',
        'max_drawdown': 'mean',
        'skewness': 'mean'
    }).round(3)
    cluster_names = {}
    for cluster_id, row in cluster_stats.iterrows():
        if row['btc_corr'] > 0.85 and row['annualized_vol'] > 1.5:
            name = 'High-beta altcoins'
        elif row['btc_corr'] > 0.8 and row['annualized_vol'] < 1.0:
            name = 'Blue-chip crypto'
        elif row['btc_corr'] < 0.5:
            name = 'Decorrelated assets'
        elif row['sharpe'] > 2.0:
            name = 'Strong performers'
        else:
            name = f'Cluster {cluster_id}'
        cluster_names[cluster_id] = name
    return cluster_stats, cluster_names

תהליך עבודה

1. איסוף וניקוי נתונים — מחירים היסטוריים, נפחים, מדדי on-chain ל-90-180 יום.
2. הנדסת תכונות — חישוב 15+ מדדים, נורמליזציה, בחירת תכונות.
3. בחירת אלגוריתם — בדיקת K-Means, DBSCAN, היררכי; אופטימיזציה של מספר האשכולות.
4. ולידציה — ציון silhouette, המחשת UMAP, יציבות אשכולות.
5. המחשה — דשבורד עם מפת אשכולות אינטראקטיבית.
6. תיעוד — פירוש כל אשכול, הוראות עדכון.

מה כלול

• קוד מודל ב-Python עם הערות.
• דשבורד (Plotly/Dash) עם המחשת אשכולות.
• תיעוד המפרש כל אשכול.
• מדריך עדכון מודל (מומלץ עדכונים חודשיים).
• חודש תמיכה לאחר מסירה.

בניצול 7 שנות הניסיון שלנו ב-ML ו-50+ פרויקטים שהושלמו, אנחנו מבטיחים עבודה באיכות גבוהה. עלות פיתוח טיפוסית נעה בין $3,000 ל-$7,000 בהתאם למספר הנכסים ועומק הנתונים; אנחנו קובעים אותה לאחר ניתוח מערך הנתונים שלכם. צרו קשר להערכה מקדימה — אנחנו נעצב ארכיטקטורה המותאמת למשימה שלכם. הזמינו פיתוח מודל קיבוץ וקבלו כלי מוכן לשימוש לפיזור תיק.