הנדסת תכונות לנתוני קריפטו: אוטומציה ואימות

בילית חודש באיסוף טיקים גולמיים, אך המודל מציג R² בסביבות 0.3. הבעיה אינה האלגוריתם—אלא התכונות. ללא צינור הנדסת תכונות אוטומטי לקריפטו, אתה מבזבז 80% מהזמן שלך על חישובים ידניים. ראינו זאת ביותר מ-30 פרויקטים: נרות גולמיים ללא הנדסה מניבים תוצאות חלשות, בעוד שמערכת הנדסת תכונות איכותית מעלה את R² ל-0.65. ניתוח on-chain, ספרי הזמנות בבורסות, סנטימנט חברתי—כל מקור דורש תכונות ספציפיות. אנו מבצעים אוטומציה של כל הצינור: מאיסוף נתונים ועד Feature Store. צור קשר—נעריך את הנתונים שלך תוך יומיים.

רקורד שלנו: 5+ שנים ב-ML בשווקי קריפטו, עיבוד 7 TB של נתונים ביום על מופע יחיד. אנו מבטיחים הפחתה של 40% בעלויות מחשוב על ידי בחירת תכונות משמעותיות בלבד, מה שכבר חסך ללקוחות עד $5,000 בחודש על משאבי ענן.

מדוע הנדסת תכונות היא המפתח להצלחה?

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

כיצד אנו בונים את צינור יצירת התכונות?

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

def create_price_features(df):
    f = pd.DataFrame(index=df.index)
    for period in [1, 2, 4, 8, 12, 24, 48, 72, 168]:
        f[f'ret_{period}h'] = df['close'].pct_change(period)
        f[f'log_ret_{period}h'] = np.log(df['close']).diff(period)
    for window in [12, 24, 72, 168]:
        rets = df['close'].pct_change()
        f[f'ret_mean_{window}'] = rets.rolling(window).mean()
        f[f'ret_std_{window}'] = rets.rolling(window).std()
        f[f'ret_skew_{window}'] = rets.rolling(window).skew()
        f[f'ret_kurt_{window}'] = rets.rolling(window).kurt()
    for window in [24, 72, 168]:
        rolling_high = df['high'].rolling(window).max()
        rolling_low = df['low'].rolling(window).min()
        f[f'price_position_{window}'] = (df['close'] - rolling_low) / (rolling_high - rolling_low + 1e-8)
    for ma_period in [9, 21, 50, 100, 200]:
        ma = df['close'].ewm(span=ma_period).mean()
        f[f'dist_ema_{ma_period}'] = (df['close'] - ma) / ma
    return f

def create_volume_features(df):
    f = pd.DataFrame(index=df.index)
    for window in [6, 12, 24, 72]:
        f[f'vol_ratio_{window}'] = df['volume'] / df['volume'].rolling(window).mean()
    f['vwap_distance'] = (df['close'] - (df['close'] * df['volume']).rolling(24).sum() / df['volume'].rolling(24).sum()) / df['close']
    f['obv'] = talib.OBV(df['close'], df['volume'])
    f['obv_slope'] = f['obv'].diff(12) / 12
    f['atr_14'] = talib.ATR(df['high'], df['low'], df['close'], timeperiod=14)
    f['atr_ratio'] = f['atr_14'] / df['close']
    f['mfi_14'] = talib.MFI(df['high'], df['low'], df['close'], df['volume'], timeperiod=14)
    return f

def create_technical_features(df):
    f = pd.DataFrame(index=df.index)
    for period in [9, 14, 21]:
        f[f'rsi_{period}'] = talib.RSI(df['close'], timeperiod=period) / 100
    for fast, slow, signal in [(12, 26, 9), (5, 13, 5), (24, 52, 18)]:
        macd, sig, hist = talib.MACD(df['close'], fast, slow, signal)
        f[f'macd_hist_{fast}_{slow}'] = hist / df['close']
    for window, std in [(20, 2), (20, 1), (50, 2)]:
        upper, mid, lower = talib.BBANDS(df['close'], window, std, std)
        f[f'bb_width_{window}_{std}'] = (upper - lower) / mid
        f[f'bb_pos_{window}_{std}'] = (df['close'] - lower) / (upper - lower + 1e-8)
    f['adx_14'] = talib.ADX(df['high'], df['low'], df['close'], timeperiod=14) / 100
    f['adx_trend'] = (f['adx_14'] > 0.25).astype(float)
    slowk, slowd = talib.STOCH(df['high'], df['low'], df['close'])
    f['stoch_k'] = slowk / 100
    f['stoch_d'] = slowd / 100
    return f

def create_microstructure_features(df_ticks):
    f = pd.DataFrame(index=df_ticks.index)
    f['spread'] = (df_ticks['ask'] - df_ticks['bid']) / df_ticks['mid']
    f['spread_ma'] = f['spread'].rolling(100).mean()
    f['spread_relative'] = f['spread'] / f['spread_ma']
    f['buy_volume'] = df_ticks['buy_volume']
    f['sell_volume'] = df_ticks['sell_volume']
    f['ofi'] = (f['buy_volume'] - f['sell_volume']) / (f['buy_volume'] + f['sell_volume'] + 1e-8)
    f['ofi_ma'] = f['ofi'].rolling(20).mean()
    return f

כל מודול מכוסה על ידי בדיקות יחידה ומתווסף לגרסאות דרך Git LFS. זה מאפשר חזרות מהירות ושחזור ניסויים.

מדוע אימות תכונות הוא קריטי?

טעויות נפוצות: הטיית מבט קדימה, אי-סטציונריות, מולטיקולינאריות. ללא סינון, המודל משנן רעש. המאמת שלנו בודק אוטומטית כל תכונה מול חמישה מדדים. לפי ויקיפדיה, הנדסת תכונות היא שלב קריטי ב-ML, ומחקרים מראים שעד 70% מהשיפור במודל מגיע מתכונות איכותיות.

class FeatureValidator:
    def validate(self, features_df, target_series):
        report = {}
        for col in features_df.columns:
            series = features_df[col]
            missing_pct = series.isna().mean()
            valid_mask = series.notna() & target_series.notna()
            if valid_mask.sum() > 100:
                corr = series[valid_mask].corr(target_series[valid_mask])
            else:
                corr = 0
            from statsmodels.tsa.stattools import adfuller
            try:
                adf_stat, adf_p = adfuller(series.dropna())[:2]
                stationary = adf_p < 0.05
            except:
                stationary = None
            variance = series.var()
            report[col] = {
                'missing_pct': missing_pct,
                'correlation_with_target': corr,
                'stationary': stationary,
                'variance': variance,
                'recommended': (missing_pct < 0.05 and abs(corr) > 0.01 and variance > 1e-8)
            }
        return pd.DataFrame(report).T

בניגוד לבדיקות ידניות, המאמת שלנו מעבד 200+ תכונות בשניות. התוצאה היא קבוצה נקייה של תכונות מוכנות לאימון.

בחירת תכונות: כמות אינה שווה לאיכות

לאחר היצירה, אנו מקבלים עד 200 תכונות. 95% מהן הן רעש. אנו בוחרים את המשמעותיות ביותר באמצעות שלוש שיטות:

• מידע הדדי (Mutual Information) — לוכד תלות לא-לינארית.
• חשיבות SHAP — מראה תרומה אמיתית לתחזיות על מודל בסיס.
• מסנן מתאם — מסיר זוגות עם מתאם > 0.95.

תוצאה: 30–50 תכונות נכנסות לאימון. עבור סדרות זמן, אנו בודקים בנוסף סטציונריות וסיבתיות גראנג'ר.

from sklearn.feature_selection import mutual_info_classif
import shap

mi_scores = mutual_info_classif(X_train, y_train, random_state=42)
mi_df = pd.DataFrame({'feature': X_train.columns, 'mi_score': mi_scores})
top_features = mi_df.nlargest(50, 'mi_score')['feature'].tolist()

explainer = shap.TreeExplainer(lgb_model)
shap_values = explainer.shap_values(X_val)
feature_importance = pd.Series(np.abs(shap_values).mean(0), index=X_val.columns).sort_values(ascending=False)

Feature Store — מאגר תכונות מרכזי

ארכיטקטורת ייצור דורשת הפרדה בין online ל-offline. Online (Redis) להסקה בזמן אמת, offline (Parquet/S3) לאימון אצווה. גרסאות מאפשרות חזרה לאחור אם תכונה חדשה פוגעת במודל. Feature Store מפחית את זמן ההשהיה בהסקה פי 3 בהשוואה לשאילתות על נתונים גולמיים.

טעויות נפוצות ביצירת תכונות

• הטיית מבט קדימה: שימוש בנתונים עתידיים בחישוב תכונות (לדוגמה, VWAP של יום שלם באמצע היום).
• אי-סטציונריות: למחיר יש מגמה — השתמש בתשואות לוגריתמיות במקום מחירים מוחלטים.
• מולטיקולינאריות: שמור רק תכונה אחת מקבוצה של תכונות עם מתאם גבוה.
• ערכים חסרים >5%: התכונה חסרת תועלת — הסר או בצע אינטרפולציה.

מה כלול בעבודה

1. ביקורת מקורות נתונים — זיהוי APIs זמינים, פורמטים, תדירות עדכון.
2. פיתוח צינור — יצירת מודולים לכל קטגוריית תכונות עם בדיקות מבט קדימה.
3. בחירת תכונות — בחירת 30–50 תכונות באמצעות MI, SHAP ומסנן מתאם.
4. Feature Store — פריסת אחסון עם גרסאות ושתי חנויות (online/offline).
5. תיעוד והדרכה — תיאור כל תכונה, API של Feature Store, סדנה לצוות שלך.
6. תמיכה — 3 חודשים לאחר המסירה, כולל התאמות לתנאי שוק משתנים.

הפחתה של 40% בעלויות מחשוב היא אפקט אמיתי לאחר יישום המערכת שלנו. החיסכון הממוצע בתשתית מסתכם ב-$7,500 בחודש, והפרויקט מחזיר את עצמו בממוצע תוך חודשיים (חיסכון של $10,000). קבל ייעוץ — המהנדסים שלנו יכינו ארכיטקטורה לסטack שלך תוך יומיים.