https://www.kaggle.com/code/lblhandsome/optiver-robust-best-single-model

特征组合1

首先生成一些不平衡特征，这些特征可以用于训练机器学习模型，以预测股票价格走势或其他市场行为。

# generate imbalance features
def imbalance_features(df):
    prices = ["reference_price", "far_price", "near_price", "ask_price", "bid_price", "wap"]
    sizes = ["matched_size", "bid_size", "ask_size", "imbalance_size"]

    # V1
    df["volume"] = df.eval("ask_size + bid_size")
    df["mid_price"] = df.eval("(ask_price + bid_price) / 2")
    df["liquidity_imbalance"] = df.eval("(bid_size-ask_size)/(bid_size+ask_size)")
    df["matched_imbalance"] = df.eval("(imbalance_size-matched_size)/(matched_size+imbalance_size)")
    df["size_imbalance"] = df.eval("bid_size / ask_size")
    
    for c in combinations(prices, 2):
        df[f"{c[0]}_{c[1]}_imb"] = df.eval(f"({c[0]} - {c[1]})/({c[0]} + {c[1]})")

    for c in [['ask_price', 'bid_price', 'wap', 'reference_price'], sizes]:
        triplet_feature = calculate_triplet_imbalance_numba(c, df)
        df[triplet_feature.columns] = triplet_feature.values
        
    # V2
    df["imbalance_momentum"] = df.groupby(['stock_id'])['imbalance_size'].diff(periods=1) / df['matched_size']
    df["price_spread"] = df["ask_price"] - df["bid_price"]
    df["spread_intensity"] = df.groupby(['stock_id'])['price_spread'].diff()
    df['price_pressure'] = df['imbalance_size'] * (df['ask_price'] - df['bid_price'])
    df['market_urgency'] = df['price_spread'] * df['liquidity_imbalance']
    df['depth_pressure'] = (df['ask_size'] - df['bid_size']) * (df['far_price'] - df['near_price'])
    for func in ["mean", "std", "skew", "kurt"]:
        df[f"all_prices_{func}"] = df[prices].agg(func, axis=1)
        df[f"all_sizes_{func}"] = df[sizes].agg(func, axis=1)
        
    # V3
    for col in ['matched_size', 'imbalance_size', 'reference_price', 'imbalance_buy_sell_flag']:
        for window in [1, 2, 3, 10]:
            df[f"{col}_shift_{window}"] = df.groupby('stock_id')[col].shift(window)
            df[f"{col}_ret_{window}"] = df.groupby('stock_id')[col].pct_change(window)
            
    for col in ['ask_price', 'bid_price', 'ask_size', 'bid_size']:
        for window in [1, 2, 3, 10]:
            df[f"{col}_diff_{window}"] = df.groupby("stock_id")[col].diff(window)

    return df.replace([np.inf, -np.inf], 0)

特征组合2

提出时间和股票特征，用于提供更多关于交易数据的上下文信息。

# generate time & stock features
def other_features(df):
    df["dow"] = df["date_id"] % 5
    df["seconds"] = df["seconds_in_bucket"] % 60
    df["minute"] = df["seconds_in_bucket"] // 60

    for key, value in global_stock_id_feats.items():
        df[f"global_{key}"] = df["stock_id"].map(value.to_dict())

    return df

时序验证集

接下来使用LightGBM来建立一个回归模型，以在股票市场上预测股票收盘价格的变动。模型的参数和数据集的划分都是关键因素，影响着模型的性能和泛化能力。

lgb_params = {
    "objective" : "mae",
    "n_estimators" : 3000,
    "num_leaves" : 128,
    "subsample" : 0.6,
    "colsample_bytree" : 0.6,
    "learning_rate" : 0.05,
    "n_jobs" : 4,
    "device" : "gpu",
    "verbosity": -1,
    "importance_type" : "gain",
}

print(f"Feature length = {len(feature_name)}")

offline_split = df_train['date_id']>(split_day - 45)
df_offline_train = df_train_feats[~offline_split]
df_offline_valid = df_train_feats[offline_split]
df_offline_train_target = df_train['target'][~offline_split]
df_offline_valid_target = df_train['target'][offline_split]

print("Valid Model Trainning.")
lgb_model = lgb.LGBMRegressor(**lgb_params)
lgb_model.fit(
    df_offline_train[feature_name],
    df_offline_train_target,
    eval_set=[(df_offline_valid[feature_name], df_offline_valid_target)],
    callbacks=[
        lgb.callback.early_stopping(stopping_rounds=100),
        lgb.callback.log_evaluation(period=100),
    ],
)

预测结果后处理

在预测代码中加入数据缓存，用于存储历史测试数据，以便在进行预测时使用。然后根据缓存数据生成特征，这些特征将用于进行预测。 最终使用np.clip函数来确保预测结果在一个指定的范围内，通常是评估标准所要求的范围。

for (test, revealed_targets, sample_prediction) in iter_test:
    now_time = time.time()
    cache = pd.concat([cache, test], ignore_index=True, axis=0)
    if counter > 0:
        cache = cache.groupby(['stock_id']).tail(21).sort_values(by=['date_id', 'seconds_in_bucket', 'stock_id']).reset_index(drop=True)
    feat = generate_all_features(cache)[-len(test):]
    lgb_prediction = infer_lgb_model.predict(feat)
    lgb_prediction = zero_sum(lgb_prediction, test['bid_size'] + test['ask_size'])
    clipped_predictions = np.clip(lgb_prediction, y_min, y_max)
    sample_prediction['target'] = clipped_predictions
    env.predict(sample_prediction)