Update app.py

app.py

@@ -1,4 +1,7 @@
+# ticket_classifier.py
+
 import pandas as pd
+import numpy as np
 import re
 import nltk
 from nltk.corpus import stopwords
@@ -10,67 +13,53 @@ from sklearn.metrics import classification_report
 from sklearn.pipeline import Pipeline
 from sklearn.compose import ColumnTransformer
 import gradio as gr
+import json
 
+# Download NLTK resources
 nltk.download('stopwords')
 nltk.download('wordnet')
 nltk.download('omw-1.4')
 
-lemmatizer = WordNetLemmatizer()
-stop_words = set(stopwords.words('english'))
+# -------------------- 1. Load and Preprocess --------------------
+def load_data(file_path):
+    df = pd.read_excel(file_path)
+    print(f"Loaded data shape: {df.shape}")
+    return df
 
 def clean_text(text):
     if not isinstance(text, str):
         return ""
-    text = text.lower()
-    text = re.sub(r'[^a-z0-9\s]', '', text)
-    return text
+    return re.sub(r'[^a-z0-9\s]', '', text.lower())
 
 def tokenize_lemmatize(text):
-    tokens = text.split()
-    return [lemmatizer.lemmatize(token) for token in tokens if token not in stop_words]
+    lemmatizer = WordNetLemmatizer()
+    stop_words = set(stopwords.words('english'))
+    return [lemmatizer.lemmatize(word) for word in text.split() if word not in stop_words]
 
-def simple_sentiment(text):
-    positive = ['good', 'great', 'excellent', 'thanks']
-    negative = ['bad', 'broken', 'late', 'error', 'issue', 'problem']
-    tokens = text.split()
-    pos_count = sum(1 for word in tokens if word in positive)
-    neg_count = sum(1 for word in tokens if word in negative)
-    return (pos_count - neg_count) / len(tokens) if tokens else 0
-
-def extract_entities(text):
-    entities = {"product": [], "dates": [], "complaint_keywords": []}
-    product_list = ['phone', 'tablet', 'laptop', 'router', 'monitor', 'printer']
-    for product in product_list:
-        if re.search(rf"\\b{product}\\b", text, re.IGNORECASE):
-            entities["product"].append(product)
-
-    date_patterns = [
-        r'\d{1,2}/\d{1,2}/\d{2,4}',
-        r'\d{1,2}-\d{1,2}-\d{2,4}',
-        r'\b(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]* \d{1,2},? \d{4}\b'
-    ]
-    for pattern in date_patterns:
-        entities["dates"].extend(re.findall(pattern, text))
-
-    complaint_words = ['broken', 'damage', 'late', 'delay', 'error', 'fault', 
-                      'defect', 'issue', 'problem', 'not working', 'failed']
-    for word in complaint_words:
-        if re.search(rf"\\b{word}\\b", text, re.IGNORECASE):
-            entities["complaint_keywords"].append(word)
-    return entities
-
-def load_and_train():
-    df = pd.read_excel("ai_dev_assignment_tickets_complex_1000.xls")
+def preprocess_data(df):
     df[['ticket_text','issue_type','urgency_level']] = (
-        df.groupby('product')[['ticket_text', 'issue_type','urgency_level']]
-        .transform(lambda group: group.ffill().bfill())
+        df.groupby('product')[['ticket_text','issue_type','urgency_level']]
+          .transform(lambda group: group.ffill().bfill())
     )
     df['clean_text'] = df['ticket_text'].apply(clean_text)
-    df['processed_text'] = df['clean_text'].apply(tokenize_lemmatize).apply(' '.join)
+    df['processed_text'] = df['clean_text'].apply(lambda x: ' '.join(tokenize_lemmatize(x)))
+    return df
+
+# -------------------- 2. Feature Engineering --------------------
+def simple_sentiment(text):
+    pos = ['good', 'great', 'excellent', 'thanks']
+    neg = ['bad', 'broken', 'late', 'error', 'issue', 'problem']
+    tokens = text.split()
+    return (sum(w in pos for w in tokens) - sum(w in neg for w in tokens)) / (len(tokens) or 1)
+
+def feature_engineering(df):
     df['ticket_length'] = df['clean_text'].apply(len)
     df['word_count'] = df['clean_text'].apply(lambda x: len(x.split()))
     df['sentiment'] = df['clean_text'].apply(simple_sentiment)
+    return df
 
+# -------------------- 3. Train Models --------------------
+def train_models(df):
     X = df[['processed_text', 'ticket_length', 'word_count', 'sentiment']]
     y_issue = df['issue_type']
     y_urgency = df['urgency_level']
@@ -79,65 +68,72 @@ def load_and_train():
         X, y_issue, y_urgency, test_size=0.2, random_state=42
     )
 
-    text_transformer = Pipeline([
+    text_pipe = Pipeline([
         ('tfidf', TfidfVectorizer(max_features=500))
     ])
 
-    preprocessor = ColumnTransformer(
-        transformers=[
-            ('text', text_transformer, 'processed_text'),
-            ('num', 'passthrough', ['ticket_length', 'word_count', 'sentiment'])
-        ])
+    preprocessor = ColumnTransformer([
+        ('text', text_pipe, 'processed_text'),
+        ('numeric', 'passthrough', ['ticket_length', 'word_count', 'sentiment'])
+    ])
 
-    issue_pipe = Pipeline([
-        ('preprocessor', preprocessor),
+    issue_model = Pipeline([
+        ('pre', preprocessor),
         ('clf', RandomForestClassifier(n_estimators=100, random_state=42))
     ])
 
-    urgency_pipe = Pipeline([
-        ('preprocessor', preprocessor),
+    urgency_model = Pipeline([
+        ('pre', preprocessor),
         ('clf', RandomForestClassifier(n_estimators=100, random_state=42))
     ])
 
-    issue_pipe.fit(X_train, y_issue_train)
-    urgency_pipe.fit(X_train, y_urgency_train)
+    issue_model.fit(X_train, y_issue_train)
+    urgency_model.fit(X_train, y_urgency_train)
 
-    return issue_pipe, urgency_pipe
+    print("Issue Classification:\n", classification_report(y_issue_test, issue_model.predict(X_test)))
+    print("Urgency Classification:\n", classification_report(y_urgency_test, urgency_model.predict(X_test)))
 
-# Train the models at startup
-issue_model, urgency_model = load_and_train()
+    return issue_model, urgency_model
 
-def gradio_interface(ticket_text):
-    clean = clean_text(ticket_text)
-    tokens = tokenize_lemmatize(clean)
-    processed = ' '.join(tokens)
+# -------------------- 4. Predict Single Ticket --------------------
+def predict_ticket(ticket_text, issue_model, urgency_model):
+    cleaned = clean_text(ticket_text)
+    processed = ' '.join(tokenize_lemmatize(cleaned))
     features = pd.DataFrame([{
         'processed_text': processed,
-        'ticket_length': len(clean),
-        'word_count': len(clean.split()),
-        'sentiment': simple_sentiment(clean)
+        'ticket_length': len(cleaned),
+        'word_count': len(cleaned.split()),
+        'sentiment': simple_sentiment(cleaned)
     }])
+    return issue_model.predict(features)[0], urgency_model.predict(features)[0]
+
+# -------------------- 5. Gradio Interface --------------------
+def create_gradio_interface(issue_model, urgency_model):
+    def wrapped(ticket_text):
+        try:
+            issue, urgency = predict_ticket(ticket_text, issue_model, urgency_model)
+            return issue, urgency
+        except Exception as e:
+            return f"Error: {e}", ""
+
+    return gr.Interface(
+        fn=wrapped,
+        inputs=gr.Textbox(label="Ticket Text", lines=4),
+        outputs=[
+            gr.Textbox(label="Predicted Issue Type"),
+            gr.Textbox(label="Predicted Urgency Level")
+        ],
+        title="Support Ticket Classifier",
+        description="Enter a ticket to classify its issue type and urgency level."
+    )
+
+# -------------------- 6. Main --------------------
+if __name__ == "__main__":
+    df = load_data("ai_dev_assignment_tickets_complex_1000.xls")
+    df = preprocess_data(df)
+    df = feature_engineering(df)
+    issue_model, urgency_model = train_models(df)
+    iface = create_gradio_interface(issue_model, urgency_model)
 
-    issue_pred = issue_model.predict(features)[0]
-    urgency_pred = urgency_model.predict(features)[0]
-    entities = extract_entities(ticket_text)
-
-    return {
-        "Predicted Issue Type": issue_pred,
-        "Predicted Urgency Level": urgency_pred,
-        "Extracted Entities": entities
-    }
-
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs=gr.Textbox(lines=5, placeholder="Enter ticket text here..."),
-    outputs=[
-        gr.Textbox(label="Predicted Issue Type"),
-        gr.Textbox(label="Predicted Urgency Level"),
-        gr.JSON(label="Extracted Entities")
-    ],
-    title="Support Ticket Classifier",
-    description="Classifies support ticket issue type and urgency, and extracts key entities."
-)
-
-iface.launch()
+    #Deploy to public Gradio space (with temporary link)
+    iface.launch(share=True)