Update app.py

app.py

@@ -1,5 +1,4 @@
 import pandas as pd
-import numpy as np
 import re
 import nltk
 from nltk.corpus import stopwords
@@ -10,281 +9,135 @@ from sklearn.model_selection import train_test_split
 from sklearn.metrics import classification_report
 from sklearn.pipeline import Pipeline
 from sklearn.compose import ColumnTransformer
-from sklearn.preprocessing import FunctionTransformer
-import json
 import gradio as gr
 
-# Download NLTK resources
 nltk.download('stopwords')
 nltk.download('wordnet')
 nltk.download('omw-1.4')
 
-# --------------------
-# 1. Data Preparation
-# --------------------
-def load_data(file_path):
-    df = pd.read_excel('ai_dev_assignment_tickets_complex_1000.xls')
-    print(f"Original data shape: {df.shape}")
-    return df
+lemmatizer = WordNetLemmatizer()
+stop_words = set(stopwords.words('english'))
 
 def clean_text(text):
     if not isinstance(text, str):
         return ""
-    # Normalization
     text = text.lower()
     text = re.sub(r'[^a-z0-9\s]', '', text)
     return text
 
-def preprocess_data(df):
-    # Handle missing data
-    # df['ticket_text'] = df['ticket_text'].fillna('')
+def tokenize_lemmatize(text):
+    tokens = text.split()
+    return [lemmatizer.lemmatize(token) for token in tokens if token 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")
     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())
     )
-    
-    # Text cleaning
     df['clean_text'] = df['ticket_text'].apply(clean_text)
-    
-    # Tokenization and lemmatization
-    lemmatizer = WordNetLemmatizer()
-    stop_words = set(stopwords.words('english'))
-    
-    def tokenize_lemmatize(text):
-        tokens = text.split()
-        return [lemmatizer.lemmatize(token) for token in tokens if token not in stop_words]
-    
     df['processed_text'] = df['clean_text'].apply(tokenize_lemmatize).apply(' '.join)
-    return df
-
-# --------------------
-# 2. Feature Engineering
-# --------------------
-def feature_engineering(df):
-    # Text-based features
     df['ticket_length'] = df['clean_text'].apply(len)
     df['word_count'] = df['clean_text'].apply(lambda x: len(x.split()))
-    
-    # Sentiment score (simplified)
-    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
-    
     df['sentiment'] = df['clean_text'].apply(simple_sentiment)
-    return df
 
-# --------------------
-# 3. Multi-Task Learning
-# --------------------
-def train_models(df):
-    # Feature preparation
     X = df[['processed_text', 'ticket_length', 'word_count', 'sentiment']]
     y_issue = df['issue_type']
     y_urgency = df['urgency_level']
-    
-    # Train-test split
+
     X_train, X_test, y_issue_train, y_issue_test, y_urgency_train, y_urgency_test = train_test_split(
         X, y_issue, y_urgency, test_size=0.2, random_state=42
     )
-    
-    # Model pipelines
+
     text_transformer = Pipeline([
         ('tfidf', TfidfVectorizer(max_features=500))
     ])
-    
+
     preprocessor = ColumnTransformer(
         transformers=[
             ('text', text_transformer, 'processed_text'),
             ('num', 'passthrough', ['ticket_length', 'word_count', 'sentiment'])
         ])
-    
-    # Issue type classifier
+
     issue_pipe = Pipeline([
         ('preprocessor', preprocessor),
         ('clf', RandomForestClassifier(n_estimators=100, random_state=42))
     ])
-    
-    # Urgency classifier
+
     urgency_pipe = Pipeline([
         ('preprocessor', preprocessor),
         ('clf', RandomForestClassifier(n_estimators=100, random_state=42))
     ])
-    
-    # Train models
+
     issue_pipe.fit(X_train, y_issue_train)
     urgency_pipe.fit(X_train, y_urgency_train)
-    
-    # Evaluate models
-    print("Issue Type Classification Report:")
-    print(classification_report(y_issue_test, issue_pipe.predict(X_test)))
-    
-    print("\nUrgency Level Classification Report:")
-    print(classification_report(y_urgency_test, urgency_pipe.predict(X_test)))
-    
+
     return issue_pipe, urgency_pipe
 
-# --------------------
-# 4. Entity Extraction
-# --------------------
-def extract_entities(text,product_list):
-    # Initialize empty entities
-    entities = {
-        "product": [],
-        "dates": [],
-        "complaint_keywords": []
-    }
-    
-    # Product extraction (simulated product list)
-    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 extraction
-    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 keywords
-    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
+# Train the models at startup
+issue_model, urgency_model = load_and_train()
 
-# --------------------
-# 5. Integration
-# --------------------
-def process_ticket(ticket_text, issue_model, urgency_model):
-    # Create input dataframe
-    input_df = pd.DataFrame([{
-        'ticket_text': ticket_text,
-        'clean_text': clean_text(ticket_text),
-        'processed_text': ' '.join(tokenize_lemmatize(clean_text(ticket_text))),
-        'ticket_length': len(ticket_text),
-        'word_count': len(ticket_text.split()),
-        'sentiment': simple_sentiment(clean_text(ticket_text))
+def gradio_interface(ticket_text):
+    clean = clean_text(ticket_text)
+    tokens = tokenize_lemmatize(clean)
+    processed = ' '.join(tokens)
+    features = pd.DataFrame([{
+        'processed_text': processed,
+        'ticket_length': len(clean),
+        'word_count': len(clean.split()),
+        'sentiment': simple_sentiment(clean)
     }])
-    
-    # Predictions
-    issue_pred = issue_model.predict(input_df)[0]
-    urgency_pred = urgency_model.predict(input_df)[0]
-    
-    # Entity extraction
-    entities = extract_entities(ticket_text)
-    
-    return {
-        "issue_type": issue_pred,
-        "urgency_level": urgency_pred,
-        "entities": entities
-    }
-# --------------------
-# Gradio Interface Creation
-# --------------------
-def create_gradio_interface(predict_fn):
-    def wrapper(ticket_text):
-        try:
-            result = predict_fn(ticket_text)
-            return (
-                result["issue_type"],
-                result["urgency_level"],
-                json.dumps(result["entities"], indent=2)
-            )
-        except Exception as e:
-            return f"Error: {str(e)}", "", "{}"
-    
-    iface = gr.Interface(
-        fn=wrapper,
-        inputs=gr.Textbox(label="Ticket Text", lines=5),
-        outputs=[
-            gr.Textbox(label="Issue Type"),
-            gr.Textbox(label="Urgency Level"),
-            gr.JSON(label="Extracted Entities")
-        ],
-        title="Customer Support Ticket Analyzer",
-        description="Classify ticket issue type and urgency level, extract key entities",
-        examples=[
-            ["payment issue with smartwatch v2, underbilled order 29224"],
-            ["Router stopped working after update, need immediate help"],
-            ["Received damaged headphones in shipment, request refund"]
-        ]
-    )
-    return iface
 
-# --------------------
-# Main Execution (Corrected)
-# --------------------
-if __name__ == "__main__":
-    # Load data
-    df = load_data("ai_dev_assignment_tickets_complex_1000.xlsx")
-    
-    # Generate product list from data
-    all_products = df['product'].dropna().unique()
-    product_list = set()
-    for product in all_products:
-        # Split multi-word products and clean
-        words = re.split(r'\W+', str(product).lower())
-        product_list.update([w for w in words if w and len(w) > 1])
-    
-    # Add common tech products
-    product_list.update(['smartwatch', 'v2', 'v3', 'headphones', 'camera', 
-                        'phone', 'tablet', 'laptop', 'router', 'monitor', 'printer'])
-    
-    # Preprocess data
-    df = preprocess_data(df)
-    df = feature_engineering(df)
-    
-    # Train models
-    issue_model, urgency_model = train_models(df)
-    
-    # Create a function that takes ticket_text and returns the result
-    def updated_process_ticket(ticket_text):
-        return process_ticket(ticket_text, issue_model, urgency_model, product_list)
-    
-    # Create Gradio interface with the function
-    iface = create_gradio_interface(updated_process_ticket)
-    iface.launch(server_name="0.0.0.0", server_port=7866)
+    issue_pred = issue_model.predict(features)[0]
+    urgency_pred = urgency_model.predict(features)[0]
+    entities = extract_entities(ticket_text)
 
-# --------------------
-# Integration Function
-# --------------------
-def process_ticket(ticket_text, issue_model, urgency_model, product_list):
-    # Preprocess input
-    cleaned = clean_text(ticket_text)
-    tokenized = tokenize_lemmatize(cleaned)
-    processed_text = ' '.join(tokenized)
-    
-    # Create input features
-    input_df = pd.DataFrame([{
-        'ticket_text': ticket_text,
-        'clean_text': cleaned,
-        'processed_text': processed_text,
-        'ticket_length': len(cleaned),
-        'word_count': len(cleaned.split()),
-        'sentiment': simple_sentiment(cleaned)
-    }])
-    
-    # Predictions
-    issue_pred = issue_model.predict(input_df)[0]
-    urgency_pred = urgency_model.predict(input_df)[0]
-    
-    # Entity extraction with generated product list
-    entities = extract_entities(ticket_text, product_list)
-    
     return {
-        "issue_type": issue_pred,
-        "urgency_level": urgency_pred,
-        "entities": entities
+        "Predicted Issue Type": issue_pred,
+        "Predicted Urgency Level": urgency_pred,
+        "Extracted Entities": entities
     }
 
-#https://a60c2c3e8e37afc8af.gradio.live/
+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()