data_audit.py

"""
===============================================================================
VERİ TEMİZLEME VE ÖN İŞLEME ANALİZİ
===============================================================================

Bu script veri setini derinlemesine inceleyip şu soruları cevaplar:
1. Eksik değer var mı?
2. Outlier (aykırı değer) var mı?
3. Özellik dağılımları nasıl?
4. Sınıf dengesizliği ne kadar ciddi?
5. Hangi temizleme/ön işleme adımları sonuçları iyileştirir?

KULLANIM:
  python data_audit.py --data_dir ./dataset
===============================================================================
"""

import os, sys, argparse, warnings
import numpy as np
import pandas as pd
from collections import Counter

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler
from sklearn.ensemble import RandomForestClassifier, IsolationForest
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score, classification_report
from sklearn.feature_selection import mutual_info_classif
from imblearn.over_sampling import SMOTE, ADASYN
from imblearn.under_sampling import RandomUnderSampler
from imblearn.combine import SMOTETomek
import lightgbm as lgb

warnings.filterwarnings('ignore')
np.random.seed(42)

def main(data_dir):
    FIGDIR = os.path.join(data_dir, '..', 'audit_figures')
    os.makedirs(FIGDIR, exist_ok=True)
    
    # ─── VERİ YÜKLE ───
    print("=" * 70)
    print("1. VERİ YÜKLEME")
    print("=" * 70)
    
    feat_df = pd.read_csv(os.path.join(data_dir, 'elliptic_txs_features.csv'), header=None)
    class_df = pd.read_csv(os.path.join(data_dir, 'elliptic_txs_classes.csv'))
    edge_df = pd.read_csv(os.path.join(data_dir, 'elliptic_txs_edgelist.csv'))
    
    txids = feat_df.iloc[:, 0].values
    timesteps = feat_df.iloc[:, 1].values.astype(int)
    features = feat_df.iloc[:, 2:].values
    
    label_map = {'1': 1, '2': 0, 'unknown': -1}
    labels = np.array([label_map[str(c)] for c in class_df['class'].values])
    
    labeled_mask = labels >= 0
    X = features[labeled_mask].astype(np.float64)
    y = labels[labeled_mask]
    ts = timesteps[labeled_mask]
    
    print(f"  Toplam: {len(features)}, Etiketli: {len(X)}")
    print(f"  Özellik sayısı: {X.shape[1]}")
    print(f"  Sınıf dağılımı: illicit={y.sum()} ({y.mean()*100:.1f}%), licit={len(y)-y.sum()}")
    
    # ─── EKSİK DEĞER ANALİZİ ───
    print("\n" + "=" * 70)
    print("2. EKSİK DEĞER ANALİZİ")
    print("=" * 70)
    
    nan_count = np.isnan(X).sum()
    inf_count = np.isinf(X).sum()
    zero_cols = (X == 0).all(axis=0).sum()
    
    print(f"  NaN sayısı: {nan_count}")
    print(f"  Inf sayısı: {inf_count}")
    print(f"  Tamamen sıfır olan sütun: {zero_cols}")
    
    # Her sütundaki NaN oranı
    nan_per_col = np.isnan(X).sum(axis=0)
    if nan_count > 0:
        problematic = np.where(nan_per_col > 0)[0]
        print(f"  NaN içeren sütunlar: {len(problematic)}")
        for col in problematic[:10]:
            print(f"    Sütun {col}: {nan_per_col[col]} NaN ({nan_per_col[col]/len(X)*100:.2f}%)")
    else:
        print(f"  ✓ Eksik değer yok")
    
    # ─── OUTLIER ANALİZİ ───
    print("\n" + "=" * 70)
    print("3. OUTLIER (AYKIRI DEĞER) ANALİZİ")
    print("=" * 70)
    
    # IQR yöntemi
    Q1 = np.percentile(X, 25, axis=0)
    Q3 = np.percentile(X, 75, axis=0)
    IQR = Q3 - Q1
    lower = Q1 - 1.5 * IQR
    upper = Q3 + 1.5 * IQR
    
    outlier_mask = (X < lower) | (X > upper)
    outlier_per_col = outlier_mask.sum(axis=0)
    outlier_per_row = outlier_mask.sum(axis=1)
    total_outliers = outlier_mask.sum()
    
    print(f"  Toplam outlier hücre: {total_outliers} ({total_outliers/(X.shape[0]*X.shape[1])*100:.2f}%)")
    print(f"  En az 1 outlier'ı olan satır: {(outlier_per_row > 0).sum()} ({(outlier_per_row > 0).mean()*100:.1f}%)")
    print(f"  Ortalama outlier/satır: {outlier_per_row.mean():.1f}")
    
    # En çok outlier içeren sütunlar
    top_outlier_cols = np.argsort(-outlier_per_col)[:10]
    print(f"\n  En çok outlier içeren 10 sütun:")
    for col in top_outlier_cols:
        print(f"    Sütun {col}: {outlier_per_col[col]} outlier ({outlier_per_col[col]/len(X)*100:.1f}%)")
    
    # İllicit vs licit outlier karşılaştırması
    ill_outliers = outlier_per_row[y == 1].mean()
    lic_outliers = outlier_per_row[y == 0].mean()
    print(f"\n  İllicit örneklerin ortalama outlier sayısı: {ill_outliers:.1f}")
    print(f"  Licit örneklerin ortalama outlier sayısı: {lic_outliers:.1f}")
    if ill_outliers > lic_outliers * 1.2:
        print(f"  ⚠️ İllicit örnekler {ill_outliers/lic_outliers:.1f}x daha fazla outlier içeriyor!")
        print(f"  Bu, outlier temizliğinin illicit sınıfını orantısız etkileyebileceği anlamına gelir.")
    
    # ─── ÖZELLİK DAĞILIMI ANALİZİ ───
    print("\n" + "=" * 70)
    print("4. ÖZELLİK DAĞILIMI ANALİZİ")
    print("=" * 70)
    
    # Local vs Aggregated ayrımı
    local_features = X[:, :93]    # İlk 93: local özellikler (sütun 2-94)
    agg_features = X[:, 93:]      # Son 72: aggregated özellikler (sütun 95-166)
    
    local_mean = np.mean(np.abs(local_features))
    agg_mean = np.mean(np.abs(agg_features))
    local_std = np.std(local_features)
    agg_std = np.std(agg_features)
    
    print(f"  Local özellikler (93 adet):")
    print(f"    Ortalama |değer|: {local_mean:.4f}")
    print(f"    Standart sapma: {local_std:.4f}")
    print(f"    Min: {local_features.min():.4f}, Max: {local_features.max():.4f}")
    
    print(f"\n  Aggregated özellikler (72 adet):")
    print(f"    Ortalama |değer|: {agg_mean:.4f}")
    print(f"    Standart sapma: {agg_std:.4f}")
    print(f"    Min: {agg_features.min():.4f}, Max: {agg_features.max():.4f}")
    
    # Varyansı çok düşük özellikler
    variances = np.var(X, axis=0)
    low_var = (variances < 1e-6).sum()
    print(f"\n  Varyansı çok düşük (< 1e-6) özellik: {low_var}")
    
    # Yüksek korelasyonlu özellik çiftleri
    corr_matrix = np.corrcoef(X.T)
    np.fill_diagonal(corr_matrix, 0)
    high_corr = (np.abs(corr_matrix) > 0.95).sum() // 2  # Üçgen matris
    print(f"  Yüksek korelasyonlu (|r|>0.95) özellik çifti: {high_corr}")
    
    # ─── SINIF DENGESİZLİĞİ ANALİZİ ───
    print("\n" + "=" * 70)
    print("5. SINIF DENGESİZLİĞİ ANALİZİ")
    print("=" * 70)
    
    ratio = (y == 0).sum() / max((y == 1).sum(), 1)
    print(f"  Licit/İllicit oranı: {ratio:.1f}:1")
    print(f"  Bu çok ciddi bir dengesizlik.")
    
    # Timestep bazında dengesizlik
    print(f"\n  Timestep bazında dengesizlik:")
    for t in sorted(np.unique(ts))[:10]:
        mask = ts == t
        t_ill = y[mask].sum()
        t_total = mask.sum()
        t_rate = t_ill / max(t_total, 1) * 100
        print(f"    TS {t:2d}: {t_total:5d} örnek, {t_ill:4d} illicit ({t_rate:.1f}%)")
    print(f"    ... (49 timestep toplam)")
    
    # ─── TEMİZLEME VE ÖN İŞLEME ETKİ TESTİ ───
    print("\n" + "=" * 70)
    print("6. TEMİZLEME VE ÖN İŞLEME ETKİ TESTİ")
    print("=" * 70)
    print("  Her adımın F1 skoruna etkisini test ediyoruz...")
    print("  Temporal split kullanılıyor (TS 1-39 eğitim, 40-49 test)")
    
    tr_mask = ts <= 39
    te_mask = ts > 39
    
    def eval_pipeline(X_tr, y_tr, X_te, y_te, name):
        """LightGBM ile hızlı değerlendirme."""
        model = lgb.LGBMClassifier(
            n_estimators=300, max_depth=10, learning_rate=0.1,
            scale_pos_weight=10, random_state=42, n_jobs=-1, verbose=-1
        )
        model.fit(X_tr, y_tr)
        pred = model.predict(X_te)
        f1 = f1_score(y_te, pred, zero_division=0)
        return f1
    
    results = {}
    
    # Baseline: ham veri, scaling yok
    print("\n  [1/8] Baseline (ham veri)...")
    f1_base = eval_pipeline(X[tr_mask], y[tr_mask], X[te_mask], y[te_mask], "baseline")
    results['1. Ham Veri (Baseline)'] = f1_base
    print(f"         F1 = {f1_base:.4f}")
    
    # StandardScaler
    print("  [2/8] StandardScaler...")
    scaler = StandardScaler()
    X_ss = scaler.fit_transform(X[tr_mask]), scaler.transform(X[te_mask])
    f1_ss = eval_pipeline(X_ss[0], y[tr_mask], X_ss[1], y[te_mask], "standard")
    results['2. StandardScaler'] = f1_ss
    print(f"         F1 = {f1_ss:.4f} (fark: {f1_ss-f1_base:+.4f})")
    
    # RobustScaler (outlier'lara dayanıklı)
    print("  [3/8] RobustScaler...")
    rscaler = RobustScaler()
    X_rs = rscaler.fit_transform(X[tr_mask]), rscaler.transform(X[te_mask])
    f1_rs = eval_pipeline(X_rs[0], y[tr_mask], X_rs[1], y[te_mask], "robust")
    results['3. RobustScaler'] = f1_rs
    print(f"         F1 = {f1_rs:.4f} (fark: {f1_rs-f1_base:+.4f})")
    
    # NaN temizleme + StandardScaler
    print("  [4/8] NaN temizleme + StandardScaler...")
    X_clean = np.nan_to_num(X, nan=0.0, posinf=0.0, neginf=0.0)
    scaler2 = StandardScaler()
    X_c = scaler2.fit_transform(X_clean[tr_mask]), scaler2.transform(X_clean[te_mask])
    f1_c = eval_pipeline(X_c[0], y[tr_mask], X_c[1], y[te_mask], "clean")
    results['4. NaN Temizleme + Standard'] = f1_c
    print(f"         F1 = {f1_c:.4f} (fark: {f1_c-f1_base:+.4f})")
    
    # Outlier clipping + StandardScaler
    print("  [5/8] Outlier Clipping (IQR)...")
    X_clipped = np.clip(X, lower, upper)
    scaler3 = StandardScaler()
    X_cl = scaler3.fit_transform(X_clipped[tr_mask]), scaler3.transform(X_clipped[te_mask])
    f1_cl = eval_pipeline(X_cl[0], y[tr_mask], X_cl[1], y[te_mask], "clipped")
    results['5. Outlier Clipping + Standard'] = f1_cl
    print(f"         F1 = {f1_cl:.4f} (fark: {f1_cl-f1_base:+.4f})")
    
    # SMOTE (oversampling)
    print("  [6/8] SMOTE Oversampling...")
    try:
        smote = SMOTE(random_state=42)
        X_tr_sm, y_tr_sm = smote.fit_resample(X_clean[tr_mask], y[tr_mask])
        scaler4 = StandardScaler()
        X_sm_tr = scaler4.fit_transform(X_tr_sm)
        X_sm_te = scaler4.transform(X_clean[te_mask])
        f1_sm = eval_pipeline(X_sm_tr, y_tr_sm, X_sm_te, y[te_mask], "smote")
        results['6. SMOTE + Standard'] = f1_sm
        print(f"         F1 = {f1_sm:.4f} (fark: {f1_sm-f1_base:+.4f})")
    except Exception as e:
        print(f"         SMOTE başarısız: {e}")
        results['6. SMOTE + Standard'] = 0
    
    # Düşük varyans özellik çıkarma
    print("  [7/8] Düşük Varyans Özellik Çıkarma...")
    var_mask = variances > 1e-6
    X_var = X_clean[:, var_mask]
    scaler5 = StandardScaler()
    X_v = scaler5.fit_transform(X_var[tr_mask]), scaler5.transform(X_var[te_mask])
    f1_v = eval_pipeline(X_v[0], y[tr_mask], X_v[1], y[te_mask], "var_filter")
    results[f'7. Düşük Varyans Çıkarma ({var_mask.sum()} feat)'] = f1_v
    print(f"         F1 = {f1_v:.4f} (fark: {f1_v-f1_base:+.4f})")
    
    # Tam pipeline: NaN + Outlier Clip + RobustScaler + SMOTE
    print("  [8/8] Tam Pipeline: Temizle + Clip + RobustScale + SMOTE...")
    try:
        X_full = np.nan_to_num(X, nan=0.0, posinf=0.0, neginf=0.0)
        X_full = np.clip(X_full, lower, upper)
        rscaler2 = RobustScaler()
        X_full_tr = rscaler2.fit_transform(X_full[tr_mask])
        X_full_te = rscaler2.transform(X_full[te_mask])
        smote2 = SMOTE(random_state=42)
        X_full_tr_sm, y_full_tr_sm = smote2.fit_resample(X_full_tr, y[tr_mask])
        f1_full = eval_pipeline(X_full_tr_sm, y_full_tr_sm, X_full_te, y[te_mask], "full")
        results['8. Tam Pipeline'] = f1_full
        print(f"         F1 = {f1_full:.4f} (fark: {f1_full-f1_base:+.4f})")
    except Exception as e:
        print(f"         Tam pipeline başarısız: {e}")
        results['8. Tam Pipeline'] = 0
    
    # ─── ÖZET TABLO ───
    print("\n" + "=" * 70)
    print("7. ÖZET: TEMİZLEME ADIMLARININ ETKİSİ")
    print("=" * 70)
    
    print(f"\n  {'Adım':<45s} {'F1':>8s} {'Fark':>10s}")
    print("  " + "-" * 65)
    for name, f1 in sorted(results.items()):
        diff = f1 - f1_base
        marker = " ✓ EN İYİ" if f1 == max(results.values()) else ""
        print(f"  {name:<45s} {f1:>8.4f} {diff:>+10.4f}{marker}")
    
    best_name = max(results, key=results.get)
    best_f1 = max(results.values())
    print(f"\n  En iyi pipeline: {best_name}")
    print(f"  Baseline'dan iyileşme: {best_f1 - f1_base:+.4f} ({(best_f1-f1_base)/f1_base*100:+.1f}%)")
    
    # ─── FİGÜR ───
    print("\nFigür oluşturuluyor...")
    sns.set_theme(style='whitegrid', font_scale=1.0)
    
    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
    
    # 1: Pipeline karşılaştırma
    names = list(results.keys())
    vals = list(results.values())
    colors = ['#FF6B6B' if v == f1_base else '#4ECDC4' if v == best_f1 else '#45B7D1' for v in vals]
    axes[0,0].barh(names, vals, color=colors)
    axes[0,0].set_xlabel('Illicit F1 Score')
    axes[0,0].set_title('Ön İşleme Adımlarının F1 Etkisi\n(Kırmızı=baseline, Yeşil=en iyi)')
    axes[0,0].axvline(x=f1_base, color='red', linestyle='--', alpha=0.5)
    
    # 2: Outlier dağılımı
    axes[0,1].hist(outlier_per_row[y==0], bins=30, alpha=0.6, label='Licit', color='green', density=True)
    axes[0,1].hist(outlier_per_row[y==1], bins=30, alpha=0.6, label='Illicit', color='red', density=True)
    axes[0,1].set_xlabel('Outlier Sayısı / Satır')
    axes[0,1].set_ylabel('Yoğunluk')
    axes[0,1].set_title('Sınıf Bazında Outlier Dağılımı')
    axes[0,1].legend()
    
    # 3: Sınıf dağılımı
    axes[1,0].bar(['Licit', 'Illicit'], [(y==0).sum(), (y==1).sum()], color=['green', 'red'])
    axes[1,0].set_ylabel('Örnek Sayısı')
    axes[1,0].set_title(f'Sınıf Dengesizliği ({ratio:.1f}:1)')
    
    # 4: Özellik varyansları
    axes[1,1].hist(np.log10(variances + 1e-10), bins=50, color='steelblue')
    axes[1,1].set_xlabel('log10(Varyans)')
    axes[1,1].set_ylabel('Özellik Sayısı')
    axes[1,1].set_title('Özellik Varyans Dağılımı')
    axes[1,1].axvline(x=np.log10(1e-6), color='red', linestyle='--', label='Düşük varyans eşiği')
    axes[1,1].legend()
    
    plt.tight_layout()
    plt.savefig(os.path.join(FIGDIR, 'data_audit.png'), dpi=150, bbox_inches='tight')
    plt.close()
    print(f"  ✓ {os.path.join(FIGDIR, 'data_audit.png')}")
    
    # Sonuçları kaydet
    pd.DataFrame([
        {'adim': k, 'f1': v, 'fark': v - f1_base}
        for k, v in results.items()
    ]).to_csv(os.path.join(FIGDIR, '..', 'audit_results.csv'), index=False)
    
    print("\n" + "=" * 70)
    print("VERİ DENETİMİ TAMAMLANDI!")
    print("=" * 70)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--data_dir', type=str, default='./dataset')
    args = parser.parse_args()
    main(args.data_dir)