Update app.py

app.py

@@ -15,7 +15,8 @@ import time
 
 # Initialize models
 sentiment_analyzer = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")
-absa_analyzer = pipeline("ner", model="yangheng/deberta-v3-base-absa-v1.1", aggregation_strategy="simple")
+# Use a simpler ABSA approach with keyword extraction instead of the problematic model
+absa_analyzer = None
 
 class ReviewAnalyzer:
     def __init__(self):
@@ -43,54 +44,72 @@ class ReviewAnalyzer:
         return text
     
     def extract_aspect_keywords(self, reviews: List[str]) -> Dict:
-        """Extract aspect-based sentiment keywords"""
-        all_aspects = {'positive': {}, 'negative': {}}
+        """Extract aspect-based sentiment keywords using rule-based approach"""
+        positive_aspects = {}
+        negative_aspects = {}
         detailed_aspects = []
         
+        # Define aspect keywords
+        aspect_keywords = {
+            'quality': ['quality', 'build', 'material', 'durable', 'cheap', 'flimsy'],
+            'price': ['price', 'cost', 'expensive', 'cheap', 'value', 'money', 'affordable'],
+            'delivery': ['delivery', 'shipping', 'fast', 'slow', 'quick', 'late'],
+            'service': ['service', 'support', 'staff', 'helpful', 'rude', 'friendly'],
+            'design': ['design', 'look', 'beautiful', 'ugly', 'style', 'appearance'],
+            'usability': ['easy', 'difficult', 'simple', 'complex', 'user-friendly'],
+            'performance': ['performance', 'speed', 'fast', 'slow', 'efficient']
+        }
+        
         for review in reviews:
             if not review.strip() or len(review) < 10:
                 continue
-                
+            
+            # Get sentiment for the review
             try:
-                aspects = absa_analyzer(review)
-                for aspect in aspects:
-                    word = aspect['word'].lower()
-                    label = aspect['entity_group'].lower()
-                    confidence = float(aspect['score'])
-                    
-                    # Map labels to sentiment
-                    if 'pos' in label or label == 'positive':
-                        sentiment = 'positive'
-                    elif 'neg' in label or label == 'negative':
-                        sentiment = 'negative'
-                    else:
-                        continue
-                    
-                    # Count aspects
-                    if word not in all_aspects[sentiment]:
-                        all_aspects[sentiment][word] = 0
-                    all_aspects[sentiment][word] += 1
-                    
-                    detailed_aspects.append({
-                        'review': review[:50] + '...',
-                        'aspect': word,
-                        'sentiment': sentiment,
-                        'confidence': round(confidence, 3)
-                    })
+                sentiment_result = sentiment_analyzer(review)[0]
+                review_sentiment = 'positive' if 'pos' in sentiment_result['label'].lower() else 'negative'
+                confidence = float(sentiment_result['score'])
             except:
                 continue
+            
+            review_lower = review.lower()
+            
+            # Check for aspect mentions
+            for aspect, keywords in aspect_keywords.items():
+                for keyword in keywords:
+                    if keyword in review_lower:
+                        # Determine if this specific aspect mention is positive or negative
+                        aspect_sentiment = review_sentiment
+                        
+                        # Add to aspect counts
+                        if aspect_sentiment == 'positive':
+                            if aspect not in positive_aspects:
+                                positive_aspects[aspect] = 0
+                            positive_aspects[aspect] += 1
+                        else:
+                            if aspect not in negative_aspects:
+                                negative_aspects[aspect] = 0
+                            negative_aspects[aspect] += 1
+                        
+                        detailed_aspects.append({
+                            'review': review[:50] + '...',
+                            'aspect': aspect,
+                            'sentiment': aspect_sentiment,
+                            'confidence': round(confidence, 3)
+                        })
+                        break  # Only count each aspect once per review
         
         # Get top aspects
-        top_positive = sorted(all_aspects['positive'].items(), key=lambda x: x[1], reverse=True)[:10]
-        top_negative = sorted(all_aspects['negative'].items(), key=lambda x: x[1], reverse=True)[:10]
+        top_positive = sorted(positive_aspects.items(), key=lambda x: x[1], reverse=True)[:10]
+        top_negative = sorted(negative_aspects.items(), key=lambda x: x[1], reverse=True)[:10]
         
         return {
             'top_positive_aspects': top_positive,
             'top_negative_aspects': top_negative,
             'detailed_aspects': detailed_aspects,
             'summary': {
-                'total_positive_aspects': len(all_aspects['positive']),
-                'total_negative_aspects': len(all_aspects['negative'])
+                'total_positive_aspects': len(positive_aspects),
+                'total_negative_aspects': len(negative_aspects)
             }
         }