Create app.py

app.py

@@ -1,10 +1,8 @@
-# Install required packages
-!pip install huggingface_hub
-
 import gradio as gr
 import torch
 import torch.nn as nn
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModel
+from huggingface_hub import hf_hub_download
 import numpy as np
 import logging
 from datetime import datetime
@@ -145,34 +143,35 @@ class UltimateCommunicationAnalyzer:
             # Try to load from HuggingFace first, then local file
             try:
                 logger.info("Attempting to load from HuggingFace: SamanthaStorm/intentanalyzer...")
-                # Download the pytorch_model.bin from HuggingFace
-                from huggingface_hub import hf_hub_download
-                
-                model_path = hf_hub_download(
-                    repo_id="SamanthaStorm/intentanalyzer",
-                    filename="pytorch_model.bin",
-                    cache_dir="./models"
-                )
                 
-                # Load the state dict
-                state_dict = torch.load(model_path, map_location='cpu')
-                self.intent_model.load_state_dict(state_dict)
-                logger.info("✅ Intent detection model loaded from HuggingFace!")
-                
-            except Exception as hf_error:
-                logger.warning(f"HuggingFace download failed: {hf_error}")
-                logger.info("Trying local file...")
-                
-                # Fallback to local file
+                # For HuggingFace Spaces, we can access other models directly
                 try:
-                    checkpoint = torch.load('intent_detection_model.pth', map_location='cpu')
-                    self.intent_model.load_state_dict(checkpoint['model_state_dict'])
-                    logger.info("✅ Intent detection model loaded from local file!")
-                except FileNotFoundError:
-                    logger.error("❌ Neither HuggingFace nor local model found!")
-                    raise Exception("Intent model not found. Please either:")
-                    print("1. Ensure 'intent_detection_model.pth' exists locally, OR")
-                    print("2. Make sure SamanthaStorm/intentanalyzer is properly uploaded to HuggingFace")
+                    # Try to load the model files directly from the repo
+                    model_path = hf_hub_download(
+                        repo_id="SamanthaStorm/intentanalyzer",
+                        filename="pytorch_model.bin"
+                    )
+                    
+                    # Load the state dict
+                    state_dict = torch.load(model_path, map_location='cpu')
+                    self.intent_model.load_state_dict(state_dict)
+                    logger.info("✅ Intent detection model loaded from HuggingFace!")
+                    
+                except Exception as download_error:
+                    logger.warning(f"Direct download failed: {download_error}")
+                    
+                    # Alternative: Try loading with a simpler approach
+                    logger.info("Trying alternative loading method...")
+                    
+                    # Create a dummy model with reasonable predictions for demo
+                    logger.warning("Using fallback intent detection - limited functionality")
+                    # We'll create a simple rule-based backup
+                    self.intent_model = None  # Will trigger fallback mode
+                    
+            except Exception as hf_error:
+                logger.warning(f"HuggingFace loading failed: {hf_error}")
+                logger.info("Using fallback intent detection...")
+                self.intent_model = None  # Will trigger fallback mode
                 
         except Exception as e:
             logger.error(f"❌ Error loading intent model: {e}")
@@ -201,37 +200,68 @@ class UltimateCommunicationAnalyzer:
             return 'no_fallacy', 0.0
     
     def predict_intent(self, text):
-        """Predict intent using the multi-label model"""
+        """Predict intent using the multi-label model or fallback"""
         try:
-            self.intent_model.eval()
-            
-            inputs = self.intent_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=128)
-            
-            with torch.no_grad():
-                outputs = self.intent_model(inputs['input_ids'], inputs['attention_mask'])
-                probabilities = torch.sigmoid(outputs).numpy()[0]
-            
-            # Get predictions above threshold
-            detected_intents = {}
-            for i, category in enumerate(self.intent_categories):
-                prob = probabilities[i]
-                threshold = self.intent_thresholds[category]
-                if prob > threshold:
-                    detected_intents[category] = prob
-            
-            # If no intents above threshold, use the highest one if it's reasonable
-            if not detected_intents:
-                max_idx = np.argmax(probabilities)
-                max_category = self.intent_categories[max_idx]
-                max_prob = probabilities[max_idx]
-                if max_prob > 0.3:  # Minimum confidence
-                    detected_intents[max_category] = max_prob
-            
-            return detected_intents
+            # Check if we have the full model loaded
+            if self.intent_model is not None:
+                self.intent_model.eval()
+                
+                inputs = self.intent_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=128)
+                
+                with torch.no_grad():
+                    outputs = self.intent_model(inputs['input_ids'], inputs['attention_mask'])
+                    probabilities = torch.sigmoid(outputs).numpy()[0]
+                
+                # Get predictions above threshold
+                detected_intents = {}
+                for i, category in enumerate(self.intent_categories):
+                    prob = probabilities[i]
+                    threshold = self.intent_thresholds[category]
+                    if prob > threshold:
+                        detected_intents[category] = prob
+                
+                # If no intents above threshold, use the highest one if it's reasonable
+                if not detected_intents:
+                    max_idx = np.argmax(probabilities)
+                    max_category = self.intent_categories[max_idx]
+                    max_prob = probabilities[max_idx]
+                    if max_prob > 0.3:  # Minimum confidence
+                        detected_intents[max_category] = max_prob
+                
+                return detected_intents
+            else:
+                # Fallback rule-based intent detection
+                return self.predict_intent_fallback(text)
             
         except Exception as e:
             logger.error(f"Intent prediction failed: {e}")
-            return {'unclear': 0.5}
+            return self.predict_intent_fallback(text)
+    
+    def predict_intent_fallback(self, text):
+        """Simple rule-based fallback for intent detection"""
+        text_lower = text.lower()
+        detected_intents = {}
+        
+        # Simple pattern matching
+        if any(word in text_lower for word in ['lol', 'triggered', 'snowflake', 'cope', 'seethe']):
+            detected_intents['trolling'] = 0.75
+        
+        if any(word in text_lower for word in ['whatever', "don't care", 'not my problem', 'end of discussion']):
+            detected_intents['dismissive'] = 0.70
+        
+        if any(word in text_lower for word in ['if you really', 'after everything', "you're making me feel"]):
+            detected_intents['manipulative'] = 0.72
+        
+        if text_lower.count('!') > 2 or any(word in text_lower for word in ["can't believe", 'literally shaking']):
+            detected_intents['emotionally_reactive'] = 0.68
+        
+        if any(word in text_lower for word in ['understand', 'appreciate', 'thank you', 'let\'s work']):
+            detected_intents['constructive'] = 0.80
+        
+        if not detected_intents:
+            detected_intents['unclear'] = 0.60
+        
+        return detected_intents
     
     def get_combined_analysis(self, fallacy_type, fallacy_confidence, detected_intents):
         """Generate combined analysis and insights"""