updating logging

mediaunmasked/analyzers/bias_analyzer.py

@@ -140,27 +140,42 @@ class BiasAnalyzer:
     def _analyze_with_llm(self, text: str) -> Dict[str, Any]:
         """Analyze bias using LLM zero-shot classification with batch processing."""
         try:
+            logger.info("\n" + "="*50)
+            logger.info("BIAS ANALYSIS STARTED")
+            logger.info("="*50)
+            
             # Define bias categories
             bias_categories = [
                 "left-wing bias",
                 "right-wing bias",
                 "neutral/balanced perspective"
             ]
+            logger.info("Using categories for analysis:")
+            for cat in bias_categories:
+                logger.info(f"  - {cat}")
             
             # Clean and prepare text
+            logger.info("\nCleaning and preparing text...")
             cleaned_text = text.replace('$!/$', '').replace('##', '').replace('#', '')
             cleaned_text = '\n'.join(line for line in cleaned_text.split('\n') 
                                    if not line.startswith('[') and not line.startswith('More on'))
+            logger.info(f"Text prepared - Length: {len(cleaned_text)} characters")
             
             # Split into larger chunks (4000 chars) for fewer API calls
             chunks = [cleaned_text[i:i+4000] for i in range(0, len(cleaned_text), 4000)]
+            logger.info(f"Split text into {len(chunks)} chunks for processing")
             
             # Process chunks in batches
             chunk_scores = []
             flagged_phrases = []
             
-            for chunk in chunks:
+            for i, chunk in enumerate(chunks, 1):
+                logger.info(f"\n{'-'*30}")
+                logger.info(f"Processing chunk {i}/{len(chunks)}")
+                logger.info(f"Chunk length: {len(chunk)} characters")
+                
                 # Analyze chunk as a whole first
+                logger.info("Analyzing chunk for overall bias...")
                 chunk_result = self.classifier(
                     chunk,
                     bias_categories,
@@ -172,16 +187,24 @@ class BiasAnalyzer:
                     for label, score in zip(chunk_result['labels'], chunk_result['scores'])
                 })
                 
+                logger.info("Chunk bias scores:")
+                for label, score in chunk_scores[-1].items():
+                    logger.info(f"  - {label}: {score:.3f}")
+                
                 # Only analyze individual sentences if chunk shows strong bias
                 max_chunk_score = max(chunk_result['scores'])
                 if max_chunk_score > 0.6:
+                    logger.info(f"Strong bias detected (score: {max_chunk_score:.3f}), analyzing individual sentences...")
                     sentences = sent_tokenize(chunk)
+                    logger.info(f"Found {len(sentences)} sentences to analyze")
+                    
                     # Filter sentences for analysis (longer, potentially more meaningful ones)
                     relevant_sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+                    logger.info(f"Filtered to {len(relevant_sentences)} relevant sentences")
                     
                     # Process sentences in batches of 8
-                    for i in range(0, len(relevant_sentences), 8):
-                        batch = relevant_sentences[i:i+8]
+                    for j in range(0, len(relevant_sentences), 8):
+                        batch = relevant_sentences[j:j+8]
                         try:
                             batch_results = self.classifier(
                                 batch,
@@ -196,6 +219,8 @@ class BiasAnalyzer:
                             for sentence, result in zip(batch, batch_results):
                                 max_score = max(result['scores'])
                                 if max_score > 0.8 and result['labels'][0] != "neutral/balanced perspective":
+                                    logger.info(f"Found biased sentence (score: {max_score:.3f}, type: {result['labels'][0]}):")
+                                    logger.info(f"  \"{sentence}\"")
                                     flagged_phrases.append({
                                         "text": sentence,
                                         "type": result['labels'][0],
@@ -208,6 +233,7 @@ class BiasAnalyzer:
                             continue
 
             # Aggregate scores across chunks
+            logger.info("\nAggregating scores across all chunks...")
             aggregated_scores = {
                 category: np.mean([
                     scores[category] 
@@ -216,6 +242,10 @@ class BiasAnalyzer:
                 for category in bias_categories
             }
 
+            logger.info("\nFinal aggregated scores:")
+            for category, score in aggregated_scores.items():
+                logger.info(f"  - {category}: {score:.3f}")
+
             # Calculate bias metrics
             left_score = aggregated_scores["left-wing bias"]
             right_score = aggregated_scores["right-wing bias"]
@@ -223,6 +253,7 @@ class BiasAnalyzer:
             
             # Calculate bias score (-1 to 1)
             bias_score = (right_score - left_score) / max(right_score + left_score, 0.0001)
+            logger.info(f"\nRaw bias score: {bias_score:.3f}")
             
             # Determine bias label
             if bias_score < -0.6:
@@ -240,8 +271,11 @@ class BiasAnalyzer:
             else:
                 bias = "Neutral"
             
+            logger.info(f"Determined bias label: {bias}")
+            
             # Calculate bias percentage (0-100)
             bias_percentage = min(100, abs(bias_score * 100))
+            logger.info(f"Bias percentage: {bias_percentage:.1f}%")
             
             # Sort and limit flagged phrases
             sorted_phrases = sorted(flagged_phrases, key=lambda x: x['score'], reverse=True)
@@ -255,6 +289,10 @@ class BiasAnalyzer:
                 if len(unique_phrases) >= 5:
                     break
             
+            logger.info(f"\nFlagged {len(unique_phrases)} unique biased phrases")
+            
+            logger.info("\nBias analysis completed successfully")
+            
             return {
                 "bias": bias,
                 "bias_score": round(bias_score, 2),

mediaunmasked/analyzers/evidence_analyzer.py

@@ -71,19 +71,27 @@ class EvidenceAnalyzer:
     def _analyze_with_llm(self, text: str) -> Dict[str, Any]:
         """Analyze evidence using LLM."""
         try:
+            logger.info("\n" + "="*50)
+            logger.info("EVIDENCE ANALYSIS STARTED")
+            logger.info("="*50)
+            
             # Clean the text of formatting markers
+            logger.info("Cleaning and preparing text...")
             cleaned_text = text.replace('$!/$', '').replace('##', '').replace('#', '')
             cleaned_text = '\n'.join(line for line in cleaned_text.split('\n') 
                                    if not line.startswith('[') and not line.startswith('More on'))
+            logger.info(f"Text prepared - Length: {len(cleaned_text)} characters")
             
             # Download NLTK data if needed
             try:
                 nltk.data.find('tokenizers/punkt')
             except LookupError:
+                logger.info("Downloading required NLTK data...")
                 nltk.download('punkt')
             
             # Split text into chunks
             chunks = [cleaned_text[i:i+2000] for i in range(0, len(cleaned_text), 2000)]
+            logger.info(f"Split text into {len(chunks)} chunks for processing")
             
             # Categories for evidence classification
             evidence_categories = [
@@ -95,15 +103,28 @@ class EvidenceAnalyzer:
                 "opinion statement"
             ]
             
+            logger.info("\nUsing evidence categories:")
+            for cat in evidence_categories:
+                logger.info(f"  - {cat}")
+            
             chunk_scores = []
             flagged_phrases = []
             
-            for chunk in chunks:
+            for i, chunk in enumerate(chunks, 1):
+                logger.info(f"\n{'-'*30}")
+                logger.info(f"Processing chunk {i}/{len(chunks)}")
+                logger.info(f"Chunk length: {len(chunk)} characters")
+                
                 # Analyze each sentence in the chunk
                 sentences = sent_tokenize(chunk)
+                logger.info(f"Found {len(sentences)} sentences to analyze")
+                
+                sentence_count = 0
+                strong_evidence_count = 0
                 
                 for sentence in sentences:
                     if len(sentence.strip()) > 10:
+                        sentence_count += 1
                         # Classify the type of evidence
                         result = self.classifier(
                             sentence.strip(),
@@ -141,17 +162,28 @@ class EvidenceAnalyzer:
                             marker in sentence.lower() 
                             for marker in ['more on this story', 'click here', 'read more']
                         ):
+                            strong_evidence_count += 1
+                            logger.info(f"Found strong evidence (score: {strong_evidence:.3f}):")
+                            logger.info(f"  \"{sentence.strip()}\"")
                             flagged_phrases.append({
                                 'text': sentence.strip(),
                                 'type': 'strong_evidence',
                                 'score': strong_evidence
                             })
+                
+                logger.info(f"Processed {sentence_count} sentences in chunk {i}")
+                logger.info(f"Found {strong_evidence_count} sentences with strong evidence")
             
             # Calculate overall evidence score
+            logger.info("\nCalculating final evidence scores...")
             if chunk_scores:
                 avg_strong = np.mean([s['strong_evidence'] for s in chunk_scores])
                 avg_weak = np.mean([s['weak_evidence'] for s in chunk_scores])
                 
+                logger.info("Average evidence scores:")
+                logger.info(f"  - Strong evidence: {avg_strong:.3f}")
+                logger.info(f"  - Weak evidence: {avg_weak:.3f}")
+                
                 # Evidence score formula:
                 # - Reward strong evidence (70% weight)
                 # - Penalize weak/unsubstantiated claims (30% weight)
@@ -162,6 +194,9 @@ class EvidenceAnalyzer:
                 ) * 100)
             else:
                 evidence_score = 0
+                logger.warning("No scores available, defaulting to 0")
+            
+            logger.info(f"Final evidence score: {evidence_score:.1f}")
             
             # Sort and select top evidence phrases
             sorted_phrases = sorted(
@@ -169,6 +204,7 @@ class EvidenceAnalyzer:
                 key=lambda x: x['score'],
                 reverse=True
             )
+            
             # Filter out formatting text and duplicates
             unique_phrases = []
             seen = set()
@@ -183,6 +219,10 @@ class EvidenceAnalyzer:
                 if len(unique_phrases) >= 5:
                     break
             
+            logger.info(f"\nFlagged {len(unique_phrases)} unique evidence-based phrases")
+            
+            logger.info("\nEvidence analysis completed successfully")
+            
             return {
                 "evidence_based_score": round(evidence_score, 1),
                 "flagged_phrases": unique_phrases

mediaunmasked/analyzers/headline_analyzer.py

@@ -82,6 +82,12 @@ class HeadlineAnalyzer:
     def _analyze_section(self, headline: str, section: str) -> Dict[str, Any]:
         """Analyze a single section for headline accuracy and sensationalism."""
         try:
+            logger.info("\n" + "-"*30)
+            logger.info("ANALYZING SECTION")
+            logger.info("-"*30)
+            logger.info(f"Headline: {headline}")
+            logger.info(f"Section length: {len(section)} characters")
+            
             # Download NLTK data if needed
             try:
                 nltk.data.find('tokenizers/punkt')
@@ -89,10 +95,12 @@ class HeadlineAnalyzer:
                 nltk.download('punkt')
             
             sentences = sent_tokenize(section)
+            logger.info(f"Found {len(sentences)} sentences in section")
+            
             if not sentences:
                 logger.warning("No sentences found in section")
                 return {
-                    "accuracy_score": 50.0,  # Neutral score
+                    "accuracy_score": 50.0,
                     "flagged_phrases": [],
                     "detailed_scores": {
                         "nli": {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0},
@@ -109,7 +117,7 @@ class HeadlineAnalyzer:
                 "accurate headline"
             ]
             
-            # Check headline for sensationalism
+            logger.info("Checking headline for sensationalism...")
             sensationalism_result = self.zero_shot(
                 headline,
                 sensationalism_categories,
@@ -120,14 +128,16 @@ class HeadlineAnalyzer:
                 label: score 
                 for label, score in zip(sensationalism_result['labels'], sensationalism_result['scores'])
             }
+            logger.info(f"Sensationalism scores: {sensationalism_scores}")
             
             # Filter relevant sentences (longer than 20 chars)
             relevant_sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+            logger.info(f"Found {len(relevant_sentences)} relevant sentences after filtering")
             
             if not relevant_sentences:
                 logger.warning("No relevant sentences found in section")
                 return {
-                    "accuracy_score": 50.0,  # Neutral score
+                    "accuracy_score": 50.0,
                     "flagged_phrases": [],
                     "detailed_scores": {
                         "nli": {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0},
@@ -140,6 +150,7 @@ class HeadlineAnalyzer:
             flagged_phrases = []
             batch_size = 8
             
+            logger.info("Processing sentences for contradictions...")
             for i in range(0, len(relevant_sentences), batch_size):
                 batch = relevant_sentences[i:i+batch_size]
                 batch_inputs = [f"{headline} [SEP] {sentence}" for sentence in batch]
@@ -154,14 +165,25 @@ class HeadlineAnalyzer:
                         scores = {item['label']: item['score'] for item in result}
                         nli_scores.append(scores)
                         
-                        # Flag contradictory content
-                        if scores.get('CONTRADICTION', 0) > 0.4:
+                        # Flag contradictory content with lower threshold
+                        if scores.get('CONTRADICTION', 0) > 0.3:  # Lowered threshold
+                            logger.info(f"Found contradictory sentence (score: {scores['CONTRADICTION']:.2f}): {sentence}")
                             flagged_phrases.append({
                                 'text': sentence,
                                 'type': 'Contradiction',
                                 'score': scores['CONTRADICTION'],
                                 'highlight': f"[CONTRADICTION] (Score: {round(scores['CONTRADICTION'] * 100, 1)}%) \"{sentence}\""
                             })
+                        
+                        # Flag highly sensationalized content
+                        if sensationalism_scores.get('sensationalized', 0) > 0.6 or sensationalism_scores.get('clickbait', 0) > 0.6:
+                            logger.info(f"Found sensationalized content: {sentence}")
+                            flagged_phrases.append({
+                                'text': sentence,
+                                'type': 'Sensationalized',
+                                'score': max(sensationalism_scores.get('sensationalized', 0), sensationalism_scores.get('clickbait', 0)),
+                                'highlight': f"[SENSATIONALIZED] \"{sentence}\""
+                            })
                             
                 except Exception as batch_error:
                     logger.warning(f"Batch processing error: {str(batch_error)}")
@@ -180,6 +202,7 @@ class HeadlineAnalyzer:
                         ])) 
                         for label in ['ENTAILMENT', 'CONTRADICTION', 'NEUTRAL']
                     }
+                    logger.info(f"Average NLI scores: {avg_scores}")
                 except Exception as agg_error:
                     logger.error(f"Error aggregating NLI scores: {str(agg_error)}")
                     avg_scores = {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0}
@@ -199,6 +222,7 @@ class HeadlineAnalyzer:
                     ) * 0.15
                 }
                 
+                logger.info(f"Accuracy components: {accuracy_components}")
                 accuracy_score = sum(accuracy_components.values()) * 100
                 
                 # Validate final score
@@ -207,6 +231,7 @@ class HeadlineAnalyzer:
                     accuracy_score = 50.0
                 else:
                     accuracy_score = float(accuracy_score)
+                    logger.info(f"Final accuracy score: {accuracy_score:.1f}")
                     
             except Exception as score_error:
                 logger.error(f"Error calculating accuracy score: {str(score_error)}")
@@ -228,6 +253,8 @@ class HeadlineAnalyzer:
                 if len(unique_phrases) >= 5:
                     break
             
+            logger.info(f"Final number of flagged phrases: {len(unique_phrases)}")
+            
             return {
                 "accuracy_score": accuracy_score,
                 "flagged_phrases": unique_phrases,
@@ -240,7 +267,7 @@ class HeadlineAnalyzer:
         except Exception as e:
             logger.error(f"Section analysis failed: {str(e)}")
             return {
-                "accuracy_score": 50.0,  # Neutral score for errors
+                "accuracy_score": 50.0,
                 "flagged_phrases": [],
                 "detailed_scores": {
                     "nli": {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0},

mediaunmasked/analyzers/scoring.py

@@ -115,24 +115,47 @@ class MediaScorer:
     def calculate_media_score(self, headline: str, content: str) -> Dict[str, Any]:
         """Calculate final media credibility score."""
         try:
-            logger.info(f"Calculating media score using {self.analysis_mode} analysis")
+            logger.info("\n" + "="*50)
+            logger.info("MEDIA SCORE CALCULATION STARTED")
+            logger.info("="*50)
+            logger.info(f"Analysis Mode: {self.analysis_mode}")
             
+            # Headline Analysis
+            logger.info("\n" + "-"*30)
+            logger.info("HEADLINE ANALYSIS")
+            logger.info("-"*30)
             headline_analysis = self.headline_analyzer.analyze(headline, content)
+            logger.info(f"Headline Score: {headline_analysis.get('headline_vs_content_score', 0)}")
+            logger.info(f"Flagged Phrases: {headline_analysis.get('flagged_phrases', [])}")
+            
+            # Sentiment Analysis
+            logger.info("\n" + "-"*30)
+            logger.info("SENTIMENT ANALYSIS")
+            logger.info("-"*30)
             sentiment_analysis = self.sentiment_analyzer.analyze(content)
-            bias_analysis = self.bias_analyzer.analyze(content)
-            evidence_analysis = self.evidence_analyzer.analyze(content)
+            logger.info(f"Sentiment: {sentiment_analysis.get('sentiment', 'Unknown')}")
+            logger.info(f"Manipulation Score: {sentiment_analysis.get('manipulation_score', 0)}")
+            logger.info(f"Flagged Phrases: {sentiment_analysis.get('flagged_phrases', [])}")
             
-            # Log intermediate results
-            logger.info("\n=== Raw Analysis Results ===")
-            logger.info(f"Headline Analysis: {headline_analysis}")
-            logger.info(f"Sentiment Analysis: {sentiment_analysis}")
-            logger.info(f"""Bias Analysis: 
-                Raw: {bias_analysis}
-                Label: {bias_analysis['bias']}
-                Score: {bias_analysis['bias_score']}
-                Percentage: {bias_analysis['bias_percentage']}%
+            # Bias Analysis
+            logger.info("\n" + "-"*30)
+            logger.info("BIAS ANALYSIS")
+            logger.info("-"*30)
+            bias_analysis = self.bias_analyzer.analyze(content)
+            logger.info(f"""Bias Results:
+                Label: {bias_analysis.get('bias', 'Unknown')}
+                Score: {bias_analysis.get('bias_score', 0)}
+                Percentage: {bias_analysis.get('bias_percentage', 0)}%
+                Flagged Phrases: {bias_analysis.get('flagged_phrases', [])}
             """)
-            logger.info(f"Evidence Analysis: {evidence_analysis}")
+            
+            # Evidence Analysis
+            logger.info("\n" + "-"*30)
+            logger.info("EVIDENCE ANALYSIS")
+            logger.info("-"*30)
+            evidence_analysis = self.evidence_analyzer.analyze(content)
+            logger.info(f"Evidence Score: {evidence_analysis.get('evidence_based_score', 0)}")
+            logger.info(f"Flagged Phrases: {evidence_analysis.get('flagged_phrases', [])}")
             
             # Calculate component scores with NaN handling
             # For headline: 20% contradiction = 20% score (don't invert)

mediaunmasked/analyzers/sentiment_analyzer.py

@@ -85,18 +85,21 @@ class SentimentAnalyzer:
     def _analyze_with_llm(self, text: str) -> Dict[str, Any]:
         """Perform sentiment analysis using LLM models."""
         try:
-            logger.info("Starting LLM sentiment analysis")
+            logger.info("\n" + "="*50)
+            logger.info("SENTIMENT ANALYSIS STARTED")
+            logger.info("="*50)
             
             # Clean the text of formatting markers
+            logger.info("Cleaning and preparing text...")
             cleaned_text = text.replace('$!/$', '').replace('##', '').replace('#', '')
             cleaned_text = '\n'.join(line for line in cleaned_text.split('\n') 
                                    if not line.startswith('[') and not line.startswith('More on'))
             
-            logger.info("Text cleaned and prepared for analysis")
+            logger.info(f"Text prepared - Length: {len(cleaned_text)} characters")
             
             # Split text into chunks of 512 tokens (approximate)
             chunks = [cleaned_text[i:i+2000] for i in range(0, len(cleaned_text), 2000)]
-            logger.info(f"Text split into {len(chunks)} chunks for processing")
+            logger.info(f"Split text into {len(chunks)} chunks for processing")
             
             # Initialize aggregation variables
             sentiment_scores = []
@@ -114,40 +117,42 @@ class SentimentAnalyzer:
             
             # Process each chunk
             for i, chunk in enumerate(chunks, 1):
+                logger.info(f"\n{'-'*30}")
                 logger.info(f"Processing chunk {i}/{len(chunks)}")
+                logger.info(f"Chunk length: {len(chunk)} characters")
                 
                 try:
-                    # Get emotion scores with detailed logging
-                    logger.debug(f"Analyzing emotions for chunk {i}")
+                    # Get emotion scores
+                    logger.info("Analyzing emotions...")
                     emotions = self.sentiment_pipeline(chunk)
                     logger.debug(f"Raw emotion response: {emotions}")
                     
                     # Handle different response formats
                     if isinstance(emotions, list):
-                        # Multiple results format
                         for emotion in emotions:
                             if isinstance(emotion, dict) and 'label' in emotion and 'score' in emotion:
                                 sentiment_scores.append(emotion)
+                                logger.info(f"Detected emotion: {emotion['label']} (score: {emotion['score']:.3f})")
                     elif isinstance(emotions, dict) and 'label' in emotions and 'score' in emotions:
-                        # Single result format
                         sentiment_scores.append(emotions)
-                    logger.debug(f"Processed emotion scores: {sentiment_scores}")
+                        logger.info(f"Detected emotion: {emotions['label']} (score: {emotions['score']:.3f})")
                     
                     # Get toxicity scores if available
                     if self.toxicity_available:
-                        logger.debug(f"Analyzing toxicity for chunk {i}")
+                        logger.info("Analyzing toxicity...")
                         try:
                             toxicity = self.toxicity_pipeline(chunk)
                             if isinstance(toxicity, list):
                                 toxicity_scores.extend(toxicity)
                             else:
                                 toxicity_scores.append(toxicity)
-                            logger.debug(f"Processed toxicity scores: {toxicity_scores}")
+                            logger.info(f"Toxicity analysis complete for chunk {i}")
+                            logger.debug(f"Toxicity scores: {toxicity_scores[-1]}")
                         except Exception as tox_error:
                             logger.warning(f"Toxicity analysis failed for chunk {i}: {str(tox_error)}")
                     
                     # Get manipulation scores
-                    logger.debug(f"Analyzing manipulation for chunk {i}")
+                    logger.info("Analyzing manipulation patterns...")
                     manipulation = self.zero_shot(
                         chunk,
                         manipulation_categories,
@@ -155,13 +160,17 @@ class SentimentAnalyzer:
                     )
                     
                     if isinstance(manipulation, dict) and 'labels' in manipulation and 'scores' in manipulation:
-                        manipulation_scores.append({
+                        chunk_scores = {
                             label: score 
                             for label, score in zip(manipulation['labels'], manipulation['scores'])
-                        })
-                    logger.debug(f"Processed manipulation scores: {manipulation_scores}")
+                        }
+                        manipulation_scores.append(chunk_scores)
+                        logger.info("Manipulation scores for chunk:")
+                        for label, score in chunk_scores.items():
+                            logger.info(f"  - {label}: {score:.3f}")
                     
                     # Analyze sentences for manipulation
+                    logger.info("Analyzing individual sentences for manipulation...")
                     sentences = chunk.split('.')
                     for sentence in sentences:
                         if len(sentence.strip()) > 10:
@@ -172,6 +181,7 @@ class SentimentAnalyzer:
                             )
                             if (sent_result['labels'][0] in ["emotional manipulation", "fear mongering", "propaganda"] 
                                 and sent_result['scores'][0] > 0.7):
+                                logger.info(f"Found manipulative content (score: {sent_result['scores'][0]:.3f}): {sentence.strip()}")
                                 flagged_phrases.append({
                                     'text': sentence.strip(),
                                     'type': sent_result['labels'][0],
@@ -182,7 +192,7 @@ class SentimentAnalyzer:
                     logger.error(f"Error processing chunk {i}: {str(chunk_error)}")
                     continue
             
-            logger.info("All chunks processed, aggregating scores")
+            logger.info("\nAggregating final scores...")
             
             # Aggregate scores with error handling
             def aggregate_scores(scores_list, score_type: str):
@@ -222,8 +232,15 @@ class SentimentAnalyzer:
             
             emotion_scores = aggregate_scores(sentiment_scores, "emotion")
             toxicity_scores = aggregate_scores(toxicity_scores, "toxicity") if self.toxicity_available else {}
-            logger.debug(f"Aggregated emotion scores: {emotion_scores}")
-            logger.debug(f"Aggregated toxicity scores: {toxicity_scores}")
+            
+            logger.info("\nFinal emotion scores:")
+            for emotion, score in emotion_scores.items():
+                logger.info(f"  - {emotion}: {score:.3f}")
+            
+            if toxicity_scores:
+                logger.info("\nFinal toxicity scores:")
+                for category, score in toxicity_scores.items():
+                    logger.info(f"  - {category}: {score:.3f}")
             
             # Aggregate manipulation scores
             manipulation_agg = {
@@ -232,9 +249,12 @@ class SentimentAnalyzer:
                     for scores in manipulation_scores
                 ])) 
                 for category in manipulation_categories
-                if manipulation_scores  # Only process if we have scores
+                if manipulation_scores
             }
-            logger.debug(f"Aggregated manipulation scores: {manipulation_agg}")
+            
+            logger.info("\nFinal manipulation scores:")
+            for category, score in manipulation_agg.items():
+                logger.info(f"  - {category}: {score:.3f}")
             
             # Calculate manipulation score based on multiple factors
             manipulation_indicators = {
@@ -263,7 +283,7 @@ class SentimentAnalyzer:
                 # Fallback to traditional analysis if no scores available
                 manipulation_score = len(self._detect_manipulative_phrases(text)) * 10
             
-            logger.info(f"Final manipulation score: {manipulation_score}")
+            logger.info(f"\nFinal manipulation score: {manipulation_score:.1f}")
             
             # Determine overall sentiment
             positive_emotions = ['admiration', 'joy', 'amusement', 'approval']
@@ -274,7 +294,10 @@ class SentimentAnalyzer:
             neg_score = sum(emotion_scores.get(emotion, 0) for emotion in negative_emotions)
             neu_score = sum(emotion_scores.get(emotion, 0) for emotion in neutral_emotions)
             
-            logger.debug(f"Sentiment scores - Positive: {pos_score}, Negative: {neg_score}, Neutral: {neu_score}")
+            logger.info(f"\nSentiment component scores:")
+            logger.info(f"  - Positive: {pos_score:.3f}")
+            logger.info(f"  - Negative: {neg_score:.3f}")
+            logger.info(f"  - Neutral: {neu_score:.3f}")
             
             # Determine sentiment based on highest score
             max_score = max(pos_score, neg_score, neu_score)
@@ -285,7 +308,7 @@ class SentimentAnalyzer:
             else:
                 sentiment = "Neutral"
             
-            logger.info(f"Final sentiment determination: {sentiment}")
+            logger.info(f"\nFinal sentiment determination: {sentiment}")
             
             # Sort and limit flagged phrases by manipulation score
             sorted_phrases = sorted(flagged_phrases, key=lambda x: x['score'], reverse=True)
@@ -299,7 +322,9 @@ class SentimentAnalyzer:
                 if len(unique_phrases) >= 5:
                     break
             
-            logger.info("LLM analysis completed successfully")
+            logger.info(f"\nFlagged {len(unique_phrases)} unique manipulative phrases")
+            
+            logger.info("\nSentiment analysis completed successfully")
             
             return {
                 "sentiment": sentiment,