Update app.py

app.py

@@ -2,188 +2,1170 @@ import gradio as gr
 import joblib
 import numpy as np
 import pandas as pd
-from propy import AAComposition, Autocorrelation, CTD, PseudoAAC
 import torch
+
+from propy import AAComposition, Autocorrelation, CTD, PseudoAAC
 from transformers import BertTokenizer, BertModel
 from lime.lime_tabular import LimeTabularExplainer
 from math import expm1
 
-# Load AMP Classifier and Scaler
-model = joblib.load("RF.joblib")
-scaler = joblib.load("norm (4).joblib")
-
-# Load 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()
-
-# Define selected features (146 RFE-selected features)
-selected_features = ["_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", "_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",
-"MoreauBrotoAuto_FreeEnergy30", "MoranAuto_Hydrophobicity2", "MoranAuto_Hydrophobicity4",
-"GearyAuto_Hydrophobicity20", "GearyAuto_Hydrophobicity24", "GearyAuto_Hydrophobicity26",
-"GearyAuto_Hydrophobicity27", "GearyAuto_Hydrophobicity28", "GearyAuto_Hydrophobicity29",
-"GearyAuto_Hydrophobicity30", "GearyAuto_AvFlexibility22", "GearyAuto_AvFlexibility26",
-"GearyAuto_AvFlexibility27", "GearyAuto_AvFlexibility28", "GearyAuto_AvFlexibility29", "GearyAuto_AvFlexibility30",
-"GearyAuto_Polarizability22", "GearyAuto_Polarizability24", "GearyAuto_Polarizability25",
-"GearyAuto_Polarizability27", "GearyAuto_Polarizability28", "GearyAuto_Polarizability29",
-"GearyAuto_Polarizability30", "GearyAuto_FreeEnergy24", "GearyAuto_FreeEnergy25", "GearyAuto_FreeEnergy30",
-"GearyAuto_ResidueASA21", "GearyAuto_ResidueASA22", "GearyAuto_ResidueASA23", "GearyAuto_ResidueASA24",
-"GearyAuto_ResidueASA30", "GearyAuto_ResidueVol21", "GearyAuto_ResidueVol24", "GearyAuto_ResidueVol25",
-"GearyAuto_ResidueVol26", "GearyAuto_ResidueVol28", "GearyAuto_ResidueVol29", "GearyAuto_ResidueVol30",
-"GearyAuto_Steric18", "GearyAuto_Steric21", "GearyAuto_Steric26", "GearyAuto_Steric27", "GearyAuto_Steric28",
-"GearyAuto_Steric29", "GearyAuto_Steric30", "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"]
-
-# --- FIX (LIME): seed the random background so explanations are reproducible
-# across Space restarts. (Loading a real saved training sample here would
-# produce more faithful weights; see build_lime_background.py for that path.)
-np.random.seed(42)
-sample_data = np.random.rand(500, len(selected_features))
+
+# ============================================================
+# CONFIG
+# ============================================================
+
+MODEL_PATH = "RF.joblib"
+SCALER_PATH = "norm (4).joblib"
+
+# REAL training data used by the 146-feature classifier
+LIME_DATA_PATH = "lime_training_data.csv"
+
+
+# ============================================================
+# LOAD CLASSIFIER
+# ============================================================
+
+print("Loading Random Forest...")
+
+model = joblib.load(MODEL_PATH)
+
+print(
+    "Random Forest loaded."
+)
+
+print(
+    "RF expects:",
+    getattr(model, "n_features_in_", "unknown"),
+    "features"
+)
+
+
+# ============================================================
+# LOAD SCALER
+# ============================================================
+
+print("Loading scaler...")
+
+amp_scaler = joblib.load(SCALER_PATH)
+
+print(
+    "Scaler loaded."
+)
+
+print(
+    "Scaler expects:",
+    getattr(
+        amp_scaler,
+        "n_features_in_",
+        "unknown"
+    ),
+    "features"
+)
+
+
+# ============================================================
+# YOUR 146 FEATURES
+# ============================================================
+
+selected_features = [
+    "_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",
+    "_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",
+
+    "MoreauBrotoAuto_FreeEnergy30",
+
+    "MoranAuto_Hydrophobicity2",
+    "MoranAuto_Hydrophobicity4",
+
+    "GearyAuto_Hydrophobicity20",
+    "GearyAuto_Hydrophobicity24",
+    "GearyAuto_Hydrophobicity26",
+    "GearyAuto_Hydrophobicity27",
+    "GearyAuto_Hydrophobicity28",
+    "GearyAuto_Hydrophobicity29",
+    "GearyAuto_Hydrophobicity30",
+
+    "GearyAuto_AvFlexibility22",
+    "GearyAuto_AvFlexibility26",
+    "GearyAuto_AvFlexibility27",
+    "GearyAuto_AvFlexibility28",
+    "GearyAuto_AvFlexibility29",
+    "GearyAuto_AvFlexibility30",
+
+    "GearyAuto_Polarizability22",
+    "GearyAuto_Polarizability24",
+    "GearyAuto_Polarizability25",
+    "GearyAuto_Polarizability27",
+    "GearyAuto_Polarizability28",
+    "GearyAuto_Polarizability29",
+    "GearyAuto_Polarizability30",
+
+    "GearyAuto_FreeEnergy24",
+    "GearyAuto_FreeEnergy25",
+    "GearyAuto_FreeEnergy30",
+
+    "GearyAuto_ResidueASA21",
+    "GearyAuto_ResidueASA22",
+    "GearyAuto_ResidueASA23",
+    "GearyAuto_ResidueASA24",
+    "GearyAuto_ResidueASA30",
+
+    "GearyAuto_ResidueVol21",
+    "GearyAuto_ResidueVol24",
+    "GearyAuto_ResidueVol25",
+    "GearyAuto_ResidueVol26",
+    "GearyAuto_ResidueVol28",
+    "GearyAuto_ResidueVol29",
+    "GearyAuto_ResidueVol30",
+
+    "GearyAuto_Steric18",
+    "GearyAuto_Steric21",
+    "GearyAuto_Steric26",
+    "GearyAuto_Steric27",
+    "GearyAuto_Steric28",
+    "GearyAuto_Steric29",
+    "GearyAuto_Steric30",
+
+    "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"
+]
+
+
+print(
+    "Selected feature count:",
+    len(selected_features)
+)
+
+
+# ============================================================
+# VERIFY CLASSIFIER
+# ============================================================
+
+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."
+        )
+
+
+# ============================================================
+# LOAD REAL LIME TRAINING DATA
+# ============================================================
+
+print(
+    "\nLoading REAL training data for LIME..."
+)
+
+training_df = pd.read_csv(
+    LIME_DATA_PATH
+)
+
+
+# Remove accidental pandas index
+if "Unnamed: 0" in training_df.columns:
+
+    training_df = training_df.drop(
+        "Unnamed: 0",
+        axis=1
+    )
+
+
+print(
+    "Training CSV shape:",
+    training_df.shape
+)
+
+
+# ============================================================
+# CHECK ALL 146 FEATURES EXIST
+# ============================================================
+
+missing_features = [
+    feature
+    for feature in selected_features
+    if feature not in training_df.columns
+]
+
+
+if missing_features:
+
+    raise ValueError(
+        "\n\nLIME TRAINING DATA IS MISSING FEATURES:\n"
+        + "\n".join(
+            missing_features[:20]
+        )
+    )
+
+
+# ============================================================
+# PREPARE REAL LIME DATA
+# ============================================================
+
+lime_training_df = (
+    training_df[
+        selected_features
+    ]
+    .copy()
+)
+
+
+# Convert to numbers
+lime_training_df = (
+    lime_training_df.apply(
+        pd.to_numeric,
+        errors="coerce"
+    )
+)
+
+
+# Missing numerical values
+lime_training_df = (
+    lime_training_df.fillna(0)
+)
+
+
+# Convert to numpy
+lime_training_data = (
+    lime_training_df
+    .values
+    .astype(np.float64)
+)
+
+
+print(
+    "Real LIME data:",
+    lime_training_data.shape
+)
+
+
+# ============================================================
+# LIMIT LIME BACKGROUND
+# ============================================================
+
+# This is NOT generating artificial data.
+# It only selects real rows from your training dataset.
+
+MAX_LIME_BACKGROUND = 1000
+
+
+if len(lime_training_data) > MAX_LIME_BACKGROUND:
+
+    rng = np.random.RandomState(42)
+
+    indices = rng.choice(
+        len(lime_training_data),
+        MAX_LIME_BACKGROUND,
+        replace=False
+    )
+
+    lime_training_data = (
+        lime_training_data[
+            indices
+        ]
+    )
+
+
+print(
+    "LIME background:",
+    lime_training_data.shape
+)
+
+
+# ============================================================
+# CREATE LIME EXPLAINER
+# ============================================================
+
 explainer = LimeTabularExplainer(
-    training_data=sample_data,
+
+    training_data=lime_training_data,
+
     feature_names=selected_features,
-    class_names=["AMP", "Non-AMP"],
+
+    class_names=[
+        "AMP",
+        "Non-AMP"
+    ],
+
     mode="classification",
-    random_state=42,
+
+    discretize_continuous=True,
+
+    random_state=42
+)
+
+
+print(
+    "REAL LIME EXPLAINER READY."
+)
+
+
+# ============================================================
+# LOAD 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()
 )
 
-# Feature extraction function
+
+print(
+    "ProtBert loaded on:",
+    device
+)
+
+
+# ============================================================
+# VALID AMINO ACIDS
+# ============================================================
+
+VALID_AA = set(
+    "ACDEFGHIKLMNPQRSTVWY"
+)
+
+
+# ============================================================
+# CLEAN SEQUENCE
+# ============================================================
+
+def clean_sequence(sequence):
+
+    sequence = str(
+        sequence
+    ).upper().strip()
+
+
+    sequence = "".join(
+        aa
+        for aa in sequence
+        if aa in VALID_AA
+    )
+
+
+    return sequence
+
+
+# ============================================================
+# FEATURE EXTRACTION
+# ============================================================
+
 def extract_features(sequence):
-    sequence = ''.join([aa for aa in sequence.upper() if aa in "ACDEFGHIKLMNPQRSTVWY"])
+
+    sequence = clean_sequence(
+        sequence
+    )
+
+
     if len(sequence) < 10:
-        return "Error: Sequence too short."
+
+        return (
+            None,
+            "Sequence must contain at least 10 valid amino acids."
+        )
+
 
     try:
-        dipeptide_features = AAComposition.CalculateAADipeptideComposition(sequence)
-        filtered_dipeptide_features = {k: dipeptide_features[k] for k in list(dipeptide_features.keys())[:420]}
-        ctd_features = CTD.CalculateCTD(sequence)
-        auto_features = Autocorrelation.CalculateAutoTotal(sequence)
-        pseudo_features = PseudoAAC.GetAPseudoAAC(sequence, lamda=9)
-
-        all_features_dict = {}
-        all_features_dict.update(ctd_features)
-        all_features_dict.update(filtered_dipeptide_features)
-        all_features_dict.update(auto_features)
-        all_features_dict.update(pseudo_features)
-
-        feature_df_all = pd.DataFrame([all_features_dict])
-        normalized_array = scaler.transform(feature_df_all.values)
-        normalized_df = pd.DataFrame(normalized_array, columns=feature_df_all.columns)
-
-        if not set(selected_features).issubset(normalized_df.columns):
-            return "Error: Some selected features are missing."
-
-        selected_df = normalized_df[selected_features].fillna(0)
-        return selected_df.values
+
+        # ----------------------------------------------------
+        # DIPEPTIDE
+        # ----------------------------------------------------
+
+        dipeptide_features = (
+            AAComposition.CalculateAADipeptideComposition(
+                sequence
+            )
+        )
+
+
+        filtered_dipeptide_features = {
+
+            k: dipeptide_features[k]
+
+            for k in list(
+                dipeptide_features.keys()
+            )[:420]
+        }
+
+
+        # ----------------------------------------------------
+        # CTD
+        # ----------------------------------------------------
+
+        ctd_features = (
+            CTD.CalculateCTD(
+                sequence
+            )
+        )
+
+
+        # ----------------------------------------------------
+        # AUTOCORRELATION
+        # ----------------------------------------------------
+
+        auto_features = (
+            Autocorrelation.CalculateAutoTotal(
+                sequence
+            )
+        )
+
+
+        # ----------------------------------------------------
+        # PSEUDO AAC
+        # ----------------------------------------------------
+
+        pseudo_features = (
+            PseudoAAC.GetAPseudoAAC(
+                sequence,
+                lamda=9
+            )
+        )
+
+
+        # ----------------------------------------------------
+        # COMBINE
+        # ----------------------------------------------------
+
+        all_features = {}
+
+        all_features.update(
+            ctd_features
+        )
+
+        all_features.update(
+            filtered_dipeptide_features
+        )
+
+        all_features.update(
+            auto_features
+        )
+
+        all_features.update(
+            pseudo_features
+        )
+
+
+        feature_df = pd.DataFrame(
+            [all_features]
+        )
+
+
+        # ----------------------------------------------------
+        # ALIGN WITH SCALER
+        # ----------------------------------------------------
+
+        if hasattr(
+            amp_scaler,
+            "feature_names_in_"
+        ):
+
+            scaler_features = list(
+                amp_scaler.feature_names_in_
+            )
+
+
+            missing_scaler = [
+                f
+                for f in scaler_features
+                if f not in feature_df.columns
+            ]
+
+
+            if missing_scaler:
+
+                return (
+                    None,
+                    "Missing features required by scaler: "
+                    + str(
+                        missing_scaler[:10]
+                    )
+                )
+
+
+            feature_df = (
+                feature_df[
+                    scaler_features
+                ]
+            )
+
+
+        # ----------------------------------------------------
+        # NORMALIZATION
+        # ----------------------------------------------------
+
+        normalized_array = (
+            amp_scaler.transform(
+                feature_df
+            )
+        )
+
+
+        normalized_df = pd.DataFrame(
+            normalized_array,
+            columns=feature_df.columns
+        )
+
+
+        # ----------------------------------------------------
+        # SELECT THE SAME 146 FEATURES
+        # ----------------------------------------------------
+
+        missing_selected = [
+            f
+            for f in selected_features
+            if f not in normalized_df.columns
+        ]
+
+
+        if missing_selected:
+
+            return (
+                None,
+                "Missing selected features: "
+                + str(
+                    missing_selected[:10]
+                )
+            )
+
+
+        selected_df = (
+            normalized_df[
+                selected_features
+            ]
+            .fillna(0)
+        )
+
+
+        X = (
+            selected_df
+            .values
+            .astype(np.float64)
+        )
+
+
+        # Final check
+        if X.shape[1] != len(
+            selected_features
+        ):
+
+            return (
+                None,
+                f"Feature count error: "
+                f"{X.shape[1]} generated."
+            )
+
+
+        return X, None
+
+
     except Exception as e:
-        return f"Error in feature extraction: {str(e)}"
 
-# MIC prediction function
-def predictmic(sequence):
-    sequence = ''.join([aa for aa in sequence.upper() if aa in "ACDEFGHIKLMNPQRSTVWY"])
+        return (
+            None,
+            f"{type(e).__name__}: {str(e)}"
+        )
+
+
+# ============================================================
+# MIC PREDICTION
+# ============================================================
+
+def predict_mic(sequence):
+
+    sequence = clean_sequence(
+        sequence
+    )
+
+
     if len(sequence) < 10:
-        return {"Error": "Sequence too short or invalid."}
 
-    seq_spaced = ' '.join(list(sequence))
-    tokens = tokenizer(seq_spaced, return_tensors="pt", padding='max_length', truncation=True, max_length=512)
-    tokens = {k: v.to(device) for k, v in tokens.items()}
+        return {
+            "Error": "Sequence too short."
+        }
+
+
+    # --------------------------------------------------------
+    # PROTBERT
+    # --------------------------------------------------------
+
+    seq_spaced = " ".join(
+        list(sequence)
+    )
+
+
+    tokens = tokenizer(
+        seq_spaced,
+        return_tensors="pt",
+        padding="max_length",
+        truncation=True,
+        max_length=512
+    )
+
+
+    tokens = {
+        k: v.to(device)
+        for k, v in tokens.items()
+    }
+
 
     with torch.no_grad():
-        outputs = protbert_model(**tokens)
-        embedding = outputs.last_hidden_state.mean(dim=1).squeeze().cpu().numpy().reshape(1, -1)
+
+        outputs = (
+            protbert_model(
+                **tokens
+            )
+        )
+
+
+        embedding = (
+            outputs
+            .last_hidden_state
+            .mean(dim=1)
+            .squeeze()
+            .cpu()
+            .numpy()
+            .reshape(1, -1)
+        )
+
+
+    # --------------------------------------------------------
+    # 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},
-        "K.Pneumonia": {"model": "pne_mlp_model.pkl", "scaler": "pne_scaler.pkl", "pca": "pne_pca.pkl"}
+
+        "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
+        },
+
+
+        "K. pneumoniae": {
+            "model":
+                "pne_mlp_model.pkl",
+
+            "scaler":
+                "pne_scaler.pkl",
+
+            "pca":
+                "pne_pca.pkl"
+        }
     }
 
+
     mic_results = {}
-    for bacterium, cfg in bacteria_config.items():
+
+
+    for bacterium, config in (
+        bacteria_config.items()
+    ):
+
         try:
-            # --- FIX (variable shadowing): renamed locals so the global `scaler`
-            # and `model` (the AMP RF + its MinMax scaler) are NEVER overwritten.
-            # The original code reused the names `scaler` and `model` here, which
-            # silently broke the AMP classifier on every prediction after the
-            # first MIC run.
-            mic_scaler = joblib.load(cfg["scaler"])
-            scaled = mic_scaler.transform(embedding)
-            transformed = joblib.load(cfg["pca"]).transform(scaled) if cfg["pca"] else scaled
-            mic_model = joblib.load(cfg["model"])
-            mic_log = mic_model.predict(transformed)[0]
-            mic = round(expm1(mic_log), 3)
-            mic_results[bacterium] = mic
+
+            mic_scaler = joblib.load(
+                config["scaler"]
+            )
+
+
+            mic_model = joblib.load(
+                config["model"]
+            )
+
+
+            scaled = (
+                mic_scaler.transform(
+                    embedding
+                )
+            )
+
+
+            if config["pca"]:
+
+                mic_pca = joblib.load(
+                    config["pca"]
+                )
+
+
+                transformed = (
+                    mic_pca.transform(
+                        scaled
+                    )
+                )
+
+            else:
+
+                transformed = scaled
+
+
+            mic_log = (
+                mic_model.predict(
+                    transformed
+                )[0]
+            )
+
+
+            mic = round(
+                expm1(mic_log),
+                3
+            )
+
+
+            mic_results[
+                bacterium
+            ] = mic
+
+
         except Exception as e:
-            mic_results[bacterium] = f"Error: {str(e)}"
+
+            mic_results[
+                bacterium
+            ] = (
+                f"Error: {str(e)}"
+            )
+
 
     return mic_results
 
-# Main prediction function
+
+# ============================================================
+# FULL PREDICTION
+# ============================================================
+
 def full_prediction(sequence):
-    features = extract_features(sequence)
-    if isinstance(features, str):
-        return features
 
-    prediction = model.predict(features)[0]
-    probabilities = model.predict_proba(features)[0]
+    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
+        )
+    )
+
+
+    if error:
+
+        return (
+            "Feature extraction failed:\n\n"
+            + error
+        )
+
+
+    # ========================================================
+    # 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)
-        confidence = round(probabilities[class_index] * 100, 2)
+
+        class_index = list(
+            model.classes_
+        ).index(
+            prediction
+        )
+
+
+        confidence = round(
+            probabilities[
+                class_index
+            ] * 100,
+            2
+        )
+
+
     except Exception:
-        confidence = "Unknown"
 
-    amp_result = "Antimicrobial Peptide (AMP)" if prediction == 0 else "Non-AMP"
-    result = f"Prediction: {amp_result}\nConfidence: {confidence}%\n"
+        confidence = None
+
+
+    # ========================================================
+    # AMP LABEL
+    # ========================================================
+
+    if prediction == 0:
+
+        amp_result = (
+            "Antimicrobial Peptide (AMP)"
+        )
+
+    else:
+
+        amp_result = (
+            "Non-AMP"
+        )
+
+
+    result = (
+        "====================================\n"
+        "AMP CLASSIFICATION\n"
+        "====================================\n\n"
+        f"Prediction: {amp_result}\n"
+        f"Confidence: {confidence}%\n"
+    )
+
+
+    # ========================================================
+    # LIME
+    # ========================================================
+
+    result += (
+        "\n====================================\n"
+        "LIME INTERPRETABILITY\n"
+        "====================================\n"
+    )
+
 
-    # --- LIME first (per spec: LIME before SHAP in the HTML report).
-    # explain_instance perturbs THIS single input sequence's feature row 2000
-    # times and fits a local linear model; weights describe this specific input.
     try:
-        explanation = explainer.explain_instance(
-            data_row=features[0],
-            predict_fn=model.predict_proba,
-            num_features=10,
-            num_samples=2000,
-        )
-        result += "\nTop Features Influencing Prediction (LIME):\n"
-        for feat, weight in explanation.as_list():
-            result += f"- {feat}: {round(weight, 4)}\n"
+
+        # Reproducibility
+        np.random.seed(42)
+
+
+        explanation = (
+            explainer.explain_instance(
+
+                data_row=features[0],
+
+                predict_fn=model.predict_proba,
+
+                labels=[
+                    int(prediction)
+                ],
+
+                num_features=10,
+
+                num_samples=3000
+            )
+        )
+
+
+        lime_results = (
+            explanation.as_list(
+                label=int(prediction)
+            )
+        )
+
+
+        result += (
+            "\nTop features contributing "
+            "to this prediction:\n"
+        )
+
+
+        for feature, weight in (
+            lime_results
+        ):
+
+            if weight > 0:
+
+                direction = "↑"
+
+            else:
+
+                direction = "↓"
+
+
+            result += (
+                f"\n{direction} "
+                f"{feature}: "
+                f"{weight:.4f}"
+            )
+
+
     except Exception as e:
-        result += f"\nLIME explanation failed: {str(e)}\n"
+
+        result += (
+            "\n\nLIME failed:\n"
+            f"{type(e).__name__}: {e}"
+        )
+
+
+    # ========================================================
+    # MIC
+    # ========================================================
 
     if prediction == 0:
-        mic_values = predictmic(sequence)
-        result += "\nPredicted MIC Values (μM):\n"
-        for org, mic in mic_values.items():
-            result += f"- {org}: {mic}\n"
+
+        result += (
+            "\n\n====================================\n"
+            "PREDICTED MIC VALUES\n"
+            "====================================\n"
+        )
+
+
+        mic_results = predict_mic(
+            sequence
+        )
+
+
+        for organism, value in (
+            mic_results.items()
+        ):
+
+            result += (
+                f"\n{organism}: "
+                f"{value} μM"
+            )
+
+
     else:
-        result += "\nMIC prediction skipped for Non-AMP sequences.\n"
+
+        result += (
+            "\n\nMIC prediction skipped "
+            "for Non-AMP sequences."
+        )
+
 
     return result
 
-# Gradio UI
+
+# ============================================================
+# GRADIO
+# ============================================================
+
 iface = gr.Interface(
+
     fn=full_prediction,
-    inputs=gr.Textbox(label="Enter Protein Sequence"),
-    outputs=gr.Textbox(label="Results"),
-    title="AMP & MIC Predictor + LIME Explanation",
-    description="Paste an amino acid sequence (≥10 characters). Get AMP classification, MIC predictions, and LIME interpretability insights."
+
+    inputs=gr.Textbox(
+        label="Protein Sequence",
+        placeholder=(
+            "Enter an amino acid sequence..."
+        ),
+        lines=5
+    ),
+
+    outputs=gr.Textbox(
+        label="Results",
+        lines=30
+    ),
+
+    title=(
+        "AMP & MIC Predictor + "
+        "LIME Interpretability"
+    ),
+
+    description=(
+        "Enter an amino acid sequence "
+        "(≥10 amino acids) to obtain AMP "
+        "classification, confidence, LIME "
+        "interpretability, and MIC predictions."
+    ),
+
+    examples=[
+        [
+            "GLWSKIKEVGKEAAKAAAKAAGKAALGAVSEAV"
+        ]
+    ],
+
+    allow_flagging="never"
 )
 
-# --- FIX (launch): removed share=True. On Hugging Face Spaces the public URL
-# is provided by the platform; share=True is for local dev only.
-iface.launch()
+
+# ============================================================
+# LAUNCH
+# ============================================================
+
+if __name__ == "__main__":
+
+    iface.launch()