Update app.py

app.py

@@ -23,9 +23,6 @@ import matplotlib.pyplot as plt
 import warnings
 warnings.filterwarnings('ignore')
 
-# ---------------------------------------------------------------------------
-# Globals
-# ---------------------------------------------------------------------------
 training_data = None
 column_names  = None
 test_list     = []
@@ -33,12 +30,8 @@ test_list     = []
 DEFAULT_N_BOOT_CI = 1000
 
 
-# ---------------------------------------------------------------------------
-# Probability calibration helpers  (ported from first codebase)
-# ---------------------------------------------------------------------------
-
 def calibrate_probabilities_undersampling(p_s, beta):
-    """Pozzolo et al. correction for undersampling bias."""
+  
     p_s         = np.asarray(p_s, dtype=float)
     numerator   = beta * p_s
     denominator = np.maximum((beta - 1.0) * p_s + 1.0, 1e-10)
@@ -52,10 +45,7 @@ def bootstrap_ci_from_oof(
     confidence: float = 0.95,
     random_state: int = 42,
 ) -> tuple:
-    """
-    Bootstrap percentile CI for a point estimate, anchored on OOF probabilities
-    (mirrors the implementation in the first codebase).
-    """
+ 
     if oof_probs is None or len(oof_probs) == 0:
         return float(point_estimate), float(point_estimate)
 
@@ -124,9 +114,6 @@ def compute_efs_ci(
     return p_efs, efs_lo, efs_hi
 
 
-# ---------------------------------------------------------------------------
-# Original modelling helpers (unchanged from second codebase)
-# ---------------------------------------------------------------------------
 
 def rand_for(neww_list, x_te, rf, lab, x_tr, actual, paramss,
              X_Tempp, enco, my_table_str, my_table_num, tabl, tracount):
@@ -279,10 +266,6 @@ def run_model(x_tr, x_te, y_tr, deltaa, lab, rf, X_Tempp, track,
     return a_lisy, probab_lisy, secondlisy
 
 
-# ---------------------------------------------------------------------------
-# Data loading
-# ---------------------------------------------------------------------------
-
 def load_training_data():
     global training_data, column_names, test_list
 
@@ -301,9 +284,6 @@ def load_training_data():
         return "No training Data"
 
 
-# ---------------------------------------------------------------------------
-# Main evaluation function
-# ---------------------------------------------------------------------------
 
 def train_and_evaluate(input_file):
     global training_data, column_names, test_list
@@ -323,9 +303,7 @@ def train_and_evaluate(input_file):
         if not available_features_input:
             return "Error: No matching columns found between datasets", None, None
 
-        # -------------------------------------------------------------------
-        # Outcome columns: add DWOGF so EFS can be derived from it + GF
-        # -------------------------------------------------------------------
+  
         base_outcome_cols = ['DEAD', 'GF', 'AGVHD', 'CGVHD', 'VOCPSHI', 'STROKEHI']
         efs_outcomes      = ['DWOGF', 'GF']            # needed for EFS calculation
         all_model_outcomes = base_outcome_cols.copy()
@@ -344,9 +322,7 @@ def train_and_evaluate(input_file):
         X_input  = inter_input[available_features][my_table.columns]
         my_test  = X_input
 
-        # -------------------------------------------------------------------
-        # Encode training features
-        # -------------------------------------------------------------------
+       
         li1 = ['Yes', 'No']
         cols_yes_no_train = [col for col in my_table.columns if my_table[col].isin(li1).all()]
         my_ye_train       = my_table[cols_yes_no_train].replace({'Yes': 1, 'No': 0}).astype('int64')
@@ -354,14 +330,14 @@ def train_and_evaluate(input_file):
         my_table_str      = my_table_modify.select_dtypes(exclude=['number'])
         my_table_num      = my_table_modify.select_dtypes(include=['number'])
 
-        # Encode test features
+       
         cols_yes_no_test = [col for col in my_test.columns if my_test[col].isin(li1).all()]
         my_ye_test       = my_test[cols_yes_no_test].replace({'Yes': 1, 'No': 0}).astype('int64')
         my_test_modify   = pd.concat([my_test.drop(cols_yes_no_test, axis=1), my_ye_test], axis=1)
         my_test_str_raw  = my_test_modify.select_dtypes(exclude=['number'])
         my_test_num      = my_test_modify.select_dtypes(include=['number'])
 
-        # Fit encoder on combined train+test categorical columns
+        
         df_combined = pd.concat([my_table_str, my_test_str_raw], axis=0, ignore_index=True)
         enco        = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
         encoded     = enco.fit_transform(df_combined)
@@ -372,23 +348,21 @@ def train_and_evaluate(input_file):
         my_test_str    = encoded_df.iloc[len(my_table_str):].reset_index(drop=True)
         my_test_real   = pd.concat([my_test_str, my_test_num], axis=1)
 
-        # -------------------------------------------------------------------
-        # Train models for every outcome (including DWOGF)
-        # -------------------------------------------------------------------
+        
         outcome_display_names = {
-            'DEAD':     'Overall Survival',        # reported as 1 – P(DEAD)
+            'DEAD':     'Overall Survival',       
             'GF':       'Graft Failure',
             'AGVHD':    'Acute GVHD',
             'CGVHD':    'Chronic GVHD',
             'VOCPSHI':  'Vaso-Occlusive Crisis Post-HCT',
             'STROKEHI': 'Stroke Post-HCT',
-            'DWOGF':    'Death Without Graft Failure',   # internal; used for EFS
+            'DWOGF':    'Death Without Graft Failure',  
         }
 
-        # Storage for per-outcome predicted probabilities (test set)
-        all_pred_proba  = {}   # outcome -> np.ndarray of calibrated probs (test set)
-        all_pred_labels = {}   # outcome -> list of predicted labels
-        all_y_test      = {}   # outcome -> np.ndarray of true labels
+    
+        all_pred_proba  = {}   
+        all_pred_labels = {}   
+        all_y_test      = {}   
 
         metrics_results     = []
         calibration_results = []
@@ -429,9 +403,9 @@ def train_and_evaluate(input_file):
             all_pred_labels[outcome_col] = y_pred
             all_y_test[outcome_col]      = y_test
 
-            # Only report metrics/plots for the display outcomes (not DWOGF standalone)
+           
             if outcome_col == 'DWOGF':
-                continue    # used internally for EFS; no separate display row
+                continue   
 
             outcome_name = outcome_display_names.get(outcome_col, outcome_col)
 
@@ -467,22 +441,15 @@ def train_and_evaluate(input_file):
             plt.tight_layout()
             calibration_plots.append(fig)
 
-        # -------------------------------------------------------------------
-        # EFS calculation  (mirrors first codebase exactly)
-        #   EFS = 1 – P(DWOGF) – P(GF)
-        #   CI  = bootstrap percentile on shifted OOF distributions
-        # -------------------------------------------------------------------
+        
         if 'DWOGF' in all_pred_proba and 'GF' in all_pred_proba:
             proba_dwogf = all_pred_proba['DWOGF']   # test-set probabilities
             proba_gf    = all_pred_proba['GF']
 
-            # We treat the full test-set probability vectors as the "OOF"
-            # equivalents for CI construction (matches the spirit of the
-            # first codebase where oof_probs_calibrated were stored from
-            # training; here we use the held-out test predictions instead).
+         
             efs_probs = np.clip(1.0 - proba_dwogf - proba_gf, 0.0, 1.0)
 
-            # Point estimate: mean EFS across the test cohort
+         
             p_efs_point = float(np.mean(efs_probs))
 
             p_efs, efs_lo, efs_hi = compute_efs_ci(
@@ -498,9 +465,7 @@ def train_and_evaluate(input_file):
                 f"[95% CI: {efs_lo:.3f} – {efs_hi:.3f}]"
             )
 
-            # --- EFS calibration plot ---
-            # For a calibration curve we need a binary "EFS occurred" label.
-            # EFS event = DWOGF event OR GF event (i.e. 1 if either happened).
+          
             if 'DWOGF' in all_y_test and 'GF' in all_y_test:
                 n_min_efs   = min(len(all_y_test['DWOGF']), len(all_y_test['GF']))
                 y_efs_true  = np.clip(
@@ -570,9 +535,7 @@ def train_and_evaluate(input_file):
                 except Exception as e:
                     print(f"Warning: EFS metrics computation failed: {e}")
 
-        # -------------------------------------------------------------------
-        # Assemble output DataFrames
-        # -------------------------------------------------------------------
+      
         metrics_df     = pd.DataFrame(
             metrics_results,
             columns=['Outcome', 'Accuracy', 'Balanced Accuracy', 'Precision', 'Recall', 'AUC']
@@ -590,9 +553,7 @@ def train_and_evaluate(input_file):
         return f"Error processing data: {str(e)}", None, None
 
 
-# ---------------------------------------------------------------------------
-# Gradio interface
-# ---------------------------------------------------------------------------
+
 
 def create_interface():
     load_training_data()