Machine Learning in Trading Strategy Design › Alternative Data in Trading Strategies

# Simulate alternative data integration
import numpy as np
import pandas as pd

np.random.seed(42)

# Create synthetic alt data that leads market by 5 days
n_periods = 500
dates = pd.date_range("2020-01-01", periods=n_periods, freq="B")

# True underlying economic activity (unobserved)
economic_activity = np.cumsum(np.random.normal(0.001, 0.02, n_periods))

# Stock returns follow economic activity with noise
stock_returns = np.diff(economic_activity) + np.random.normal(
    0, 0.015, n_periods - 1
)
stock_returns = np.insert(stock_returns, 0, 0)

# Alternative data: credit card spending (leads economic activity by ~5 days)
alt_data_noise = np.random.normal(0, 0.3, n_periods)
credit_card_spending = np.roll(economic_activity, -5) + alt_data_noise

# Traditional data: reported revenues (lags by ~20 days)
traditional_data_noise = np.random.normal(0, 0.2, n_periods)
reported_revenues = np.roll(economic_activity, 20) + traditional_data_noise

alt_data_df = pd.DataFrame(
    {
        "date": dates,
        "stock_return": stock_returns,
        "credit_card_spending": credit_card_spending,
        "reported_revenues": reported_revenues,
        "economic_activity": economic_activity,
    }
).set_index("date")

# Calculate correlations at different lags
max_lag = 30
lags = range(-max_lag, max_lag + 1)
cc_corrs = []
trad_corrs = []

for lag in lags:
    if lag >= 0:
        cc_corr = np.corrcoef(
            alt_data_df["credit_card_spending"].iloc[lag:],
            alt_data_df["economic_activity"].iloc[:-lag]
            if lag > 0
            else alt_data_df["economic_activity"],
        )[0, 1]
        trad_corr = np.corrcoef(
            alt_data_df["reported_revenues"].iloc[lag:],
            alt_data_df["economic_activity"].iloc[:-lag]
            if lag > 0
            else alt_data_df["economic_activity"],
        )[0, 1]
    else:
        cc_corr = np.corrcoef(
            alt_data_df["credit_card_spending"].iloc[:lag],
            alt_data_df["economic_activity"].iloc[-lag:],
        )[0, 1]
        trad_corr = np.corrcoef(
            alt_data_df["reported_revenues"].iloc[:lag],
            alt_data_df["economic_activity"].iloc[-lag:],
        )[0, 1]
    cc_corrs.append(cc_corr)
    trad_corrs.append(trad_corr)

def create_combined_features(df, alt_data_cols, traditional_cols):
    """
    Create feature set combining alternative and traditional data.
    Handles different data frequencies and missing values.
    """
    features = pd.DataFrame(index=df.index)

    # Alternative data features
    for col in alt_data_cols:
        # Current level
        features[f"{col}_level"] = df[col]
        # Rate of change
        features[f"{col}_change_5d"] = df[col].diff(5)
        # Z-score (deviation from recent mean)
        features[f"{col}_zscore"] = (df[col] - df[col].rolling(21).mean()) / df[
            col
        ].rolling(21).std()

    # Traditional data features
    for col in traditional_cols:
        features[f"{col}_level"] = df[col]
        features[f"{col}_change_21d"] = df[col].diff(21)

    # Interaction features: alternative data relative to traditional
    if len(alt_data_cols) > 0 and len(traditional_cols) > 0:
        alt_col = alt_data_cols[0]
        trad_col = traditional_cols[0]
        features["alt_vs_trad_spread"] = (
            features[f"{alt_col}_zscore"]
            - (df[trad_col] - df[trad_col].rolling(21).mean())
            / df[trad_col].rolling(21).std()
        )

    return features


# Create combined feature set
combined_features = create_combined_features(
    alt_data_df,
    alt_data_cols=["credit_card_spending"],
    traditional_cols=["reported_revenues"],
)

# Prepare data for modeling
combined_features["target"] = (
    alt_data_df["stock_return"].shift(-1) > 0
).astype(int)
model_data = combined_features.dropna()

# Train-test split
split_point = int(len(model_data) * 0.7)
train = model_data.iloc[:split_point]
test = model_data.iloc[split_point:]

feature_names = [c for c in combined_features.columns if c != "target"]

# Compare model performance with and without alternative data

# Model using only traditional data
trad_features = [c for c in feature_names if "reported" in c]
rf_trad = RandomForestClassifier(n_estimators=100, max_depth=4, random_state=42)
rf_trad.fit(train[trad_features], train["target"])
pred_trad = rf_trad.predict_proba(test[trad_features])[:, 1]
auc_trad = roc_auc_score(test["target"], pred_trad)

# Model using alternative data
alt_features = [c for c in feature_names if "credit_card" in c]
rf_alt = RandomForestClassifier(n_estimators=100, max_depth=4, random_state=42)
rf_alt.fit(train[alt_features], train["target"])
pred_alt = rf_alt.predict_proba(test[alt_features])[:, 1]
auc_alt = roc_auc_score(test["target"], pred_alt)

# Combined model
rf_combined = RandomForestClassifier(
    n_estimators=100, max_depth=4, random_state=42
)
rf_combined.fit(train[feature_names], train["target"])
pred_combined = rf_combined.predict_proba(test[feature_names])[:, 1]
auc_combined = roc_auc_score(test["target"], pred_combined)