Add debug version to diagnose model loading issues

app.py

@@ -1,232 +1,178 @@
 """
-Gradio Demo for Hebrew Intent Classification
-Deploy this as a Hugging Face Space
+Hebrew Intent Classification Demo - Debug Version
 """
 
 import gradio as gr
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import torch
-
-
-class HebrewIntentClassifier:
-    def __init__(self):
-        # Use your deployed model
+import sys
+import traceback
+
+def test_model_loading():
+    """Test if model can be loaded"""
+    try:
+        print("🔄 Testing model loading...")
+        from transformers import AutoTokenizer, AutoModelForSequenceClassification
+        
         model_name = "humy65/hebrew-intent-classifier"
-
-        try:
-            print(f"Loading Hebrew Intent Classification model: {model_name}")
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-            self.model = AutoModelForSequenceClassification.from_pretrained(
-                model_name)
-            self.model.eval()
-            print("Model loaded successfully!")
-            print(f"Model labels: {self.model.config.id2label}")
-        except Exception as e:
-            print(f"Error loading model: {e}")
-            import traceback
-            traceback.print_exc()
-            raise e
-
-    def predict(self, text):
-        """Predict intent for Hebrew text"""
-        if not text.strip():
-            return "Please enter some Hebrew text", {}, "אנא הכנס טקסט בעברית"
-
-        try:
-            # Tokenize input
-            inputs = self.tokenizer(
-                text,
-                return_tensors="pt",
-                padding=True,
-                truncation=True,
-                max_length=128
-            )
-
-            # Get prediction
-            with torch.no_grad():
-                outputs = self.model(**inputs)
-                logits = outputs.logits
-                probabilities = torch.softmax(logits, dim=-1)
-
-            # Get all predictions
-            all_scores = {}
-            for i, prob in enumerate(probabilities[0]):
-                intent_name = self.model.config.id2label[i]
-                all_scores[intent_name] = float(prob)
-
-            # Get top prediction
-            predicted_id = torch.argmax(logits, dim=-1).item()
-            predicted_label = self.model.config.id2label[predicted_id]
-            confidence = probabilities[0][predicted_id].item()
-
-            # Format results in Hebrew and English
-            intent_translations = {
-                "ביטול מנוי": "Cancel Subscription",
-                "שאלה כללית": "General Question", 
-                "שכחת סיסמה": "Password Reset",
-                "תמיכה טכנית": "Technical Support"
-            }
-
-            result_text = f"""
-🎯 **כוונה חזויה / Predicted Intent:** {predicted_label}
-🎲 **רמת ביטחון / Confidence:** {confidence:.1%}
-🔤 **תרגום / Translation:** {intent_translations.get(predicted_label, predicted_label)}
-
-📊 **כל התחזיות / All Predictions:**
-"""
-
-            # Sort by confidence and show all
-            sorted_scores = sorted(
-                all_scores.items(), key=lambda x: x[1], reverse=True)
-            for intent, score in sorted_scores:
-                bar = "█" * int(score * 20)
-                translation = intent_translations.get(intent, intent)
-                result_text += f"\\n{intent} ({translation}): {score:.1%} {bar}"
-
-            return result_text, all_scores, predicted_label
-
-        except Exception as e:
-            print(f"Prediction error: {e}")
-            import traceback
-            traceback.print_exc()
-            return f"Classification Error: {str(e)}", {}, f"Error: {str(e)}"
-
-
-# Initialize the classifier
-try:
-    classifier = HebrewIntentClassifier()
-except Exception as e:
-    print(f"Failed to initialize classifier: {e}")
-    classifier = None
-
+        print(f"📡 Attempting to load: {model_name}")
+        
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        print("✅ Tokenizer loaded")
+        
+        model = AutoModelForSequenceClassification.from_pretrained(model_name)
+        print("✅ Model loaded")
+        
+        print(f"📋 Labels: {model.config.id2label}")
+        return True, "Model loaded successfully!", model, tokenizer
+        
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        print(error_msg)
+        return False, error_msg, None, None
 
 def classify_text(text):
-    """Main classification function"""
-    if classifier is None:
-        return "❌ Model not loaded properly - please check logs", {}, "Model Error"
-    
+    """Classification function with lazy loading"""
     if not text or not text.strip():
-        return "⚠️ Please enter some Hebrew text to classify", {}, "Empty Input"
-
-    return classifier.predict(text)
-
-
-def load_example(example_text):
-    """Load example text into the input"""
-    return example_text
-
-
-# Create the Gradio interface
-with gr.Blocks(
-    title="🇮🇱 Hebrew Intent Classification",
-    theme=gr.themes.Soft(),
-    css=".rtl { direction: rtl; text-align: right; }"
-) as demo:
-
-    gr.Markdown("""
-    # 🇮🇱 מסווג כוונות עברית / Hebrew Intent Classification
-    
-    ## מה זה עושה? / What does this do?
+        return "⚠️ Please enter Hebrew text", {}
     
-    מסווג טקסט עברית לפי כוונת הלקוח לאחת מ-4 קטגוריות:
+    try:
+        # Try to load model on demand
+        success, message, model, tokenizer = test_model_loading()
+        
+        if not success:
+            return f"Model Loading Failed:\n{message}", {}
+        
+        # Perform classification
+        import torch
+        
+        inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=128)
+        
+        with torch.no_grad():
+            outputs = model(**inputs)
+            logits = outputs.logits
+            probabilities = torch.softmax(logits, dim=-1)
+        
+        # Get results
+        predicted_id = torch.argmax(logits, dim=-1).item()
+        predicted_label = model.config.id2label[predicted_id]
+        confidence = probabilities[0][predicted_id].item()
+        
+        # Create confidence scores for all labels
+        all_scores = {}
+        for i, prob in enumerate(probabilities[0]):
+            intent_name = model.config.id2label[i]
+            all_scores[intent_name] = float(prob)
+        
+        result = f"""
+🎯 Predicted Intent: {predicted_label}
+🎲 Confidence: {confidence:.1%}
+
+📊 All Predictions:
+"""
+        
+        # Sort and display
+        sorted_scores = sorted(all_scores.items(), key=lambda x: x[1], reverse=True)
+        for intent, score in sorted_scores:
+            bar = "█" * max(1, int(score * 20))
+            result += f"\n{intent}: {score:.1%} {bar}"
+        
+        return result, all_scores
+        
+    except Exception as e:
+        error_msg = f"Classification Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        print(error_msg)
+        return error_msg, {}
+
+def test_connection():
+    """Test Hugging Face connection"""
+    try:
+        from huggingface_hub import HfApi
+        api = HfApi()
+        info = api.model_info("humy65/hebrew-intent-classifier")
+        return f"✅ Model repository accessible\nModel ID: {info.modelId}\nLast Modified: {info.lastModified}"
+    except Exception as e:
+        return f"❌ Repository access failed: {str(e)}"
+
+# Create interface
+with gr.Blocks(title="Hebrew Intent Classification - Debug") as demo:
     
-    **Classifies Hebrew customer service text into 4 categories:**
+    gr.Markdown("# 🇮🇱 Hebrew Intent Classification - Debug Version")
     
-    - 🔐 **שכחת סיסמה** (Password Reset) - בעיות התחברות וסיסמאות
-    - ❌ **ביטול מנוי** (Cancel Subscription) - בקשות לביטול שירות  
-    - ❓ **שאלה כללית** (General Question) - שאלות על מחירים, שירותים, חשבון
-    - 🔧 **תמיכה טכנית** (Technical Support) - בעיות טכניות, תקלות, באגים
-    """)
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 📝 הכנס טקסט עברית / Enter Hebrew Text")
-
-            text_input = gr.Textbox(
-                label="טקסט / Text:",
-                placeholder="לדוגמה: שכחתי את הסיסמה שלי",
-                lines=4,
-                elem_classes=["rtl"],
-                info="הכנס טקסט בעברית הקשור לשירות לקוחות"
-            )
-
-            classify_btn = gr.Button(
-                "🔍 סווג כוונה / Classify Intent",
-                variant="primary",
-                size="lg"
-            )
-
-            gr.Markdown("### 📋 דוגמאות לניסוי / Try These Examples:")
-
-            examples = [
-                ("שכחתי את הסיסמה שלי", "🔐 שכחת סיסמה"),
-                ("רוצה לבטל את המנוי", "❌ ביטול מנוי"),
-                ("כמה עולה החבילה השנתית", "❓ שאלה כללית"),
-                ("האתר לא עובד לי", "🔧 תמיכה טכנית"),
-                ("איך אני משנה את האימייל", "❓ שאלה כללית"),
-                ("יש לי בעיה טכנית באפליקציה", "🔧 תמיכה טכנית"),
-                ("איך מבטלים את החשבון", "❌ ביטול מנוי"),
-                ("לא מצליח להיכנס למערכת", "🔐 שכחת סיסמה")
-            ]
-
-            for text, category in examples:
-                gr.Button(
-                    f"{category}: {text}",
-                    size="sm"
-                ).click(
-                    lambda x=text: x,
-                    outputs=text_input
+    with gr.Tab("Classification"):
+        with gr.Row():
+            with gr.Column():
+                text_input = gr.Textbox(
+                    label="Hebrew Text:",
+                    placeholder="שכחתי את הסיסמה שלי",
+                    lines=3
                 )
-
-        with gr.Column(scale=1):
-            gr.Markdown("### 📊 תוצאות / Results")
-
-            result_output = gr.Markdown(
-                value="התוצאות יופיעו כאן / Results will appear here",
-                elem_classes=["rtl"]
-            )
-
-            confidence_plot = gr.Label(
-                label="ציוני ביטחון / Confidence Scores",
-                num_top_classes=4
-            )
-
-            predicted_intent = gr.Textbox(
-                label="כוונה חזויה / Predicted Intent",
-                interactive=False
-            )
-
-    # Connect the classification function
+                classify_btn = gr.Button("Classify", variant="primary")
+                
+                # Quick examples
+                gr.Markdown("### Examples:")
+                examples = [
+                    "שכחתי את הסיסמה שלי",
+                    "רוצה לבטל את המנוי", 
+                    "כמה עולה החבילה",
+                    "האתר לא עובד"
+                ]
+                
+                for example in examples:
+                    gr.Button(example, size="sm").click(
+                        lambda x=example: x, outputs=text_input
+                    )
+            
+            with gr.Column():
+                result_output = gr.Textbox(
+                    label="Result:",
+                    lines=12,
+                    interactive=False
+                )
+                
+                confidence_output = gr.Label(
+                    label="Confidence Scores",
+                    num_top_classes=4
+                )
+    
+    with gr.Tab("Debug"):
+        gr.Markdown("### Debug Information")
+        
+        test_btn = gr.Button("Test Model Loading")
+        debug_output = gr.Textbox(
+            label="Debug Output:",
+            lines=15,
+            interactive=False
+        )
+        
+        test_btn.click(
+            lambda: test_model_loading()[1],
+            outputs=debug_output
+        )
+        
+        conn_btn = gr.Button("Test Repository Connection")
+        conn_output = gr.Textbox(
+            label="Connection Test:",
+            lines=5,
+            interactive=False
+        )
+        
+        conn_btn.click(
+            test_connection,
+            outputs=conn_output
+        )
+    
+    # Connect classification
     classify_btn.click(
         classify_text,
         inputs=[text_input],
-        outputs=[result_output, confidence_plot, predicted_intent]
+        outputs=[result_output, confidence_output]
     )
-
-    # Allow Enter key to trigger classification
+    
     text_input.submit(
         classify_text,
         inputs=[text_input],
-        outputs=[result_output, confidence_plot, predicted_intent]
+        outputs=[result_output, confidence_output]
     )
 
-    gr.Markdown("""
-    ---
-    ### 📈 מידע על המודל / Model Information
-    
-    - **בסיס / Base Model:** BERT Multilingual
-    - **נתוני אימון / Training Data:** 135 דוגמאות עברית מתחום שירות לקוחות
-    - **ביצועים / Performance:** דיוק גבוה >90% על טקסט עברית
-    - **קוד מקור / Source:** [GitHub Repository](https://github.com/your-repo)
-    
-    ### 🔗 קישורים / Links
-    - [Model on Hugging Face](https://huggingface.co/humy65/hebrew-intent-classifier)
-    - [Documentation](https://huggingface.co/humy65/hebrew-intent-classifier/blob/main/README.md)
-    
-    Built with ❤️ using Hugging Face Transformers and Gradio
-    """)
-
-# Launch the demo
 if __name__ == "__main__":
     demo.launch(
         share=True,