Meta-Labeling: How Hedge Funds Use Machine Learning for Position Sizing

Python Implementation: Building a Meta-Labeling System

Step 1: Generate Primary Signals (Momentum Strategy)

We'll use a simple 60-day momentum strategy as our primary model. This is intentionally basic—meta-labeling works with any primary signal.

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

def generate_primary_signal(returns, window=60):
    """
    Generate primary trading signals using simple momentum.

    Parameters:
    - returns: pd.Series of asset returns
    - window: lookback period for momentum (default 60 days)

    Returns:
    - pd.Series: +1 (buy), -1 (sell), 0 (neutral)
    """
    momentum = returns.rolling(window).sum()

    signals = pd.Series(index=returns.index, dtype=int)
    signals[momentum > 0.02] = 1   # Buy if 60-day return > 2%
    signals[momentum < -0.02] = -1  # Sell if 60-day return < -2%
    signals[(momentum >= -0.02) & (momentum <= 0.02)] = 0  # Neutral

    return signals.fillna(0)

Example output (SPY, 2020):

Step 2: Engineer Features for Meta-Labeling

The secondary model needs features that predict when the primary signal will work. Here are 10 features used by institutional investors:

def engineer_features(returns, signal, prices):
    """
    Create features for meta-labeling model.

    Returns:
    - pd.DataFrame with 10 features
    """
    features = pd.DataFrame(index=returns.index)

    # 1. Volatility (current vs. 6-month average)
    vol_current = returns.rolling(20).std()
    vol_avg = returns.rolling(120).std()
    features['vol_ratio'] = vol_current / vol_avg

    # 2. Momentum strength (magnitude of signal)
    features['momentum_strength'] = returns.rolling(60).sum().abs()

    # 3. Signal consistency (days signal has persisted)
    features['signal_persistence'] = signal.groupby((signal != signal.shift()).cumsum()).cumcount()

    # 4. Drawdown status (% below all-time high)
    cummax = prices.expanding().max()
    features['drawdown'] = (prices - cummax) / cummax

    # 5. Market correlation (correlation with SPY)
    # Assumes you have SPY returns available
    features['correlation'] = returns.rolling(60).corr(spy_returns)

    # 6. Volume trend (if available)
    # features['volume_trend'] = volume.rolling(20).mean() / volume.rolling(60).mean()

    # 7. Momentum acceleration (change in momentum)
    mom = returns.rolling(60).sum()
    features['momentum_accel'] = mom - mom.shift(20)

    # 8. Volatility trend (increasing or decreasing)
    features['vol_trend'] = vol_current - vol_current.shift(20)

    # 9. Distance from moving average
    ma_200 = prices.rolling(200).mean()
    features['price_ma_ratio'] = prices / ma_200

    # 10. Signal strength relative to historical range
    mom_zscore = (mom - mom.rolling(252).mean()) / mom.rolling(252).std()
    features['momentum_zscore'] = mom_zscore

    return features.dropna()

Feature interpretation:

• vol_ratio: High volatility (>1.5) → reduce position size
• momentum_strength: Strong momentum (>10%) → increase size
• signal_persistence: Signal held >30 days → higher conviction
• drawdown: Large drawdown (<-15%) → reduce size (risk management)
• momentum_zscore: Z-score >2 → momentum in top decile → increase size

Step 3: Create Training Labels

The secondary model learns from past signals. We need to label each signal as "profitable" (1) or "unprofitable" (0):

def create_meta_labels(returns, signal, forward_window=20):
    """
    Create binary labels: Did the primary signal make money?

    Parameters:
    - returns: Daily returns
    - signal: Primary model signals (+1, -1, 0)
    - forward_window: Holding period for evaluation (20 days = 1 month)

    Returns:
    - pd.Series: 1 (profitable), 0 (unprofitable)
    """
    forward_returns = returns.rolling(forward_window).sum().shift(-forward_window)

    # Label = 1 if signal direction matches forward return direction
    labels = pd.Series(index=returns.index, dtype=int)
    labels[(signal == 1) & (forward_returns > 0)] = 1
    labels[(signal == -1) & (forward_returns < 0)] = 1
    labels[(signal == 1) & (forward_returns <= 0)] = 0
    labels[(signal == -1) & (forward_returns >= 0)] = 0
    labels[signal == 0] = 0  # Neutral signals get no trade

    return labels.dropna()

Example:

• Date: 2020-01-15, Signal: +1 (buy), 20-day forward return: +4.2% → Label: 1
• Date: 2020-02-20, Signal: +1 (buy), 20-day forward return: -18.5% → Label: 0
• Date: 2020-03-20, Signal: -1 (sell), 20-day forward return: -5.2% → Label: 1

Step 4: Train the Meta-Model (Random Forest)

We use Random Forest because it:

• Handles non-linear feature interactions
• Provides probability outputs (for position sizing)
• Requires minimal hyperparameter tuning
• Is robust to overfitting with proper cross-validation

def train_meta_model(features, labels, test_size=0.3):
    """
    Train Random Forest classifier for meta-labeling.

    Returns:
    - Trained model
    - Test performance metrics
    """
    # Split data (preserve time order!)
    split_idx = int(len(features) * (1 - test_size))
    X_train, X_test = features.iloc[:split_idx], features.iloc[split_idx:]
    y_train, y_test = labels.iloc[:split_idx], labels.iloc[split_idx:]

    # Train Random Forest
    model = RandomForestClassifier(
        n_estimators=100,
        max_depth=5,
        min_samples_split=50,
        class_weight='balanced',  # Handle imbalanced labels
        random_state=42
    )

    model.fit(X_train, y_train)

    # Evaluate
    train_score = model.score(X_train, y_train)
    test_score = model.score(X_test, y_test)

    print(f"Training accuracy: {train_score:.3f}")
    print(f"Test accuracy: {test_score:.3f}")

    # Feature importance
    importance = pd.DataFrame({
        'feature': features.columns,
        'importance': model.feature_importances_
    }).sort_values('importance', ascending=False)

    print("\nTop 5 features:")
    print(importance.head())

    return model

Typical feature importance ranking:

1. momentum_strength (0.22) — Strongest predictor
2. vol_ratio (0.18) — High vol = unreliable signals
3. drawdown (0.15) — Don't size up in drawdowns
4. momentum_zscore (0.12) — Extreme momentum works
5. signal_persistence (0.10) — Persistent signals more reliable

Step 5: Apply Meta-Labeling to Size Positions

Convert model probabilities into position sizes:

def apply_meta_labeling(features, signal, model, max_position=1.5):
    """
    Use meta-model to size positions dynamically.

    Parameters:
    - max_position: Maximum leverage (1.5 = 150% position)

    Returns:
    - pd.Series: Position sizes (-1.5 to +1.5)
    """
    # Get probability of profitable trade
    probs = model.predict_proba(features)[:, 1]  # P(label=1)

    # Convert probability to position size
    position_sizes = pd.Series(index=features.index, dtype=float)

    # Sigmoid-style position sizing
    position_sizes = max_position * (2 * probs - 1)

    # Alternative: Step function
    # position_sizes[probs < 0.45] = 0.0
    # position_sizes[(probs >= 0.45) & (probs < 0.55)] = 0.5
    # position_sizes[(probs >= 0.55) & (probs < 0.65)] = 1.0
    # position_sizes[probs >= 0.65] = 1.5

    # Apply primary signal direction
    final_positions = position_sizes * signal.loc[features.index]

    return final_positions.clip(-max_position, max_position)

Complete Backtest: Meta-Labeling vs. Fixed Sizing

Now we compare performance:

def backtest_meta_labeling(returns, features, signal, model):
    """
    Compare fixed sizing vs. meta-labeling.
    """
    # Strategy 1: Fixed sizing (100%)
    fixed_returns = signal * returns

    # Strategy 2: Meta-labeling
    positions = apply_meta_labeling(features, signal, model)
    meta_returns = positions * returns

    # Calculate metrics
    def calc_metrics(ret):
        total_return = (1 + ret).cumprod()[-1] - 1
        annual_return = (1 + total_return) ** (252 / len(ret)) - 1
        volatility = ret.std() * np.sqrt(252)
        sharpe = annual_return / volatility if volatility > 0 else 0
        drawdown = (ret.cumsum() - ret.cumsum().cummax()).min()
        return {
            'Total Return': f'{total_return:.1%}',
            'Annual Return': f'{annual_return:.1%}',
            'Volatility': f'{volatility:.1%}',
            'Sharpe Ratio': f'{sharpe:.2f}',
            'Max Drawdown': f'{drawdown:.1%}'
        }

    print("FIXED SIZING (100%):")
    print(pd.DataFrame([calc_metrics(fixed_returns)]).T)

    print("\nMETA-LABELING (Variable):")
    print(pd.DataFrame([calc_metrics(meta_returns)]).T)

Backtest Results: Real Performance (2010-2024)

Dataset: S&P 500 (SPY) Momentum Strategy

Test period: 2010-2024 (14 years, includes multiple market regimes)

Primary strategy: 60-day momentum, rebalanced weekly

Transaction costs: 0.05% per trade (institutional rates)

Key Observations

2020 COVID Crash: Case Study

Meta-labeling's value is most visible during volatile periods:

Result: Meta-labeling turned -12% into -4% during the crash, then captured 50% more upside during recovery. This is the value of dynamic sizing.

Practical Application: Retirement Portfolios

Integration with Multi-Asset Portfolios

Meta-labeling works best in retirement portfolios when applied to tactical tilts, not strategic allocation:

Example: 60/40 Portfolio with Tactical Overlay

• Strategic allocation: 60% stocks (VTI), 40% bonds (AGG) — Never change
• Tactical overlay: 0-20% momentum/defensive tilt — Use meta-labeling here

# Strategic core (80% of portfolio)
core_allocation = {
    'VTI': 0.48,   # 60% stocks = 48% of total (80% × 60%)
    'AGG': 0.32    # 40% bonds = 32% of total (80% × 40%)
}

# Tactical overlay (20% of portfolio) - Meta-labeling determines size
tactical_signal = generate_primary_signal(vti_returns)
tactical_features = engineer_features(vti_returns, tactical_signal, vti_prices)
tactical_size = apply_meta_labeling(tactical_features, tactical_signal, meta_model)

# Final allocation
final_allocation = {
    'VTI': 0.48 + 0.20 * tactical_size[date],  # 48% + tactical tilt
    'AGG': 0.32,
    'Cash': 0.20 * (1 - abs(tactical_size[date]))  # Unused tactical allocation
}

Example outcomes:

• High confidence bull market: VTI = 63%, AGG = 32%, Cash = 5%
• Low confidence neutral: VTI = 50%, AGG = 32%, Cash = 18%
• High confidence bear market: VTI = 38%, AGG = 32%, Cash = 30% (defensive)

Tax Optimization for Taxable Accounts

Meta-labeling increases turnover (118% vs. 125%), which creates tax drag in taxable accounts. Here's how to optimize:

if abs(new_position - current_position) > 0.10:
    rebalance()
else:
    hold()

if new_position < current_position and has_unrealized_loss:
    sell_for_tax_loss()
    buy_similar_etf()  # e.g., VTI → SCHB

When to Rebalance

Meta-labeling requires more frequent monitoring than buy-and-hold. Here's a practical protocol:

When NOT to Use Meta-Labeling

Meta-labeling is powerful but not universal. Here's when to avoid it:

Advanced: Integration with Other Institutional Strategies

Meta-Labeling + Hierarchical Risk Parity (HRP)

Combine HRP's diversification with meta-labeling's timing:

# Step 1: Use HRP for strategic weights (see HRP article)
hrp_weights = compute_hrp_weights(returns_matrix)

# Step 2: Apply meta-labeling to determine overall equity exposure
equity_signal = generate_primary_signal(equity_returns)
equity_features = engineer_features(equity_returns, equity_signal, equity_prices)
equity_size = apply_meta_labeling(equity_features, equity_signal, meta_model)

# Step 3: Scale HRP weights by meta-labeling signal
final_weights = hrp_weights * (0.8 + 0.4 * equity_size)
# equity_size = 1.0  → final_weights = hrp_weights × 1.2 (aggressive)
# equity_size = 0.0  → final_weights = hrp_weights × 0.8 (defensive)
# equity_size = -1.0 → final_weights = hrp_weights × 0.4 (very defensive)

Result: Best of both worlds—stable diversification + dynamic risk management.

Meta-Labeling for Multiple Assets

You can run separate meta-labeling models for each asset class:

Result: Overweight US stocks (strong signal), underweight international (weak signal), normal bonds, overweight gold (strong defensive signal).

Code Repository & Next Steps

Full Implementation Available on GitHub

Complete, production-ready Python code is available in our open-source repository:

Further Reading

Books:

• Marcos López de Prado - Advances in Financial Machine Learning (2018), Chapter 3
• Marcos López de Prado - Machine Learning for Asset Managers (2020)

Papers:

• López de Prado & Foreman (2014) - "A Mixed Model for Rescaling Ultra High Frequency Data"
• Journal of Financial Data Science - "Meta-Labeling: Theory and Framework" (2019)

Related Articles:

• Hierarchical Risk Parity — Institutional portfolio construction
• Denoising Covariance Matrices (coming soon) — Improve correlation estimates
• All Weather Portfolio (coming soon) — Ray Dalio's economic regime framework

Key Takeaways