Upload 4 files

DEPLOY_GUIDE.txt

@@ -0,0 +1,63 @@
+# FungalPep - Hugging Face Spaces 部署指南
+# ==========================================
+
+# ═══════════════ 第一步：注册 Hugging Face ═══════════════
+# 1. 打开 https://huggingface.co/join
+# 2. 注册账号（免费）
+# 3. 登录后点击右上角头像 → Settings → Access Tokens
+# 4. 创建一个 Token（选 Write 权限），复制保存
+
+# ═══════════════ 第二步：安装 Git LFS ═══════════════
+# 模型文件较大，需要 Git LFS（Large File Storage）
+# Windows 下载: https://git-lfs.com/ 安装后运行:
+#   git lfs install
+
+# ═══════════════ 第三步：创建 Space ═══════════════
+# 1. 打开 https://huggingface.co/new-space
+# 2. 填写:
+#    - Space name: fungalpep
+#    - License: MIT
+#    - SDK: Streamlit
+#    - Hardware: CPU basic（免费） 或 T4 small（更快，可能需付费）
+# 3. 点击 Create Space
+
+# ═══════════════ 第四步：上传文件 ═══════════════
+# 在 E:\my_project 下运行以下命令:
+
+# 克隆你的 Space 仓库
+# git clone https://huggingface.co/spaces/你的用户名/fungalpep
+# cd fungalpep
+
+# 复制文件到仓库
+# copy E:\my_project\hf_deploy\README.md .
+# copy E:\my_project\hf_deploy\app.py .
+# copy E:\my_project\hf_deploy\requirements.txt .
+# mkdir checkpoints
+# mkdir checkpoints_mic
+# copy E:\my_project\checkpoints\best_model.pt checkpoints\
+# copy E:\my_project\checkpoints_mic\best_mic_model.pt checkpoints_mic\
+
+# 用 Git LFS 追踪大文件
+# git lfs track "*.pt"
+
+# 提交并推送
+# git add .
+# git commit -m "Initial deployment: FungalPep AMP + MIC prediction"
+# git push
+
+# 推送时会要求输入用户名和密码:
+#   用户名: 你的 HuggingFace 用户名
+#   密码: 你在第一步创建的 Access Token
+
+# ═══════════════ 第五步：等待部署 ═══════════════
+# 推送后 Hugging Face 会自动构建和部署
+# 打开 https://huggingface.co/spaces/你的用户名/fungalpep 查看状态
+# 首次构建约 5-10 分钟（需要安装依赖和下载 ESM-2）
+# 构建成功后，你会看到 FungalPep 网页界面
+
+# ═══════════════ 注意事项 ═══════════════
+# 1. 免费 CPU 版本: ESM-2 推理较慢（约 10-30 秒/序列），但完全免费
+# 2. 如需更快速度: 在 Space Settings 中升级到 T4 GPU（约 $0.60/小时）
+# 3. 免费版会在不活跃时休眠，首次访问需要约 1 分钟唤醒
+# 4. best_model.pt 和 best_mic_model.pt 加起来约几十 MB，不超限
+# 5. ESM-2 模型会在首次运行时自动从 HuggingFace Hub 下载并缓存

README.md

@@ -0,0 +1,40 @@
+---
+title: ML Binary Classification Pipeline
+emoji: 🧬
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🧬 ML Binary Classification Pipeline
+
+Machine learning binary classification training & evaluation platform.
+
+## Features
+
+- **8 Models**: RF, DT, KNN, XGB, AdaBoost, LR, NB, SVM
+- **Interactive Model Selection**: Choose any combination of models
+- **Hyperparameter Tuning**: GridSearchCV with configurable folds
+- **DeLong Test**: Statistical comparison between models
+- **SHAP Analysis**: Feature importance with beeswarm plots
+- **Feature Ablation**: Optimal feature subset selection
+- **External Validation**: ROC, PR, DCA curves, confusion matrix
+- **ZIP Download**: All results packaged for download
+
+## Data Format
+
+CSV files with:
+- Column 1: Label (0/1)
+- Column 2: Any (e.g., ID)
+- Column 3+: Features
+
+## Output Files
+
+- PDF/PNG charts (ROC, PR, DCA, confusion matrices, SHAP plots)
+- Excel files (model metrics, feature ablation, external validation)
+- Best parameters text file
+- Final model pickle file

app.py

@@ -0,0 +1,946 @@
+"""
+ML Binary Classification Pipeline — Hugging Face Spaces Deployment
+Supports 8 models with interactive selection, file upload, and ZIP download.
+"""
+
+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 gradio as gr
+import io
+import traceback
+
+warnings.filterwarnings('ignore')
+
+# Font settings
+plt.rcParams['font.sans-serif'] = ['DejaVu Sans', 'SimHei']
+plt.rcParams['axes.unicode_minus'] = False
+
+# ============================================================================
+# Helper Functions (from original script)
+# ============================================================================
+
+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(predictions_sorted_transposed, label_1_count):
+    m = label_1_count
+    n = predictions_sorted_transposed.shape[1] - m
+    positive_examples = predictions_sorted_transposed[:, :m]
+    negative_examples = predictions_sorted_transposed[:, m:]
+    k = predictions_sorted_transposed.shape[0]
+    tx = np.empty([k, m], dtype=float)
+    ty = np.empty([k, n], dtype=float)
+    tz = np.empty([k, m + n], dtype=float)
+    for r in range(k):
+        tx[r, :] = compute_midrank(positive_examples[r, :])
+        ty[r, :] = compute_midrank(negative_examples[r, :])
+        tz[r, :] = compute_midrank(predictions_sorted_transposed[r, :])
+    aucs = tz[:, :m].sum(axis=1) / m / n - float(m + 1.0) / 2.0 / n
+    v01 = (tz[:, :m] - tx[:, :]) / n
+    v10 = 1.0 - (tz[:, m:] - ty[:, :]) / m
+    sx = np.cov(v01)
+    sy = np.cov(v10)
+    delongcov = sx / m + sy / n
+    return aucs, delongcov
+
+def calc_pvalue(aucs, sigma):
+    l_mat = np.array([[1, -1]])
+    z = np.abs(np.diff(aucs)) / np.sqrt(np.dot(np.dot(l_mat, sigma), l_mat.T))
+    return np.log10(2) + stats.norm.logsf(z, loc=0, scale=1) / np.log(10)
+
+def delong_roc_test(ground_truth, predictions_one, predictions_two):
+    order = (-ground_truth).argsort()
+    label_1_count = int(ground_truth.sum())
+    predictions_sorted_transposed = np.vstack([predictions_one, predictions_two])[:, order]
+    aucs, delongcov = fastDeLong(predictions_sorted_transposed, label_1_count)
+    p_value = 10 ** calc_pvalue(aucs, delongcov)[0][0]
+    return p_value, aucs[0], aucs[1]
+
+def find_optimal_threshold(y_true, y_probs, method='youden'):
+    fpr, tpr, thresholds = roc_curve(y_true, y_probs)
+    if method == 'youden':
+        youden_index = tpr - fpr
+        optimal_idx = np.argmax(youden_index)
+        optimal_threshold = thresholds[optimal_idx]
+        metric_value = youden_index[optimal_idx]
+    elif method == 'f1':
+        f1_scores = []
+        for threshold in thresholds:
+            y_pred = (y_probs >= threshold).astype(int)
+            tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
+            precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+            recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+            f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
+            f1_scores.append(f1)
+        optimal_idx = np.argmax(f1_scores)
+        optimal_threshold = thresholds[optimal_idx]
+        metric_value = f1_scores[optimal_idx]
+    elif method == 'gmean':
+        gmean = np.sqrt(tpr * (1 - fpr))
+        optimal_idx = np.argmax(gmean)
+        optimal_threshold = thresholds[optimal_idx]
+        metric_value = gmean[optimal_idx]
+    return optimal_threshold, metric_value, optimal_idx
+
+def calculate_net_benefit(y_true, y_probs, threshold):
+    y_pred = (y_probs >= threshold).astype(int)
+    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
+    n = len(y_true)
+    net_benefit = (tp / n) - (fp / n) * (threshold / (1 - threshold))
+    return net_benefit
+
+
+# ============================================================================
+# Model Configuration Builder
+# ============================================================================
+ALL_MODELS = ['RF', 'DT', 'KNN', 'XGB', 'AdaBoost', 'LR', 'NB', 'SVM']
+
+def get_models_config(selected_models, random_state=42):
+    full_config = {
+        'RF': {
+            'model': RandomForestClassifier(random_state=random_state, 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=random_state),
+            '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=random_state, 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=random_state),
+            'params': {
+                'n_estimators': [50, 100],
+                'learning_rate': [0.1, 0.5, 1.0]
+            },
+        },
+        'LR': {
+            'model': LogisticRegression(random_state=random_state, 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=random_state),
+            'params': {
+                'C': [1, 10],
+                'kernel': ['rbf', 'linear'],
+                'gamma': ['scale', 'auto']
+            },
+        }
+    }
+    return {k: v for k, v in full_config.items() if k in selected_models}
+
+
+# ============================================================================
+# Main Pipeline
+# ============================================================================
+def run_pipeline(
+    train_file,
+    val_file,
+    selected_models,
+    enable_tuning,
+    cv_folds,
+    alpha,
+    top_n_features,
+    shap_sample_size,
+    progress=gr.Progress()
+):
+    """Main ML pipeline — returns (zip_path, log_text)"""
+    if train_file is None:
+        return None, "❌ 请上传训练集 CSV 文件！"
+
+    if not selected_models:
+        return None, "❌ 请至少选择一个模型！"
+
+    RANDOM_STATE = 42
+    CV_FOLDS = int(cv_folds)
+    ALPHA = float(alpha)
+    TOP_N_FEATURES = int(top_n_features)
+    SHAP_SAMPLE_SIZE = int(shap_sample_size)
+    ENABLE_HYPERPARAMETER_TUNING = enable_tuning
+
+    log_lines = []
+    def log(msg):
+        log_lines.append(msg)
+
+    # Create temp output folder
+    result_folder = tempfile.mkdtemp(prefix="ml_results_")
+
+    try:
+        # ======== Load Data ========
+        progress(0.02, desc="加载训练数据...")
+        log("=" * 70)
+        log("🚀 机器学习二分类模型训练与评估")
+        log("=" * 70)
+
+        data = pd.read_csv(train_file.name)
+        X = data.iloc[:, 2:]
+        y = data.iloc[:, 0]
+        feature_names = X.columns.tolist()
+
+        log(f"训练集: {X.shape[0]} 样本, {X.shape[1]} 特征")
+        log(f"标签分布: {dict(y.value_counts())}")
+        log(f"选择模型: {', '.join(selected_models)}")
+        log(f"超参数调优: {'启用' if ENABLE_HYPERPARAMETER_TUNING else '禁用'}")
+        log(f"交叉验证: {CV_FOLDS} 折")
+
+        models_config = get_models_config(selected_models, RANDOM_STATE)
+        skf = StratifiedKFold(n_splits=CV_FOLDS, shuffle=True, random_state=RANDOM_STATE)
+
+        # ======== Train All Models ========
+        best_params_dict = {}
+        all_model_results = {}
+        trained_models = {}
+        total_models = len(models_config)
+
+        for m_idx, (model_name, config) in enumerate(models_config.items()):
+            progress_val = 0.05 + 0.45 * (m_idx / total_models)
+            progress(progress_val, desc=f"训练模型 {model_name} ({m_idx+1}/{total_models})...")
+            log(f"\n{'*' * 50}")
+            log(f"模型: {model_name}")
+
+            X_scaled = X.values
+
+            if ENABLE_HYPERPARAMETER_TUNING:
+                log(f"  超参数调优 (GridSearchCV, CV={CV_FOLDS})...")
+                grid_search = GridSearchCV(
+                    estimator=config['model'],
+                    param_grid=config['params'],
+                    cv=skf, scoring='roc_auc', n_jobs=-1, verbose=0
+                )
+                grid_search.fit(X_scaled, y)
+                best_params = grid_search.best_params_
+                best_params_dict[model_name] = best_params
+                log(f"  ✓ 最佳参数: {best_params}")
+                log(f"  ✓ 最佳CV AUC: {grid_search.best_score_:.4f}")
+            else:
+                best_params = {}
+                best_params_dict[model_name] = "默认参数"
+
+            model = deepcopy(config['model'])
+            if best_params:
+                model.set_params(**best_params)
+            model.fit(X_scaled, y)
+            trained_models[model_name] = {'model': model, 'scaler': None}
+
+            # Cross-validation
+            fold_results = []
+            all_y_true = []
+            all_y_probs = []
+            tprs = []
+            base_fpr = np.linspace(0, 1, 101)
+
+            for fold_idx, (train_idx, test_idx) in enumerate(skf.split(X, y), 1):
+                X_train_fold = X.iloc[train_idx].values
+                X_test_fold = X.iloc[test_idx].values
+                y_train_fold = y.iloc[train_idx]
+                y_test_fold = y.iloc[test_idx]
+
+                model_fold = deepcopy(config['model'])
+                if best_params:
+                    model_fold.set_params(**best_params)
+                model_fold.fit(X_train_fold, y_train_fold)
+
+                y_pred_probs = model_fold.predict_proba(X_test_fold)[:, 1]
+                y_pred = (y_pred_probs > 0.5).astype(int)
+
+                tn, fp, fn, tp = confusion_matrix(y_test_fold, y_pred).ravel()
+                sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0
+                specificity = tn / (tn + fp) if (tn + fp) > 0 else 0
+                accuracy = (tp + tn) / (tp + tn + fp + fn)
+                prec = tp / (tp + fp) if (tp + fp) > 0 else 0
+                f1 = 2 * prec * sensitivity / (prec + sensitivity) if (prec + sensitivity) > 0 else 0
+                roc_auc = roc_auc_score(y_test_fold, y_pred_probs)
+
+                fold_results.append({
+                    'Fold': fold_idx, 'AUC': roc_auc, 'Accuracy': accuracy,
+                    'Sensitivity': sensitivity, 'Specificity': specificity,
+                    'Precision': prec, 'F1 Score': f1,
+                    'TP': tp, 'TN': tn, 'FP': fp, 'FN': fn
+                })
+
+                all_y_true.extend(y_test_fold)
+                all_y_probs.extend(y_pred_probs)
+
+                fpr_arr, tpr_arr, _ = roc_curve(y_test_fold, y_pred_probs)
+                tpr_interp = np.interp(base_fpr, fpr_arr, tpr_arr)
+                tpr_interp[0] = 0.0
+                tprs.append(tpr_interp)
+
+            results_df = pd.DataFrame(fold_results)
+            mean_row = {
+                'Fold': 'Mean±Std',
+                'AUC': results_df['AUC'].mean(),
+                'Accuracy': results_df['Accuracy'].mean(),
+                'Sensitivity': results_df['Sensitivity'].mean(),
+                'Specificity': results_df['Specificity'].mean(),
+                'Precision': results_df['Precision'].mean(),
+                'F1 Score': results_df['F1 Score'].mean(),
+                'TP': results_df['TP'].sum(), 'TN': results_df['TN'].sum(),
+                'FP': results_df['FP'].sum(), 'FN': results_df['FN'].sum()
+            }
+            results_df = pd.concat([results_df, pd.DataFrame([mean_row])], ignore_index=True)
+
+            all_model_results[model_name] = {
+                'results_df': results_df,
+                'mean_auc': results_df.iloc[-1]['AUC'],
+                'all_y_true': np.array(all_y_true),
+                'all_y_probs': np.array(all_y_probs),
+                'tprs': tprs,
+                'base_fpr': base_fpr
+            }
+
+            opt_thr, youden_val, _ = find_optimal_threshold(
+                np.array(all_y_true), np.array(all_y_probs), method='youden'
+            )
+            all_model_results[model_name]['optimal_threshold'] = opt_thr
+            all_model_results[model_name]['youden_index'] = youden_val
+
+            log(f"  ✓ 平均AUC={mean_row['AUC']:.4f}, Acc={mean_row['Accuracy']:.4f}, 最佳阈值={opt_thr:.4f}")
+
+        log(f"\n{'=' * 70}")
+        log("所有模型训练完成!")
+
+        model_names = list(all_model_results.keys())
+        n_models = len(model_names)
+
+        # ======== ROC Curves (All Models - Internal CV) ========
+        progress(0.52, desc="绘制ROC曲线...")
+        colors_all = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f']
+
+        plt.figure(figsize=(12, 10))
+        for idx, mn in enumerate(model_names):
+            res = all_model_results[mn]
+            mean_tpr = np.mean(res['tprs'], axis=0)
+            mean_tpr[-1] = 1.0
+            mean_auc_val = auc_score(res['base_fpr'], mean_tpr)
+            std_auc = res['results_df'].iloc[:-1]['AUC'].std()
+            std_tpr = np.std(res['tprs'], axis=0)
+            tprs_upper = np.minimum(mean_tpr + std_tpr, 1)
+            tprs_lower = np.maximum(mean_tpr - std_tpr, 0)
+            plt.plot(res['base_fpr'], mean_tpr, color=colors_all[idx % 8], lw=2.5, alpha=0.8,
+                     label=f'{mn} (AUC={mean_auc_val:.3f}±{std_auc:.3f})')
+            plt.plot(res['base_fpr'], tprs_upper, color=colors_all[idx % 8], lw=1, alpha=0.3, linestyle='--')
+            plt.plot(res['base_fpr'], tprs_lower, color=colors_all[idx % 8], lw=1, alpha=0.3, linestyle='--')
+        plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='gray', label='Chance', alpha=0.5)
+        plt.xlim([-0.05, 1.05]); plt.ylim([-0.05, 1.05])
+        plt.xlabel('FPR', fontsize=13); plt.ylabel('TPR', fontsize=13)
+        plt.title('ROC Curves (Internal CV)', fontsize=14, fontweight='bold')
+        plt.legend(loc="lower right", fontsize=10, framealpha=0.9)
+        plt.grid(True, alpha=0.3); plt.tight_layout()
+        plt.savefig(os.path.join(result_folder, 'roc_curves_all_models_internal_cv.pdf'), format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(result_folder, 'roc_curves_all_models_internal_cv.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # ======== PR Curves ========
+        progress(0.55, desc="绘制PR曲线...")
+        plt.figure(figsize=(12, 10))
+        for idx, mn in enumerate(model_names):
+            res = all_model_results[mn]
+            pr_aucs_fold = []
+            for train_idx, test_idx in skf.split(X, y):
+                cfg = models_config[mn]
+                X_tr = X.iloc[train_idx].values
+                X_te = X.iloc[test_idx].values
+                y_tr = y.iloc[train_idx]; y_te = y.iloc[test_idx]
+                m_pr = deepcopy(cfg['model'])
+                bp = best_params_dict[mn]
+                if isinstance(bp, dict) and bp:
+                    m_pr.set_params(**bp)
+                m_pr.fit(X_tr, y_tr)
+                yp = m_pr.predict_proba(X_te)[:, 1]
+                prc, rec, _ = precision_recall_curve(y_te, yp)
+                pr_aucs_fold.append(auc_score(rec, prc))
+            mean_pr = np.mean(pr_aucs_fold); std_pr = np.std(pr_aucs_fold)
+            precision_all, recall_all, _ = precision_recall_curve(res['all_y_true'], res['all_y_probs'])
+            plt.plot(recall_all, precision_all, color=colors_all[idx % 8], lw=2.5, alpha=0.8,
+                     label=f'{mn} (PR={mean_pr:.3f}±{std_pr:.3f})')
+        plt.xlim([-0.05, 1.05]); plt.ylim([-0.05, 1.05])
+        plt.xlabel('Recall', fontsize=13); plt.ylabel('Precision', fontsize=13)
+        plt.title('PR Curves (Internal CV)', fontsize=14, fontweight='bold')
+        plt.legend(loc="lower left", fontsize=10, framealpha=0.9)
+        plt.grid(True, alpha=0.3); plt.tight_layout()
+        plt.savefig(os.path.join(result_folder, 'pr_curves_all_models_internal_cv.pdf'), format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(result_folder, 'pr_curves_all_models_internal_cv.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # ======== Confusion Matrices ========
+        progress(0.58, desc="绘制混淆矩阵...")
+        n_rows = (n_models + 3) // 4
+        fig, axes = plt.subplots(n_rows, 4, figsize=(16, 4 * n_rows))
+        axes_flat = axes.flatten() if n_models > 1 else [axes]
+        for idx, mn in enumerate(model_names):
+            res = all_model_results[mn]
+            y_pred_cm = (res['all_y_probs'] >= res['optimal_threshold']).astype(int)
+            cm = confusion_matrix(res['all_y_true'], y_pred_cm)
+            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False,
+                        xticklabels=['Neg', 'Pos'], yticklabels=['Neg', 'Pos'],
+                        ax=axes_flat[idx], annot_kws={'fontsize': 11})
+            axes_flat[idx].set_xlabel('Predicted', fontsize=11)
+            axes_flat[idx].set_ylabel('True', fontsize=11)
+            acc_cm = (cm[0, 0] + cm[1, 1]) / cm.sum()
+            axes_flat[idx].set_title(f'{mn}\n(Acc={acc_cm:.3f}, Thr={res["optimal_threshold"]:.3f})', fontsize=12, fontweight='bold')
+        for idx in range(n_models, len(axes_flat)):
+            axes_flat[idx].set_visible(False)
+        plt.suptitle('Confusion Matrices (Internal CV)', fontsize=15, fontweight='bold', y=1.00)
+        plt.tight_layout()
+        plt.savefig(os.path.join(result_folder, 'confusion_matrices_all_models.pdf'), format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(result_folder, 'confusion_matrices_all_models.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # ======== DeLong Test ========
+        progress(0.62, desc="DeLong检验...")
+        best_model_name = max(all_model_results, key=lambda x: all_model_results[x]['mean_auc'])
+        best_model_auc = all_model_results[best_model_name]['mean_auc']
+        log(f"\n最佳模型: {best_model_name} (AUC={best_model_auc:.4f})")
+
+        delong_results = []
+        retained_models = [best_model_name]
+
+        for other_model in model_names:
+            if other_model == best_model_name:
+                continue
+            y_true_dl = all_model_results[best_model_name]['all_y_true']
+            y_probs_best = all_model_results[best_model_name]['all_y_probs']
+            y_probs_other = all_model_results[other_model]['all_y_probs']
+            try:
+                p_value, auc1, auc2 = delong_roc_test(y_true_dl, y_probs_best, y_probs_other)
+            except:
+                p_value = 1.0; auc1 = best_model_auc; auc2 = all_model_results[other_model]['mean_auc']
+            if p_value >= ALPHA:
+                decision = f"保留 (P>={ALPHA})"
+                retained_models.append(other_model)
+            else:
+                decision = f"排除 (P<{ALPHA})"
+            delong_results.append({
+                'Model 1': best_model_name, 'AUC 1': auc1,
+                'Model 2': other_model, 'AUC 2': auc2,
+                'P-value': p_value, 'Decision': decision
+            })
+            log(f"  {best_model_name} vs {other_model}: P={p_value:.4e} → {decision}")
+
+        delong_df = pd.DataFrame(delong_results).sort_values('P-value', ascending=False) if delong_results else pd.DataFrame()
+        log(f"保留模型: {', '.join(retained_models)}")
+
+        # ======== SHAP Analysis ========
+        progress(0.65, desc="SHAP特征重要性分析...")
+        shap_feature_importance = {}
+
+        for s_idx, mn in enumerate(retained_models):
+            progress(0.65 + 0.1 * (s_idx / len(retained_models)), desc=f"SHAP分析 {mn}...")
+            log(f"\n计算 {mn} 的SHAP值...")
+            model_obj = trained_models[mn]['model']
+            X_for_shap = X.values
+            n_samples = min(SHAP_SAMPLE_SIZE, X_for_shap.shape[0])
+            np.random.seed(RANDOM_STATE)
+            sample_indices = np.random.choice(X_for_shap.shape[0], n_samples, replace=False)
+            X_shap_sample = X_for_shap[sample_indices]
+
+            try:
+                if mn in ['RF', 'XGB', 'DT', 'AdaBoost']:
+                    explainer = shap.TreeExplainer(model_obj)
+                    shap_values = explainer.shap_values(X_shap_sample)
+                    if isinstance(shap_values, list):
+                        shap_values = shap_values[1]
+                else:
+                    bg_size = min(100, n_samples)
+                    bg_idx = np.random.choice(n_samples, bg_size, replace=False)
+                    background = X_shap_sample[bg_idx]
+                    def predict_fn(x, m=model_obj):
+                        return m.predict_proba(x)[:, 1]
+                    explainer = shap.KernelExplainer(predict_fn, background)
+                    shap_values = explainer.shap_values(X_shap_sample)
+
+                if isinstance(shap_values, list):
+                    shap_values = shap_values[0]
+                shap_values = np.array(shap_values)
+                if shap_values.ndim > 2:
+                    shap_values = shap_values[0]
+
+                feature_importance = np.abs(shap_values).mean(axis=0)
+                if feature_importance.ndim > 1:
+                    feature_importance = feature_importance.flatten()
+                if len(feature_importance) != len(feature_names):
+                    feature_importance = feature_importance[:len(feature_names)] if len(feature_importance) > len(feature_names) else np.pad(feature_importance, (0, len(feature_names) - len(feature_importance)), 'constant')
+
+                importance_df = pd.DataFrame({'Feature': feature_names, 'Importance': feature_importance}).sort_values('Importance', ascending=False)
+                shap_feature_importance[mn] = importance_df
+
+                X_shap_df = pd.DataFrame(X_shap_sample, columns=feature_names)
+                if shap_values.shape[1] != X_shap_df.shape[1]:
+                    if shap_values.shape[1] > X_shap_df.shape[1]:
+                        shap_values = shap_values[:, :X_shap_df.shape[1]]
+                    else:
+                        padding = np.zeros((shap_values.shape[0], X_shap_df.shape[1] - shap_values.shape[1]))
+                        shap_values = np.hstack([shap_values, padding])
+
+                plt.figure(figsize=(12, 8))
+                shap.summary_plot(shap_values, X_shap_df, plot_type="dot", show=False, max_display=TOP_N_FEATURES)
+                plt.title(f'SHAP Feature Importance - {mn} (Top {TOP_N_FEATURES})', fontsize=14, fontweight='bold')
+                plt.tight_layout()
+                plt.savefig(os.path.join(result_folder, f'shap_beeswarm_{mn}.pdf'), format='pdf', bbox_inches='tight')
+                plt.savefig(os.path.join(result_folder, f'shap_beeswarm_{mn}.png'), format='png', bbox_inches='tight', dpi=150)
+                plt.close()
+                log(f"  ✓ {mn} SHAP完成, 前5特征: {', '.join(importance_df.head(5)['Feature'].tolist())}")
+
+            except Exception as e:
+                log(f"  ✗ {mn} SHAP出错: {str(e)}")
+                traceback.print_exc()
+
+        # ======== Feature Ablation ========
+        progress(0.78, desc="特征消融分析...")
+        ablation_results = {}
+        for mn in retained_models:
+            if mn not in shap_feature_importance:
+                continue
+            log(f"\n特征消融: {mn}")
+            imp_df = shap_feature_importance[mn]
+            top_features = imp_df.head(TOP_N_FEATURES)['Feature'].tolist()
+            feature_counts = []; auc_scores_abl = []; all_subset_probs = {}
+            cfg = models_config[mn]
+
+            for n_feat in range(1, len(top_features) + 1):
+                sel_feats = top_features[:n_feat]
+                X_sub = X[sel_feats]
+                fold_aucs = []; sub_yt = []; sub_yp = []
+                for train_idx, test_idx in skf.split(X_sub, y):
+                    X_tr = X_sub.iloc[train_idx].values; X_te = X_sub.iloc[test_idx].values
+                    y_tr = y.iloc[train_idx]; y_te = y.iloc[test_idx]
+                    m_f = deepcopy(cfg['model'])
+                    bp = best_params_dict.get(mn, {})
+                    if isinstance(bp, dict) and bp:
+                        m_f.set_params(**bp)
+                    m_f.fit(X_tr, y_tr)
+                    yp = m_f.predict_proba(X_te)[:, 1]
+                    sub_yt.extend(y_te); sub_yp.extend(yp)
+                    fold_aucs.append(roc_auc_score(y_te, yp))
+                ma = np.mean(fold_aucs)
+                feature_counts.append(n_feat); auc_scores_abl.append(ma)
+                all_subset_probs[n_feat] = {'y_true': np.array(sub_yt), 'y_probs': np.array(sub_yp)}
+
+            # DeLong for ablation
+            full_probs = all_model_results[mn]['all_y_probs']
+            full_auc = all_model_results[mn]['mean_auc']
+            optimal_n = None
+            abl_delong = []
+            for n_feat in range(1, len(top_features) + 1):
+                sd = all_subset_probs[n_feat]
+                sauc = auc_scores_abl[n_feat - 1]
+                try:
+                    if len(full_probs) == len(sd['y_probs']):
+                        pv, _, _ = delong_roc_test(sd['y_true'], full_probs, sd['y_probs'])
+                    else:
+                        pv = 0.1 if abs(sauc - full_auc) <= 0.05 else 0.01
+                except:
+                    pv = 0.1 if abs(sauc - full_auc) <= 0.05 else 0.01
+                sig = "有显著差异" if pv < ALPHA else "无显著差异"
+                abl_delong.append({'N_Features': n_feat, 'Subset_AUC': sauc, 'Full_AUC': full_auc, 'P_value': pv, 'Significance': sig})
+                if optimal_n is None and pv >= ALPHA:
+                    optimal_n = n_feat
+
+            ablation_results[mn] = {
+                'feature_counts': feature_counts, 'auc_scores': auc_scores_abl,
+                'top_features': top_features, 'delong_results': pd.DataFrame(abl_delong),
+                'optimal_n_features': optimal_n if optimal_n else len(top_features),
+                'optimal_features': top_features[:optimal_n] if optimal_n else top_features
+            }
+            log(f"  ✓ {mn} 最优特征数: {ablation_results[mn]['optimal_n_features']}")
+
+        # ======== Select Final Model ========
+        final_candidates = {}
+        for mn in retained_models:
+            if mn in ablation_results:
+                ar = ablation_results[mn]
+                final_candidates[mn] = {
+                    'n_features': ar['optimal_n_features'],
+                    'features': ar['optimal_features'],
+                    'auc': ar['auc_scores'][ar['optimal_n_features'] - 1]
+                }
+        final_model_name = min(final_candidates, key=lambda x: final_candidates[x]['n_features']) if final_candidates else None
+        final_model_info = final_candidates.get(final_model_name) if final_model_name else None
+
+        if final_model_name:
+            log(f"\n★ 最终模型: {final_model_name}, 特征数={final_model_info['n_features']}, AUC={final_model_info['auc']:.4f}")
+
+        # ======== Ablation Plot ========
+        progress(0.83, desc="绘制消融曲线...")
+        plt.figure(figsize=(12, 8))
+        colors_abl = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'orange']
+        for idx, (mn, ar) in enumerate(ablation_results.items()):
+            plt.plot(ar['feature_counts'], ar['auc_scores'], marker='o', lw=2, ms=6,
+                     color=colors_abl[idx % 8], label=mn)
+            opt_n = ar['optimal_n_features']
+            opt_auc = ar['auc_scores'][opt_n - 1]
+            plt.scatter([opt_n], [opt_auc], s=200, marker='*', color=colors_abl[idx % 8], edgecolors='black', lw=2, zorder=5)
+        plt.xlabel('Number of Features', fontsize=13); plt.ylabel('AUC', fontsize=13)
+        plt.title('Feature Ablation (★=Optimal)', fontsize=14, fontweight='bold')
+        plt.legend(loc='lower right', fontsize=11); plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+        plt.savefig(os.path.join(result_folder, 'feature_ablation_curve.pdf'), format='pdf', bbox_inches='tight')
+        plt.savefig(os.path.join(result_folder, 'feature_ablation_curve.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # ======== DCA Curves (Retained Models) ========
+        progress(0.85, desc="绘制DCA曲线...")
+        plt.figure(figsize=(12, 8))
+        threshold_range = np.linspace(0.01, 0.99, 100)
+        for idx, mn in enumerate(retained_models):
+            res = all_model_results[mn]
+            nbs = [calculate_net_benefit(res['all_y_true'], res['all_y_probs'], t) for t in threshold_range]
+            lbl = f'{mn} ★' if mn == final_model_name else mn
+            plt.plot(threshold_range, nbs, color=colors_abl[idx % 8], lw=2.5, alpha=0.8, label=lbl)
+        prevalence = np.mean(all_model_results[retained_models[0]]['all_y_true'])
+        treat_all = [(prevalence - (1 - prevalence) * (pt / (1 - pt))) for pt in threshold_range]
+        plt.plot(threshold_range, treat_all, 'k--', lw=2, alpha=0.5, label='Treat All')
+        plt.plot(threshold_range, [0] * len(threshold_range), 'gray', lw=2, alpha=0.5, label='Treat None')
+        plt.xlim([0, 1]); plt.xlabel('Threshold', fontsize=13); plt.ylabel('Net Benefit', fontsize=13)
+        plt.title('Decision Curve Analysis', fontsize=14, fontweight='bold')
+        plt.legend(loc="upper right", fontsize=11); plt.grid(True, alpha=0.3); plt.tight_layout()
+        plt.savefig(os.path.join(result_folder, 'dca_curve_retained_models.pdf'), format='pdf', bbox_inches='tight')
+        plt.savefig(os.path.join(result_folder, 'dca_curve_retained_models.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # ======== External Validation ========
+        if val_file is not None and final_model_name:
+            progress(0.88, desc="外部验证...")
+            log(f"\n{'=' * 70}")
+            log("外部验证集评估")
+
+            ext_data = pd.read_csv(val_file.name)
+            X_ext = ext_data.iloc[:, 2:]
+            y_ext = ext_data.iloc[:, 0]
+            log(f"验证集: {X_ext.shape[0]} 样本, {X_ext.shape[1]} 特征")
+
+            X_ext_sel = X_ext[final_model_info['features']]
+            X_train_f = X[final_model_info['features']]
+            cfg = models_config[final_model_name]
+
+            final_m = deepcopy(cfg['model'])
+            bp = best_params_dict[final_model_name]
+            if isinstance(bp, dict) and bp:
+                final_m.set_params(**bp)
+            final_m.fit(X_train_f.values, y)
+
+            y_ext_probs = final_m.predict_proba(X_ext_sel.values)[:, 1]
+            y_ext_pred = (y_ext_probs > 0.5).astype(int)
+
+            tn, fp, fn, tp = confusion_matrix(y_ext, y_ext_pred).ravel()
+            sens = tp / (tp + fn) if (tp + fn) > 0 else 0
+            spec = tn / (tn + fp) if (tn + fp) > 0 else 0
+            acc = (tp + tn) / (tp + tn + fp + fn)
+            prec = tp / (tp + fp) if (tp + fp) > 0 else 0
+            f1 = 2 * prec * sens / (prec + sens) if (prec + sens) > 0 else 0
+            ext_auc = roc_auc_score(y_ext, y_ext_probs)
+
+            log(f"  AUC={ext_auc:.4f}, Acc={acc:.4f}, Sens={sens:.4f}, Spec={spec:.4f}, F1={f1:.4f}")
+
+            # External ROC
+            fpr_e, tpr_e, _ = roc_curve(y_ext, y_ext_probs)
+            plt.figure(figsize=(10, 8))
+            plt.plot(fpr_e, tpr_e, 'b', lw=2.5, label=f'{final_model_name} (AUC={ext_auc:.3f})')
+            plt.plot([0, 1], [0, 1], '--', color='gray', alpha=0.5)
+            plt.xlabel('FPR'); plt.ylabel('TPR')
+            plt.title(f'ROC - External Validation ({final_model_name})', fontweight='bold')
+            plt.legend(loc="lower right"); plt.grid(True, alpha=0.3); plt.tight_layout()
+            plt.savefig(os.path.join(result_folder, 'roc_external_validation.pdf'), format='pdf', bbox_inches='tight')
+            plt.savefig(os.path.join(result_folder, 'roc_external_validation.png'), format='png', bbox_inches='tight', dpi=150)
+            plt.close()
+
+            # External CM
+            cm_ext = confusion_matrix(y_ext, y_ext_pred)
+            plt.figure(figsize=(8, 6))
+            sns.heatmap(cm_ext, annot=True, fmt='d', cmap='Blues', cbar=False,
+                        xticklabels=['Neg', 'Pos'], yticklabels=['Neg', 'Pos'])
+            plt.xlabel('Predicted'); plt.ylabel('True')
+            plt.title(f'Confusion Matrix - External ({final_model_name})', fontweight='bold')
+            plt.tight_layout()
+            plt.savefig(os.path.join(result_folder, 'cm_external_validation.pdf'), format='pdf', bbox_inches='tight')
+            plt.savefig(os.path.join(result_folder, 'cm_external_validation.png'), format='png', bbox_inches='tight', dpi=150)
+            plt.close()
+
+            # External PR
+            pr_e, re_e, _ = precision_recall_curve(y_ext, y_ext_probs)
+            plt.figure(figsize=(10, 8))
+            plt.plot(re_e, pr_e, 'b', lw=2.5, label=final_model_name)
+            plt.xlabel('Recall'); plt.ylabel('Precision')
+            plt.title(f'PR Curve - External ({final_model_name})', fontweight='bold')
+            plt.legend(); plt.grid(True, alpha=0.3); plt.tight_layout()
+            plt.savefig(os.path.join(result_folder, 'pr_external_validation.pdf'), format='pdf', bbox_inches='tight')
+            plt.savefig(os.path.join(result_folder, 'pr_external_validation.png'), format='png', bbox_inches='tight', dpi=150)
+            plt.close()
+
+            # External DCA
+            opt_thr_e, _, _ = find_optimal_threshold(y_ext, y_ext_probs, method='youden')
+            nbs_ext = [calculate_net_benefit(y_ext, y_ext_probs, t) for t in threshold_range]
+            prev_e = np.mean(y_ext)
+            ta_e = [(prev_e - (1 - prev_e) * (pt / (1 - pt))) for pt in threshold_range]
+            plt.figure(figsize=(10, 8))
+            plt.plot(threshold_range, nbs_ext, 'b', lw=2.5, label=final_model_name)
+            plt.plot(threshold_range, ta_e, 'k--', lw=2, alpha=0.5, label='Treat All')
+            plt.plot(threshold_range, [0]*len(threshold_range), 'gray', lw=2, alpha=0.5, label='Treat None')
+            plt.xlabel('Threshold'); plt.ylabel('Net Benefit')
+            plt.title(f'DCA - External ({final_model_name})', fontweight='bold')
+            plt.legend(loc="upper right"); plt.grid(True, alpha=0.3); plt.tight_layout()
+            plt.savefig(os.path.join(result_folder, 'dca_external_validation.pdf'), format='pdf', bbox_inches='tight')
+            plt.savefig(os.path.join(result_folder, 'dca_external_validation.png'), format='png', bbox_inches='tight', dpi=150)
+            plt.close()
+
+            # Save external validation Excel
+            with pd.ExcelWriter(os.path.join(result_folder, 'external_validation_results.xlsx'), engine='openpyxl') as writer:
+                pd.DataFrame([{
+                    'Model': final_model_name, 'N_Features': final_model_info['n_features'],
+                    'AUC': ext_auc, 'Accuracy': acc, 'Sensitivity': sens,
+                    'Specificity': spec, 'Precision': prec, 'F1 Score': f1
+                }]).to_excel(writer, sheet_name='Metrics', index=False)
+                pd.DataFrame({'Feature': final_model_info['features']}).to_excel(writer, sheet_name='Features', index=False)
+                pd.DataFrame({'True': y_ext, 'Predicted': y_ext_pred, 'Probability': y_ext_probs}).to_excel(writer, sheet_name='Predictions', index=False)
+
+        # ======== Save Excel Results ========
+        progress(0.92, desc="保存结果到Excel...")
+
+        # Model evaluation Excel
+        with pd.ExcelWriter(os.path.join(result_folder, 'model_evaluation_results.xlsx'), engine='openpyxl') as writer:
+            for mn, res in all_model_results.items():
+                res['results_df'].to_excel(writer, sheet_name=mn, index=False)
+            summary_data = []
+            for mn, res in all_model_results.items():
+                row = res['results_df'].iloc[-1].to_dict()
+                row['Model'] = mn
+                row['Retained'] = 'Yes' if mn in retained_models else 'No'
+                row['Is_Final'] = 'Yes' if mn == final_model_name else 'No'
+                summary_data.append(row)
+            summary_df = pd.DataFrame(summary_data)
+            cols = ['Model', 'Retained', 'Is_Final'] + [c for c in summary_df.columns if c not in ['Model', 'Fold', 'Retained', 'Is_Final']]
+            summary_df[cols].sort_values('AUC', ascending=False).to_excel(writer, sheet_name='Summary', index=False)
+            if len(delong_df) > 0:
+                delong_df.to_excel(writer, sheet_name='DeLong_Test', index=False)
+
+        # Feature ablation Excel
+        with pd.ExcelWriter(os.path.join(result_folder, 'feature_ablation_results.xlsx'), engine='openpyxl') as writer:
+            for mn, ar in ablation_results.items():
+                abl_df = pd.DataFrame({'Feature_Count': ar['feature_counts'], 'AUC': ar['auc_scores']})
+                abl_df.to_excel(writer, sheet_name=mn, index=False)
+                if 'delong_results' in ar:
+                    ar['delong_results'].to_excel(writer, sheet_name=f'{mn}_DeLong', index=False)
+            for mn, imp_df in shap_feature_importance.items():
+                imp_df.to_excel(writer, sheet_name=f'{mn}_Importance', index=False)
+
+        # Save best params txt
+        with open(os.path.join(result_folder, 'best_parameters.txt'), 'w', encoding='utf-8') as f:
+            f.write("=" * 70 + "\n")
+            f.write("各模型最佳超参数\n")
+            f.write("=" * 70 + "\n\n")
+            for mn in models_config.keys():
+                f.write(f"\n模型: {mn}\n")
+                params = best_params_dict[mn]
+                if isinstance(params, dict):
+                    for k, v in params.items():
+                        f.write(f"  {k}: {v}\n")
+                else:
+                    f.write(f"  {params}\n")
+                f.write(f"  AUC: {all_model_results[mn]['mean_auc']:.4f}\n")
+                f.write(f"  保留: {'是' if mn in retained_models else '否'}\n")
+            if final_model_name:
+                f.write(f"\n\n最终模型: {final_model_name}\n")
+                f.write(f"特征数: {final_model_info['n_features']}\n")
+                f.write(f"特征: {', '.join(final_model_info['features'])}\n")
+
+        # Save final model pickle
+        if final_model_name:
+            pickle.dump({
+                'model_name': final_model_name,
+                'model': trained_models[final_model_name]['model'],
+                'best_params': best_params_dict[final_model_name],
+                'optimal_features': final_model_info['features'],
+                'n_features': final_model_info['n_features'],
+                'train_auc': final_model_info['auc'],
+                'optimal_threshold': all_model_results[final_model_name]['optimal_threshold']
+            }, open(os.path.join(result_folder, f'final_model_{final_model_name}.pkl'), 'wb'))
+
+        # ======== Create ZIP ========
+        progress(0.96, desc="打包为ZIP...")
+        zip_path = os.path.join(tempfile.gettempdir(), "ml_results.zip")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for root, dirs, files in os.walk(result_folder):
+                for file in files:
+                    filepath = os.path.join(root, file)
+                    arcname = os.path.relpath(filepath, result_folder)
+                    zf.write(filepath, arcname)
+
+        n_files = len([f for _, _, files in os.walk(result_folder) for f in files])
+        log(f"\n{'=' * 70}")
+        log(f"✅ 分析完成! 共生成 {n_files} 个文件")
+        log(f"{'=' * 70}")
+
+        progress(1.0, desc="完成!")
+        return zip_path, "\n".join(log_lines)
+
+    except Exception as e:
+        log(f"\n❌ 运行出错: {str(e)}")
+        log(traceback.format_exc())
+        return None, "\n".join(log_lines)
+
+
+# ============================================================================
+# Gradio Interface
+# ============================================================================
+
+DESCRIPTION = """
+# 🧬 ML 二分类模型训练与评估平台
+
+上传训练集和验证集 CSV 文件，自动完成以下分析流程：
+
+**📊 分析内容：** 8种机器学习模型训练 → 交叉验证 → DeLong检验筛选 → SHAP特征重要性 → 特征消融 → 外部验证
+
+**📁 数据格式要求：** CSV文件，第1列为标签(0/1)，第2列任意(如ID)，第3列起为特征
+
+**⬇️ 输出：** 所有结果打包为ZIP下载（含PDF图表 + PNG图表 + Excel数据 + 模型文件）
+"""
+
+with gr.Blocks(
+    title="ML Binary Classification Pipeline",
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="slate",
+    ),
+    css="""
+    .main-header { text-align: center; margin-bottom: 1rem; }
+    .model-selector label { font-weight: 600; }
+    footer { display: none !important; }
+    """
+) as demo:
+
+    gr.Markdown(DESCRIPTION)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📂 数据上传")
+            train_file = gr.File(label="训练集 CSV（必需）", file_types=[".csv"])
+            val_file = gr.File(label="验证集 CSV（可选）", file_types=[".csv"])
+
+            gr.Markdown("### 🤖 模型选择")
+            model_selector = gr.CheckboxGroup(
+                choices=ALL_MODELS,
+                value=ALL_MODELS,
+                label="选择要运行的模型（可多选）",
+                info="默认全选8个模型，可取消不需要的"
+            )
+
+            gr.Markdown("### ⚙️ 参数设置")
+            enable_tuning = gr.Checkbox(value=True, label="启用超参数调优 (GridSearchCV)")
+            with gr.Row():
+                cv_folds = gr.Slider(minimum=3, maximum=10, value=5, step=1, label="交叉验证折数")
+                alpha = gr.Slider(minimum=0.01, maximum=0.10, value=0.05, step=0.01, label="DeLong显著性水平 α")
+            with gr.Row():
+                top_n = gr.Slider(minimum=5, maximum=50, value=20, step=1, label="SHAP前N个特征")
+                shap_samples = gr.Slider(minimum=30, maximum=200, value=80, step=10, label="SHAP采样数量")
+
+            run_btn = gr.Button("🚀 开始运行", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### 📋 运行日志")
+            log_output = gr.Textbox(label="实时日志", lines=25, max_lines=50, interactive=False)
+
+            gr.Markdown("### ⬇️ 结果下载")
+            zip_output = gr.File(label="下载结果 ZIP")
+
+    # Quick-select buttons
+    with gr.Row():
+        gr.Markdown("""
+        **💡 快捷模型组合：**
+        点击下方按钮快速选择常用组合
+        """)
+
+    with gr.Row():
+        btn_all = gr.Button("全选", size="sm")
+        btn_tree = gr.Button("树模型 (RF+DT+XGB+AdaBoost)", size="sm")
+        btn_linear = gr.Button("线性模型 (LR+SVM+NB)", size="sm")
+        btn_top4 = gr.Button("经典四模型 (RF+XGB+LR+SVM)", size="sm")
+
+    btn_all.click(lambda: ALL_MODELS, 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)
+
+    # Run
+    run_btn.click(
+        fn=run_pipeline,
+        inputs=[train_file, val_file, model_selector, enable_tuning, cv_folds, alpha, top_n, shap_samples],
+        outputs=[zip_output, log_output],
+        show_progress="full"
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,10 @@
+numpy>=1.24.0
+pandas>=2.0.0
+matplotlib>=3.7.0
+scikit-learn>=1.3.0
+xgboost>=2.0.0
+seaborn>=0.12.0
+scipy>=1.11.0
+shap>=0.43.0
+openpyxl>=3.1.0
+gradio>=4.0.0