Update src/streamlit_app.py

src/streamlit_app.py

@@ -3,28 +3,25 @@ import torch
 from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
 from openai import OpenAI
 import re
-import os
 
-# Page configuration
+# --- Page configuration ---
 st.set_page_config(
     page_title="Sentiment Analyzer",
     page_icon="🎭",
     layout="wide"
 )
 
-# Title and description
+# --- App Header ---
 st.title("🎭 Sentiment Analysis with AI Responses")
 st.markdown("**5-Class Amazon Review Sentiment Analysis + AI-Generated Customer Support Responses**")
 st.markdown("*Powered by GPT4.0 mini*")
 st.markdown("---")
 
-# HARDCODE YOUR GITHUB API KEY HERE
-GITHUB_TOKEN = "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"  # REPLACE WITH YOUR REAL KEY
+# --- API Key and Model Setup ---
+GITHUB_TOKEN = "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"
 
-# Initialize LLM client with your key
 @st.cache_resource
 def load_llm_client():
-    """Initialize GitHub Models client with hardcoded key"""
     try:
         return OpenAI(
             api_key=GITHUB_TOKEN,
@@ -34,24 +31,18 @@ def load_llm_client():
         st.error(f"Failed to initialize LLM client: {str(e)}")
         return None
 
-# Load model
 @st.cache_resource
 def load_sentiment_model():
-    """Load the fine-tuned DistilBERT model with proper 5-class handling"""
     try:
-        # EDIT THIS: Replace with your actual model path
-        model_name = "shivam-1706/distilbert-amazon-sentiment"  # UPDATE THIS
-        
-        # Load with explicit configuration
+        model_name = "shivam-1706/distilbert-amazon-sentiment"
         tokenizer = AutoTokenizer.from_pretrained(model_name)
         model = AutoModelForSequenceClassification.from_pretrained(model_name)
-        
-        # Verify model has 5 classes
+
         if model.config.num_labels == 5:
             st.success("✅ 5-class sentiment model loaded successfully!")
         else:
             st.warning(f"⚠️ Model has {model.config.num_labels} classes, expected 5")
-        
+
         return pipeline(
             "text-classification",
             model=model,
@@ -68,19 +59,16 @@ def load_sentiment_model():
             return_all_scores=True
         )
 
-# Load models
 with st.spinner("Loading DistilBERT model..."):
     sentiment_pipeline = load_sentiment_model()
 
-# Load LLM client automatically
 llm_client = load_llm_client()
 if llm_client:
     st.success("✅ GPT4.0 mini connected automatically!")
 
+# --- Helper functions ---
 def fix_problematic_words(text):
-    """Quick fix for specific words causing classification issues"""
     fixes = {
-        # Extremely positive words that need emphasis
         'phenomenal': 'absolutely amazing excellent outstanding incredible wonderful',
         'fabulous': 'excellent amazing wonderful fantastic great',
         'superb': 'excellent outstanding amazing great wonderful',
@@ -96,8 +84,6 @@ def fix_problematic_words(text):
         'incredible': 'amazing excellent outstanding wonderful',
         'outstanding': 'excellent amazing great wonderful',
         'remarkable': 'excellent amazing outstanding wonderful',
-
-        # Extremely negative words that need emphasis
         'horrendous': 'absolutely terrible awful horrible disgusting',
         'dreadful': 'terrible awful horrible bad disgusting',
         'atrocious': 'extremely terrible awful horrible disgusting',
@@ -109,154 +95,91 @@ def fix_problematic_words(text):
         'abominable': 'terrible awful horrible disgusting',
         'despicable': 'terrible awful horrible bad'
     }
-    
     text_fixed = text
-    for problematic, replacement in fixes.items():
-        text_fixed = re.sub(rf'\b{problematic}\b', replacement, text_fixed, flags=re.IGNORECASE)
-    
+    for word, replacement in fixes.items():
+        text_fixed = re.sub(rf'\b{word}\b', replacement, text_fixed, flags=re.IGNORECASE)
     return text_fixed
 
 def predict_sentiment_enhanced(text):
-    """Enhanced sentiment prediction ensuring 5-class output"""
     if not text.strip():
         return "Average", 0.20, {
-            'Very Bad': 0.10,
-            'Bad': 0.15, 
-            'Average': 0.50,
-            'Good': 0.15,
-            'Very Good': 0.10
+            'Very Bad': 0.10, 'Bad': 0.15, 'Average': 0.50, 'Good': 0.15, 'Very Good': 0.10
         }
-    
     try:
         results = sentiment_pipeline(fix_problematic_words(text))
         if isinstance(results[0], list):
             results = results[0]
-        
-        # Enhanced label mapping for 5-class model
+
         label_map = {
             'LABEL_0': 'Very Bad',
-            'LABEL_1': 'Bad', 
+            'LABEL_1': 'Bad',
             'LABEL_2': 'Average',
             'LABEL_3': 'Good',
             'LABEL_4': 'Very Good'
         }
-        
-        # Check if we have 5 classes (correct model)
+
         if len(results) == 5:
             best_result = max(results, key=lambda x: x['score'])
             sentiment = label_map.get(best_result['label'], best_result['label'])
             confidence = best_result['score']
-            
-            all_scores = {}
-            for result in results:
-                mapped_label = label_map.get(result['label'], result['label'])
-                all_scores[mapped_label] = result['score']
-            
+            all_scores = {label_map.get(r['label'], r['label']): r['score'] for r in results}
             return sentiment, confidence, all_scores
-        
-        # Fallback for 3-class model
         else:
             fallback_map = {'NEGATIVE': 'Bad', 'NEUTRAL': 'Average', 'POSITIVE': 'Good'}
             best_result = max(results, key=lambda x: x['score'])
             sentiment = fallback_map.get(best_result['label'], 'Average')
             confidence = best_result['score']
-            
-            # Create approximated 5-class scores
             all_scores = {'Very Bad': 0.0, 'Bad': 0.0, 'Average': 0.0, 'Good': 0.0, 'Very Good': 0.0}
-            for result in results:
-                mapped = fallback_map.get(result['label'], 'Average')
-                all_scores[mapped] = result['score']
-            
+            all_scores[sentiment] = confidence
             return sentiment, confidence, all_scores
-        
     except Exception as e:
         st.error(f"Error in prediction: {str(e)}")
         return "Average", 0.5, {'Average': 0.5}
 
 def generate_llm_response(review_text, sentiment):
-    """Generate AI-powered customer support response using your API key"""
     if not llm_client:
         return "❌ GitHub Models API not available. Please check your API key."
-    
-    # Same prompts as before...
-    prompts = {
-        'Very Bad': f"""You are a professional customer service manager. A customer left this review: "{review_text}"
-
-Their sentiment is very negative. Provide a professional response that:
-1. Shows genuine empathy and takes responsibility
-2. Offers concrete solutions: refund, replacement, customer support contact
-3. Provides next steps and assures resolution
-4. Don't mention star ratings
-
-Keep it professional and solution-focused (2-3 sentences).
-Response:""",
-
-        'Bad': f"""You are a customer service representative. A customer wrote: "{review_text}"
-
-Their experience was negative. Provide a response that:
-1. Acknowledges their concerns and validates feedback
-2. Offers solutions: replacement, troubleshooting, partial refund
-3. Asks for suggestions to improve
-4. Shows commitment to making it right
-
-Keep it constructive (2-3 sentences). Don't mention star ratings.
-Response:""",
-
-        'Average': f"""You are responding to a customer who wrote: "{review_text}"
 
-They had a mixed experience. Provide a response that:
-1. Thanks them for honest feedback
-2. Acknowledges both positives and areas for improvement
-3. Offers assistance and support
-4. Invites suggestions for enhancement
-
-Keep it balanced and appreciative (2-3 sentences). Don't mention star ratings.
+    prompts = {
+        'Very Bad': f"""You are a professional customer service manager. A customer left this review: "{review_text}"...
+Their sentiment is very negative. Provide a response that:
+1. Shows empathy
+2. Offers resolution (refund/replacement)
+3. Provides next steps
 Response:""",
 
-        'Good': f"""You are responding to a satisfied customer: "{review_text}"
+        'Bad': f"""You are a customer service rep. Customer said: "{review_text}"...
+Their experience was bad. Acknowledge & offer help. Response:""",
 
-They had a positive experience. Provide a response that:
-1. Thanks them genuinely for positive feedback
-2. Acknowledges specific aspects they liked
-3. Shows commitment to maintaining quality
-4. Offers continued support
+        'Average': f"""Respond to a mixed review: "{review_text}"...
+Thank, acknowledge, offer help, ask for suggestions. Response:""",
 
-Keep it appreciative (2-3 sentences). Don't mention star ratings.
-Response:""",
-
-        'Very Good': f"""You are responding to a delighted customer: "{review_text}"
+        'Good': f"""Customer left a positive review: "{review_text}"...
+Thank them and reinforce quality. Response:""",
 
-They had an excellent experience. Provide a response that:
-1. Expresses genuine gratitude for amazing feedback
-2. Celebrates their positive experience
-3. Shows this motivates your team
-4. Invites them to share their experience
-
-Keep it enthusiastic yet professional (2-3 sentences). Don't mention star ratings.
-Response:"""
+        'Very Good': f"""Delighted customer wrote: "{review_text}"...
+Celebrate, thank, and invite sharing. Response:"""
     }
-    
-    prompt = prompts.get(sentiment, prompts['Average'])
-    
+
     try:
         response = llm_client.chat.completions.create(
             model="gpt-4o-mini",
-            messages=[{"role": "user", "content": prompt}],
+            messages=[{"role": "user", "content": prompts.get(sentiment)}],
             max_tokens=150,
             temperature=0.7
         )
         return response.choices[0].message.content.strip()
-    except Exception as e:
-        fallbacks = {
-            'Very Bad': "We sincerely apologize for this disappointing experience. Please contact our customer support immediately so we can arrange a full refund or replacement.",
-            'Bad': "Thank you for bringing these concerns to our attention. We'd like to work together to find a solution that meets your needs.",
-            'Average': "We appreciate your honest feedback and suggestions. Your input helps us continue improving our products and services.",
-            'Good': "Thank you for your positive feedback! We're delighted you had a good experience and appreciate your support.",
-            'Very Good': "Wow, thank you for this fantastic review! Your enthusiasm means the world to our team."
+    except Exception:
+        fallback = {
+            'Very Bad': "We’re truly sorry for your experience. Please reach out so we can make this right.",
+            'Bad': "Thanks for your feedback. We’d like to help resolve your concern.",
+            'Average': "Thanks for your honest review. We're listening and happy to improve.",
+            'Good': "Thank you for your kind words! We appreciate your support.",
+            'Very Good': "We’re thrilled you loved it! Thanks for your amazing review."
         }
-        return fallbacks.get(sentiment, "Thank you for your valuable feedback!")
+        return fallback.get(sentiment, "Thank you for your feedback!")
 
-# Main interface
+# --- App Interface ---
 col1, col2 = st.columns([2, 1])
 
 with col1:
@@ -266,69 +189,56 @@ with col1:
         height=150,
         placeholder="Example: This product broke after just two days of use. Very disappointed with the quality and delivery was delayed too."
     )
-    
     analyze_button = st.button("🔍 Analyze & Generate Response", type="primary")
 
-with col2:
-    st.subheader("📊 Analysis Results")
-    
-    if analyze_button and review_text.strip():
-        with st.spinner("Analyzing sentiment..."):
-            sentiment, confidence, all_scores = predict_sentiment_enhanced(review_text)
-            
-            # Display sentiment
-            color_map = {
-                'Very Good': 'green',
-                'Good': 'blue', 
-                'Average': 'orange',
-                'Bad': 'red',
-                'Very Bad': 'violet'
-            }
-            
-            emoji_map = {
-                'Very Bad': '😡',
-                'Bad': '😞',
-                'Average': '😐',
-                'Good': '😊',
-                'Very Good': '🤩'
-            }
-            
-            color = color_map.get(sentiment, 'blue')
-            emoji = emoji_map.get(sentiment, '😐')
-            
-            st.markdown(f"**Sentiment:** :{color}[{sentiment}] {emoji}")
-            st.progress(confidence)
-            st.caption(f"Confidence: {confidence:.2%}")
-            
-            st.subheader("🎯 All 5 Class Predictions")
-            class_order = ['Very Bad', 'Bad', 'Average', 'Good', 'Very Good']
-            for class_name in class_order:
-                score = all_scores.get(class_name, 0.0)
-                emoji_display = emoji_map.get(class_name, '😐')
-                st.write(f"{emoji_display} {class_name}: {score:.1%}")
+if analyze_button and not review_text.strip():
+    st.warning("⚠️ Please enter a review to analyze!")
 
-# NEW: put response in col1 below the button
 if analyze_button and review_text.strip():
+    sentiment, confidence, all_scores = predict_sentiment_enhanced(review_text)
+
+    with col2:
+        st.subheader("📊 Analysis Results")
+
+        color_map = {
+            'Very Good': 'green',
+            'Good': 'blue',
+            'Average': 'orange',
+            'Bad': 'red',
+            'Very Bad': 'violet'
+        }
+        emoji_map = {
+            'Very Bad': '😡',
+            'Bad': '😞',
+            'Average': '😐',
+            'Good': '😊',
+            'Very Good': '🤩'
+        }
+        color = color_map.get(sentiment, 'blue')
+        emoji = emoji_map.get(sentiment, '😐')
+
+        st.markdown(f"**Sentiment:** :{color}[{sentiment}] {emoji}")
+        st.progress(confidence)
+        st.caption(f"Confidence: {confidence:.2%}")
+
+        st.subheader("🎯 All 5 Class Predictions")
+        class_order = ['Very Bad', 'Bad', 'Average', 'Good', 'Very Good']
+        for class_name in class_order:
+            score = all_scores.get(class_name, 0.0)
+            st.write(f"{emoji_map.get(class_name)} {class_name}: {score:.1%}")
+
     with col1:
         st.markdown("---")
         with st.spinner("Generating AI response..."):
             ai_response = generate_llm_response(review_text, sentiment)
-            
             st.subheader("🤖 AI Customer Support Response")
             st.info(ai_response)
-            
-            # Show strategy
+
             strategies = {
                 'Very Bad': "🆘 Crisis Management: Immediate resolution",
-                'Bad': "🔧 Problem Resolution: Solutions & improvements", 
+                'Bad': "🔧 Problem Resolution: Solutions & improvements",
                 'Average': "⚖️ Balanced: Acknowledge & enhance",
                 'Good': "👍 Appreciation: Maintain quality",
                 'Very Good': "🎉 Celebration: Encourage sharing"
             }
-            st.caption(f"**Strategy:** {strategies.get(sentiment, '⚖️ Balanced')}")
-    
-    elif analyze_button and not review_text.strip():
-        st.warning("⚠️ Please enter a review to analyze!")
-
-# Rest of your app (examples section, etc.) remains the same...
-# [Include the examples section, instructions, and footer from the previous code]
+            st.caption(f"**Strategy:** {strategies.get(sentiment)}")