Update app.py

app.py

@@ -1,53 +1,59 @@
 import gradio as gr
 import joblib
+from huggingface_hub import hf_hub_download
 import os
-import numpy as np
-
-
 
 def load_model():
-    """Load joblib model and components"""
+    """Download and load model from HF Hub"""
     try:
-        print("Loading joblib model...")
+        print("Loading model from Hugging Face Hub...")
         
-        # Load model (try different possible names)
-        model = None
-        model_file = None
+       
+        HF_USERNAME = "Daizzyy" 
+        HF_MODEL = "cyberbullying-model"  
+        repo_id = f"{HF_USERNAME}/{HF_MODEL}"
         
-        if os.path.exists("model.safetensors"):
-            print("Found model.safetensors")
-            model = joblib.load("model.safetensors")
-            model_file = "model.safetensors"
-        elif os.path.exists("model.jobilib"):
-            print("Found model.jobilib")
-            model = joblib.load("model.jobilib")
-            model_file = "model.jobilib"
-        elif os.path.exists("tfidf_logreg_best.jobilib"):
-            print("Found tfidf_logreg_best.jobilib")
-            model = joblib.load("tfidf_logreg_best.jobilib")
-            model_file = "tfidf_logreg_best.jobilib"
-        else:
-            # List available files
-            files = os.listdir(".")
-            print(f"Available files: {files}")
-            raise FileNotFoundError("No model file found")
+        print(f"Downloading from: {repo_id}")
+        
+        # Download and load model
+        try:
+            model_file = hf_hub_download(
+                repo_id=repo_id,
+                filename="tfidf_logreg_best.jobilib",
+                cache_dir=".cache"
+            )
+            model = joblib.load(model_file)
+            print(f"✅ Model loaded successfully")
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            return None
+        
+        # Download and load vectorizer
+        try:
+            vectorizer_file = hf_hub_download(
+                repo_id=repo_id,
+                filename="vocab",
+                cache_dir=".cache"
+            )
+            vectorizer = joblib.load(vectorizer_file)
+            print(f"✅ Vectorizer loaded successfully")
+        except Exception as e:
+            print(f"❌ Error loading vectorizer: {e}")
+            vectorizer = None
         
-        # Load vectorizer/tokenizer
-        vectorizer = None
-        if os.path.exists("vocab"):
-            print("Found vocab file")
-            vectorizer = joblib.load("vocab")
-        elif os.path.exists("tokenizer"):
-            print("Found tokenizer file")
-            vectorizer = joblib.load("tokenizer")
         
-        # Load label encoder
-        label_encoder = None
-        if os.path.exists("label_encoder.jobilib"):
-            print("Found label_encoder.jobilib")
-            label_encoder = joblib.load("label_encoder.jobilib")
+        try:
+            label_encoder_file = hf_hub_download(
+                repo_id=repo_id,
+                filename="label_encoder.jobilib",
+                cache_dir=".cache"
+            )
+            label_encoder = joblib.load(label_encoder_file)
+            print(f"✅ Label encoder loaded successfully")
+        except Exception as e:
+            print(f"⚠️ Label encoder not found (optional): {e}")
+            label_encoder = None
         
-        print(f"✅ Model loaded successfully from {model_file}")
         return {
             "model": model,
             "vectorizer": vectorizer,
@@ -55,42 +61,51 @@ def load_model():
         }
         
     except Exception as e:
-        print(f"❌ Error loading joblib model: {str(e)}")
+        print(f"❌ Critical error loading model: {str(e)}")
+        import traceback
+        print(traceback.format_exc())
         return None
 
-# Load model
+# Load model on startup
+print("Starting model loading...")
 model_components = load_model()
 
+if model_components is None:
+    print("⚠️ Model loading failed!")
+else:
+    print("✅ All models loaded successfully!")
 
 
 def predict(text):
-    """Predict cyberbullying category using joblib model"""
+    """Predict cyberbullying category"""
     if not text.strip():
         return "<div class='warn'>⚠️ Please enter some text.</div>"
     
     try:
+        # Check if models are loaded
         if model_components is None:
-            return "<div class='warn'>❌ Model not loaded properly</div>"
+            return "<div class='warn'>❌ Model not loaded. Please check server logs.</div>"
         
         model = model_components["model"]
         vectorizer = model_components["vectorizer"]
         label_encoder = model_components["label_encoder"]
         
-        # Vectorize the text
-        if vectorizer is not None:
-            text_vector = vectorizer.transform([text])
-        else:
-            return "<div class='warn'>❌ Vectorizer not found</div>"
+        # Check if vectorizer exists
+        if vectorizer is None:
+            return "<div class='warn'>❌ Vectorizer not available</div>"
+        
+        # Vectorize the input text
+        text_vector = vectorizer.transform([text])
         
         # Get prediction
         prediction = model.predict(text_vector)[0]
         
-        # Get probability if available
+        # Get confidence score
         try:
             probabilities = model.predict_proba(text_vector)[0]
             score = max(probabilities)
         except:
-            score = 0.8  # Default score
+            score = 0.8
         
         # Decode label if encoder exists
         if label_encoder is not None:
@@ -101,9 +116,9 @@ def predict(text):
         else:
             label = str(prediction)
         
-        print(f"Prediction: {label}, Score: {score}")
+        print(f"Prediction: {label}, Score: {score:.4f}")
         
-        # Category definitions
+        # Category definitions with colors and emojis
         cyberbullying_types = {
             "age": {"emoji": "👶", "color": "#ff6b6b", "text": "Age-Based Cyberbullying"},
             "gender": {"emoji": "⚥️", "color": "#ff8c42", "text": "Gender-Based Cyberbullying"},
@@ -113,9 +128,12 @@ def predict(text):
             "not_cyberbullying": {"emoji": "✅", "color": "#00ff64", "text": "Safe Message"}
         }
         
-        # Get category (handle case variations)
+        # Get category info (handle case variations)
         label_lower = str(label).lower().strip()
-        category = cyberbullying_types.get(label_lower, cyberbullying_types.get(label, cyberbullying_types["not_cyberbullying"]))
+        category = cyberbullying_types.get(
+            label_lower, 
+            cyberbullying_types.get(label, cyberbullying_types["not_cyberbullying"])
+        )
         
         # Safe message
         if label_lower == "not_cyberbullying":
@@ -146,7 +164,7 @@ def predict(text):
     except Exception as e:
         import traceback
         error_msg = traceback.format_exc()
-        print(f"ERROR: {str(e)}")
+        print(f"ERROR in prediction: {str(e)}")
         print(error_msg)
         return f"<div class='warn'>❌ Error: {str(e)}</div>"