Update demo with enhanced Hebrew intent model

app.py

@@ -1,49 +1,226 @@
+"""
+Gradio Demo for Hebrew Intent Classification
+Deploy this as a Hugging Face Space
+"""
+
 import gradio as gr
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoConfig
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import torch
 
-# Load model and tokenizer from Hugging Face Hub
-model_name = "humy65/hebrew-intent-classifier"
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForSequenceClassification.from_pretrained(model_name)
-
-# Load config and extract label mapping
-config = AutoConfig.from_pretrained(model_name)
-
-# Try to get label names from config.id2label (if available)
-if hasattr(config, "id2label") and config.id2label:
-    intent_labels = [config.id2label[i] for i in range(config.num_labels)]
-else:
-    # Fallback: generate generic labels
-    intent_labels = [f"כוונה {i}" for i in range(config.num_labels)]
-
-def classify_intent(text):
-    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
-    with torch.no_grad():
-        outputs = model(**inputs)
-        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
-        top_prob, top_label = torch.max(probs, dim=1)
+
+class HebrewIntentClassifier:
+    def __init__(self):
+        # Use your deployed model
+        model_name = "Huggingm1r@n/hebrew-intent-classifier"
+
+        try:
+            print("Loading Hebrew Intent Classification model...")
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                model_name)
+            self.model.eval()
+            print("Model loaded successfully!")
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            raise e
+
+    def predict(self, text):
+        """Predict intent for Hebrew text"""
+        if not text.strip():
+            return "Please enter some Hebrew text", {}, "אנא הכנס טקסט בעברית"
+
         try:
-            intent = intent_labels[top_label.item()]
-        except IndexError:
-            intent = "כוונה לא מזוהה"
-        confidence = top_prob.item()
-    return f"כוונה: {intent}\nרמת ביטחון: {confidence:.2f}"
-
-# Build Gradio interface
-with gr.Blocks(theme="soft") as demo:
-    gr.Markdown("## 🔍 מסווג כוונות של סקולי")
-    gr.Markdown("מודל לזיהוי כוונות בשפה העברית. הקלד שאלה וראה את הכוונה המשוערת.")
+            # 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, "Unknown")}
+
+📊 **כל התחזיות / 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, "Unknown")
+                result_text += f"\\n{intent} ({translation}): {score:.1%} {bar}"
+
+            return result_text, all_scores, predicted_label
+
+        except Exception as e:
+            return f"Error: {str(e)}", {}, "שגיאה"
+
+
+# Initialize the classifier
+try:
+    classifier = HebrewIntentClassifier()
+except Exception as e:
+    print(f"Failed to initialize classifier: {e}")
+    classifier = None
+
+
+def classify_text(text):
+    """Main classification function"""
+    if classifier is None:
+        return "Model not loaded properly", {}, "Model Error"
+
+    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?
+    
+    מסווג טקסט עברית לפי כוונת הלקוח לאחת מ-4 קטגוריות:
+    
+    **Classifies Hebrew customer service text into 4 categories:**
     
-    # Display supported intents
-    gr.Markdown("### כוונות נתמכות:\n" + "\n".join(f"- {label}" for label in intent_labels))
+    - 🔐 **שכחת סיסמה** (Password Reset) - בעיות התחברות וסיסמאות
+    - ❌ **ביטול מנוי** (Cancel Subscription) - בקשות לביטול שירות  
+    - ❓ **שאלה כללית** (General Question) - שאלות על מחירים, שירותים, חשבון
+    - 🔧 **תמיכה טכנית** (Technical Support) - בעיות טכניות, תקלות, באגים
+    """)
 
     with gr.Row():
-        input_text = gr.Textbox(label="הקלד שאלה בעברית", placeholder="לדוגמה: שכחתי את הסיסמה שלי")
-    
-    output_text = gr.Textbox(label="תוצאה")
-    submit_btn = gr.Button("סווג")
+        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 = [
+                ("שכחתי את הסיסמה שלי", "🔐 שכחת סיסמה"),
+                ("רוצה לבטל את המנוי", "❌ ביטול מנוי"),
+                ("כמה עולה החבילה השנתית", "❓ שאלה כללית"),
+                ("האתר לא עובד לי", "🔧 תמיכה טכנית"),
+                ("איך אני משנה את האימייל", "❓ שאלה כללית"),
+                ("יש לי בעיה טכנית באפליקציה", "🔧 תמיכה טכנית"),
+                ("איך מבטלים את החשבון", "❌ ביטול מנוי"),
+                ("לא מצליח להיכנס למערכת", "🔐 שכחת סיסמה")
+            ]
 
-    submit_btn.click(fn=classify_intent, inputs=input_text, outputs=output_text)
+            for text, category in examples:
+                gr.Button(
+                    f"{category}: {text}",
+                    size="sm"
+                ).click(
+                    lambda x=text: x,
+                    outputs=text_input
+                )
+
+        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.click(
+        classify_text,
+        inputs=[text_input],
+        outputs=[result_output, confidence_plot, predicted_intent]
+    )
+
+    # Allow Enter key to trigger classification
+    text_input.submit(
+        classify_text,
+        inputs=[text_input],
+        outputs=[result_output, confidence_plot, predicted_intent]
+    )
+
+    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/Huggingm1r@n/hebrew-intent-classifier)
+    - [Documentation](https://huggingface.co/Huggingm1r@n/hebrew-intent-classifier/blob/main/README.md)
+    
+    Built with ❤️ using Hugging Face Transformers and Gradio
+    """)
 
-demo.launch()
+# Launch the demo
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860
+    )

requirements.txt

@@ -1,3 +1,4 @@
-transformers
-torch
-gradio
+gradio>=4.0.0
+transformers>=4.20.0
+torch>=1.9.0
+numpy