Update app.py

app.py

@@ -130,8 +130,12 @@ import re
 import nltk
 import numpy as np
 import traceback
+import warnings
 
 # --- 1. SETUP ---
+# Filter out the harmless warnings from the logs
+warnings.filterwarnings("ignore")
+
 from khmernltk import word_tokenize
 
 # NLTK Setup
@@ -174,18 +178,11 @@ def khmer_tokenize(text):
             
     return " ".join(processed_tokens)
 
-# --- 2. LOAD MODELS ---
-print("Loading processors...")
-try:
-    vectorizer = joblib.load("tfidf_vectorizer.joblib")
-    svd = joblib.load("truncated_svd.joblib")
-    print("✅ Vectorizer & SVD loaded")
-except Exception as e:
-    print(f"❌ CRITICAL LOAD ERROR: {e}")
-    vectorizer = None 
-    svd = None
-
-models = {}
+# --- 2. LAZY LOADING MODELS (Prevents Crashing) ---
+vectorizer = None
+svd = None
+models_cache = {} 
+
 model_files = {
     "XGBoost": "xgboost_model.joblib",
     "LightGBM": "lightgbm_model.joblib",
@@ -194,31 +191,49 @@ model_files = {
     "Linear SVM": "linear_svm_model.joblib"
 }
 
-for name, filename in model_files.items():
+def load_vectorizers():
+    global vectorizer, svd
+    if vectorizer is None:
+        try:
+            vectorizer = joblib.load("tfidf_vectorizer.joblib")
+            svd = joblib.load("truncated_svd.joblib")
+        except Exception as e:
+            print(f"Error loading vectorizers: {e}")
+            return False
+    return True
+
+def get_model(name):
+    if name in models_cache:
+        return models_cache[name]
+    
     try:
-        models[name] = joblib.load(filename)
-        print(f"✅ Loaded {name}")
+        filename = model_files.get(name)
+        if not filename: return None
+        loaded_model = joblib.load(filename)
+        models_cache[name] = loaded_model 
+        return loaded_model
     except Exception as e:
-        print(f"⚠️ Skipping {name}: {e}")
+        print(f"Error loading {name}: {e}")
+        return None
 
 # --- 3. PREDICTION FUNCTION ---
 def predict(text, model_name):
     if not text: 
         return "Please enter text", {}, []
     
-    if model_name not in models: 
-        return "Model not found", {}, []
+    # Load resources only when needed
+    if not load_vectorizers():
+        return "System Error: Vectorizers missing", {}, []
 
-    if vectorizer is None or svd is None:
-        return "Vectorizers not loaded", {}, []
+    current_model = get_model(model_name)
+    if current_model is None:
+        return f"Error: Could not load {model_name}", {}, []
 
     try:
         processed = khmer_tokenize(text)
         vectors = vectorizer.transform([processed])
         vectors_reduced = svd.transform(vectors)
         
-        current_model = models[model_name]
-        
         # --- Keyword Extraction ---
         feature_array = np.array(vectorizer.get_feature_names_out())
         tfidf_sorting = np.argsort(vectors.toarray()).flatten()[::-1]
@@ -233,21 +248,34 @@ def predict(text, model_name):
         confidences = {}
         top_label = ""
         
+        # CASE A: Models that support probabilities (XGBoost, RF, etc.)
         if hasattr(current_model, "predict_proba"):
             probas = current_model.predict_proba(vectors_reduced)[0]
             for i in range(len(LABELS)):
                 if i < len(probas):
                     confidences[LABELS[i]] = float(probas[i])
             top_label = max(confidences, key=confidences.get)
+            
+        # CASE B: Models without probabilities (SVM, etc.)
         else:
             raw_pred = current_model.predict(vectors_reduced)[0]
-            if isinstance(raw_pred, (int, np.integer, float, np.floating)):
+            
+            # --- FIX FOR [1 0 0 0] ISSUE ---
+            # If the model returns an array/list (One-Hot Encoded), we find the index of the highest value
+            if isinstance(raw_pred, (list, np.ndarray)):
+                pred_idx = np.argmax(raw_pred)
+                top_label = LABELS[pred_idx]
+            
+            # If the model returns a simple integer number
+            elif isinstance(raw_pred, (int, np.integer, float, np.floating)):
                  pred_idx = int(raw_pred)
                  top_label = LABELS[pred_idx]
-                 confidences = {LABELS[pred_idx]: 1.0}
+            
+            # Fallback (rare)
             else:
                  top_label = str(raw_pred)
-                 confidences = {top_label: 1.0}
+            
+            confidences = {top_label: 1.0}
 
         return top_label, confidences, keywords
             
@@ -260,7 +288,7 @@ demo = gr.Interface(
     fn=predict,
     inputs=[
         gr.Textbox(lines=5, placeholder="Enter Khmer news text here...", label="Input Text"), 
-        gr.Dropdown(choices=list(models.keys()), value="XGBoost", label="Select Model")
+        gr.Dropdown(choices=list(model_files.keys()), value="XGBoost", label="Select Model")
     ],
     outputs=[
         gr.Label(label="Top Prediction"), 
@@ -272,5 +300,4 @@ demo = gr.Interface(
 )
 
 if __name__ == "__main__":
-    # ssr_mode=False is CRITICAL for stability on HF Spaces currently
-    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)
+    demo.launch()