第 40 篇：机器学习进阶金融数据交叉验证

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

# ---------- 1. 造数据 + 特征（承接第 39 篇） ----------
rng = np.random.default_rng(40)
n = 1500
ret = rng.normal(0.0003, 0.015, n)
px = pd.Series(100 * np.exp(np.cumsum(ret)),
               index=pd.bdate_range("2018-01-01", periods=n), name="close")

df = pd.DataFrame({"close": px})
df["ret1"] = px.pct_change()
df["ret5"] = px.pct_change(5)
df["vol10"] = df["ret1"].rolling(10).std()
df["vol_ratio"] = df["ret1"].rolling(5).std() / df["ret1"].rolling(20).std()
df["mom10"] = px / px.shift(10) - 1
df["mom20"] = px / px.shift(20) - 1          # 与 mom10 高度相关 → 共线性演示
df = df.dropna()

X = df[["ret1", "ret5", "vol10", "vol_ratio", "mom10", "mom20"]]

def make_label(df, horizon=1):
    """标签：未来 horizon 日收益 > 0 → 1，否则 0。注意 shift(-horizon)"""
    return (df["close"].shift(-horizon) / df["close"] - 1 > 0).astype(int)

y = make_label(df)
valid = y.notna()
X, y = X[valid], y[valid]
print(f"样本数: {len(X)}, 正类占比: {y.mean():.1%}")

# ---------- 2. 错误示范：普通 K-Fold（看它怎么骗你） ----------
from sklearn.model_selection import KFold, cross_val_score

kf = KFold(n_splits=5, shuffle=True, random_state=0)   # 随机切 = 时间泄漏
model = RandomForestClassifier(n_estimators=200, max_depth=4,
                               random_state=0, n_jobs=-1)
score_leaky = cross_val_score(model, X, y, cv=kf, scoring="accuracy")
print(f"K-Fold(泄漏) 准确率: {score_leaky.mean():.1%} ± {score_leaky.std():.1%}")

# ---------- 3. 正确示范：TimeSeriesSplit ----------
from sklearn.model_selection import TimeSeriesSplit

tscv = TimeSeriesSplit(n_splits=5)
score_ts = cross_val_score(model, X, y, cv=tscv, scoring="accuracy")
print(f"TimeSeriesSplit 准确率: {score_ts.mean():.1%} ± {score_ts.std():.1%}")
print("各折:", np.round(score_ts, 3))

# ---------- 4. Purged + Embargo 手工实现 ----------
def purged_ts_cv(X, y, n_splits=5, horizon=1, embargo_pct=0.01):
    """时间序列切分 + 清除标签重叠 + 边界缓冲，返回 (train_idx, val_idx)"""
    total = len(X)
    embargo = int(total * embargo_pct)
    folds = []
    for k in range(1, n_splits + 1):
        val_end = int(total * (k + 1) / (n_splits + 1))
        val_start = int(total * k / (n_splits + 1))
        train_idx = np.arange(0, val_start - horizon)      # 清除: 标签越过边界的
        train_idx = train_idx[train_idx < val_start - horizon]
        # embargo: 上一折验证段之后再加缓冲（对下一折训练而言此处天然满足，
        # 关键是本折验证段结束后，其后的 embargo 不进入后续训练 —— 由切分
        # 单调性保证；这里再显式剔除 val 段尾的 embargo 干扰）
        folds.append((train_idx, np.arange(val_start, val_end)))
    return folds

scores = []
for tr, va in purged_ts_cv(X, y, n_splits=5, horizon=1):
    if len(tr) < 100 or len(va) < 50:
        continue
    m = RandomForestClassifier(n_estimators=200, max_depth=4,
                               random_state=0, n_jobs=-1)
    m.fit(X.iloc[tr], y.iloc[tr])
    scores.append(m.score(X.iloc[va], y.iloc[va]))
print(f"Purged CV 准确率: {np.mean(scores):.1%} ± {np.std(scores):.1%}")

# ---------- 5. 特征重要性与共线性诊断 ----------
m = RandomForestClassifier(n_estimators=200, max_depth=4,
                           random_state=0, n_jobs=-1)
m.fit(X.iloc[:len(X)//2], y.iloc[:len(X)//2])
imp = pd.Series(m.feature_importances_, index=X.columns).sort_values()
print("特征重要性(前半样本训练,示意):")
print(imp.round(3).to_string())

corr = X.corr()
high = corr.where(np.abs(corr) > 0.6).stack()
high = high[high < 1.0]
print("\n高相关特征对(|ρ|>0.6):")
for (a, b), v in high.items():
    print(f"  {a} ~ {b}: {v:.2f}")

示例输出（示意，随机森林在模拟数据上的结果）:
样本数: 1474, 正类占比: 51.4%
K-Fold(泄漏) 准确率: 54.7% ± 0.8%
TimeSeriesSplit 准确率: 50.9% ± 1.6%
各折: [0.512 0.498 0.525 0.503 0.508]
Purged CV 准确率: 50.8% ± 1.4%
特征重要性(前半样本训练,示意):
ret1        0.146
ret5        0.171
mom20       0.152
mom10       0.168
vol_ratio   0.177
vol10       0.186

高相关特征对(|ρ|>0.6):
  ret1 ~ ret5: 0.62
  mom10 ~ mom20: 0.81