Add application file

app.py

@@ -1,231 +1,239 @@
-# app.py - Main Gradio interface for Hugging Face Space
-
 import gradio as gr
 import torch
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import numpy as np
 import pandas as pd
-from datasets import load_dataset
-
-# Load model and tokenizer from Hugging Face Hub
-MODEL_NAME = "Rajeshwartiwari/incident-classification-model"  # Your uploaded model
-CACHE_DIR = "./model_cache"
+import json
 
-# Initialize components
-tokenizer = None
-model = None
-label2id = None
-id2label = None
-
-def load_components():
-    """Load model and tokenizer"""
-    global tokenizer, model, label2id, id2label
-    
-    print("Loading model and tokenizer...")
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, cache_dir=CACHE_DIR)
-    model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, cache_dir=CACHE_DIR)
-    
-    # Get label mappings from model config
-    if hasattr(model.config, 'id2label') and model.config.id2label:
-        id2label = model.config.id2label
-        label2id = {v: k for k, v in id2label.items()}
-    else:
-        # Fallback: load from dataset
-        raw_dataset = load_dataset("6StringNinja/synthetic-servicenow-incidents")
-        labels = sorted(list(set(raw_dataset['train']['category'])))
-        label2id = {label: i for i, label in enumerate(labels)}
-        id2label = {i: label for i, label in enumerate(labels)}
-    
-    print(f"Model loaded. Available categories: {list(id2label.values())}")
-    return True
+# Configuration
+MODEL_NAME = "distilbert-base-uncased-finetuned-sst-2-english"  # Using a default model for testing
+# Replace with your model: "Rajeshwartiwari/incident-classification-model"
 
-def preprocess_text(text, max_length=128):
-    """Preprocess input text"""
-    return tokenizer(
-        text,
-        truncation=True,
-        padding="max_length",
-        max_length=max_length,
-        return_tensors="pt"
-    )
+# Default categories (replace with your actual categories)
+DEFAULT_CATEGORIES = [
+    "Software", "Hardware", "Network", "Database", 
+    "Security", "Access", "Email", "VPN", "Application"
+]
 
-def classify_incident(short_description, detailed_description=""):
-    """Classify incident text"""
-    if not tokenizer or not model:
-        return "Error: Model not loaded", {}
-    
-    # Combine inputs
-    full_text = f"{short_description} {detailed_description}".strip()
-    
-    if not full_text:
-        return "Please enter incident description", {}
-    
-    # Preprocess
-    inputs = preprocess_text(full_text)
-    
-    # Predict
-    with torch.no_grad():
-        outputs = model(**inputs)
-        logits = outputs.logits
-        probabilities = torch.nn.functional.softmax(logits, dim=-1)
-    
-    # Get predictions
-    predicted_class_id = logits.argmax().item()
-    predicted_label = id2label.get(predicted_class_id, "Unknown")
-    
-    # Get confidence scores for all classes
-    confidence_scores = {}
-    for idx, score in enumerate(probabilities[0]):
-        label_name = id2label.get(idx, f"Class_{idx}")
-        confidence_scores[label_name] = float(score) * 100
+class IncidentClassifier:
+    def __init__(self):
+        self.tokenizer = None
+        self.model = None
+        self.categories = DEFAULT_CATEGORIES
+        self.id2label = {i: label for i, label in enumerate(self.categories)}
+        self.loaded = False
+        
+    def load_model(self):
+        """Load the model - simplified for Hugging Face Spaces"""
+        try:
+            print("Loading tokenizer and model...")
+            self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                MODEL_NAME,
+                num_labels=len(self.categories)
+            )
+            self.loaded = True
+            return "✅ Model loaded successfully!"
+        except Exception as e:
+            return f"❌ Error loading model: {str(e)}"
     
-    # Sort by confidence
-    sorted_scores = dict(sorted(confidence_scores.items(), key=lambda x: x[1], reverse=True))
+    def predict(self, short_desc, detailed_desc=""):
+        """Make prediction"""
+        if not self.loaded:
+            return "Please load the model first", {}
+            
+        if not short_desc.strip():
+            return "Please enter incident description", {}
+        
+        # Combine text
+        full_text = f"{short_desc} {detailed_desc}".strip()
+        
+        # Tokenize
+        inputs = self.tokenizer(
+            full_text, 
+            return_tensors="pt", 
+            truncation=True, 
+            max_length=128
+        )
+        
+        # Predict
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        
+        # Get predictions
+        predicted_id = torch.argmax(probabilities).item()
+        predicted_label = self.id2label.get(predicted_id % len(self.categories), "Unknown")
+        
+        # Get all confidence scores
+        confidences = {}
+        for idx, prob in enumerate(probabilities[0]):
+            if idx < len(self.categories):
+                label = self.categories[idx]
+                confidences[label] = float(prob) * 100
+            else:
+                break
+        
+        # Sort by confidence
+        sorted_confidences = dict(sorted(confidences.items(), key=lambda x: x[1], reverse=True))
+        
+        return predicted_label, sorted_confidences
     
-    return predicted_label, sorted_scores
-
-def batch_classify(file):
-    """Classify incidents from CSV file"""
-    try:
-        df = pd.read_csv(file.name)
-        results = []
-        
-        # Check required columns
-        if 'short_description' not in df.columns:
-            return "Error: CSV must contain 'short_description' column"
-        
-        for idx, row in df.iterrows():
-            short_desc = str(row.get('short_description', ''))
-            detailed_desc = str(row.get('description', ''))
+    def batch_predict(self, csv_file):
+        """Process batch of incidents from CSV"""
+        if not self.loaded:
+            return pd.DataFrame({"Error": ["Model not loaded"]})
+        
+        try:
+            # Read CSV
+            df = pd.read_csv(csv_file.name)
             
-            predicted_label, scores = classify_incident(short_desc, detailed_desc)
+            results = []
+            for idx, row in df.iterrows():
+                short_desc = str(row.get('short_description', row.get('description', '')))
+                if len(short_desc) > 100:
+                    short_display = short_desc[:100] + "..."
+                else:
+                    short_display = short_desc
+                
+                predicted, confidences = self.predict(short_desc)
+                top_conf = max(confidences.values()) if confidences else 0
+                
+                results.append({
+                    "Incident": short_display,
+                    "Predicted Category": predicted,
+                    "Confidence": f"{top_conf:.1f}%",
+                    "Top 3 Predictions": ", ".join([
+                        f"{k}: {v:.1f}%" 
+                        for k, v in list(confidences.items())[:3]
+                    ])
+                })
             
-            # Get top 3 predictions
-            top_3 = dict(list(scores.items())[:3])
+            return pd.DataFrame(results)
             
-            results.append({
-                'short_description': short_desc[:100] + "..." if len(short_desc) > 100 else short_desc,
-                'predicted_category': predicted_label,
-                'confidence': f"{max(scores.values()):.1f}%" if scores else "N/A",
-                'top_3_predictions': ", ".join([f"{k}: {v:.1f}%" for k, v in top_3.items()])
-            })
-        
-        results_df = pd.DataFrame(results)
-        return results_df
-    
-    except Exception as e:
-        return f"Error processing file: {str(e)}"
+        except Exception as e:
+            return pd.DataFrame({"Error": [f"Failed to process CSV: {str(e)}"]})
+
+# Initialize classifier
+classifier = IncidentClassifier()
 
 # Create Gradio interface
 def create_interface():
-    with gr.Blocks(title="Incident Classification System", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="Incident Classifier", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
-        # 🚀 Incident Classification & Routing System
-        **Automatically classify service tickets and route to the correct team**
-        
-        Target: 90%+ accuracy in team identification
+        # 🔧 Incident Classification System
+        Automatically classify and route IT incidents to the correct team
         """)
         
+        # Model Status Section
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📊 Model Info")
-                gr.Markdown(f"""
-                - **Model**: {MODEL_NAME.split('/')[-1]}
-                - **Categories**: {len(id2label) if id2label else 'Loading...'}
-                - **Purpose**: Reduce false positives & multiple routing hops
-                """)
-                
-                # Load components button
-                load_btn = gr.Button("🔄 Load/Refresh Model", variant="primary")
-                status = gr.Textbox(label="Status", value="Click to load model", interactive=False)
-                
-                load_btn.click(
-                    fn=lambda: "✅ Model loaded successfully!" if load_components() else "❌ Failed to load model",
-                    outputs=status
+            status_box = gr.Textbox(
+                label="Model Status", 
+                value="⚠️ Model not loaded", 
+                interactive=False
+            )
+            load_btn = gr.Button("🔄 Load Model", variant="primary")
+        
+        # Single Incident Classification
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📝 Single Incident")
+                short_desc = gr.Textbox(
+                    label="Short Description*",
+                    placeholder="Brief description of the issue...",
+                    lines=2
                 )
-            
-            with gr.Column(scale=2):
-                gr.Markdown("### 🔍 Single Incident Classification")
-                
-                with gr.Row():
-                    short_desc = gr.Textbox(
-                        label="Short Description",
-                        placeholder="e.g., Cannot access Oracle database...",
-                        lines=2
-                    )
-                
                 detailed_desc = gr.Textbox(
                     label="Detailed Description (Optional)",
-                    placeholder="Additional details, error messages, steps to reproduce...",
-                    lines=4
+                    placeholder="Additional details, error messages...",
+                    lines=3
                 )
+                predict_btn = gr.Button("🔍 Classify", variant="primary")
                 
-                classify_btn = gr.Button("🎯 Classify Incident", variant="primary")
-                
+                # Results
                 with gr.Row():
                     prediction = gr.Textbox(label="Predicted Category", interactive=False)
-                    confidence = gr.Textbox(label="Confidence", interactive=False)
+                    confidence = gr.Textbox(label="Top Confidence", interactive=False)
                 
-                # Confidence scores visualization
-                confidence_plot = gr.Label(
-                    label="Detailed Confidence Scores",
+                confidences_chart = gr.Label(
+                    label="Confidence Scores",
                     num_top_classes=5
                 )
         
+        # Batch Processing
         with gr.Row():
-            gr.Markdown("### 📁 Batch Classification (CSV Upload)")
+            with gr.Column():
+                gr.Markdown("### 📁 Batch Processing")
+                gr.Markdown("Upload CSV with 'short_description' column")
+                
+                file_input = gr.File(
+                    label="Upload CSV",
+                    file_types=[".csv"],
+                    type="filepath"
+                )
+                batch_btn = gr.Button("📊 Process Batch", variant="secondary")
+                batch_output = gr.Dataframe(label="Results")
+        
+        # Examples
+        gr.Markdown("### 💡 Example Incidents")
+        examples = gr.Examples(
+            examples=[
+                ["Oracle database connection error ORA-12154", "Users cannot connect to production Oracle DB"],
+                ["Outlook not syncing emails", "Email client stopped receiving new messages"],
+                ["VPN keeps disconnecting", "Cisco AnyConnect drops connection every 5 minutes"],
+                ["Monitor screen flickering", "Display flickers with dark backgrounds"]
+            ],
+            inputs=[short_desc, detailed_desc],
+            label="Try these examples:"
+        )
+        
+        # Event Handlers
+        def on_load_model():
+            message = classifier.load_model()
+            if classifier.loaded:
+                return f"✅ Model loaded! {len(classifier.categories)} categories available"
+            return message
+        
+        def on_predict(short, detailed):
+            if not classifier.loaded:
+                return "Please load model first", {}, "0%"
             
-            file_input = gr.File(
-                label="Upload CSV file",
-                file_types=[".csv"],
-                type="filepath"
-            )
+            predicted, confidences = classifier.predict(short, detailed)
+            top_conf = max(confidences.values()) if confidences else 0
             
-            batch_btn = gr.Button("📊 Process Batch", variant="secondary")
-            batch_output = gr.Dataframe(label="Batch Results")
+            return predicted, confidences, f"{top_conf:.1f}%"
+        
+        # Connect events
+        load_btn.click(
+            fn=on_load_model,
+            outputs=status_box
+        )
         
-        # Connect single classification
-        classify_btn.click(
-            fn=classify_incident,
+        predict_btn.click(
+            fn=on_predict,
             inputs=[short_desc, detailed_desc],
-            outputs=[prediction, confidence_plot]
-        ).then(
-            fn=lambda x: f"{x:.1f}%" if isinstance(x, (int, float)) else x,
-            inputs=gr.State(0),  # Placeholder
-            outputs=confidence
+            outputs=[prediction, confidences_chart, confidence]
         )
         
-        # Connect batch classification
         batch_btn.click(
-            fn=batch_classify,
+            fn=classifier.batch_predict,
             inputs=file_input,
             outputs=batch_output
         )
-        
-        # Examples
-        gr.Markdown("### 📋 Example Incidents")
-        examples = [
-            ["I cannot access the Oracle database, getting ORA-12154 error", "Tried connecting via SQL Developer but getting TNS listener error. This started after the recent patch."],
-            ["Email client not syncing new messages", "Outlook 365 not downloading emails since 2 PM. Tried restarting and repairing Office."],
-            ["VPN connection drops every 5 minutes", "When connected to corporate VPN, it disconnects randomly. Using Cisco AnyConnect 4.10."],
-            ["Monitor screen flickering intermittently", "Dell UltraSharp monitor flickers when displaying dark colors. Already tried different cable."]
-        ]
-        
-        gr.Examples(
-            examples=examples,
-            inputs=[short_desc, detailed_desc],
-            outputs=[prediction, confidence_plot],
-            fn=classify_incident,
-            cache_examples=True
-        )
     
     return demo
 
-# Initialize components on startup
-if load_components():
-    print("✅ Components loaded successfully!")
-
-# Launch the interface
+# Launch the app
 if __name__ == "__main__":
+    # Try to load model on startup
+    print("Initializing Incident Classifier...")
+    
+    # Create and launch interface
     demo = create_interface()
-    demo.launch(debug=True)
+    
+    # For Hugging Face Spaces, use share=False
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    )

inference.py

@@ -0,0 +1,70 @@
+# inference.py - Simple inference script
+
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import gradio as gr
+
+class IncidentClassifier:
+    def __init__(self, model_name="Rajeshwartiwari/incident-classification-model"):
+        self.model_name = model_name
+        self.tokenizer = None
+        self.model = None
+        self.id2label = None
+        
+    def load(self):
+        """Load the model and tokenizer"""
+        print(f"Loading model: {self.model_name}")
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
+        self.id2label = self.model.config.id2label
+        print(f"Model loaded with {len(self.id2label)} categories")
+        return self
+    
+    def predict(self, text):
+        """Make prediction on input text"""
+        if not text.strip():
+            return "Please enter text", {}
+        
+        # Tokenize
+        inputs = self.tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            padding=True,
+            max_length=128
+        )
+        
+        # Predict
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        
+        # Get top prediction
+        predicted_id = outputs.logits.argmax().item()
+        predicted_label = self.id2label.get(predicted_id, "Unknown")
+        
+        # Get all confidences
+        confidences = {}
+        for idx, prob in enumerate(probabilities[0]):
+            label = self.id2label.get(idx, f"Class_{idx}")
+            confidences[label] = float(prob) * 100
+        
+        return predicted_label, confidences
+
+# Quick test
+if __name__ == "__main__":
+    classifier = IncidentClassifier().load()
+    
+    test_cases = [
+        "Oracle database connection error ORA-12154",
+        "Email not syncing in Outlook",
+        "VPN keeps disconnecting every few minutes",
+        "Monitor screen flickering issues"
+    ]
+    
+    for test in test_cases:
+        label, confidences = classifier.predict(test)
+        top_3 = dict(sorted(confidences.items(), key=lambda x: x[1], reverse=True)[:3])
+        print(f"\n📝 Input: {test}")
+        print(f"   🎯 Predicted: {label}")
+        print(f"   📊 Top 3: {top_3}")

requirements.txt

@@ -0,0 +1,9 @@
+torch>=2.0.0
+transformers>=4.36.0
+gradio>=4.0.0
+datasets>=2.16.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+numpy>=1.24.0
+accelerate>=0.24.0
+evaluate>=0.4.0

train.py

@@ -0,0 +1,191 @@
+# train.py - Training script for Hugging Face
+
+import os
+import torch
+import pandas as pd
+import numpy as np
+from datasets import load_dataset, DatasetDict
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    TrainingArguments,
+    Trainer,
+    DataCollatorWithPadding
+)
+import evaluate
+from sklearn.model_selection import train_test_split
+import json
+
+# Configuration
+CONFIG = {
+    "model_name": "distilbert-base-uncased",
+    "dataset_name": "6StringNinja/synthetic-servicenow-incidents",
+    "output_dir": "./incident-classifier",
+    "test_size": 0.2,
+    "random_state": 42,
+    "max_length": 128,
+    "batch_size": 16,
+    "learning_rate": 2e-5,
+    "num_epochs": 3,
+    "push_to_hub": True,
+    "hub_model_id": "Rajeshwartiwari/incident-classification-model"
+}
+
+def load_and_prepare_data():
+    """Load and split dataset"""
+    print("📂 Loading dataset...")
+    dataset = load_dataset(CONFIG["dataset_name"])
+    
+    # Convert to pandas for splitting
+    df = pd.DataFrame(dataset["train"])
+    
+    # Train/test split
+    train_df, test_df = train_test_split(
+        df,
+        test_size=CONFIG["test_size"],
+        random_state=CONFIG["random_state"],
+        stratify=df["category"]
+    )
+    
+    # Convert back to Hugging Face datasets
+    train_dataset = DatasetDict({"train": dataset["train"].new_from_pandas(train_df)})
+    test_dataset = DatasetDict({"test": dataset["train"].new_from_pandas(test_df)})
+    
+    # Get labels
+    labels = sorted(list(set(df["category"])))
+    label2id = {label: i for i, label in enumerate(labels)}
+    id2label = {i: label for i, label in enumerate(labels)}
+    
+    print(f"✅ Dataset loaded. Categories: {labels}")
+    print(f"   Train samples: {len(train_df)}, Test samples: {len(test_df)}")
+    
+    return train_dataset["train"], test_dataset["test"], label2id, id2label
+
+def tokenize_function(examples, tokenizer):
+    """Tokenize the examples"""
+    # Combine short description and description
+    texts = [
+        f"{sd} {d}" if d else sd 
+        for sd, d in zip(examples['short_description'], examples['description'])
+    ]
+    
+    # Tokenize
+    tokenized = tokenizer(
+        texts,
+        truncation=True,
+        padding=True,
+        max_length=CONFIG["max_length"]
+    )
+    
+    # Add labels
+    tokenized["labels"] = [label2id[l] for l in examples["category"]]
+    return tokenized
+
+def compute_metrics(eval_pred):
+    """Compute evaluation metrics"""
+    metric = evaluate.load("accuracy")
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    
+    # Calculate accuracy
+    accuracy = metric.compute(predictions=predictions, references=labels)
+    
+    # You can add more metrics here
+    return accuracy
+
+def main():
+    """Main training function"""
+    print("🚀 Starting Incident Classification Model Training")
+    
+    # Load data
+    train_dataset, test_dataset, label2id, id2label = load_and_prepare_data()
+    
+    # Initialize tokenizer and model
+    print("🔧 Initializing tokenizer and model...")
+    tokenizer = AutoTokenizer.from_pretrained(CONFIG["model_name"])
+    model = AutoModelForSequenceClassification.from_pretrained(
+        CONFIG["model_name"],
+        num_labels=len(label2id),
+        id2label=id2label,
+        label2id=label2id
+    )
+    
+    # Tokenize datasets
+    print("🔠 Tokenizing datasets...")
+    tokenized_train = train_dataset.map(
+        lambda x: tokenize_function(x, tokenizer),
+        batched=True,
+        remove_columns=train_dataset.column_names
+    )
+    
+    tokenized_test = test_dataset.map(
+        lambda x: tokenize_function(x, tokenizer),
+        batched=True,
+        remove_columns=test_dataset.column_names
+    )
+    
+    # Data collator
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+    
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir=CONFIG["output_dir"],
+        learning_rate=CONFIG["learning_rate"],
+        per_device_train_batch_size=CONFIG["batch_size"],
+        per_device_eval_batch_size=CONFIG["batch_size"],
+        num_train_epochs=CONFIG["num_epochs"],
+        weight_decay=0.01,
+        evaluation_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        report_to="none",  # Disable WandB by default
+        push_to_hub=CONFIG["push_to_hub"],
+        hub_model_id=CONFIG["hub_model_id"],
+        hub_strategy="end",
+        save_total_limit=2,
+    )
+    
+    # Initialize trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_train,
+        eval_dataset=tokenized_test,
+        tokenizer=tokenizer,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics,
+    )
+    
+    # Train
+    print("🎯 Starting training...")
+    trainer.train()
+    
+    # Evaluate
+    print("📊 Evaluating model...")
+    eval_results = trainer.evaluate()
+    print(f"✅ Evaluation results: {eval_results}")
+    
+    # Save everything locally
+    print("💾 Saving model locally...")
+    trainer.save_model(CONFIG["output_dir"])
+    tokenizer.save_pretrained(CONFIG["output_dir"])
+    
+    # Save label mappings
+    with open(os.path.join(CONFIG["output_dir"], "label_mappings.json"), "w") as f:
+        json.dump({"label2id": label2id, "id2label": id2label}, f, indent=2)
+    
+    # Save configuration
+    with open(os.path.join(CONFIG["output_dir"], "config.json"), "w") as f:
+        json.dump(CONFIG, f, indent=2)
+    
+    print(f"🎉 Training complete! Model saved to {CONFIG['output_dir']}")
+    
+    if CONFIG["push_to_hub"]:
+        print("☁️ Pushing to Hugging Face Hub...")
+        trainer.push_to_hub()
+        tokenizer.push_to_hub(CONFIG["hub_model_id"])
+        print(f"✅ Model pushed to: https://huggingface.co/{CONFIG['hub_model_id']}")
+
+if __name__ == "__main__":
+    main()