Create app.py

app.py

@@ -6,48 +6,67 @@ import numpy as np
 from datetime import datetime
 import io
 import json
+import logging
+import os
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("analysis_debug.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("communication_analyzer")
 
 class CommunicationAnalyzer:
     def __init__(self):
+        logger.info("Initializing Communication Analyzer")
         self.load_models()
         
     def load_models(self):
         """Load all the analysis models"""
         try:
-            # DARVO Detection
+            logger.info("Loading DARVO detection model")
             self.darvo_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1")
             self.darvo_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1")
             
-            # Sentiment Analysis
+            logger.info("Loading sentiment analysis model")
             self.sentiment_pipeline = pipeline("text-classification", model="SamanthaStorm/tether-sentiment-v3")
             
-            # Multilabel Classification
+            logger.info("Loading multilabel classification model")
             self.multilabel_pipeline = pipeline("text-classification", model="SamanthaStorm/tether-multilabel-v6")
             
-            # Healthy Boundary Detection
+            logger.info("Loading boundary detection model")
             self.boundary_pipeline = pipeline("text-classification", model="SamanthaStorm/healthy-boundary-predictor")
             
-            # Fallacy Detection
+            logger.info("Loading fallacy detection model")
             self.fallacy_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/fallacyfinder")
             self.fallacy_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/fallacyfinder")
             
+            logger.info("All models loaded successfully")
         except Exception as e:
-            print(f"Error loading models: {e}")
+            logger.error(f"Error loading models: {e}", exc_info=True)
     
     def analyze_darvo(self, text):
         """Analyze DARVO tactics in text"""
         try:
+            logger.debug(f"Analyzing DARVO for text: '{text[:50]}...'")
             inputs = self.darvo_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
             with torch.no_grad():
                 outputs = self.darvo_model(**inputs)
                 darvo_score = torch.sigmoid(outputs.logits).item()
+            logger.info(f"DARVO score: {darvo_score:.3f} for text: '{text[:50]}...'")
             return darvo_score
-        except:
+        except Exception as e:
+            logger.error(f"Error in DARVO analysis: {e}", exc_info=True)
             return 0.0
     
     def analyze_fallacy(self, text):
         """Detect logical fallacies in text"""
         try:
+            logger.debug(f"Analyzing fallacies for text: '{text[:50]}...'")
             inputs = self.fallacy_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
             with torch.no_grad():
                 outputs = self.fallacy_model(**inputs)
@@ -57,18 +76,23 @@ class CommunicationAnalyzer:
             
             if hasattr(self.fallacy_model.config, 'id2label'):
                 predicted_label = self.fallacy_model.config.id2label[predicted_class_id]
+                logger.info(f"Fallacy detected: {predicted_label} with confidence {confidence:.3f} for text: '{text[:50]}...'")
             else:
                 predicted_label = f"Fallacy_Type_{predicted_class_id}"
+                logger.info(f"Fallacy detected: {predicted_label} with confidence {confidence:.3f} for text: '{text[:50]}...'")
             
             return predicted_label, confidence
-        except:
+        except Exception as e:
+            logger.error(f"Error in fallacy analysis: {e}", exc_info=True)
             return "No Fallacy", 0.0
     
     def analyze_message(self, text):
         """Comprehensive analysis of a single message"""
         if not text or len(text.strip()) < 3:
+            logger.debug(f"Skipping analysis for short/empty text: '{text}'")
             return {}
         
+        logger.info(f"Starting comprehensive analysis for message: '{text[:50]}...'")
         analysis = {}
         
         # DARVO Analysis
@@ -79,7 +103,9 @@ class CommunicationAnalyzer:
             sentiment_result = self.sentiment_pipeline(text)
             analysis['sentiment'] = sentiment_result[0]['label']
             analysis['sentiment_confidence'] = sentiment_result[0]['score']
-        except:
+            logger.info(f"Sentiment: {analysis['sentiment']} with confidence {analysis['sentiment_confidence']:.3f}")
+        except Exception as e:
+            logger.error(f"Error in sentiment analysis: {e}", exc_info=True)
             analysis['sentiment'] = 'NEUTRAL'
             analysis['sentiment_confidence'] = 0.5
         
@@ -87,7 +113,9 @@ class CommunicationAnalyzer:
         try:
             multilabel_result = self.multilabel_pipeline(text)
             analysis['categories'] = multilabel_result
-        except:
+            logger.info(f"Categories: {multilabel_result}")
+        except Exception as e:
+            logger.error(f"Error in multilabel analysis: {e}", exc_info=True)
             analysis['categories'] = []
         
         # Boundary Analysis
@@ -95,7 +123,9 @@ class CommunicationAnalyzer:
             boundary_result = self.boundary_pipeline(text)
             analysis['boundary_type'] = boundary_result[0]['label']
             analysis['boundary_confidence'] = boundary_result[0]['score']
-        except:
+            logger.info(f"Boundary type: {analysis['boundary_type']} with confidence {analysis['boundary_confidence']:.3f}")
+        except Exception as e:
+            logger.error(f"Error in boundary analysis: {e}", exc_info=True)
             analysis['boundary_type'] = 'UNCLEAR'
             analysis['boundary_confidence'] = 0.5
         
@@ -104,20 +134,42 @@ class CommunicationAnalyzer:
         analysis['fallacy_type'] = fallacy_type
         analysis['fallacy_confidence'] = fallacy_confidence
         
+        logger.info(f"Completed analysis for message: '{text[:50]}...'")
         return analysis
     
     def calculate_abuse_indicators(self, person_data):
         """Calculate abuse indicators for a person based on their messages"""
         if not person_data:
+            logger.warning("No data provided for abuse indicators calculation")
             return {}
         
+        person_id = person_data[0].get('sender', 'unknown') if person_data else 'unknown'
+        logger.info(f"Calculating abuse indicators for {person_id} with {len(person_data)} messages")
+        
         # Aggregate scores
         darvo_scores = [msg.get('darvo_score', 0) for msg in person_data]
-        negative_sentiments = sum(1 for msg in person_data if msg.get('sentiment') == 'NEGATIVE')
-        fallacy_count = sum(1 for msg in person_data if msg.get('fallacy_confidence', 0) > 0.7)
+        
+        # Count messages with negative sentiment
+        negative_sentiments = 0
+        for msg in person_data:
+            if msg.get('sentiment') == 'NEGATIVE':
+                negative_sentiments += 1
+                logger.debug(f"Negative sentiment detected in message: '{msg.get('message', '')[:50]}...'")
+        
+        # Count messages with high fallacy confidence
+        fallacy_count = 0
+        for msg in person_data:
+            if msg.get('fallacy_confidence', 0) > 0.7:
+                fallacy_count += 1
+                logger.debug(f"High confidence fallacy detected in message: '{msg.get('message', '')[:50]}...' - {msg.get('fallacy_type')}")
         
         total_messages = len(person_data)
         
+        # Log raw scores for debugging
+        logger.info(f"Raw DARVO scores for {person_id}: {darvo_scores}")
+        logger.info(f"Negative sentiment count for {person_id}: {negative_sentiments}/{total_messages}")
+        logger.info(f"High confidence fallacy count for {person_id}: {fallacy_count}/{total_messages}")
+        
         indicators = {
             'avg_darvo_score': np.mean(darvo_scores) if darvo_scores else 0,
             'max_darvo_score': max(darvo_scores) if darvo_scores else 0,
@@ -127,28 +179,37 @@ class CommunicationAnalyzer:
             'high_darvo_messages': sum(1 for score in darvo_scores if score > 0.7)
         }
         
-        # Calculate overall abuse likelihood
-        abuse_score = (
-            indicators['avg_darvo_score'] * 0.4 +
-            indicators['negative_sentiment_ratio'] * 0.2 +
-            indicators['fallacy_ratio'] * 0.2 +
-            (indicators['high_darvo_messages'] / total_messages if total_messages > 0 else 0) * 0.2
-        )
+        # Calculate overall abuse likelihood with detailed logging
+        abuse_score_components = {
+            'darvo_component': indicators['avg_darvo_score'] * 0.4,
+            'sentiment_component': indicators['negative_sentiment_ratio'] * 0.2,
+            'fallacy_component': indicators['fallacy_ratio'] * 0.2,
+            'high_darvo_component': (indicators['high_darvo_messages'] / total_messages if total_messages > 0 else 0) * 0.2
+        }
         
+        abuse_score = sum(abuse_score_components.values())
         indicators['abuse_likelihood'] = min(abuse_score, 1.0)
         
+        logger.info(f"Abuse score components for {person_id}: {abuse_score_components}")
+        logger.info(f"Final abuse likelihood for {person_id}: {indicators['abuse_likelihood']:.3f}")
+        
         return indicators
 
 def analyze_csv_file(file, message_col, sender_col, report_type):
     """Main function to analyze uploaded CSV file"""
     if file is None:
+        logger.warning("No file uploaded")
         return "Please upload a CSV file.", "", ""
     
     try:
+        logger.info(f"Processing file: {file.name}")
+        
         # Read CSV file
         df = pd.read_csv(file.name)
+        logger.info(f"CSV loaded with {len(df)} rows and columns: {df.columns.tolist()}")
         
         if message_col not in df.columns or sender_col not in df.columns:
+            logger.error(f"Required columns not found. Available columns: {df.columns.tolist()}")
             return f"Columns '{message_col}' or '{sender_col}' not found in CSV.", "", ""
         
         # Initialize analyzer
@@ -158,10 +219,13 @@ def analyze_csv_file(file, message_col, sender_col, report_type):
         results = []
         person_analyses = {}
         
+        logger.info(f"Starting analysis of {len(df)} messages")
         for idx, row in df.iterrows():
             message = str(row[message_col])
             sender = str(row[sender_col])
             
+            logger.info(f"Analyzing message {idx} from {sender}: '{message[:50]}...'")
+            
             if sender not in person_analyses:
                 person_analyses[sender] = []
             
@@ -174,25 +238,32 @@ def analyze_csv_file(file, message_col, sender_col, report_type):
             person_analyses[sender].append(analysis)
         
         # Calculate abuse indicators for each person
+        logger.info("Calculating abuse indicators for each participant")
         person_indicators = {}
         for person, messages in person_analyses.items():
+            logger.info(f"Analyzing {len(messages)} messages from {person}")
             person_indicators[person] = analyzer.calculate_abuse_indicators(messages)
         
         # Generate reports
+        logger.info("Generating reports")
         summary_report = generate_summary_report(person_indicators, results, report_type)
         detailed_report = generate_detailed_report(results, person_indicators, report_type)
         downloadable_report = generate_downloadable_report(results, person_indicators, report_type)
         
+        logger.info("Analysis completed successfully")
         return summary_report, detailed_report, downloadable_report
         
     except Exception as e:
+        logger.error(f"Error processing file: {str(e)}", exc_info=True)
         return f"Error processing file: {str(e)}", "", ""
 
 def generate_summary_report(person_indicators, results, report_type):
     """Generate summary report identifying potential abuser"""
+    logger.info("Generating summary report")
     
     # Sort people by abuse likelihood
     sorted_people = sorted(person_indicators.items(), key=lambda x: x[1]['abuse_likelihood'], reverse=True)
+    logger.info(f"Sorted participants by abuse likelihood: {[(p[0], p[1]['abuse_likelihood']) for p in sorted_people]}")
     
     report = f"# Communication Analysis Summary Report\n"
     report += f"**Report Type:** {report_type}\n"
@@ -222,11 +293,13 @@ def generate_summary_report(person_indicators, results, report_type):
 
 def generate_detailed_report(results, person_indicators, report_type):
     """Generate detailed analysis report"""
+    logger.info("Generating detailed report")
     
     report = f"# Detailed Communication Analysis\n\n"
     
     # High-risk messages
     high_risk_messages = [r for r in results if r.get('darvo_score', 0) > 0.7]
+    logger.info(f"Found {len(high_risk_messages)} high-risk messages")
     
     if high_risk_messages:
         report += "## High-Risk Messages (DARVO Score > 0.7)\n\n"
@@ -250,6 +323,7 @@ def generate_detailed_report(results, person_indicators, report_type):
 
 def generate_downloadable_report(results, person_indicators, report_type):
     """Generate downloadable comprehensive report"""
+    logger.info("Generating downloadable report")
     
     report_data = {
         "analysis_metadata": {
@@ -321,15 +395,18 @@ def create_interface():
         download_output = gr.File(label="Download Complete Report (JSON)")
         
         def process_and_create_download(file, message_col, sender_col, report_type):
+            logger.info(f"Starting analysis with parameters: message_col={message_col}, sender_col={sender_col}, report_type={report_type}")
             summary, detailed, report_data = analyze_csv_file(file, message_col, sender_col, report_type)
             
             # Create downloadable file
             if report_data:
                 filename = f"communication_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+                logger.info(f"Creating downloadable report: {filename}")
                 with open(filename, 'w') as f:
                     f.write(report_data)
                 return summary, detailed, filename
             
+            logger.warning("No report data generated")
             return summary, detailed, None
         
         analyze_btn.click(
@@ -353,5 +430,6 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
+    logger.info("Starting Communication Analysis Tool")
     interface = create_interface()
     interface.launch()