Update app.py

app.py

@@ -1,157 +1,71 @@
-import gradio as gr
+import os
 import joblib
 import numpy as np
 import pandas as pd
+import gradio as gr
 import torch
 
-from propy import AAComposition, Autocorrelation, CTD, PseudoAAC
-from transformers import BertTokenizer, BertModel
-from lime.lime_tabular import LimeTabularExplainer
 from math import expm1
 
+from propy import AAComposition
+from propy import Autocorrelation
+from propy import CTD
+from propy import PseudoAAC
 
-# ============================================================
-# CONFIG
-# ============================================================
-
-MODEL_PATH = "RF.joblib"
-SCALER_PATH = "norm (4).joblib"
+from transformers import BertTokenizer, BertModel
 
-# REAL training data used by the 146-feature classifier
-LIME_DATA_PATH = "lime_training_data.csv"
+from lime.lime_tabular import LimeTabularExplainer
 
 
 # ============================================================
-# LOAD CLASSIFIER
+# FILES
 # ============================================================
 
-print("Loading Random Forest...")
-
-model = joblib.load(MODEL_PATH)
-
-print(
-    "Random Forest loaded."
-)
-
-print(
-    "RF expects:",
-    getattr(model, "n_features_in_", "unknown"),
-    "features"
-)
+RF_MODEL_PATH = "RF.joblib"
+SCALER_PATH = "norm (4).joblib"
+TRAINING_DATA_PATH = "training_data.csv"
 
 
 # ============================================================
-# LOAD SCALER
+# MODEL SETTINGS
 # ============================================================
 
-print("Loading scaler...")
-
-amp_scaler = joblib.load(SCALER_PATH)
-
-print(
-    "Scaler loaded."
-)
-
-print(
-    "Scaler expects:",
-    getattr(
-        amp_scaler,
-        "n_features_in_",
-        "unknown"
-    ),
-    "features"
-)
+LIME_BACKGROUND_SIZE = 1000
+LIME_NUM_SAMPLES = 3000
 
 
 # ============================================================
-# YOUR 146 FEATURES
+# EXACT 146 RF FEATURES
 # ============================================================
 
 selected_features = [
-    "_SolventAccessibilityC3",
-    "_SecondaryStrC1",
-    "_SecondaryStrC3",
-    "_ChargeC1",
-    "_PolarityC1",
-    "_NormalizedVDWVC1",
-    "_HydrophobicityC3",
-    "_SecondaryStrT23",
-    "_PolarizabilityD1001",
-    "_PolarizabilityD2001",
-    "_PolarizabilityD3001",
+    "_SolventAccessibilityC3", "_SecondaryStrC1",
+    "_SecondaryStrC3", "_ChargeC1", "_PolarityC1",
+    "_NormalizedVDWVC1", "_HydrophobicityC3",
+    "_SecondaryStrT23", "_PolarizabilityD1001",
+    "_PolarizabilityD2001", "_PolarizabilityD3001",
     "_SolventAccessibilityD1001",
     "_SolventAccessibilityD2001",
-    "_SolventAccessibilityD3001",
-    "_SecondaryStrD1001",
-    "_SecondaryStrD1075",
-    "_SecondaryStrD2001",
-    "_SecondaryStrD3001",
-    "_ChargeD1001",
-    "_ChargeD1025",
-    "_ChargeD2001",
-    "_ChargeD3075",
-    "_ChargeD3100",
-    "_PolarityD1001",
-    "_PolarityD1050",
-    "_PolarityD2001",
-    "_PolarityD3001",
-    "_NormalizedVDWVD1001",
-    "_NormalizedVDWVD2001",
-    "_NormalizedVDWVD2025",
-    "_NormalizedVDWVD2050",
-    "_NormalizedVDWVD3001",
-    "_HydrophobicityD1001",
-    "_HydrophobicityD2001",
-    "_HydrophobicityD3001",
+    "_SolventAccessibilityD3001", "_SecondaryStrD1001",
+    "_SecondaryStrD1075", "_SecondaryStrD2001",
+    "_SecondaryStrD3001", "_ChargeD1001",
+    "_ChargeD1025", "_ChargeD2001", "_ChargeD3075",
+    "_ChargeD3100", "_PolarityD1001", "_PolarityD1050",
+    "_PolarityD2001", "_PolarityD3001",
+    "_NormalizedVDWVD1001", "_NormalizedVDWVD2001",
+    "_NormalizedVDWVD2025", "_NormalizedVDWVD2050",
+    "_NormalizedVDWVD3001", "_HydrophobicityD1001",
+    "_HydrophobicityD2001", "_HydrophobicityD3001",
     "_HydrophobicityD3025",
 
-    "A",
-    "R",
-    "D",
-    "C",
-    "E",
-    "Q",
-    "H",
-    "I",
-    "M",
-    "P",
-    "Y",
-    "V",
-
-    "AR",
-    "AV",
-    "RC",
-    "RL",
-    "RV",
-    "CR",
-    "CC",
-    "CL",
-    "CK",
-    "EE",
-    "EI",
-    "EL",
-    "HC",
-    "IA",
-    "IL",
-    "IV",
-    "LA",
-    "LC",
-    "LE",
-    "LI",
-    "LT",
-    "LV",
-    "KC",
-    "MA",
-    "MS",
-    "SC",
-    "TC",
-    "TV",
-    "YC",
-    "VC",
-    "VE",
-    "VL",
-    "VK",
-    "VV",
+    "A", "R", "D", "C", "E", "Q", "H", "I",
+    "M", "P", "Y", "V",
+
+    "AR", "AV", "RC", "RL", "RV", "CR", "CC",
+    "CL", "CK", "EE", "EI", "EL", "HC", "IA",
+    "IL", "IV", "LA", "LC", "LE", "LI", "LT",
+    "LV", "KC", "MA", "MS", "SC", "TC", "TV",
+    "YC", "VC", "VE", "VL", "VK", "VV",
 
     "MoreauBrotoAuto_FreeEnergy30",
 
@@ -210,176 +124,292 @@ selected_features = [
     "GearyAuto_Mutability23",
     "GearyAuto_Mutability25",
     "GearyAuto_Mutability26",
-    "GearyAuto_Mutability27",
     "GearyAuto_Mutability28",
     "GearyAuto_Mutability29",
     "GearyAuto_Mutability30",
 
-    "APAAC1",
-    "APAAC4",
-    "APAAC5",
-    "APAAC6",
-    "APAAC8",
-    "APAAC9",
-    "APAAC12",
-    "APAAC13",
-    "APAAC15",
-    "APAAC18",
-    "APAAC19",
-    "APAAC24"
+    "APAAC1", "APAAC4", "APAAC5", "APAAC6",
+    "APAAC8", "APAAC9", "APAAC12", "APAAC13",
+    "APAAC15", "APAAC18", "APAAC19", "APAAC24"
 ]
 
 
+# ============================================================
+# CHECK FEATURE COUNT
+# ============================================================
+
+print("=" * 70)
+print("AMP + LIME APPLICATION")
+print("=" * 70)
+
 print(
-    "Selected feature count:",
+    "Selected RF feature count:",
     len(selected_features)
 )
 
 
 # ============================================================
-# VERIFY CLASSIFIER
+# LOAD RF
 # ============================================================
 
-if hasattr(model, "n_features_in_"):
-
-    if model.n_features_in_ != len(selected_features):
-
-        raise ValueError(
-            "\n\nMODEL / FEATURE MISMATCH\n"
-            f"RF expects {model.n_features_in_} features.\n"
-            f"Your selected feature list contains "
-            f"{len(selected_features)} features.\n\n"
-            "Do not continue until these match."
-        )
+print("\nLoading Random Forest...")
 
+model = joblib.load(
+    RF_MODEL_PATH
+)
 
-# ============================================================
-# LOAD REAL LIME TRAINING DATA
-# ============================================================
+print("Random Forest loaded.")
 
 print(
-    "\nLoading REAL training data for LIME..."
-)
-
-training_df = pd.read_csv(
-    LIME_DATA_PATH
+    "RF expects:",
+    model.n_features_in_,
+    "features"
 )
 
 
-# Remove accidental pandas index
-if "Unnamed: 0" in training_df.columns:
+if model.n_features_in_ != len(
+    selected_features
+):
 
-    training_df = training_df.drop(
-        "Unnamed: 0",
-        axis=1
+    raise ValueError(
+        "RF feature count does not match "
+        "selected feature list."
     )
 
 
+# ============================================================
+# LOAD SCALER
+# ============================================================
+
+print("\nLoading scaler...")
+
+scaler = joblib.load(
+    SCALER_PATH
+)
+
+print("Scaler loaded.")
+
 print(
-    "Training CSV shape:",
-    training_df.shape
+    "Scaler expects:",
+    scaler.n_features_in_,
+    "features"
 )
 
 
 # ============================================================
-# CHECK ALL 146 FEATURES EXIST
+# BUILD REAL LIME DATA
 # ============================================================
 
-missing_features = [
-    feature
-    for feature in selected_features
-    if feature not in training_df.columns
-]
+def build_lime_background():
 
+    print("\n")
+    print("=" * 70)
+    print("LOADING ORIGINAL TRAINING DATA")
+    print("=" * 70)
 
-if missing_features:
 
-    raise ValueError(
-        "\n\nLIME TRAINING DATA IS MISSING FEATURES:\n"
-        + "\n".join(
-            missing_features[:20]
+    if not os.path.exists(
+        TRAINING_DATA_PATH
+    ):
+
+        raise FileNotFoundError(
+            f"Missing {TRAINING_DATA_PATH}"
         )
+
+
+    df = pd.read_csv(
+        TRAINING_DATA_PATH
     )
 
 
-# ============================================================
-# PREPARE REAL LIME DATA
-# ============================================================
+    if "Unnamed: 0" in df.columns:
 
-lime_training_df = (
-    training_df[
-        selected_features
-    ]
-    .copy()
-)
+        df = df.drop(
+            "Unnamed: 0",
+            axis=1
+        )
 
 
-# Convert to numbers
-lime_training_df = (
-    lime_training_df.apply(
-        pd.to_numeric,
-        errors="coerce"
+    print(
+        "Training data shape:",
+        df.shape
     )
-)
 
 
-# Missing numerical values
-lime_training_df = (
-    lime_training_df.fillna(0)
-)
+    # --------------------------------------------------------
+    # Remove non-feature columns
+    # --------------------------------------------------------
 
+    non_feature_columns = []
 
-# Convert to numpy
-lime_training_data = (
-    lime_training_df
-    .values
-    .astype(np.float64)
-)
+    if "Sequence" in df.columns:
 
+        non_feature_columns.append(
+            "Sequence"
+        )
 
-print(
-    "Real LIME data:",
-    lime_training_data.shape
-)
+    if "Activity" in df.columns:
 
+        non_feature_columns.append(
+            "Activity"
+        )
 
-# ============================================================
-# LIMIT LIME BACKGROUND
-# ============================================================
 
-# This is NOT generating artificial data.
-# It only selects real rows from your training dataset.
+    X_train = df.drop(
+        columns=non_feature_columns,
+        errors="ignore"
+    )
+
+
+    print(
+        "Feature matrix shape:",
+        X_train.shape
+    )
+
+
+    # --------------------------------------------------------
+    # Match scaler columns
+    # --------------------------------------------------------
+
+    if hasattr(
+        scaler,
+        "feature_names_in_"
+    ):
+
+        scaler_features = list(
+            scaler.feature_names_in_
+        )
+
+        missing = [
+            col
+            for col in scaler_features
+            if col not in X_train.columns
+        ]
+
+
+        if missing:
+
+            raise ValueError(
+                "Training data is missing "
+                "features required by scaler:\n\n"
+                + "\n".join(
+                    missing[:30]
+                )
+            )
+
 
-MAX_LIME_BACKGROUND = 1000
+        # EXACT scaler order
 
+        X_train = X_train[
+            scaler_features
+        ]
 
-if len(lime_training_data) > MAX_LIME_BACKGROUND:
 
-    rng = np.random.RandomState(42)
+    else:
+
+        if X_train.shape[1] != (
+            scaler.n_features_in_
+        ):
 
-    indices = rng.choice(
-        len(lime_training_data),
-        MAX_LIME_BACKGROUND,
-        replace=False
+            raise ValueError(
+                "Training feature count does "
+                "not match scaler."
+            )
+
+
+    # --------------------------------------------------------
+    # Select reproducible subset
+    # --------------------------------------------------------
+
+    if len(X_train) > LIME_BACKGROUND_SIZE:
+
+        X_train = (
+            X_train
+            .sample(
+                n=LIME_BACKGROUND_SIZE,
+                random_state=42
+            )
+        )
+
+
+    # --------------------------------------------------------
+    # SAME SCALING USED BY MODEL
+    # --------------------------------------------------------
+
+    print(
+        "Applying saved scaler..."
     )
 
-    lime_training_data = (
-        lime_training_data[
-            indices
+
+    X_scaled = scaler.transform(
+        X_train
+    )
+
+
+    X_scaled = pd.DataFrame(
+        X_scaled,
+        columns=X_train.columns
+    )
+
+
+    # --------------------------------------------------------
+    # EXACT 146 RF FEATURES
+    # --------------------------------------------------------
+
+    missing_selected = [
+        f
+        for f in selected_features
+        if f not in X_scaled.columns
+    ]
+
+
+    if missing_selected:
+
+        raise ValueError(
+            "The scaled training data is "
+            "missing RF features:\n\n"
+            + "\n".join(
+                missing_selected
+            )
+        )
+
+
+    lime_background = (
+        X_scaled[
+            selected_features
         ]
+        .fillna(0)
+        .astype(np.float64)
+        .values
     )
 
 
-print(
-    "LIME background:",
-    lime_training_data.shape
-)
+    print(
+        "REAL LIME background shape:",
+        lime_background.shape
+    )
+
+
+    if lime_background.shape[1] != 146:
+
+        raise ValueError(
+            "LIME background does not contain "
+            "146 features."
+        )
+
+
+    return lime_background
 
 
 # ============================================================
 # CREATE LIME EXPLAINER
 # ============================================================
 
+lime_training_data = (
+    build_lime_background()
+)
+
+
 explainer = LimeTabularExplainer(
 
     training_data=lime_training_data,
@@ -399,53 +429,44 @@ explainer = LimeTabularExplainer(
 )
 
 
-print(
-    "REAL LIME EXPLAINER READY."
-)
+print("\nREAL LIME EXPLAINER READY.")
 
 
 # ============================================================
-# LOAD PROTBERT
+# PROTBERT
 # ============================================================
 
-print(
-    "\nLoading ProtBert..."
-)
-
+print("\nLoading ProtBert...")
 
 tokenizer = BertTokenizer.from_pretrained(
     "Rostlab/prot_bert",
     do_lower_case=False
 )
 
-
 protbert_model = BertModel.from_pretrained(
     "Rostlab/prot_bert"
 )
 
-
 device = torch.device(
     "cuda"
     if torch.cuda.is_available()
     else "cpu"
 )
 
-
 protbert_model = (
     protbert_model
     .to(device)
     .eval()
 )
 
-
 print(
-    "ProtBert loaded on:",
+    "ProtBert device:",
     device
 )
 
 
 # ============================================================
-# VALID AMINO ACIDS
+# SEQUENCE CLEANING
 # ============================================================
 
 VALID_AA = set(
@@ -453,29 +474,21 @@ VALID_AA = set(
 )
 
 
-# ============================================================
-# CLEAN SEQUENCE
-# ============================================================
-
 def clean_sequence(sequence):
 
     sequence = str(
         sequence
     ).upper().strip()
 
-
-    sequence = "".join(
+    return "".join(
         aa
         for aa in sequence
         if aa in VALID_AA
     )
 
 
-    return sequence
-
-
 # ============================================================
-# FEATURE EXTRACTION
+# FEATURE EXTRACTION FOR NEW INPUT
 # ============================================================
 
 def extract_features(sequence):
@@ -484,65 +497,43 @@ def extract_features(sequence):
         sequence
     )
 
-
     if len(sequence) < 10:
 
-        return (
-            None,
-            "Sequence must contain at least 10 valid amino acids."
-        )
+        return None, "Sequence too short."
 
 
     try:
 
-        # ----------------------------------------------------
-        # DIPEPTIDE
-        # ----------------------------------------------------
-
-        dipeptide_features = (
-            AAComposition.CalculateAADipeptideComposition(
+        dipeptide = (
+            AAComposition
+            .CalculateAADipeptideComposition(
                 sequence
             )
         )
 
 
-        filtered_dipeptide_features = {
-
-            k: dipeptide_features[k]
-
+        filtered_dipeptide = {
+            k: dipeptide[k]
             for k in list(
-                dipeptide_features.keys()
+                dipeptide.keys()
             )[:420]
         }
 
 
-        # ----------------------------------------------------
-        # CTD
-        # ----------------------------------------------------
-
-        ctd_features = (
-            CTD.CalculateCTD(
-                sequence
-            )
+        ctd = CTD.CalculateCTD(
+            sequence
         )
 
 
-        # ----------------------------------------------------
-        # AUTOCORRELATION
-        # ----------------------------------------------------
-
-        auto_features = (
-            Autocorrelation.CalculateAutoTotal(
+        autocorr = (
+            Autocorrelation
+            .CalculateAutoTotal(
                 sequence
             )
         )
 
 
-        # ----------------------------------------------------
-        # PSEUDO AAC
-        # ----------------------------------------------------
-
-        pseudo_features = (
+        pseaac = (
             PseudoAAC.GetAPseudoAAC(
                 sequence,
                 lamda=9
@@ -550,27 +541,12 @@ def extract_features(sequence):
         )
 
 
-        # ----------------------------------------------------
-        # COMBINE
-        # ----------------------------------------------------
-
         all_features = {}
 
-        all_features.update(
-            ctd_features
-        )
-
-        all_features.update(
-            filtered_dipeptide_features
-        )
-
-        all_features.update(
-            auto_features
-        )
-
-        all_features.update(
-            pseudo_features
-        )
+        all_features.update(ctd)
+        all_features.update(filtered_dipeptide)
+        all_features.update(autocorr)
+        all_features.update(pseaac)
 
 
         feature_df = pd.DataFrame(
@@ -578,34 +554,32 @@ def extract_features(sequence):
         )
 
 
-        # ----------------------------------------------------
-        # ALIGN WITH SCALER
-        # ----------------------------------------------------
+        # Match scaler order
 
         if hasattr(
-            amp_scaler,
+            scaler,
             "feature_names_in_"
         ):
 
             scaler_features = list(
-                amp_scaler.feature_names_in_
+                scaler.feature_names_in_
             )
 
 
-            missing_scaler = [
+            missing = [
                 f
                 for f in scaler_features
                 if f not in feature_df.columns
             ]
 
 
-            if missing_scaler:
+            if missing:
 
                 return (
                     None,
-                    "Missing features required by scaler: "
+                    "Missing scaler features: "
                     + str(
-                        missing_scaler[:10]
+                        missing[:20]
                     )
                 )
 
@@ -617,69 +591,52 @@ def extract_features(sequence):
             )
 
 
-        # ----------------------------------------------------
-        # NORMALIZATION
-        # ----------------------------------------------------
+        # Same normalization
 
-        normalized_array = (
-            amp_scaler.transform(
-                feature_df
-            )
+        normalized = scaler.transform(
+            feature_df
         )
 
 
         normalized_df = pd.DataFrame(
-            normalized_array,
+            normalized,
             columns=feature_df.columns
         )
 
 
-        # ----------------------------------------------------
-        # SELECT THE SAME 146 FEATURES
-        # ----------------------------------------------------
+        # Same 146 selected features
 
-        missing_selected = [
+        missing = [
             f
             for f in selected_features
             if f not in normalized_df.columns
         ]
 
 
-        if missing_selected:
+        if missing:
 
             return (
                 None,
                 "Missing selected features: "
-                + str(
-                    missing_selected[:10]
-                )
+                + str(missing[:20])
             )
 
 
-        selected_df = (
+        X = (
             normalized_df[
                 selected_features
             ]
             .fillna(0)
-        )
-
-
-        X = (
-            selected_df
+            .astype(float)
             .values
-            .astype(np.float64)
         )
 
 
-        # Final check
-        if X.shape[1] != len(
-            selected_features
-        ):
+        if X.shape != (1, 146):
 
             return (
                 None,
-                f"Feature count error: "
-                f"{X.shape[1]} generated."
+                f"Wrong final shape: {X.shape}"
             )
 
 
@@ -695,7 +652,7 @@ def extract_features(sequence):
 
 
 # ============================================================
-# MIC PREDICTION
+# MIC
 # ============================================================
 
 def predict_mic(sequence):
@@ -705,17 +662,6 @@ def predict_mic(sequence):
     )
 
 
-    if len(sequence) < 10:
-
-        return {
-            "Error": "Sequence too short."
-        }
-
-
-    # --------------------------------------------------------
-    # PROTBERT
-    # --------------------------------------------------------
-
     seq_spaced = " ".join(
         list(sequence)
     )
@@ -746,8 +692,7 @@ def predict_mic(sequence):
 
 
         embedding = (
-            outputs
-            .last_hidden_state
+            outputs.last_hidden_state
             .mean(dim=1)
             .squeeze()
             .cpu()
@@ -756,77 +701,55 @@ def predict_mic(sequence):
         )
 
 
-    # --------------------------------------------------------
-    # BACTERIAL MODELS
-    # --------------------------------------------------------
-
     bacteria_config = {
 
-        "E. coli": {
-            "model":
-                "coli_xgboost_model.pkl",
-
-            "scaler":
-                "coli_scaler.pkl",
-
-            "pca":
-                None
-        },
-
-
-        "S. aureus": {
-            "model":
-                "aur_xgboost_model.pkl",
-
-            "scaler":
-                "aur_scaler.pkl",
-
-            "pca":
-                None
-        },
-
-
-        "P. aeruginosa": {
-            "model":
-                "arg_xgboost_model.pkl",
-
-            "scaler":
-                "arg_scaler.pkl",
-
-            "pca":
-                None
-        },
-
+        "E. coli": (
+            "coli_xgboost_model.pkl",
+            "coli_scaler.pkl",
+            None
+        ),
 
-        "K. pneumoniae": {
-            "model":
-                "pne_mlp_model.pkl",
+        "S. aureus": (
+            "aur_xgboost_model.pkl",
+            "aur_scaler.pkl",
+            None
+        ),
 
-            "scaler":
-                "pne_scaler.pkl",
+        "P. aeruginosa": (
+            "arg_xgboost_model.pkl",
+            "arg_scaler.pkl",
+            None
+        ),
 
-            "pca":
-                "pne_pca.pkl"
-        }
+        "K. pneumoniae": (
+            "pne_mlp_model.pkl",
+            "pne_scaler.pkl",
+            "pne_pca.pkl"
+        )
     }
 
 
-    mic_results = {}
+    results = {}
 
 
-    for bacterium, config in (
+    for organism, config in (
         bacteria_config.items()
     ):
 
         try:
 
-            mic_scaler = joblib.load(
-                config["scaler"]
+            model_path, scaler_path, pca_path = (
+                config
             )
 
 
             mic_model = joblib.load(
-                config["model"]
+                model_path
+            )
+
+
+            mic_scaler = joblib.load(
+                scaler_path
             )
 
 
@@ -837,15 +760,14 @@ def predict_mic(sequence):
             )
 
 
-            if config["pca"]:
+            if pca_path:
 
-                mic_pca = joblib.load(
-                    config["pca"]
+                pca = joblib.load(
+                    pca_path
                 )
 
-
                 transformed = (
-                    mic_pca.transform(
+                    pca.transform(
                         scaled
                     )
                 )
@@ -855,60 +777,37 @@ def predict_mic(sequence):
                 transformed = scaled
 
 
-            mic_log = (
+            log_value = (
                 mic_model.predict(
                     transformed
                 )[0]
             )
 
 
-            mic = round(
-                expm1(mic_log),
+            results[organism] = round(
+                expm1(
+                    log_value
+                ),
                 3
             )
 
 
-            mic_results[
-                bacterium
-            ] = mic
-
-
         except Exception as e:
 
-            mic_results[
-                bacterium
-            ] = (
+            results[organism] = (
                 f"Error: {str(e)}"
             )
 
 
-    return mic_results
+    return results
 
 
 # ============================================================
-# FULL PREDICTION
+# MAIN PREDICTION
 # ============================================================
 
 def full_prediction(sequence):
 
-    sequence = clean_sequence(
-        sequence
-    )
-
-
-    if len(sequence) < 10:
-
-        return (
-            "Invalid sequence.\n\n"
-            "Please enter at least 10 valid "
-            "amino acids."
-        )
-
-
-    # ========================================================
-    # EXTRACT FEATURES
-    # ========================================================
-
     features, error = (
         extract_features(
             sequence
@@ -924,109 +823,69 @@ def full_prediction(sequence):
         )
 
 
-    # ========================================================
-    # RANDOM FOREST PREDICTION
-    # ========================================================
-
-    try:
-
-        prediction = (
-            model.predict(
-                features
-            )[0]
-        )
-
-
-        probabilities = (
-            model.predict_proba(
-                features
-            )[0]
-        )
-
-
-    except Exception as e:
-
-        return (
-            "AMP prediction failed:\n\n"
-            f"{type(e).__name__}: {e}"
-        )
-
-
-    # ========================================================
-    # CONFIDENCE
-    # ========================================================
-
-    try:
-
-        class_index = list(
-            model.classes_
-        ).index(
-            prediction
-        )
+    # --------------------------------------------------------
+    # RF
+    # --------------------------------------------------------
 
+    prediction = model.predict(
+        features
+    )[0]
 
-        confidence = round(
-            probabilities[
-                class_index
-            ] * 100,
-            2
-        )
 
+    probabilities = (
+        model.predict_proba(
+            features
+        )[0]
+    )
 
-    except Exception:
-
-        confidence = None
 
+    class_index = list(
+        model.classes_
+    ).index(
+        prediction
+    )
 
-    # ========================================================
-    # AMP LABEL
-    # ========================================================
 
-    if prediction == 0:
+    confidence = round(
+        probabilities[class_index] * 100,
+        2
+    )
 
-        amp_result = (
-            "Antimicrobial Peptide (AMP)"
-        )
 
-    else:
-
-        amp_result = (
-            "Non-AMP"
-        )
+    label = (
+        "Antimicrobial Peptide (AMP)"
+        if prediction == 0
+        else
+        "Non-AMP"
+    )
 
 
     result = (
-        "====================================\n"
         "AMP CLASSIFICATION\n"
-        "====================================\n\n"
-        f"Prediction: {amp_result}\n"
+        "===================\n\n"
+        f"Prediction: {label}\n"
         f"Confidence: {confidence}%\n"
     )
 
 
-    # ========================================================
+    # --------------------------------------------------------
     # LIME
-    # ========================================================
+    # --------------------------------------------------------
 
     result += (
-        "\n====================================\n"
-        "LIME INTERPRETABILITY\n"
-        "====================================\n"
+        "\n\nLIME EXPLANATION\n"
+        "===================\n"
     )
 
 
     try:
 
-        # Reproducibility
-        np.random.seed(42)
-
-
         explanation = (
             explainer.explain_instance(
 
-                data_row=features[0],
+                features[0],
 
-                predict_fn=model.predict_proba,
+                model.predict_proba,
 
                 labels=[
                     int(prediction)
@@ -1034,35 +893,28 @@ def full_prediction(sequence):
 
                 num_features=10,
 
-                num_samples=3000
-            )
-        )
-
-
-        lime_results = (
-            explanation.as_list(
-                label=int(prediction)
+                num_samples=LIME_NUM_SAMPLES
             )
         )
 
 
         result += (
-            "\nTop features contributing "
-            "to this prediction:\n"
+            "\nTop features influencing "
+            "this prediction:\n"
         )
 
 
         for feature, weight in (
-            lime_results
+            explanation.as_list(
+                label=int(prediction)
+            )
         ):
 
-            if weight > 0:
-
-                direction = "↑"
-
-            else:
-
-                direction = "↓"
+            direction = (
+                "↑"
+                if weight > 0
+                else "↓"
+            )
 
 
             result += (
@@ -1075,21 +927,21 @@ def full_prediction(sequence):
     except Exception as e:
 
         result += (
-            "\n\nLIME failed:\n"
-            f"{type(e).__name__}: {e}"
+            "\nLIME failed: "
+            f"{type(e).__name__}: "
+            f"{str(e)}"
         )
 
 
-    # ========================================================
+    # --------------------------------------------------------
     # MIC
-    # ========================================================
+    # --------------------------------------------------------
 
     if prediction == 0:
 
         result += (
-            "\n\n====================================\n"
-            "PREDICTED MIC VALUES\n"
-            "====================================\n"
+            "\n\n\nPREDICTED MIC\n"
+            "===================\n"
         )
 
 
@@ -1112,7 +964,7 @@ def full_prediction(sequence):
 
         result += (
             "\n\nMIC prediction skipped "
-            "for Non-AMP sequences."
+            "for Non-AMP."
         )
 
 
@@ -1129,10 +981,10 @@ iface = gr.Interface(
 
     inputs=gr.Textbox(
         label="Protein Sequence",
+        lines=5,
         placeholder=(
             "Enter an amino acid sequence..."
-        ),
-        lines=5
+        )
     ),
 
     outputs=gr.Textbox(
@@ -1141,15 +993,14 @@ iface = gr.Interface(
     ),
 
     title=(
-        "AMP & MIC Predictor + "
-        "LIME Interpretability"
+        "AMP & MIC Predictor "
+        "+ LIME Interpretability"
     ),
 
     description=(
-        "Enter an amino acid sequence "
-        "(≥10 amino acids) to obtain AMP "
-        "classification, confidence, LIME "
-        "interpretability, and MIC predictions."
+        "AMP classification, confidence, "
+        "real LIME interpretation, and "
+        "MIC prediction."
     ),
 
     examples=[
@@ -1163,9 +1014,11 @@ iface = gr.Interface(
 
 
 # ============================================================
-# LAUNCH
+# START
 # ============================================================
 
 if __name__ == "__main__":
 
+    print("\nApplication starting...")
+
     iface.launch()