Update app.py

app.py

@@ -431,54 +431,254 @@ def run_pipeline(
         log(f"\n{'━'*50}")
         log(f"  ✅ {nm} 个模型训练完成")
 
-        # ── ROC Curves ──
-        progress(0.42, desc="📈 ROC曲线...")
-        log(f"\n  📈 绘制图表...")
+        # ============================================================
+        # ── 辅助函数：Macro ROC / PR 曲线数据 ──
+        # ============================================================
+        def _macro_roc_curve(yt, yp, nc, cls_idx):
+            """Return (all_fpr, mean_tpr, macro_auc) for overlay plotting."""
+            y_b = label_binarize(yt, classes=cls_idx)
+            if nc == 2:
+                y_b = np.hstack([1 - y_b, y_b])
+            all_fpr = np.linspace(0, 1, 300)
+            mean_tpr = np.zeros_like(all_fpr)
+            for c in range(nc):
+                f_, t_, _ = roc_curve(y_b[:, c], yp[:, c])
+                mean_tpr += np.interp(all_fpr, f_, t_)
+            mean_tpr /= nc; mean_tpr[-1] = 1.0
+            return all_fpr, mean_tpr, auc_score(all_fpr, mean_tpr)
+
+        def _macro_pr_curve(yt, yp, nc, cls_idx):
+            y_b = label_binarize(yt, classes=cls_idx)
+            if nc == 2:
+                y_b = np.hstack([1 - y_b, y_b])
+            all_rec = np.linspace(0, 1, 300)
+            mean_prec = np.zeros_like(all_rec)
+            for c in range(nc):
+                prec_, rec_, _ = precision_recall_curve(y_b[:, c], yp[:, c])
+                mean_prec += np.interp(all_rec[::-1], rec_[::-1], prec_[::-1])[::-1]
+            mean_prec /= nc
+            return all_rec, mean_prec
+
+        # ============================================================
+        # ── 训练集 ROC / PR（所有模型，in-sample）──
+        # ============================================================
+        progress(0.40, desc="📈 训练集ROC/PR曲线...")
+        log(f"\n  📈 绘制各模型训练集 ROC / PR 曲线...")
+
+        train_roc_summary = {}   # mn -> train macro_auc
+        train_roc_data = {}      # mn -> (fpr, tpr, auc)
+        train_pr_data = {}       # mn -> (rec, prec)
+
+        for mn in mnames:
+            yproba_tr = tms[mn].predict_proba(X.values)
+
+            # 每个模型：各类 + macro 的独立 ROC / PR 图
+            plot_multiclass_roc(
+                y_mapped.values, yproba_tr, class_indices,
+                f'Train ROC — {mn} ({task_type})', f'train_roc_{mn}', rf
+            )
+            plot_multiclass_pr(
+                y_mapped.values, yproba_tr, class_indices,
+                f'Train PR — {mn} ({task_type})', f'train_pr_{mn}', rf
+            )
+
+            fpr_tr, tpr_tr, auc_tr = _macro_roc_curve(
+                y_mapped.values, yproba_tr, n_classes, class_indices)
+            rec_tr, prec_tr = _macro_pr_curve(
+                y_mapped.values, yproba_tr, n_classes, class_indices)
+
+            train_roc_data[mn] = (fpr_tr, tpr_tr, auc_tr)
+            train_pr_data[mn]  = (rec_tr, prec_tr)
+            train_roc_summary[mn] = auc_tr
+
+        # 汇总训练集 ROC（所有模型叠加）
+        plt.figure(figsize=(10, 8))
+        for i, mn in enumerate(mnames):
+            fpr_tr, tpr_tr, auc_tr = train_roc_data[mn]
+            plt.plot(fpr_tr, tpr_tr, color=COLORS[i % 8], lw=2.5,
+                     label=f'{mn} (Train Macro AUC={auc_tr:.3f})')
+        plt.plot([0, 1], [0, 1], '--', color='#ccc', lw=1)
+        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(f'Train ROC — All Models ({task_type})', fontsize=14, fontweight='bold')
+        plt.legend(loc='lower right', fontsize=10)
+        plt.grid(True, alpha=0.15); plt.tight_layout()
+        plt.savefig(os.path.join(rf, 'train_roc_all.pdf'), format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(rf, 'train_roc_all.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # 汇总训练集 PR（所有模型叠加）
+        plt.figure(figsize=(10, 8))
+        for i, mn in enumerate(mnames):
+            rec_tr, prec_tr = train_pr_data[mn]
+            plt.plot(rec_tr, prec_tr, color=COLORS[i % 8], lw=2.5,
+                     label=f'{mn} (Mean AP={prec_tr.mean():.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(f'Train PR — All Models ({task_type})', fontsize=14, fontweight='bold')
+        plt.legend(loc='lower left', fontsize=10)
+        plt.grid(True, alpha=0.15); plt.tight_layout()
+        plt.savefig(os.path.join(rf, 'train_pr_all.pdf'), format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(rf, 'train_pr_all.png'), format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+        log(f"     ✅ 训练集 ROC/PR 曲线已生成（各模型独立 + 汇总共 {nm*2+2*2} 张图）")
+
+        # ============================================================
+        # ── 交叉验证 ROC（原有逻辑，保留）──
+        # ============================================================
+        progress(0.42, desc="📈 交叉验证ROC曲线...")
+        log(f"\n  📈 绘制交叉验证 ROC 曲线...")
         for mn in mnames:
             r = amr[mn]
             plot_multiclass_roc(r['all_yt'], r['all_yproba'], class_indices,
-                f'ROC — {mn} ({task_type}, Macro AUC={r["mean_auc"]:.3f})', f'roc_{mn}', rf)
+                f'CV ROC — {mn} ({task_type}, Macro AUC={r["mean_auc"]:.3f})', f'roc_{mn}', rf)
 
-        # Combined ROC (macro per model)
+        # 汇总 CV ROC（所有模型）
         plt.figure(figsize=(10, 8))
         for i, mn in enumerate(mnames):
             r = amr[mn]
-            y_bin = label_binarize(r['all_yt'], classes=class_indices)
-            if n_classes == 2: y_bin = np.hstack([1 - y_bin, y_bin])
-            all_fpr = np.linspace(0, 1, 200); mean_tpr = np.zeros_like(all_fpr)
-            for c in range(n_classes):
-                f, t, _ = roc_curve(y_bin[:, c], r['all_yproba'][:, c])
-                mean_tpr += np.interp(all_fpr, f, t)
-            mean_tpr /= n_classes; mean_tpr[-1] = 1.0
-            ma = auc_score(all_fpr, mean_tpr)
-            plt.plot(all_fpr, mean_tpr, color=COLORS[i%8], lw=2.5, label=f'{mn} (Macro AUC={ma:.3f})')
-        plt.plot([0,1],[0,1],'--',color='#ccc',lw=1)
-        plt.xlim([-0.02,1.02]); plt.ylim([-0.02,1.02])
-        plt.xlabel('FPR',fontsize=13); plt.ylabel('TPR',fontsize=13)
-        plt.title(f'ROC — All Models ({task_type})',fontsize=14,fontweight='bold')
-        plt.legend(loc='lower right',fontsize=10); plt.grid(True,alpha=0.15); 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)
+            fpr_cv, tpr_cv, auc_cv = _macro_roc_curve(
+                r['all_yt'], r['all_yproba'], n_classes, class_indices)
+            plt.plot(fpr_cv, tpr_cv, color=COLORS[i % 8], lw=2.5,
+                     label=f'{mn} (CV Macro AUC={auc_cv:.3f})')
+        plt.plot([0, 1], [0, 1], '--', color='#ccc', lw=1)
+        plt.xlim([-0.02, 1.02]); plt.ylim([-0.02, 1.02])
+        plt.xlabel('FPR', fontsize=13); plt.ylabel('TPR', fontsize=13)
+        plt.title(f'CV ROC — All Models ({task_type})', fontsize=14, fontweight='bold')
+        plt.legend(loc='lower right', fontsize=10)
+        plt.grid(True, alpha=0.15); 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 Curves ──
-        progress(0.48, desc="📈 PR曲线...")
+        # ============================================================
+        # ── 最佳模型：训练集 vs 内部验证集（CV holdout）对比 ──
+        # ============================================================
+        progress(0.44, desc="📊 最终模型训练集vs内部验证集对比...")
+
+        # 先确定最佳模型（后续 Bootstrap 也会用到，此处提前计算）
+        best_mn = max(amr, key=lambda x: amr[x]['mean_auc'])
+        best_auc = amr[best_mn]['mean_auc']
+
+        log(f"\n  📊 最终模型 [{best_mn}] 训练集 vs 内部验证集（CV holdout）对比...")
+
+        # 训练集预测
+        yproba_best_train = tms[best_mn].predict_proba(X.values)
+        ypred_best_train  = tms[best_mn].predict(X.values)
+        metrics_train = compute_multiclass_metrics(
+            y_mapped.values, ypred_best_train, yproba_best_train, class_indices
+        )
+
+        # CV holdout（已在 amr 中累积）
+        yproba_best_cv = amr[best_mn]['all_yproba']
+        ypred_best_cv  = amr[best_mn]['all_yp']
+        ytrue_best_cv  = amr[best_mn]['all_yt']
+        metrics_cv = compute_multiclass_metrics(
+            ytrue_best_cv, ypred_best_cv, yproba_best_cv, class_indices
+        )
+
+        log(f"     Train  → AUC={metrics_train['Macro_AUC']:.4f}  Acc={metrics_train['Accuracy']:.4f}"
+            f"  F1={metrics_train['Macro_F1']:.4f}  Kappa={metrics_train['Kappa']:.4f}")
+        log(f"     CV-Val → AUC={metrics_cv['Macro_AUC']:.4f}  Acc={metrics_cv['Accuracy']:.4f}"
+            f"  F1={metrics_cv['Macro_F1']:.4f}  Kappa={metrics_cv['Kappa']:.4f}")
+
+        # 对比 ROC
+        fpr_tr_b, tpr_tr_b, auc_tr_b = _macro_roc_curve(
+            y_mapped.values, yproba_best_train, n_classes, class_indices)
+        fpr_cv_b, tpr_cv_b, auc_cv_b = _macro_roc_curve(
+            ytrue_best_cv, yproba_best_cv, n_classes, class_indices)
+
+        fig, ax = plt.subplots(figsize=(10, 8))
+        ax.plot(fpr_tr_b, tpr_tr_b, color='#e41a1c', lw=2.5,
+                label=f'Train set (Macro AUC={auc_tr_b:.3f})')
+        ax.plot(fpr_cv_b, tpr_cv_b, color='#377eb8', lw=2.5, linestyle='--',
+                label=f'Internal CV (Macro AUC={auc_cv_b:.3f})')
+        ax.plot([0, 1], [0, 1], '--', color='#ccc', lw=1)
+        ax.set_xlim([-0.02, 1.02]); ax.set_ylim([-0.02, 1.02])
+        ax.set_xlabel('False Positive Rate', fontsize=13)
+        ax.set_ylabel('True Positive Rate', fontsize=13)
+        ax.set_title(f'ROC — {best_mn}: Train vs Internal CV ({task_type})',
+                     fontsize=14, fontweight='bold')
+        ax.legend(loc='lower right', fontsize=11)
+        ax.grid(True, alpha=0.15); plt.tight_layout()
+        plt.savefig(os.path.join(rf, f'roc_train_vs_cv_{best_mn}.pdf'),
+                    format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(rf, f'roc_train_vs_cv_{best_mn}.png'),
+                    format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # 对比 PR
+        rec_tr_b, prec_tr_b = _macro_pr_curve(
+            y_mapped.values, yproba_best_train, n_classes, class_indices)
+        rec_cv_b, prec_cv_b = _macro_pr_curve(
+            ytrue_best_cv, yproba_best_cv, n_classes, class_indices)
+
+        fig, ax = plt.subplots(figsize=(10, 8))
+        ax.plot(rec_tr_b, prec_tr_b, color='#e41a1c', lw=2.5,
+                label=f'Train set (Mean AP={prec_tr_b.mean():.3f})')
+        ax.plot(rec_cv_b, prec_cv_b, color='#377eb8', lw=2.5, linestyle='--',
+                label=f'Internal CV (Mean AP={prec_cv_b.mean():.3f})')
+        ax.set_xlim([-0.02, 1.02]); ax.set_ylim([-0.02, 1.02])
+        ax.set_xlabel('Recall', fontsize=13)
+        ax.set_ylabel('Precision', fontsize=13)
+        ax.set_title(f'PR — {best_mn}: Train vs Internal CV ({task_type})',
+                     fontsize=14, fontweight='bold')
+        ax.legend(loc='lower left', fontsize=11)
+        ax.grid(True, alpha=0.15); plt.tight_layout()
+        plt.savefig(os.path.join(rf, f'pr_train_vs_cv_{best_mn}.pdf'),
+                    format='pdf', bbox_inches='tight', dpi=300)
+        plt.savefig(os.path.join(rf, f'pr_train_vs_cv_{best_mn}.png'),
+                    format='png', bbox_inches='tight', dpi=150)
+        plt.close()
+
+        # 训练集混淆矩阵（最佳模型）
+        plot_confusion_matrix(
+            y_mapped.values, ypred_best_train, class_indices,
+            f'Train CM — {best_mn} (Acc={metrics_train["Accuracy"]:.3f})',
+            f'cm_train_{best_mn}', rf
+        )
+
+        # 保存 Train vs CV 汇总 Excel
+        with pd.ExcelWriter(os.path.join(rf, f'train_vs_cv_{best_mn}.xlsx'),
+                            engine='openpyxl') as w:
+            summary_rows = [
+                {'Split': 'Train', 'Model': best_mn,
+                 'Macro_AUC': metrics_train['Macro_AUC'],
+                 'Accuracy':  metrics_train['Accuracy'],
+                 'Macro_F1':  metrics_train['Macro_F1'],
+                 'Weighted_F1': metrics_train['Weighted_F1'],
+                 'Kappa':     metrics_train['Kappa']},
+                {'Split': 'Internal_CV', 'Model': best_mn,
+                 'Macro_AUC': metrics_cv['Macro_AUC'],
+                 'Accuracy':  metrics_cv['Accuracy'],
+                 'Macro_F1':  metrics_cv['Macro_F1'],
+                 'Weighted_F1': metrics_cv['Weighted_F1'],
+                 'Kappa':     metrics_cv['Kappa']},
+            ]
+            pd.DataFrame(summary_rows).to_excel(w, sheet_name='Summary', index=False)
+            pd.DataFrame(metrics_train['report']).T.to_excel(w, sheet_name='Train_PerClass', index=True)
+            pd.DataFrame(metrics_cv['report']).T.to_excel(w,    sheet_name='CV_PerClass',    index=True)
+            amr[best_mn]['fold_df'].to_excel(w, sheet_name='CV_FoldDetail', index=False)
+
+        log(f"     ✅ Train vs CV 对比图及数据已保存 → train_vs_cv_{best_mn}.xlsx")
+
+        # ── PR Curves (CV，原有逻辑) ──
+        progress(0.48, desc="📈 交叉验证PR曲线...")
         for mn in mnames:
             r = amr[mn]
             plot_multiclass_pr(r['all_yt'], r['all_yproba'], class_indices,
-                f'PR — {mn} ({task_type})', f'pr_{mn}', rf)
+                f'CV PR — {mn} ({task_type})', f'pr_{mn}', rf)
 
-        # ── Confusion Matrices ──
+        # ── Confusion Matrices (CV) ──
         progress(0.52, desc="📊 混淆矩阵...")
         for mn in mnames:
             r = amr[mn]
             plot_confusion_matrix(r['all_yt'], r['all_yp'], class_indices,
-                f'CM — {mn} (Acc={r["mean_acc"]:.3f})', f'cm_{mn}', rf)
+                f'CV CM — {mn} (Acc={r["mean_acc"]:.3f})', f'cm_{mn}', rf)
 
-        # ── Bootstrap AUC Test (模型统计检验) ──
+        # ── Bootstrap AUC Test ──
         progress(0.55, desc="🔬 Bootstrap AUC 检验...")
-        best_mn = max(amr, key=lambda x: amr[x]['mean_auc'])
-        best_auc = amr[best_mn]['mean_auc']
         log(f"\n  🏆 最佳模型: {best_mn} (Macro AUC={best_auc:.4f})")
         log(f"  🔬 Bootstrap 检验 (n=2000, α=0.05)...")
 
@@ -517,7 +717,6 @@ def run_pipeline(
         progress(0.62, desc="🔥 SHAP分析...")
         log(f"\n  🔥 SHAP特征分析 (保留模型中 Top 3)...")
         shap_imp = {}
-        # SHAP for top 3 retained models
         models_for_shap = sorted(retained, key=lambda x: amr[x]['mean_auc'], reverse=True)[:3]
 
         for si, mn in enumerate(models_for_shap):
@@ -534,12 +733,10 @@ def run_pipeline(
                     exp = shap.KernelExplainer(lambda x, m=mo: m.predict_proba(x), bg)
                     sv = exp.shap_values(Xs)
 
-                # Handle SHAP output: could be list of arrays (one per class) or 3D array
                 if isinstance(sv, list):
-                    # Average absolute SHAP across all classes
                     sv_abs = np.mean([np.abs(s) for s in sv], axis=0)
                 elif sv.ndim == 3:
-                    sv_abs = np.mean(np.abs(sv), axis=2)  # (samples, features)
+                    sv_abs = np.mean(np.abs(sv), axis=2)
                 else:
                     sv_abs = np.abs(sv)
 
@@ -550,7 +747,6 @@ def run_pipeline(
                 idf = pd.DataFrame({'Feature': fnames, 'Importance': fi}).sort_values('Importance', ascending=False)
                 shap_imp[mn] = idf
 
-                # Bar plot (works for any number of classes)
                 plt.figure(figsize=(10, max(6, TOPN * 0.3)))
                 top_df = idf.head(TOPN).iloc[::-1]
                 plt.barh(top_df['Feature'], top_df['Importance'], color='#2563eb', alpha=0.8)
@@ -564,7 +760,7 @@ def run_pipeline(
             except Exception as e:
                 log(f"     ⚠ {mn} SHAP失败: {e}")
 
-        # ── Feature Ablation (for best model only) ──
+        # ── Feature Ablation ──
         progress(0.72, desc="🧪 特征消融...")
         log(f"\n  🧪 特征消融 (仅最佳模型 {best_mn})...")
         ablation_data = None
@@ -572,7 +768,6 @@ def run_pipeline(
             imp_df = shap_imp[best_mn]
             top_feats = imp_df.head(TOPN)['Feature'].tolist()
             fcs = []; aucs_a = []
-            scoring = 'roc_auc_ovr' if n_classes > 2 else 'roc_auc'
 
             for nf in range(1, len(top_feats) + 1):
                 Xsub = X[top_feats[:nf]]
@@ -593,23 +788,25 @@ def run_pipeline(
                     fold_aucs.append(a)
                 fcs.append(nf); aucs_a.append(np.mean(fold_aucs))
 
-            # Find optimal: first N where AUC >= 95% of full AUC
             full_auc = amr[best_mn]['mean_auc']
             opt_n = len(top_feats)
             for i, a in enumerate(aucs_a):
                 if a >= full_auc * 0.95:
                     opt_n = i + 1; break
 
-            ablation_data = {'fcs': fcs, 'aucs': aucs_a, 'feats': top_feats, 'opt_n': opt_n, 'opt_feats': top_feats[:opt_n]}
+            ablation_data = {'fcs': fcs, 'aucs': aucs_a, 'feats': top_feats,
+                             'opt_n': opt_n, 'opt_feats': top_feats[:opt_n]}
             log(f"     ✅ 最优特征数: {opt_n} (AUC={aucs_a[opt_n-1]:.4f} vs Full={full_auc:.4f})")
 
-            # Plot
             plt.figure(figsize=(10, 7))
             plt.plot(fcs, aucs_a, 'o-', color='#2563eb', lw=2, ms=5)
-            plt.scatter([opt_n], [aucs_a[opt_n-1]], s=200, marker='*', color='#ef4444', edgecolors='black', lw=2, zorder=5)
-            plt.axhline(y=full_auc, color='gray', ls='--', lw=1, alpha=0.5, label=f'Full AUC={full_auc:.3f}')
+            plt.scatter([opt_n], [aucs_a[opt_n-1]], s=200, marker='*',
+                        color='#ef4444', edgecolors='black', lw=2, zorder=5)
+            plt.axhline(y=full_auc, color='gray', ls='--', lw=1, alpha=0.5,
+                        label=f'Full AUC={full_auc:.3f}')
             plt.xlabel('Number of Features', fontsize=13); plt.ylabel('Macro AUC', fontsize=13)
-            plt.title(f'Feature Ablation — {best_mn} (★ Optimal={opt_n})', fontsize=14, fontweight='bold')
+            plt.title(f'Feature Ablation — {best_mn} (★ Optimal={opt_n})',
+                      fontsize=14, fontweight='bold')
             plt.legend(fontsize=11); plt.grid(True, alpha=0.15); 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)
@@ -631,7 +828,6 @@ def run_pipeline(
                 vcol2_is_id = (vcol2.dtype == 'object') or (vcol2.nunique() / len(vcol2) > 0.5)
                 Xe = ed.iloc[:, 2:] if vcol2_is_id else ed.iloc[:, 1:]
 
-                # Map validation labels using same mapping
                 ye = ye_raw.map(label_map)
                 if ye.isna().any():
                     log(f"     ⚠ 验证集 {vi} 含有训练集中不存在的标签，已跳过")
@@ -648,22 +844,25 @@ def run_pipeline(
                 ye_np = ye.values
 
                 metrics = compute_multiclass_metrics(ye_np, yed, yep, class_indices)
-                log(f"     ✅ AUC={metrics['Macro_AUC']:.4f}  Acc={metrics['Accuracy']:.4f}  F1={metrics['Macro_F1']:.4f}  Kappa={metrics['Kappa']:.4f}")
+                log(f"     ✅ AUC={metrics['Macro_AUC']:.4f}  Acc={metrics['Accuracy']:.4f}"
+                    f"  F1={metrics['Macro_F1']:.4f}  Kappa={metrics['Kappa']:.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'
 
-                plot_multiclass_roc(ye_np, yep, class_indices, f'ROC — {tag} ({best_mn})', f'roc{sfx}', rf)
-                plot_multiclass_pr(ye_np, yep, class_indices, f'PR — {tag} ({best_mn})', f'pr{sfx}', rf)
-                plot_confusion_matrix(ye_np, yed, class_indices, f'CM — {tag} ({best_mn})', f'cm{sfx}', rf)
+                plot_multiclass_roc(ye_np, yep, class_indices,
+                    f'ROC — {tag} ({best_mn})', f'roc{sfx}', rf)
+                plot_multiclass_pr(ye_np, yep, class_indices,
+                    f'PR — {tag} ({best_mn})', f'pr{sfx}', rf)
+                plot_confusion_matrix(ye_np, yed, class_indices,
+                    f'CM — {tag} ({best_mn})', f'cm{sfx}', rf)
 
                 with pd.ExcelWriter(os.path.join(rf, f'validation{sfx}.xlsx'), engine='openpyxl') as w:
                     pd.DataFrame([{'Model': best_mn, 'N_Features': len(final_feats),
                         'Macro_AUC': metrics['Macro_AUC'], 'Accuracy': metrics['Accuracy'],
                         'Macro_F1': metrics['Macro_F1'], 'Weighted_F1': metrics['Weighted_F1'],
                         'Kappa': metrics['Kappa']}]).to_excel(w, sheet_name='Metrics', index=False)
-                    rpt = pd.DataFrame(metrics['report']).T
-                    rpt.to_excel(w, sheet_name='Per_Class', index=True)
+                    pd.DataFrame(metrics['report']).T.to_excel(w, sheet_name='Per_Class', index=True)
                     pd.DataFrame({'Feature': final_feats}).to_excel(w, sheet_name='Features', index=False)
 
         # ── Save Results ──
@@ -673,27 +872,32 @@ def run_pipeline(
         with pd.ExcelWriter(os.path.join(rf, 'model_evaluation.xlsx'), engine='openpyxl') as w:
             for mn, r in amr.items():
                 r['fold_df'].to_excel(w, sheet_name=mn, index=False)
-            # Summary with retained status
-            sd = [{'Model': mn, 'Macro_AUC': r['mean_auc'], 'Accuracy': r['mean_acc'],
-                   'Macro_F1': r['mean_f1'], 'Retained': 'Yes' if mn in retained else 'No',
+            # Summary（新增 Train_AUC 列）
+            sd = [{'Model': mn,
+                   'CV_Macro_AUC': r['mean_auc'],
+                   'Train_Macro_AUC': train_roc_summary.get(mn, ''),
+                   'CV_Accuracy': r['mean_acc'],
+                   'CV_Macro_F1': r['mean_f1'],
+                   'Retained': 'Yes' if mn in retained else 'No',
                    'Best': 'Best' if mn == best_mn else ''}
                   for mn, r in amr.items()]
-            pd.DataFrame(sd).sort_values('Macro_AUC', ascending=False).to_excel(w, sheet_name='Summary', index=False)
-            # Bootstrap test results
+            pd.DataFrame(sd).sort_values('CV_Macro_AUC', ascending=False).to_excel(
+                w, sheet_name='Summary', index=False)
             if len(bootstrap_df) > 0:
                 bootstrap_df.to_excel(w, sheet_name='Bootstrap_Test', index=False)
-            # Per-class report for best model
-            best_report = classification_report(amr[best_mn]['all_yt'], amr[best_mn]['all_yp'],
-                                                labels=class_indices, output_dict=True, zero_division=0)
+            best_report = classification_report(
+                amr[best_mn]['all_yt'], amr[best_mn]['all_yp'],
+                labels=class_indices, output_dict=True, zero_division=0)
             pd.DataFrame(best_report).T.to_excel(w, sheet_name=f'{best_mn}_PerClass', index=True)
 
         if ablation_data:
             with pd.ExcelWriter(os.path.join(rf, 'feature_ablation.xlsx'), engine='openpyxl') as w:
-                pd.DataFrame({'N': ablation_data['fcs'], 'AUC': ablation_data['aucs']}).to_excel(w, sheet_name='Ablation', index=False)
+                pd.DataFrame({'N': ablation_data['fcs'], 'AUC': ablation_data['aucs']}).to_excel(
+                    w, sheet_name='Ablation', index=False)
                 for mn, idf in shap_imp.items():
                     idf.to_excel(w, sheet_name=f'{mn}_Imp', index=False)
 
-        # Save params (English for SCI)
+        # Save params
         with open(os.path.join(rf, 'best_params.txt'), 'w', encoding='utf-8') as f:
             f.write(f"Task: {task_type} Classification ({n_classes} classes)\n")
             f.write(f"Classes: {classes}\n")
@@ -702,7 +906,8 @@ def run_pipeline(
             f.write(f"Retained Models: {', '.join(retained)} ({len(retained)}/{nm})\n\n")
             for mn in mcfg:
                 status = "* Best" if mn == best_mn else ("Retained" if mn in retained else "Excluded")
-                f.write(f"Model: {mn}  |  AUC={amr[mn]['mean_auc']:.4f}  |  {status}\n")
+                f.write(f"Model: {mn}  |  CV_AUC={amr[mn]['mean_auc']:.4f}"
+                        f"  |  Train_AUC={train_roc_summary.get(mn, 'N/A')}  |  {status}\n")
                 bp = bpd[mn]
                 if isinstance(bp, dict):
                     for k, v in bp.items(): f.write(f"  {k}: {v}\n")
@@ -714,10 +919,23 @@ def run_pipeline(
                 f.write("=" * 50 + "\n")
                 for _, row in bootstrap_df.iterrows():
                     f.write(f"  {row['Model_A']} vs {row['Model_B']}: ")
-                    f.write(f"dAUC={row['AUC_Diff']:+.4f}  95%CI=[{row['CI_95_Low']:+.4f},{row['CI_95_High']:+.4f}]  ")
+                    f.write(f"dAUC={row['AUC_Diff']:+.4f}  "
+                            f"95%CI=[{row['CI_95_Low']:+.4f},{row['CI_95_High']:+.4f}]  ")
                     f.write(f"P={row['P_value']:.4f} -> {row['Decision']}\n")
             if ablation_data:
-                f.write(f"\nOptimal Features ({ablation_data['opt_n']}): {', '.join(ablation_data['opt_feats'])}\n")
+                f.write(f"\nOptimal Features ({ablation_data['opt_n']}): "
+                        f"{', '.join(ablation_data['opt_feats'])}\n")
+            f.write(f"\n{'='*50}\n")
+            f.write(f"Best Model [{best_mn}] Train vs Internal CV\n")
+            f.write(f"{'='*50}\n")
+            f.write(f"  Train  → AUC={metrics_train['Macro_AUC']:.4f}"
+                    f"  Acc={metrics_train['Accuracy']:.4f}"
+                    f"  F1={metrics_train['Macro_F1']:.4f}"
+                    f"  Kappa={metrics_train['Kappa']:.4f}\n")
+            f.write(f"  CV-Val → AUC={metrics_cv['Macro_AUC']:.4f}"
+                    f"  Acc={metrics_cv['Accuracy']:.4f}"
+                    f"  F1={metrics_cv['Macro_F1']:.4f}"
+                    f"  Kappa={metrics_cv['Kappa']:.4f}\n")
 
         # Save model
         pickle.dump({
@@ -728,10 +946,13 @@ def run_pipeline(
 
         # ── ZIP ──
         progress(0.97, desc="📦 打包ZIP...")
-        zp = os.path.join(tempfile.gettempdir(), f"ml_results_{int(time.time())}_{os.getpid()}.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))
+                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))
         shutil.rmtree(rf, ignore_errors=True); gc.collect()
@@ -808,6 +1029,7 @@ with gr.Blocks(
     <div class="pipeline-box">
         <strong>📋 流程：</strong>
         <code>选择分类数</code> → <code>模型训练</code> → <code>交叉验证</code> →
+        <code>训练集ROC/PR</code> → <code>Train vs CV对比</code> →
         <code>SHAP分析</code> → <code>特征消融</code> → <code>外部验证</code>
         &nbsp;&nbsp;|&nbsp;&nbsp;
         <strong>CSV格式：</strong> 第1列=标签(整数), 第2列=ID, 第3列起=特征
@@ -841,20 +1063,22 @@ with gr.Blocks(
                 info="RF=随机森林  DT=决策树  KNN=K近邻  XGB=XGBoost  AdaBoost  LR=逻辑回归  NB=朴素贝叶斯  SVM=支持向量机",
             )
             with gr.Row():
-                btn_all = gr.Button("🔘 全选", size="sm", variant="secondary")
-                btn_tree = gr.Button("🌲 树模型", size="sm", variant="secondary")
+                btn_all    = gr.Button("🔘 全选",     size="sm", variant="secondary")
+                btn_tree   = gr.Button("🌲 树模型",   size="sm", variant="secondary")
                 btn_linear = gr.Button("📐 线性模型", size="sm", variant="secondary")
-                btn_top4 = gr.Button("⚡ 经典四模型", size="sm", variant="secondary")
+                btn_top4   = gr.Button("⚡ 经典四模型", size="sm", variant="secondary")
             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)  ⚠️ 开启后运行时间显著增加")
+            enable_tuning = gr.Checkbox(
+                value=False,
+                label="启用超参数调优 (GridSearchCV)  ⚠️ 开启后运行时间显著增加")
             with gr.Row():
                 cv_folds = gr.Slider(3, 10, value=5, step=1, label="交叉验证折数")
-                top_n = gr.Slider(5, 50, value=20, step=1, label="SHAP 前 N 个特征")
+                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")
@@ -900,4 +1124,4 @@ def auth_fn(username, password):
 demo.queue()
 demo.launch(server_name="0.0.0.0", server_port=7860, auth=auth_fn,
     auth_message="🔐 复旦大学附属眼耳鼻喉科医院 · ML多分类分析平台\n请输入账号和密码登录",
-    ssr_mode=False)
+    ssr_mode=False)