feature_engineering.py

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.feature_selection import SelectKBest, f_regression, RFE
from sklearn.ensemble import RandomForestRegressor
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from scipy.stats import pearsonr, spearmanr
import warnings
warnings.filterwarnings('ignore')

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False

# ===== Configuration =====
class Config:
    TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/train.parquet"
    TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/test.parquet"
    SUBMISSION_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/sample_submission.csv"
    
    LABEL_COLUMN = "label"

def load_data():
    """加载数据"""
    print("正在加载数据...")
    train_df = pd.read_parquet(Config.TRAIN_PATH, columns=Config.FEATURES + [Config.LABEL_COLUMN])
    print(f"数据加载完成，训练集形状: {train_df.shape}")
    return train_df

def feature_engineering(df):
    """特征工程（与原始代码保持一致）"""
    # Original features
    df['volume_weighted_sell'] = df['sell_qty'] * df['volume']
    df['buy_sell_ratio'] = df['buy_qty'] / (df['sell_qty'] + 1e-8)
    df['selling_pressure'] = df['sell_qty'] / (df['volume'] + 1e-8)
    df['effective_spread_proxy'] = np.abs(df['buy_qty'] - df['sell_qty']) / (df['volume'] + 1e-8)
    
    # New robust features
    df['log_volume'] = np.log1p(df['volume'])
    df['bid_ask_imbalance'] = (df['bid_qty'] - df['ask_qty']) / (df['bid_qty'] + df['ask_qty'] + 1e-8)
    df['order_flow_imbalance'] = (df['buy_qty'] - df['sell_qty']) / (df['buy_qty'] + df['sell_qty'] + 1e-8)
    df['liquidity_ratio'] = (df['bid_qty'] + df['ask_qty']) / (df['volume'] + 1e-8)
    
    # Handle infinities and NaN
    df = df.replace([np.inf, -np.inf], np.nan)
    
    # For each column, replace NaN with median for robustness
    for col in df.columns:
        if df[col].isna().any():
            median_val = df[col].median()
            df[col] = df[col].fillna(median_val if not pd.isna(median_val) else 0)
    
    return df

def analyze_feature_label_correlation(df, features, label_col):
    """分析特征与标签的相关性"""
    print("\n=== 特征与标签相关性分析 ===")
    
    correlations = []
    for feature in features:
        if feature in df.columns:
            # Pearson相关系数
            pearson_corr, pearson_p = pearsonr(df[feature], df[label_col])
            # Spearman相关系数
            spearman_corr, spearman_p = spearmanr(df[feature], df[label_col])
            
            correlations.append({
                'feature': feature,
                'pearson_corr': pearson_corr,
                'pearson_p': pearson_p,
                'spearman_corr': spearman_corr,
                'spearman_p': spearman_p,
                'abs_pearson': abs(pearson_corr),
                'abs_spearman': abs(spearman_corr)
            })
    
    # 转换为DataFrame并排序
    corr_df = pd.DataFrame(correlations)
    corr_df = corr_df.sort_values('abs_pearson', ascending=False)
    
    print("\n特征与标签相关性排序（按Pearson相关系数绝对值）:")
    print("=" * 80)
    print(f"{'特征名':<20} {'Pearson':<10} {'P值':<10} {'Spearman':<10} {'P值':<10}")
    print("=" * 80)
    
    for _, row in corr_df.iterrows():
        print(f"{row['feature']:<20} {row['pearson_corr']:<10.4f} {row['pearson_p']:<10.4f} "
              f"{row['spearman_corr']:<10.4f} {row['spearman_p']:<10.4f}")
    
    return corr_df

def analyze_feature_correlations(df, features, top_n=10):
    """分析特征间的相关性"""
    print(f"\n=== 特征间相关性分析（显示前{top_n}个最强相关） ===")
    
    # 计算相关性矩阵
    feature_df = df[features]
    corr_matrix = feature_df.corr()
    
    # 获取上三角矩阵的相关性
    upper_tri = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
    
    # 转换为长格式并排序
    correlations = []
    for i in range(len(features)):
        for j in range(i+1, len(features)):
            feat1, feat2 = features[i], features[j]
            corr_val = corr_matrix.loc[feat1, feat2]
            if not pd.isna(corr_val):
                correlations.append({
                    'feature1': feat1,
                    'feature2': feat2,
                    'correlation': corr_val,
                    'abs_correlation': abs(corr_val)
                })
    
    corr_df = pd.DataFrame(correlations)
    corr_df = corr_df.sort_values('abs_correlation', ascending=False)
    
    print(f"\n特征间相关性排序（前{top_n}个）:")
    print("=" * 60)
    print(f"{'特征1':<15} {'特征2':<15} {'相关性':<10} {'绝对值':<10}")
    print("=" * 60)
    
    for _, row in corr_df.head(top_n).iterrows():
        print(f"{row['feature1']:<15} {row['feature2']:<15} {row['correlation']:<10.4f} {row['abs_correlation']:<10.4f}")
    
    return corr_matrix, corr_df

def plot_correlation_heatmap(corr_matrix, title="特征相关性热力图", figsize=(12, 10)):
    """绘制相关性热力图"""
    plt.figure(figsize=figsize)
    mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
    sns.heatmap(corr_matrix, mask=mask, annot=True, cmap='RdBu_r', center=0,
                square=True, linewidths=0.5, cbar_kws={"shrink": .8})
    plt.title(title, fontsize=16, pad=20)
    plt.tight_layout()
    plt.savefig(f"{title.replace(' ', '_')}.png", dpi=300, bbox_inches='tight')
    plt.show()

def plot_feature_label_correlation(corr_df, title="特征与标签相关性", figsize=(12, 8)):
    """绘制特征与标签相关性条形图"""
    plt.figure(figsize=figsize)
    
    # 选择前20个特征
    top_features = corr_df.head(20)
    
    x = range(len(top_features))
    pearson_vals = top_features['pearson_corr'].values
    spearman_vals = top_features['spearman_corr'].values
    
    # 创建条形图
    width = 0.35
    plt.bar([i - width/2 for i in x], pearson_vals, width, label='Pearson', alpha=0.8)
    plt.bar([i + width/2 for i in x], spearman_vals, width, label='Spearman', alpha=0.8)
    
    plt.xlabel('特征')
    plt.ylabel('相关系数')
    plt.title(title)
    plt.xticks(x, top_features['feature'], rotation=45, ha='right')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig(f"{title.replace(' ', '_')}.png", dpi=300, bbox_inches='tight')
    plt.show()

def analyze_feature_importance_by_correlation(corr_df, threshold=0.01):
    """基于相关性分析特征重要性"""
    print(f"\n=== 基于相关性的特征重要性分析（P值阈值: {threshold}） ===")
    
    # 筛选显著相关的特征
    significant_features = corr_df[corr_df['pearson_p'] < threshold].copy()
    significant_features = significant_features.sort_values('abs_pearson', ascending=False)
    
    print(f"\n显著相关的特征数量: {len(significant_features)}")
    print("\n高重要性特征（|相关系数| > 0.05）:")
    high_importance = significant_features[significant_features['abs_pearson'] > 0.05]
    
    for _, row in high_importance.iterrows():
        print(f"- {row['feature']}: Pearson={row['pearson_corr']:.4f}, P={row['pearson_p']:.4f}")
    
    return significant_features

def find_high_correlations(corr_matrix, threshold=0.8):
    high_corr_pairs = []
    for i in range(len(corr_matrix.columns)):
        for j in range(i + 1, len(corr_matrix.columns)):
            if abs(corr_matrix.iloc[i, j]) > threshold:
                high_corr_pairs += [{
                    'feature1': corr_matrix.columns[i],
                    'feature2': corr_matrix.columns[j],
                    'correlation': corr_matrix.iloc[i, j]
                }]
    return pd.DataFrame(high_corr_pairs)



def main():
    """主函数"""
    print("开始特征相关性分析...")
    
    # 加载数据
    train = pd.read_parquet(Config.TRAIN_PATH)
    anonymized_features = list(train.columns[list(range(5, train.shape[1] - 1))])
    target = 'label'
    fig, axes = plt.subplots(2, 3, figsize=(15, 10))
    fig.suptitle('Distribution of Random 6 Anonymized Features', fontsize=16)
    import random
    for i, feature in enumerate(random.sample(list(anonymized_features), 6)):
        row, col = i // 3, i % 3
        train[feature].hist(bins=50, ax=axes[row, col], alpha=0.7)
        axes[row, col].set_title(f'{feature}')
        axes[row, col].set_xlabel('Value')
        axes[row, col].set_ylabel('Frequency')
    plt.tight_layout()
    plt.show()
    breakpoint()
    
    # heatmap correlation between features
    subset_features = anonymized_features[:50]
    correlation_matrix = train[subset_features + [target]].corr()

    # Plot correlation heatmap
    plt.figure(figsize=(32, 20))
    sns.heatmap(correlation_matrix, cmap='coolwarm', center=0, 
                square=True, fmt='.2f',annot=True, cbar_kws={'shrink': 0.8})
    plt.title('Correlation Matrix - First 50 Anonymized Features + Target')
    plt.tight_layout()
    plt.show()
    breakpoint()
    
    high_corr_df = find_high_correlations(correlation_matrix, threshold=0.98)
    print(f"High correlation pairs (|corr| > 0.98):")
    print(high_corr_df.sort_values('correlation', key=abs, ascending=False).head(50))

    # Correlation with target variable
    target_correlations = train[anonymized_features + [target]].corr()[target].abs().sort_values(ascending=False)
    print(f"\nTop 20 features most correlated with target:")
    print(target_correlations.head(51)[1:])  # Exclude target itself
    breakpoint()
    
    from sklearn.decomposition import IncrementalPCA
    X_numeric = train[anonymized_features].select_dtypes(include=[np.number]).iloc[:, :200]
    # 2. Fill missing values with column median
    X_clean = X_numeric.fillna(X_numeric.median())
    # 3. Downcast to float32 to save memory
    X_clean = X_clean.astype(np.float32)
    # 4. Standardize features
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X_clean)

    # 5. Perform Incremental PCA
    print("Performing Incremental PCA...")
    ipca = IncrementalPCA(n_components=50, batch_size=200)
    X_pca = ipca.fit_transform(X_scaled)

    # 6. Explained variance analysis
    explained_variance_ratio = ipca.explained_variance_ratio_
    cumsum_variance = np.cumsum(explained_variance_ratio)
    n_components_90 = np.argmax(cumsum_variance >= 0.90) + 1
    n_components_95 = np.argmax(cumsum_variance >= 0.95) + 1

    print(f"Number of components needed for 90% variance: {n_components_90}")
    print(f"Number of components needed for 95% variance: {n_components_95}")
    breakpoint()
    
    # t-SNE visualization (on a sample for computational efficiency)
    print("Performing t-SNE on sample data...")
    sample_size = min(5000, len(X_clean))
    sample_indices = np.random.choice(len(X_clean), sample_size, replace=False)
    X_sample = X_scaled[sample_indices]

    y = train[target]  # <-- Replace 'target' with your actual label column name
    y_sample = y.iloc[sample_indices]

    # Use PCA first to reduce dimensions before t-SNE
    pca_pre = PCA(n_components=50)
    X_pca_sample = pca_pre.fit_transform(X_sample)

    tsne = TSNE(n_components=2, random_state=42, perplexity=30)
    X_tsne = tsne.fit_transform(X_pca_sample)
    
    
    breakpoint()
    from sklearn.feature_selection import SelectKBest, f_regression
    # 使用单变量的 f回归判断，其实就是 pearson排序

    print("\n" + "="*50)
    print("4. FEATURE SELECTION")
    print("="*50)

    # Univariate feature selection
    print("Performing univariate feature selection...")
    selector_univariate = SelectKBest(score_func=f_regression, k=100)
    X_selected_univariate = selector_univariate.fit_transform(X_clean, y)

    # Get feature scores
    anonymized_features = X_clean.columns  # <-- Make sure this matches the full feature list
    feature_scores = pd.DataFrame({
        'feature': anonymized_features,
        'score': selector_univariate.scores_
    }).sort_values('score', ascending=False)

    print("Top 20 features by univariate selection:")
    print(feature_scores.head(20))
    
    breakpoint()
    
    from sklearn.ensemble import RandomForestRegressor

    print("\nTraining Random Forest for feature importance (with speed-up)...")

    rf = RandomForestRegressor(
        n_estimators=100,       # Reduce trees from 100 → 50 for faster training
        max_depth=10,          # Limit depth to prevent very deep trees
        max_features='sqrt',   # Use sqrt of features at each split (default)
        n_jobs=-1,             # Use all CPU cores
        random_state=42
    )

    y = train[target]
    rf.fit(X_clean, y)

    feature_importance = pd.DataFrame({
        'feature': anonymized_features,
        'importance': rf.feature_importances_
    }).sort_values('importance', ascending=False)

    print("Top 20 features by Random Forest importance:")
    print(feature_importance.head(20))
    breakpoint()
    
    from sklearn.linear_model import Lasso, LassoCV
    from sklearn.feature_selection import RFE

    # lasso + rfe 相比于 f回归能考虑特征之间的相关性
    # lasso alpha 0.01比较小，应该是设置越大，惩罚越大，回归系数压缩到 0的特征越多，但是如果没有，rfe也会迭代删除最弱的特征
    # lasso 的系数排序不等于 rfe的排序。lasso有时对弱相关特征选择不稳定，rfe 更鲁棒。ref是反向过程，记录是最后被保留的排名，不是当前有多大的系数

    print("\nPerforming Recursive Feature Elimination with Lasso...")

    # Initialize Lasso with a small alpha (regularization strength) and enough iterations
    lasso_cv = LassoCV(cv=5, max_iter=10000, random_state=42)
    lasso_cv.fit(X_clean, y)
    print(f"Best alpha via CV: {lasso_cv.alpha_}")
    lasso = Lasso(alpha=lasso_cv.alpha_, max_iter=10000, random_state=42)

    # RFE with step=50 (removes 50 features at a time) to speed up
    rfe = RFE(estimator=lasso, n_features_to_select=100, step=50)

    # Fit RFE on your data
    rfe.fit(X_clean, y)

    # Collect feature selection results
    rfe_features = pd.DataFrame({
        'feature': anonymized_features,
        'selected': rfe.support_,
        'ranking': rfe.ranking_
    }).sort_values('ranking')

    selected_features_rfe = rfe_features[rfe_features['selected']]['feature'].tolist()
    print(f"RFE selected {len(selected_features_rfe)} features")
    print("Top 20 RFE selected features:")
    print(rfe_features.head(20))
    breakpoint()
    
    # K-means clustering on PCA-reduced data
    print("Performing K-means clustering...")
    n_clusters_range = range(2, 11)
    inertias = []

    for k in n_clusters_range:
        kmeans = KMeans(n_clusters=k, random_state=42)
        kmeans.fit(X_pca[:, :50])  # Use first 50 PCA components
        inertias.append(kmeans.inertia_)    
        
    # Apply optimal clustering
    optimal_k = 5  # You can adjust based on elbow curve
    kmeans_final = KMeans(n_clusters=optimal_k, random_state=42)
    clusters = kmeans_final.fit_predict(X_pca[:, :50])

    # Analyze clusters
    cluster_analysis = pd.DataFrame({
        'cluster': clusters,
        'target': y
    })

    print(f"\nCluster analysis with {optimal_k} clusters:")
    cluster_stats = cluster_analysis.groupby('cluster')['target'].agg(['count', 'mean', 'std'])
    print(cluster_stats)
    
    print(f"1. Dataset contains {890} anonymized features")
    print(f"2. {n_components_90} components explain 90% of variance, {n_components_95} explain 95%")
    print(f"3. Top correlated feature with target: {target_correlations.index[1]} (corr: {target_correlations.iloc[1]:.4f})")
    print(f"4. {len(high_corr_df)} feature pairs have high correlation (>0.7)")
    print(f"5. Optimal number of clusters appears to be around {optimal_k}")

    # Save important features for further analysis
    important_features = {
        'top_univariate': feature_scores.head(50)['feature'].tolist(),
        'top_rf_importance': feature_importance.head(50)['feature'].tolist(),
        'rfe_selected': selected_features_rfe,
        'high_target_corr': target_correlations.head(50).index[1:].tolist()
    }

    common_features = set(important_features['top_univariate']) & \
                    set(important_features['top_rf_importance']) & \
                    set(important_features['rfe_selected'])
    print(f"  Common Features selected by all 3 methods: {(common_features)}")

if __name__ == "__main__":
    main()