Upload 2 files

app.py

@@ -0,0 +1,262 @@
+import streamlit as st
+import pandas as pd
+from transformers import pipeline
+import torch  # For GPU checks
+import numpy as np
+from groq import Groq
+import os
+import time
+
+# Set page config
+st.set_page_config(
+    page_title="Restaurant Review Analyzer 🍽️",
+    page_icon="🔍",
+    layout="wide"
+)
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .main {
+        padding: 2rem;
+    }
+    .stProgress > div > div > div {
+        background-color: #1f77b4;
+    }
+    .metric-card {
+        background-color: #f8f9fa;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+
+def setup_classifier():
+    """Initialize the zero-shot classification pipeline with GPU support if available"""
+    with st.spinner('Loading classification model... ⚙️'):
+        device = 0 if torch.cuda.is_available() else -1  # Use GPU if available
+        return pipeline(
+            "zero-shot-classification",
+            model="joeddav/xlm-roberta-large-xnli",
+            device=device
+        )
+
+
+def create_aspect_labels():
+    """Create labels for all aspects with positive/negative sentiment"""
+    aspects = [
+        "food quality",
+        "service",
+        "ambiance",
+        "price",
+        "cleanliness",
+        "portion size",
+        "wait time",
+        "menu variety"
+    ]
+
+    sentiment_labels = []
+    for aspect in aspects:
+        sentiment_labels.extend([
+            f"positive {aspect}",
+            f"negative {aspect}"
+        ])
+
+    return aspects, sentiment_labels
+
+
+def classify_review(classifier, review, sentiment_labels):
+    """Classify a single review across all aspects and sentiments"""
+    if pd.isna(review) or not isinstance(review, str):
+        return {label: 0 for label in sentiment_labels}
+
+    try:
+        result = classifier(
+            review,
+            sentiment_labels,
+            multi_label=True
+        )
+        return dict(zip(result['labels'], result['scores']))
+    except Exception as e:
+        st.error(f"Error processing review: {e}")
+        return {label: 0 for label in sentiment_labels}
+
+def format_summary_for_llm(summary_df):
+    """Format the classification summary into a clear text prompt"""
+    summary_text = "Restaurant Reviews Analysis Summary:\n\n"
+
+    sentiment_analysis = {}
+    for aspect in summary_df.index:
+        pos = summary_df.loc[aspect, 'positive_mentions']
+        neg = summary_df.loc[aspect, 'negative_mentions']
+        total = pos + neg
+        if total > 0:
+            pos_percent = (pos / total) * 100
+            neg_percent = (neg / total) * 100
+            difference = pos_percent - neg_percent
+            sentiment_analysis[aspect] = {
+                'difference': difference,
+                'positive_percent': pos_percent,
+                'negative_percent': neg_percent,
+                'total_mentions': total
+            }
+
+    for aspect, metrics in sentiment_analysis.items():
+        summary_text += f"{aspect}:\n"
+        summary_text += f"- Total Mentions: {metrics['total_mentions']}\n"
+        summary_text += f"- Positive Mentions: {metrics['positive_percent']:.1f}%\n"
+        summary_text += f"- Negative Mentions: {metrics['negative_percent']:.1f}%\n"
+        summary_text += f"- Sentiment Difference: {metrics['difference']:.1f}%\n"
+        summary_text += "\n"
+
+    return summary_text
+
+def generate_insights(groq_client, summary_text):
+    """Generate insights using Groq API"""
+    prompt = f"""You are an expert restaurant consultant analyzing customer feedback data.
+    Based on the following customer review analysis summary, provide actionable insights
+    and recommendations for the restaurant owner. When analyzing the data:
+
+    - If an aspect has a positive difference of 0.5% or more, consider it a strength
+    - If an aspect has a negative difference of 0.5% or more, consider it an area for improvement
+    - For differences smaller than 0.5%, consider the aspect neutral or mixed
+    - Pay special attention to aspects with high total mentions as they represent stronger customer sentiment
+
+    Analysis Data:
+    {summary_text}
+
+    Please provide:
+    1. Key Strengths: What's working well (aspects with >0.5% positive difference)
+    2. Areas for Improvement: What needs attention (aspects with >0.5% negative difference)
+    3. Mixed Reception Areas: Aspects with minimal difference (<0.5%) between positive and negative
+    4. Actionable Recommendations: Specific steps based on the analysis
+    5. Priority Actions: What should be addressed first, considering both sentiment differences and total mention count
+
+    Format your response in clear sections with bullet points where appropriate.
+    Add relevant emojis to make the response more engaging.
+    """
+
+    try:
+        with st.spinner('Generating insights... 🤔'):
+            chat_completion = groq_client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model="mixtral-8x7b-32768",
+                temperature=0.7,
+                max_tokens=1500,
+            )
+            return chat_completion.choices[0].message.content
+    except Exception as e:
+        st.error(f"Error generating insights: {str(e)}")
+        return None
+
+def main():
+    # Header
+    st.title("🍽️ Restaurant Review Analyzer")
+    st.markdown("### Transform your customer feedback into actionable insights! 📊")
+
+    # Sidebar
+    st.sidebar.header("📝 Configuration")
+
+    # File upload
+    uploaded_file = st.sidebar.file_uploader("Upload your CSV file", type=['csv'])
+
+    if uploaded_file is not None:
+        # Read CSV
+        try:
+            df = pd.read_csv(uploaded_file)
+            df.columns = df.columns.str.strip()
+
+            # Validate 'Review' column
+            if 'Review' not in df.columns:
+                st.error("❌ 'Review' column not found in the CSV file!")
+                return
+
+            # Show sample of uploaded data
+            st.subheader("📋 Sample Reviews")
+            st.dataframe(df[['Review']].head(5), use_container_width=True)
+
+            # Process reviews
+            if st.button("🚀 Analyze Reviews"):
+                # Initialize classifier
+                classifier = setup_classifier()
+                aspects, sentiment_labels = create_aspect_labels()
+
+                # Process reviews with progress bar
+                results = []
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+
+                for idx, review in enumerate(df['Review'].head(30)):
+                    status_text.text(f"Processing review {idx + 1}/30...")
+                    scores = classify_review(classifier, review, sentiment_labels)
+                    results.append(scores)
+                    progress_bar.progress((idx + 1) / 30)
+
+                results_df = pd.DataFrame(results)
+
+                # Analyze results
+                summary = pd.DataFrame()
+                for aspect in aspects:
+                    pos_col = f"positive {aspect}"
+                    neg_col = f"negative {aspect}"
+
+                    summary.loc[aspect, 'positive_mentions'] = (results_df[pos_col] > 0.5).sum()
+                    summary.loc[aspect, 'negative_mentions'] = (results_df[neg_col] > 0.5).sum()
+                    summary.loc[aspect, 'avg_positive_score'] = results_df[pos_col].mean()
+                    summary.loc[aspect, 'avg_negative_score'] = results_df[neg_col].mean()
+
+                # Display summary in columns
+                st.subheader("📊 Analysis Summary")
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    st.markdown("#### 📈 Positive Mentions")
+                    for aspect in aspects:
+                        st.metric(
+                            label=aspect.title(),
+                            value=f"{summary.loc[aspect, 'positive_mentions']} reviews",
+                            delta=f"{summary.loc[aspect, 'avg_positive_score']:.2%} avg. confidence"
+                        )
+
+                with col2:
+                    st.markdown("#### 📉 Negative Mentions")
+                    for aspect in aspects:
+                        st.metric(
+                            label=aspect.title(),
+                            value=f"{summary.loc[aspect, 'negative_mentions']} reviews",
+                            delta=f"{summary.loc[aspect, 'avg_negative_score']:.2%} avg. confidence",
+                            delta_color="inverse"
+                        )
+
+                # Generate insights
+                groq_client = Groq(api_key="groq_api_key")
+
+                summary_text = format_summary_for_llm(summary)
+                insights = generate_insights(groq_client, summary_text)
+
+                if insights:
+                    st.subheader("💡 Key Insights and Recommendations")
+                    st.markdown(insights)
+
+        except Exception as e:
+            st.error(f"Error processing file: {str(e)}")
+
+    else:
+        # Show welcome message and instructions
+        st.markdown("""
+        ### 👋 Welcome to the Restaurant Review Analyzer!
+
+        To get started:
+        1. 📁 Upload your CSV file containing customer reviews
+        2. 🔍 Make sure your file has a 'Review' column
+        3. 🚀 Click 'Analyze Reviews' to process the data
+        4. 📊 Get detailed insights and recommendations
+
+        The analyzer will process the reviews to provide quick insights!
+        """)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+streamlit 
+pandas 
+transformers 
+groq 
+numpy