app.py

"""
ML Binary Classification Pipeline
Eye & ENT Hospital of Fudan University — Laboratory Medicine, Ren Jun
Gradio 5.12.0 + Python 3.11
"""

import numpy as np
import pandas as pd
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.model_selection import StratifiedKFold, GridSearchCV
from sklearn.metrics import (
    roc_auc_score, confusion_matrix, roc_curve,
    auc as auc_score, precision_recall_curve
)
import seaborn as sns
import warnings
from scipy import stats
import os
import shap
import pickle
from copy import deepcopy
import zipfile
import tempfile
import traceback
import time
import shutil
import gc
import threading
import gradio as gr

warnings.filterwarnings('ignore')
plt.rcParams['font.sans-serif'] = ['DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False

# ============================================================================
# Cache Cleanup System
# ============================================================================
CLEANUP_MAX_AGE_MINUTES = 30       # 临时文件超过30分钟自动删除
CLEANUP_INTERVAL_SECONDS = 600     # 每10分钟检查一次
CLEANUP_MAX_DISK_MB = 1024          # /tmp 中 ml_ 文件夹超过 1GB 时强制清理

def cleanup_old_temp_files():
    """清理超时的临时文件夹和ZIP"""
    now = time.time()
    max_age = CLEANUP_MAX_AGE_MINUTES * 60
    cleaned_dirs = 0
    cleaned_mb = 0.0
    tmp_dir = tempfile.gettempdir()

    try:
        for item in os.listdir(tmp_dir):
            item_path = os.path.join(tmp_dir, item)
            # 清理 ml_ 开头的结果文件夹
            if item.startswith("ml_") and os.path.isdir(item_path):
                age = now - os.path.getmtime(item_path)
                if age > max_age:
                    size = sum(os.path.getsize(os.path.join(r, f))
                               for r, _, fs in os.walk(item_path) for f in fs)
                    shutil.rmtree(item_path, ignore_errors=True)
                    cleaned_dirs += 1
                    cleaned_mb += size / (1024 * 1024)
            # 清理旧的 ZIP 结果文件
            if item.startswith("ml_") and item.endswith(".zip") and os.path.isfile(item_path):
                age = now - os.path.getmtime(item_path)
                if age > max_age:
                    size = os.path.getsize(item_path)
                    os.remove(item_path)
                    cleaned_mb += size / (1024 * 1024)
    except Exception:
        pass

    # 强制回收 Python 内存
    gc.collect()

    if cleaned_dirs > 0:
        print(f"[Cleanup] 清理 {cleaned_dirs} 个临时文件夹, 释放 {cleaned_mb:.1f} MB")


def check_disk_pressure():
    """检查磁盘压力，超限时立即清理所有旧文件"""
    tmp_dir = tempfile.gettempdir()
    total_mb = 0
    try:
        for item in os.listdir(tmp_dir):
            item_path = os.path.join(tmp_dir, item)
            if item.startswith("ml_"):
                if os.path.isdir(item_path):
                    total_mb += sum(os.path.getsize(os.path.join(r, f))
                                    for r, _, fs in os.walk(item_path) for f in fs) / (1024*1024)
                elif os.path.isfile(item_path):
                    total_mb += os.path.getsize(item_path) / (1024*1024)
    except Exception:
        pass

    if total_mb > CLEANUP_MAX_DISK_MB:
        print(f"[Cleanup] 磁盘占用 {total_mb:.0f}MB > {CLEANUP_MAX_DISK_MB}MB, 强制清理!")
        for item in os.listdir(tmp_dir):
            item_path = os.path.join(tmp_dir, item)
            if item.startswith("ml_"):
                try:
                    if os.path.isdir(item_path): shutil.rmtree(item_path, ignore_errors=True)
                    elif os.path.isfile(item_path): os.remove(item_path)
                except: pass
        gc.collect()


def periodic_cleanup():
    """后台定时清理线程"""
    while True:
        time.sleep(CLEANUP_INTERVAL_SECONDS)
        cleanup_old_temp_files()
        check_disk_pressure()

# 启动后台清理线程
_cleanup_thread = threading.Thread(target=periodic_cleanup, daemon=True)
_cleanup_thread.start()
print("[Cleanup] 后台自动清理已启动 (每10分钟检查, 30分钟过期, 上限500MB)")

# ============================================================================
# Helper Functions
# ============================================================================
def compute_midrank(x):
    J = np.argsort(x); Z = x[J]; N = len(x)
    T = np.zeros(N, dtype=float); i = 0
    while i < N:
        j = i
        while j < N and Z[j] == Z[i]: j += 1
        T[i:j] = 0.5 * (i + j - 1); i = j
    T2 = np.empty(N, dtype=float); T2[J] = T + 1
    return T2

def fastDeLong(pst, m):
    n = pst.shape[1] - m; k = pst.shape[0]
    tx = np.empty([k, m]); ty = np.empty([k, n]); tz = np.empty([k, m + n])
    for r in range(k):
        tx[r] = compute_midrank(pst[r, :m]); ty[r] = compute_midrank(pst[r, m:])
        tz[r] = compute_midrank(pst[r])
    aucs = tz[:, :m].sum(1) / m / n - (m + 1.0) / 2.0 / n
    v01 = (tz[:, :m] - tx) / n; v10 = 1.0 - (tz[:, m:] - ty) / m
    return aucs, np.cov(v01) / m + np.cov(v10) / n

def delong_roc_test(gt, p1, p2):
    order = (-gt).argsort(); m = int(gt.sum())
    pst = np.vstack([p1, p2])[:, order]
    aucs, cov = fastDeLong(pst, m)
    l = np.array([[1, -1]])
    z = np.abs(np.diff(aucs)) / np.sqrt(np.dot(np.dot(l, cov), l.T))
    log10p = np.log10(2) + stats.norm.logsf(z, 0, 1) / np.log(10)
    return 10 ** log10p[0][0], aucs[0], aucs[1]

def find_optimal_threshold(y_true, y_probs, method='youden'):
    fpr, tpr, th = roc_curve(y_true, y_probs)
    idx = np.argmax(tpr - fpr)
    return th[idx], (tpr - fpr)[idx], idx

def calculate_net_benefit(y_true, y_probs, threshold):
    yp = (y_probs >= threshold).astype(int)
    tn, fp, fn, tp = confusion_matrix(y_true, yp).ravel()
    n = len(y_true)
    return (tp / n) - (fp / n) * (threshold / (1 - threshold))

def plot_dca(y_true, y_probs_dict, title, save_prefix, result_dir, final_model=None):
    """绘制标准临床DCA曲线（类似R语言rmda包格式）"""
    prevalence = np.mean(y_true)
    max_thr = min(0.99, max(prevalence * 3, 0.6)) if prevalence < 0.5 else 0.9
    thresholds = np.linspace(0.01, max_thr, 200)

    plt.figure(figsize=(10, 7))

    # Treat All
    ta_nb = [prevalence - (1 - prevalence) * (pt / (1 - pt)) for pt in thresholds]
    plt.plot(thresholds, ta_nb, 'k-', lw=1.5, label='Treat All')

    # Treat None (y=0)
    plt.axhline(y=0, color='#555555', lw=1.5, linestyle='-', label='Treat None')

    # Model curves
    DCA_COLORS = ['#e41a1c','#377eb8','#4daf4a','#984ea3','#ff7f00','#a65628','#f781bf','#999999']
    for idx, (mn, yp) in enumerate(y_probs_dict.items()):
        nbs = [calculate_net_benefit(y_true, yp, t) for t in thresholds]
        lbl = f'{mn} (Final)' if mn == final_model else mn
        plt.plot(thresholds, nbs, color=DCA_COLORS[idx % len(DCA_COLORS)], lw=2, label=lbl)

    # Y-axis: clinical range
    y_min = max(min(ta_nb), -0.05) - 0.01
    y_max = max(prevalence * 1.5, 0.15)
    plt.xlim([0, max_thr]); plt.ylim([y_min, y_max])
    plt.xlabel('Threshold Probability', fontsize=13)
    plt.ylabel('Net Benefit', fontsize=13)
    plt.title(title, fontsize=15, fontweight='bold')
    plt.legend(loc='upper right', fontsize=10, framealpha=0.9)
    plt.grid(True, alpha=0.15); plt.tight_layout()
    plt.savefig(os.path.join(result_dir, f'{save_prefix}.pdf'), format='pdf', bbox_inches='tight', dpi=300)
    plt.savefig(os.path.join(result_dir, f'{save_prefix}.png'), format='png', bbox_inches='tight', dpi=150)
    plt.close()

# ============================================================================
# Model configs
# ============================================================================
ALL_MODEL_NAMES = ['RF', 'DT', 'KNN', 'XGB', 'AdaBoost', 'LR', 'NB', 'SVM']

def get_models_config(selected, rs=42):
    cfg = {
        'RF':       {'model': RandomForestClassifier(random_state=rs, n_jobs=-1),
                     'params': {'n_estimators': [100,200], 'max_depth': [20,50], 'min_samples_split': [2,5], 'max_features': ['sqrt']}},
        'DT':       {'model': DecisionTreeClassifier(random_state=rs),
                     'params': {'max_depth': [20,50], 'min_samples_split': [2,10], 'min_samples_leaf': [1,4], 'criterion': ['gini','entropy']}},
        'KNN':      {'model': KNeighborsClassifier(n_jobs=-1),
                     'params': {'n_neighbors': [3,5,7], 'weights': ['uniform','distance'], 'metric': ['euclidean','manhattan']}},
        'XGB':      {'model': XGBClassifier(random_state=rs, eval_metric='logloss', n_jobs=-1),
                     'params': {'n_estimators': [100,200], 'max_depth': [5,7], 'learning_rate': [0.05,0.1], 'subsample': [0.8,1.0], 'colsample_bytree': [0.8,1.0]}},
        'AdaBoost': {'model': AdaBoostClassifier(random_state=rs),
                     'params': {'n_estimators': [50,100], 'learning_rate': [0.1,0.5,1.0]}},
        'LR':       {'model': LogisticRegression(random_state=rs, n_jobs=-1, max_iter=2000),
                     'params': {'C': [0.1,1,10], 'penalty': ['l2'], 'solver': ['lbfgs','liblinear']}},
        'NB':       {'model': GaussianNB(),
                     'params': {'var_smoothing': [1e-9,1e-7,1e-5]}},
        'SVM':      {'model': SVC(probability=True, random_state=rs),
                     'params': {'C': [1,10], 'kernel': ['rbf','linear'], 'gamma': ['scale','auto']}},
    }
    return {k: v for k, v in cfg.items() if k in selected}

# ============================================================================
# Main Pipeline with Progress
# ============================================================================
def run_pipeline(
    train_file, val_file1, val_file2, val_file3, selected_models, enable_tuning,
    cv_folds, alpha, top_n_features, shap_sample_size,
    progress=gr.Progress(track_tqdm=True),
):
    if train_file is None:
        return None, "❌ 请先上传训练集 CSV 文件"
    sel = selected_models if isinstance(selected_models, list) else [s.strip() for s in str(selected_models).split(",") if s.strip()]
    if not sel:
        return None, "❌ 请至少选择一个模型"

    RS = 42; CVF = int(cv_folds); ALP = float(alpha)
    TOPN = int(top_n_features); SHAPSZ = int(shap_sample_size)
    TUNING = bool(enable_tuning)

    L = []
    def log(m): L.append(str(m))

    rf = tempfile.mkdtemp(prefix="ml_")

    try:
        # ── Load ──
        progress(0.02, desc="📂 加载数据...")
        log("━" * 50)
        log("  🧬 ML 二分类模型训练与评估系统")
        log("━" * 50)

        tp = train_file if isinstance(train_file, str) else getattr(train_file, 'name', str(train_file))
        data = pd.read_csv(tp)
        X = data.iloc[:, 2:]; y = data.iloc[:, 0]
        fnames = X.columns.tolist()

        # Auto 0/1
        ul = sorted(y.unique())
        if set(ul) != {0, 1}:
            lm = {ul[0]: 0, ul[1]: 1}; y = y.map(lm)
            log(f"  ⚙ 标签已自动转换: {lm}")

        log(f"  📊 训练集: {X.shape[0]} 样本 × {X.shape[1]} 特征")
        log(f"  📊 标签: {dict(y.value_counts())}")
        log(f"  🤖 模型: {', '.join(sel)}")
        log(f"  🔧 调优: {'开启' if TUNING else '关闭'}  |  CV: {CVF}折")

        mcfg = get_models_config(sel, RS)
        skf = StratifiedKFold(n_splits=CVF, shuffle=True, random_state=RS)

        # ── Train ──
        bpd = {}; amr = {}; tms = {}
        total = len(mcfg)
        COLORS = ['#2563eb','#f59e0b','#10b981','#ef4444','#8b5cf6','#ec4899','#06b6d4','#6b7280']

        for mi, (mn, cf) in enumerate(mcfg.items()):
            pv = 0.05 + 0.40 * mi / total
            progress(pv, desc=f"🏋️ [{mi+1}/{total}] 训练 {mn}...")
            log(f"\n{'─'*40}")
            log(f"  🔄 [{mi+1}/{total}] {mn}")

            Xv = X.values
            if TUNING:
                log(f"     ⏳ GridSearchCV (CV={CVF})...")
                gs = GridSearchCV(cf['model'], cf['params'], cv=skf, scoring='roc_auc', n_jobs=-1, verbose=0)
                gs.fit(Xv, y)
                bp = gs.best_params_; bpd[mn] = bp
                log(f"     ✓ 最佳AUC: {gs.best_score_:.4f}")
            else:
                bp = {}; bpd[mn] = "默认参数"

            mdl = deepcopy(cf['model'])
            if bp: mdl.set_params(**bp)
            mdl.fit(Xv, y)
            tms[mn] = {'model': mdl, 'scaler': None}

            # CV eval
            folds = []; ayt = []; ayp = []; tprs = []
            bfpr = np.linspace(0, 1, 101)
            for fi, (tri, tei) in enumerate(skf.split(X, y), 1):
                Xtr, Xte = X.iloc[tri].values, X.iloc[tei].values
                ytr, yte = y.iloc[tri], y.iloc[tei]
                mf = deepcopy(cf['model'])
                if bp: mf.set_params(**bp)
                mf.fit(Xtr, ytr)
                ypp = mf.predict_proba(Xte)[:, 1]
                ypd = (ypp > 0.5).astype(int)
                tn, fp, fn, tp = confusion_matrix(yte, ypd).ravel()
                se = tp/(tp+fn) if tp+fn else 0; sp = tn/(tn+fp) if tn+fp else 0
                ac = (tp+tn)/(tp+tn+fp+fn); pr = tp/(tp+fp) if tp+fp else 0
                f1 = 2*pr*se/(pr+se) if pr+se else 0
                auc_v = roc_auc_score(yte, ypp)
                folds.append({'Fold': fi, 'AUC': auc_v, 'Accuracy': ac, 'Sensitivity': se,
                    'Specificity': sp, 'Precision': pr, 'F1': f1, 'TP': tp, 'TN': tn, 'FP': fp, 'FN': fn})
                ayt.extend(yte); ayp.extend(ypp)
                fa, ta, _ = roc_curve(yte, ypp)
                ti = np.interp(bfpr, fa, ta); ti[0] = 0.0; tprs.append(ti)

            rdf = pd.DataFrame(folds)
            mr = {'Fold': 'Mean', 'AUC': rdf['AUC'].mean(), 'Accuracy': rdf['Accuracy'].mean(),
                  'Sensitivity': rdf['Sensitivity'].mean(), 'Specificity': rdf['Specificity'].mean(),
                  'Precision': rdf['Precision'].mean(), 'F1': rdf['F1'].mean(),
                  'TP': rdf['TP'].sum(), 'TN': rdf['TN'].sum(), 'FP': rdf['FP'].sum(), 'FN': rdf['FN'].sum()}
            rdf = pd.concat([rdf, pd.DataFrame([mr])], ignore_index=True)
            ot, yv, _ = find_optimal_threshold(np.array(ayt), np.array(ayp))
            amr[mn] = {'results_df': rdf, 'mean_auc': mr['AUC'], 'all_y_true': np.array(ayt),
                'all_y_probs': np.array(ayp), 'tprs': tprs, 'base_fpr': bfpr,
                'optimal_threshold': ot, 'youden_index': yv}
            log(f"     ✅ AUC={mr['AUC']:.4f}  Acc={mr['Accuracy']:.4f}  阈值={ot:.4f}")

        mnames = list(amr.keys()); nm = len(mnames)
        log(f"\n{'━'*50}")
        log(f"  ✅ {nm} 个模型训练完成")

        # ── ROC ──
        progress(0.48, desc="📈 绘制ROC曲线...")
        log(f"\n  📈 绘制图表...")
        plt.figure(figsize=(12, 10))
        for i, mn in enumerate(mnames):
            r = amr[mn]; mt = np.mean(r['tprs'], axis=0); mt[-1] = 1.0
            ma = auc_score(r['base_fpr'], mt); sa = r['results_df'].iloc[:-1]['AUC'].std()
            st = np.std(r['tprs'], axis=0)
            c = COLORS[i % 8]
            plt.plot(r['base_fpr'], mt, color=c, lw=2.5, alpha=0.85, label=f'{mn} (AUC={ma:.3f}±{sa:.3f})')
            plt.fill_between(r['base_fpr'], np.maximum(mt-st, 0), np.minimum(mt+st, 1), color=c, alpha=0.08)
        plt.plot([0,1],[0,1],'--',lw=2,color='#9ca3af',alpha=0.5)
        plt.xlim([-0.02,1.02]); plt.ylim([-0.02,1.02])
        plt.xlabel('False Positive Rate',fontsize=13); plt.ylabel('True Positive Rate',fontsize=13)
        plt.title('ROC Curves — Internal Cross-Validation',fontsize=15,fontweight='bold')
        plt.legend(loc="lower right",fontsize=10); plt.grid(True,alpha=0.2); plt.tight_layout()
        plt.savefig(os.path.join(rf,'roc_all.pdf'),format='pdf',bbox_inches='tight',dpi=300)
        plt.savefig(os.path.join(rf,'roc_all.png'),format='png',bbox_inches='tight',dpi=150)
        plt.close()

        # ── PR ──
        progress(0.52, desc="📈 绘制PR曲线...")
        plt.figure(figsize=(12, 10))
        for i, mn in enumerate(mnames):
            r = amr[mn]; pra = []
            for tri, tei in skf.split(X, y):
                cf2 = mcfg[mn]; mpr = deepcopy(cf2['model'])
                bp2 = bpd[mn]
                if isinstance(bp2, dict) and bp2: mpr.set_params(**bp2)
                mpr.fit(X.iloc[tri].values, y.iloc[tri])
                yp2 = mpr.predict_proba(X.iloc[tei].values)[:,1]
                pc, rc, _ = precision_recall_curve(y.iloc[tei], yp2)
                pra.append(auc_score(rc, pc))
            mpr_v = np.mean(pra); spr = np.std(pra)
            pa, ra, _ = precision_recall_curve(r['all_y_true'], r['all_y_probs'])
            plt.plot(ra, pa, color=COLORS[i%8], lw=2.5, alpha=0.85, label=f'{mn} (AUPRC={mpr_v:.3f}±{spr:.3f})')
        plt.xlim([-0.02,1.02]); plt.ylim([-0.02,1.02])
        plt.xlabel('Recall',fontsize=13); plt.ylabel('Precision',fontsize=13)
        plt.title('Precision-Recall Curves — Internal CV',fontsize=15,fontweight='bold')
        plt.legend(loc="lower left",fontsize=10); plt.grid(True,alpha=0.2); plt.tight_layout()
        plt.savefig(os.path.join(rf,'pr_all.pdf'),format='pdf',bbox_inches='tight',dpi=300)
        plt.savefig(os.path.join(rf,'pr_all.png'),format='png',bbox_inches='tight',dpi=150)
        plt.close()

        # ── CM ──
        progress(0.55, desc="📊 绘制混淆矩阵...")
        nc = min(4, nm); nr = (nm+nc-1)//nc
        fig, axes = plt.subplots(nr, nc, figsize=(4.2*nc, 4.2*nr))
        if nm == 1: axes = np.array([axes])
        af = axes.flatten()
        for i, mn in enumerate(mnames):
            r = amr[mn]; ypc = (r['all_y_probs']>=r['optimal_threshold']).astype(int)
            cm = confusion_matrix(r['all_y_true'], ypc)
            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False,
                xticklabels=['Neg','Pos'], yticklabels=['Neg','Pos'], ax=af[i], annot_kws={'fontsize':12})
            af[i].set_xlabel('Predicted'); af[i].set_ylabel('True')
            acc = (cm[0,0]+cm[1,1])/cm.sum()
            af[i].set_title(f'{mn} (Acc={acc:.3f})',fontsize=12,fontweight='bold')
        for i in range(nm, len(af)): af[i].set_visible(False)
        plt.suptitle('Confusion Matrices',fontsize=15,fontweight='bold',y=1.0)
        plt.tight_layout()
        plt.savefig(os.path.join(rf,'confusion_matrices.pdf'),format='pdf',bbox_inches='tight',dpi=300)
        plt.savefig(os.path.join(rf,'confusion_matrices.png'),format='png',bbox_inches='tight',dpi=150)
        plt.close()

        # ── DeLong ──
        progress(0.58, desc="🔬 DeLong检验...")
        bmn = max(amr, key=lambda x: amr[x]['mean_auc'])
        bma = amr[bmn]['mean_auc']
        log(f"\n  🏆 最佳模型: {bmn} (AUC={bma:.4f})")
        dlr = []; retained = [bmn]
        for om in mnames:
            if om == bmn: continue
            try: pv, a1, a2 = delong_roc_test(amr[bmn]['all_y_true'], amr[bmn]['all_y_probs'], amr[om]['all_y_probs'])
            except: pv=1.0; a1=bma; a2=amr[om]['mean_auc']
            if pv >= ALP: retained.append(om); dec = "保留"
            else: dec = "排除"
            dlr.append({'Model1': bmn, 'AUC1': a1, 'Model2': om, 'AUC2': a2, 'P': pv, 'Decision': dec})
            log(f"     {bmn} vs {om}: P={pv:.2e} → {dec}")
        dldf = pd.DataFrame(dlr).sort_values('P', ascending=False) if dlr else pd.DataFrame()
        log(f"  ✅ 保留 {len(retained)} 个模型: {', '.join(retained)}")

        # ── SHAP ──
        progress(0.62, desc="🔥 SHAP分析...")
        log(f"\n  🔥 SHAP特征分析...")
        shap_imp = {}
        for si, mn in enumerate(retained):
            progress(0.62+0.10*si/len(retained), desc=f"🔥 SHAP: {mn}...")
            mo = tms[mn]['model']; Xshap = X.values
            ns = min(SHAPSZ, Xshap.shape[0])
            np.random.seed(RS); sidx = np.random.choice(Xshap.shape[0], ns, replace=False)
            Xs = Xshap[sidx]
            try:
                if mn in ['RF','XGB','DT','AdaBoost']:
                    exp = shap.TreeExplainer(mo); sv = exp.shap_values(Xs)
                    if isinstance(sv, list): sv = sv[1]
                else:
                    bg = Xs[np.random.choice(ns, min(100,ns), replace=False)]
                    exp = shap.KernelExplainer(lambda x, m=mo: m.predict_proba(x)[:,1], bg)
                    sv = exp.shap_values(Xs)
                if isinstance(sv, list): sv = sv[0]
                sv = np.array(sv)
                if sv.ndim > 2: sv = sv[0]
                fi = np.abs(sv).mean(0)
                if fi.ndim > 1: fi = fi.flatten()
                if len(fi) > len(fnames): fi = fi[:len(fnames)]
                elif len(fi) < len(fnames): fi = np.pad(fi, (0, len(fnames)-len(fi)))
                idf = pd.DataFrame({'Feature': fnames, 'Importance': fi}).sort_values('Importance', ascending=False)
                shap_imp[mn] = idf
                Xdf = pd.DataFrame(Xs, columns=fnames)
                if sv.shape[1] > Xdf.shape[1]: sv = sv[:,:Xdf.shape[1]]
                elif sv.shape[1] < Xdf.shape[1]: sv = np.hstack([sv, np.zeros((sv.shape[0], Xdf.shape[1]-sv.shape[1]))])
                plt.figure(figsize=(12,8))
                shap.summary_plot(sv, Xdf, plot_type="dot", show=False, max_display=TOPN)
                plt.title(f'SHAP — {mn} (Top {TOPN})',fontsize=14,fontweight='bold'); plt.tight_layout()
                plt.savefig(os.path.join(rf,f'shap_{mn}.pdf'),format='pdf',bbox_inches='tight')
                plt.savefig(os.path.join(rf,f'shap_{mn}.png'),format='png',bbox_inches='tight',dpi=150)
                plt.close()
                log(f"     ✅ {mn} Top3: {', '.join(idf.head(3)['Feature'].tolist())}")
            except Exception as e:
                log(f"     ⚠ {mn} SHAP失败: {e}")

        # ── Ablation ──
        progress(0.75, desc="🧪 特征消融...")
        log(f"\n  🧪 特征消融研究...")
        ablr = {}
        for mn in retained:
            if mn not in shap_imp: continue
            tfs = shap_imp[mn].head(TOPN)['Feature'].tolist()
            fcs = []; aucs_a = []; asp = {}
            for nf in range(1, len(tfs)+1):
                Xsub = X[tfs[:nf]]
                fa = []; syt = []; syp = []
                for tri, tei in skf.split(Xsub, y):
                    mf = deepcopy(mcfg[mn]['model'])
                    bp2 = bpd.get(mn, {})
                    if isinstance(bp2, dict) and bp2: mf.set_params(**bp2)
                    mf.fit(Xsub.iloc[tri].values, y.iloc[tri])
                    yp2 = mf.predict_proba(Xsub.iloc[tei].values)[:,1]
                    syt.extend(y.iloc[tei]); syp.extend(yp2)
                    fa.append(roc_auc_score(y.iloc[tei], yp2))
                fcs.append(nf); aucs_a.append(np.mean(fa))
                asp[nf] = {'yt': np.array(syt), 'yp': np.array(syp)}
            fp = amr[mn]['all_y_probs']; fauc = amr[mn]['mean_auc']; optn = None; adl = []
            for nf in range(1, len(tfs)+1):
                sd = asp[nf]; sa = aucs_a[nf-1]
                try:
                    pv = delong_roc_test(sd['yt'], fp, sd['yp'])[0] if len(fp)==len(sd['yp']) else (0.1 if abs(sa-fauc)<=0.05 else 0.01)
                except: pv = 0.1 if abs(sa-fauc)<=0.05 else 0.01
                sig = "Sig" if pv < ALP else "NS"
                adl.append({'N': nf, 'AUC': sa, 'Full_AUC': fauc, 'P': pv, 'Sig': sig})
                if optn is None and pv >= ALP: optn = nf
            ablr[mn] = {'fcs': fcs, 'aucs': aucs_a, 'tfs': tfs, 'dl': pd.DataFrame(adl),
                'optn': optn or len(tfs), 'optf': tfs[:optn] if optn else tfs}
            log(f"     {mn}: 最优 {ablr[mn]['optn']} 个特征")

        # Final model
        fcands = {}
        for mn in retained:
            if mn in ablr:
                ar = ablr[mn]
                fcands[mn] = {'nf': ar['optn'], 'feats': ar['optf'], 'auc': ar['aucs'][ar['optn']-1]}
        fmn = min(fcands, key=lambda x: fcands[x]['nf']) if fcands else None
        fmi = fcands.get(fmn) if fmn else None
        if fmn: log(f"\n  ⭐ 最终模型: {fmn} ({fmi['nf']}特征, AUC={fmi['auc']:.4f})")

        # Ablation plot
        progress(0.80, desc="📈 消融曲线...")
        plt.figure(figsize=(12,8))
        for i, (mn, ar) in enumerate(ablr.items()):
            c = COLORS[i%8]
            plt.plot(ar['fcs'], ar['aucs'], marker='o', lw=2, ms=5, color=c, label=mn)
            on = ar['optn']; oa = ar['aucs'][on-1]
            plt.scatter([on],[oa], s=200, marker='*', color=c, edgecolors='black', lw=2, zorder=5)
        plt.xlabel('Number of Features',fontsize=13); plt.ylabel('AUC',fontsize=13)
        plt.title('Feature Ablation (★=Optimal)',fontsize=15,fontweight='bold')
        plt.legend(fontsize=11); plt.grid(True,alpha=0.2); plt.tight_layout()
        plt.savefig(os.path.join(rf,'ablation.pdf'),format='pdf',bbox_inches='tight')
        plt.savefig(os.path.join(rf,'ablation.png'),format='png',bbox_inches='tight',dpi=150)
        plt.close()

        # DCA — Internal (标准临床格式)
        progress(0.83, desc="📈 DCA曲线...")
        dca_probs = {mn: amr[mn]['all_y_probs'] for mn in retained}
        plot_dca(amr[retained[0]]['all_y_true'], dca_probs,
                 'Decision Curve Analysis — Internal CV', 'dca', rf, final_model=fmn)

        # ── External Validation (支持多个验证集) ──
        val_files_list = []
        for vf in [val_file1, val_file2, val_file3]:
            if vf is not None:
                val_files_list.append(vf)

        if val_files_list and fmn:
            progress(0.86, desc="🧪 外部验证...")
            log(f"\n{'━'*50}")
            log(f"  🧪 外部验证 ({len(val_files_list)} 个验证集)")

            for vi, vf in enumerate(val_files_list, 1):
                vp = vf if isinstance(vf, str) else getattr(vf, 'name', str(vf))
                ed = pd.read_csv(vp); Xe = ed.iloc[:,2:]; ye = ed.iloc[:,0]
                ule = sorted(ye.unique())
                if set(ule)!={0,1}: lme={ule[0]:0,ule[1]:1}; ye=ye.map(lme)
                log(f"\n  📊 验证集 {vi}: {Xe.shape[0]} 样本, {os.path.basename(vp)}")

                Xes = Xe[fmi['feats']]; Xtf = X[fmi['feats']]
                fm = deepcopy(mcfg[fmn]['model'])
                bp3 = bpd[fmn]
                if isinstance(bp3, dict) and bp3: fm.set_params(**bp3)
                fm.fit(Xtf.values, y)
                yep = fm.predict_proba(Xes.values)[:,1]; yed = (yep>0.5).astype(int)
                tn,fp,fn,tp = confusion_matrix(ye,yed).ravel()
                se=tp/(tp+fn) if tp+fn else 0; sp=tn/(tn+fp) if tn+fp else 0
                ac=(tp+tn)/(tp+tn+fp+fn); pr=tp/(tp+fp) if tp+fp else 0
                f1v=2*pr*se/(pr+se) if pr+se else 0; ea=roc_auc_score(ye,yep)
                log(f"     ✅ AUC={ea:.4f}  Acc={ac:.4f}  Sens={se:.4f}  Spec={sp:.4f}  F1={f1v:.4f}")

                sfx = f'_ext{vi}' if len(val_files_list) > 1 else '_ext'
                tag = f'Validation {vi}' if len(val_files_list) > 1 else 'External'

                # ROC
                fe,te,_ = roc_curve(ye,yep)
                plt.figure(figsize=(10,8))
                plt.plot(fe,te,'#2563eb',lw=2.5,label=f'{fmn} (AUC={ea:.3f})')
                plt.plot([0,1],[0,1],'--',color='gray'); plt.xlabel('FPR'); plt.ylabel('TPR')
                plt.title(f'ROC — {tag} ({fmn})',fontweight='bold'); plt.legend(); plt.grid(True,alpha=0.2); plt.tight_layout()
                plt.savefig(os.path.join(rf,f'roc{sfx}.pdf'),format='pdf',bbox_inches='tight')
                plt.savefig(os.path.join(rf,f'roc{sfx}.png'),format='png',bbox_inches='tight',dpi=150)
                plt.close()

                # PR
                pe,re,_ = precision_recall_curve(ye,yep)
                plt.figure(figsize=(10,8))
                plt.plot(re,pe,'#2563eb',lw=2.5,label=fmn); plt.xlabel('Recall'); plt.ylabel('Precision')
                plt.title(f'PR — {tag} ({fmn})',fontweight='bold'); plt.legend(); plt.grid(True,alpha=0.2); plt.tight_layout()
                plt.savefig(os.path.join(rf,f'pr{sfx}.pdf'),format='pdf',bbox_inches='tight')
                plt.savefig(os.path.join(rf,f'pr{sfx}.png'),format='png',bbox_inches='tight',dpi=150)
                plt.close()

                # CM
                cme = confusion_matrix(ye,yed)
                plt.figure(figsize=(8,6))
                sns.heatmap(cme,annot=True,fmt='d',cmap='Blues',cbar=False,xticklabels=['Neg','Pos'],yticklabels=['Neg','Pos'])
                plt.xlabel('Predicted'); plt.ylabel('True')
                plt.title(f'CM — {tag} ({fmn})',fontweight='bold'); plt.tight_layout()
                plt.savefig(os.path.join(rf,f'cm{sfx}.pdf'),format='pdf',bbox_inches='tight')
                plt.savefig(os.path.join(rf,f'cm{sfx}.png'),format='png',bbox_inches='tight',dpi=150)
                plt.close()

                # DCA — 标准临床格式
                plot_dca(ye, {fmn: yep}, f'DCA — {tag} ({fmn})', f'dca{sfx}', rf)

                # Excel
                with pd.ExcelWriter(os.path.join(rf,f'validation{sfx}.xlsx'),engine='openpyxl') as w:
                    pd.DataFrame([{'Model':fmn,'N_Features':fmi['nf'],'AUC':ea,'Accuracy':ac,
                        'Sensitivity':se,'Specificity':sp,'Precision':pr,'F1':f1v}]).to_excel(w,sheet_name='Metrics',index=False)
                    pd.DataFrame({'Feature':fmi['feats']}).to_excel(w,sheet_name='Features',index=False)

        # ── Save Excels ──
        progress(0.92, desc="💾 保存结果...")
        log(f"\n  💾 保存结果文件...")
        with pd.ExcelWriter(os.path.join(rf,'model_evaluation.xlsx'),engine='openpyxl') as w:
            for mn, r in amr.items(): r['results_df'].to_excel(w,sheet_name=mn,index=False)
            sd = []
            for mn, r in amr.items():
                rw = r['results_df'].iloc[-1].to_dict()
                rw.update({'Model':mn,'Retained':'Yes' if mn in retained else 'No','Final':'Yes' if mn==fmn else 'No'})
                sd.append(rw)
            sdf = pd.DataFrame(sd)
            cols = ['Model','Retained','Final']+[c for c in sdf.columns if c not in ['Model','Fold','Retained','Final']]
            sdf[cols].sort_values('AUC',ascending=False).to_excel(w,sheet_name='Summary',index=False)
            if len(dldf)>0: dldf.to_excel(w,sheet_name='DeLong',index=False)

        with pd.ExcelWriter(os.path.join(rf,'feature_ablation.xlsx'),engine='openpyxl') as w:
            for mn, ar in ablr.items():
                pd.DataFrame({'N':ar['fcs'],'AUC':ar['aucs']}).to_excel(w,sheet_name=mn,index=False)
                if 'dl' in ar: ar['dl'].to_excel(w,sheet_name=f'{mn}_DL',index=False)
            for mn, idf in shap_imp.items():
                idf.to_excel(w,sheet_name=f'{mn}_Imp',index=False)

        with open(os.path.join(rf,'best_params.txt'),'w',encoding='utf-8') as f:
            f.write("模型最佳超参数\n"+"="*50+"\n\n")
            for mn in mcfg:
                f.write(f"模型: {mn}\n")
                bp = bpd[mn]
                if isinstance(bp,dict):
                    for k,v in bp.items(): f.write(f"  {k}: {v}\n")
                else: f.write(f"  {bp}\n")
                f.write(f"  AUC: {amr[mn]['mean_auc']:.4f}\n  保留: {'是' if mn in retained else '否'}\n\n")
            if fmn: f.write(f"\n最终模型: {fmn}\n特征({fmi['nf']}): {', '.join(fmi['feats'])}\n")

        if fmn:
            pickle.dump({'model_name':fmn,'model':tms[fmn]['model'],'best_params':bpd[fmn],
                'features':fmi['feats'],'n_features':fmi['nf'],'auc':fmi['auc'],
                'threshold':amr[fmn]['optimal_threshold']},
                open(os.path.join(rf,f'model_{fmn}.pkl'),'wb'))

        # ── ZIP ──
        progress(0.97, desc="📦 打包ZIP...")
        # 使用唯一文件名避免多用户冲突
        zp = os.path.join(tempfile.gettempdir(), f"ml_results_{int(time.time())}_{os.getpid()}.zip")
        with zipfile.ZipFile(zp,'w',zipfile.ZIP_DEFLATED) as zf:
            for root,_,files in os.walk(rf):
                for fn in files: zf.write(os.path.join(root,fn), os.path.relpath(os.path.join(root,fn),rf))

        nf = sum(len(f) for _,_,f in os.walk(rf))

        # 立即清理临时结果文件夹（ZIP已打包完毕）
        shutil.rmtree(rf, ignore_errors=True)
        gc.collect()

        log(f"\n{'━'*50}")
        log(f"  🎉 分析完成！共 {nf} 个文件已打包")
        log(f"  💾 临时文件已自动清理")
        log(f"{'━'*50}")
        progress(1.0, desc="✅ 完成!")
        return zp, "\n".join(L)

    except Exception as e:
        log(f"\n❌ 错误: {e}")
        log(traceback.format_exc())
        # 出错时也清理临时文件夹
        if os.path.exists(rf):
            shutil.rmtree(rf, ignore_errors=True)
        gc.collect()
        return None, "\n".join(L)


# ============================================================================
# Beautiful Gradio UI
# ============================================================================
CUSTOM_CSS = """
/* ── Header Banner ── */
.header-banner {
    background: linear-gradient(135deg, #0a2463 0%, #1e3a7a 40%, #2554a8 100%);
    border-radius: 16px;
    padding: 28px 36px;
    margin-bottom: 20px;
    box-shadow: 0 8px 32px rgba(0,0,0,0.18);
    position: relative;
    overflow: hidden;
}
.header-banner::before {
    content: '';
    position: absolute;
    top: -50%;
    right: -20%;
    width: 400px;
    height: 400px;
    background: radial-gradient(circle, rgba(96,165,250,0.2) 0%, transparent 70%);
    border-radius: 50%;
}
.header-banner img {
    max-height: 52px;
    border-radius: 6px;
    margin-bottom: 12px;
}
.header-banner h1 {
    color: #e2e8f0 !important;
    font-size: 1.7em !important;
    margin: 4px 0 6px 0 !important;
    font-weight: 700 !important;
    letter-spacing: 0.5px;
}
.header-banner p {
    color: #94a3b8 !important;
    font-size: 0.92em !important;
    margin: 2px 0 !important;
    line-height: 1.6;
}
.header-banner .credit {
    color: #64748b !important;
    font-size: 0.82em !important;
    margin-top: 10px !important;
    border-top: 1px solid rgba(148,163,184,0.15);
    padding-top: 10px;
}

/* ── Section Cards ── */
.section-title {
    background: linear-gradient(90deg, #2563eb 0%, #3b82f6 100%);
    color: white !important;
    padding: 8px 16px;
    border-radius: 8px;
    font-size: 0.95em !important;
    font-weight: 600 !important;
    margin: 12px 0 8px 0;
    letter-spacing: 0.3px;
}

/* ── Pipeline Steps ── */
.pipeline-box {
    background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%);
    border: 1px solid #bae6fd;
    border-radius: 12px;
    padding: 14px 18px;
    margin: 8px 0;
    font-size: 0.88em;
}
.pipeline-box code {
    background: #2563eb;
    color: white;
    padding: 2px 8px;
    border-radius: 4px;
    font-size: 0.85em;
    margin: 0 2px;
}

/* ── Buttons ── */
.quick-btn {
    border-radius: 8px !important;
    font-weight: 500 !important;
    transition: all 0.2s ease !important;
}
.quick-btn:hover {
    transform: translateY(-1px) !important;
    box-shadow: 0 4px 12px rgba(0,0,0,0.1) !important;
}

/* ── Log Area ── */
.log-area textarea {
    font-family: 'Menlo', 'Consolas', 'Monaco', monospace !important;
    font-size: 12.5px !important;
    line-height: 1.5 !important;
    background: #0f172a !important;
    color: #e2e8f0 !important;
    border-radius: 10px !important;
    padding: 16px !important;
    border: 1px solid #1e293b !important;
}

/* ── General Polish ── */
.gradio-container {
    max-width: 1280px !important;
}
footer { display: none !important; }
"""

with gr.Blocks(
    title="ML 二分类模型平台 — 复旦大学附属眼耳鼻喉科医院",
    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="slate", neutral_hue="slate"),
    css=CUSTOM_CSS,
) as demo:

    # ── Header ──
    gr.HTML("""
    <div class="header-banner">
        <img src="https://huggingface.co/spaces/fudan-renjun/machine-learning-2/resolve/main/hospital_logo.png"
             alt="Logo" onerror="this.style.display='none'"/>
        <h1>🧬 ML 二分类模型训练与评估平台</h1>
        <p>上传训练集与验证集 CSV，自动完成模型训练、交叉验证、统计检验、特征分析，结果打包下载</p>
        <p class="credit">复旦大学附属眼耳鼻喉科医院 · 检验科 · 任俊</p>
    </div>
    """)

    # ── Pipeline Info ──
    gr.HTML("""
    <div class="pipeline-box">
        <strong>📋 分析流程：</strong>
        <code>模型训练</code> → <code>交叉验证</code> → <code>DeLong检验</code> →
        <code>SHAP分析</code> → <code>特征消融</code> → <code>外部验证</code>
        &nbsp;&nbsp;|&nbsp;&nbsp;
        <strong>CSV格式：</strong> 第1列=标签, 第2列=ID, 第3列起=特征
    </div>
    """)

    with gr.Row(equal_height=False):
        # ══ Left Panel ══
        with gr.Column(scale=5):

            gr.HTML('<div class="section-title">📂 数据上传</div>')
            train_file = gr.File(label="训练集 CSV（必需）", file_types=[".csv"])
            gr.HTML('<p style="color:#64748b;font-size:0.85em;margin:4px 0 8px 0;">验证集为可选项，支持同时上传 1~3 个验证集，分别生成独立的评估报告</p>')
            with gr.Row():
                val_file1 = gr.File(label="验证集 1（可选）", file_types=[".csv"], scale=1)
                val_file2 = gr.File(label="验证集 2（可选）", file_types=[".csv"], scale=1)
                val_file3 = gr.File(label="验证集 3（可选）", file_types=[".csv"], scale=1)

            gr.HTML('<div class="section-title">🤖 模型选择</div>')
            model_selector = gr.Dropdown(
                choices=ALL_MODEL_NAMES,
                value=ALL_MODEL_NAMES,
                multiselect=True,
                label="选择模型（可多选，默认全部）",
                info="RF=随机森林  DT=决策树  KNN=K近邻  XGB=极限梯度提升  AdaBoost=自适应提升  LR=逻辑回归  NB=朴素贝叶斯  SVM=支持向量机",
            )
            with gr.Row():
                btn_all = gr.Button("🔘 全选", size="sm", variant="secondary", elem_classes="quick-btn")
                btn_tree = gr.Button("🌲 树模型", size="sm", variant="secondary", elem_classes="quick-btn")
                btn_linear = gr.Button("📐 线性模型", size="sm", variant="secondary", elem_classes="quick-btn")
                btn_top4 = gr.Button("⚡ 经典四模型", size="sm", variant="secondary", elem_classes="quick-btn")
            btn_all.click(lambda: ALL_MODEL_NAMES, outputs=model_selector)
            btn_tree.click(lambda: ['RF','DT','XGB','AdaBoost'], outputs=model_selector)
            btn_linear.click(lambda: ['LR','SVM','NB'], outputs=model_selector)
            btn_top4.click(lambda: ['RF','XGB','LR','SVM'], outputs=model_selector)

            gr.HTML('<div class="section-title">⚙️ 参数配置</div>')
            enable_tuning = gr.Checkbox(value=False, label="启用超参数调优 (GridSearchCV)  ⚠️ 开启后运行时间显著增加")
            with gr.Row():
                cv_folds = gr.Slider(3, 10, value=5, step=1, label="交叉验证折数")
                alpha_sl = gr.Slider(0.01, 0.10, value=0.05, step=0.01, label="DeLong 显著性水平 α")
            with gr.Row():
                top_n = gr.Slider(5, 50, value=20, step=1, label="SHAP 前 N 个特征")
                shap_sz = gr.Slider(30, 200, value=80, step=10, label="SHAP 采样数量")

            run_btn = gr.Button("🚀 开始分析", variant="primary", size="lg")

        # ══ Right Panel ══
        with gr.Column(scale=5):
            gr.HTML('<div class="section-title">📋 运行日志</div>')
            log_output = gr.Textbox(
                label="", lines=22, max_lines=50, interactive=False,
                placeholder="点击「开始分析」后，运行日志将在此实时显示...",
                elem_classes="log-area",
            )

            gr.HTML('<div class="section-title">⬇️ 结果下载</div>')
            zip_output = gr.File(label="分析结果 ZIP 压缩包")

    # ── Connect ──
    run_btn.click(
        fn=run_pipeline,
        inputs=[train_file, val_file1, val_file2, val_file3, model_selector, enable_tuning, cv_folds, alpha_sl, top_n, shap_sz],
        outputs=[zip_output, log_output],
        api_name="run",
    )

# ============================================================================
# Authentication with Expiration
# ============================================================================
from datetime import datetime

# ┌─────────────────────────────────────────────────┐
# │  账号配置 — 在这里修改账号、密码和有效期           │
# │  格式: "用户名": {"password": "密码",             │
# │         "expires": "YYYY-MM-DD"}                 │
# │  如果不需要过期限制，设 "expires": None            │
# └─────────────────────────────────────────────────┘
ACCOUNTS = {
    "admin": {
        "password": "admin123",
        "expires": None,             # 永不过期
    },
    "renjun": {
        "password": "fudan2025",
        "expires": "2026-12-31",     # 2026年12月31日过期
    },
    "guest": {
        "password": "guest888",
        "expires": "2025-06-30",     # 示例：已过期账号
    },
}

def auth_fn(username, password):
    """验证账号密码 + 检查有效期"""
    user = ACCOUNTS.get(username)
    if not user:
        return False
    if user["password"] != password:
        return False
    if user["expires"] is not None:
        try:
            exp_date = datetime.strptime(user["expires"], "%Y-%m-%d")
            if datetime.now() > exp_date:
                return False
        except ValueError:
            return False
    return True

demo.queue()
demo.launch(
    server_name="0.0.0.0",
    server_port=7860,
    auth=auth_fn,
    auth_message="🔐 复旦大学附属眼耳鼻喉科医院 · ML分析平台\n请输入账号和密码登录",
    ssr_mode=False,
)