increasing performance on AI-mode by implementing singletons

mediaunmasked/analyzers/bias_analyzer.py

@@ -1,21 +1,25 @@
 import logging
 import os
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 from transformers import pipeline
 import numpy as np
+import nltk
+from nltk.tokenize import sent_tokenize
 
 logger = logging.getLogger(__name__)
 
 class BiasAnalyzer:
-    def __init__(self, use_ai: bool = True):
+    def __init__(self, use_ai: bool = True, model_registry: Optional[Any] = None):
         """
         Initialize bias analyzer with both LLM and traditional approaches.
         
         Args:
             use_ai: Boolean indicating whether to use AI-powered analysis (True) or traditional analysis (False)
+            model_registry: Optional shared model registry for better performance
         """
         self.use_ai = use_ai
         self.llm_available = False
+        self.model_registry = model_registry
         
         # Load traditional keywords
         self.resources_dir = os.path.join(os.path.dirname(__file__), '..', 'resources')
@@ -24,14 +28,20 @@ class BiasAnalyzer:
         
         if use_ai:
             try:
-                # Initialize LLM pipeline for zero-shot classification
-                self.classifier = pipeline(
-                    "zero-shot-classification",
-                    model="facebook/bart-large-mnli",
-                    device=-1  # Use CPU, change to specific GPU index if available
-                )
-                self.llm_available = True
-                logger.info("LLM pipeline initialized successfully for bias analysis")
+                if model_registry and model_registry.is_available:
+                    self.classifier = model_registry.zero_shot
+                    self.llm_available = True
+                    logger.info("Using shared model pipeline for bias analysis")
+                else:
+                    # Initialize own pipeline if no shared registry
+                    self.classifier = pipeline(
+                        "zero-shot-classification",
+                        model="facebook/bart-large-mnli",
+                        device=-1,
+                        batch_size=8
+                    )
+                    self.llm_available = True
+                    logger.info("Initialized dedicated model pipeline for bias analysis")
             except Exception as e:
                 logger.warning(f"Failed to initialize LLM pipeline: {str(e)}")
                 self.llm_available = False
@@ -128,25 +138,30 @@ class BiasAnalyzer:
         }
 
     def _analyze_with_llm(self, text: str) -> Dict[str, Any]:
-        """Analyze bias using LLM zero-shot classification."""
+        """Analyze bias using LLM zero-shot classification with batch processing."""
         try:
-            # Define bias categories to check against
+            # Define bias categories
             bias_categories = [
                 "left-wing bias",
                 "right-wing bias",
                 "neutral/balanced perspective"
             ]
             
-            # Split text into manageable chunks (2000 chars each)
-            chunks = [text[i:i+2000] for i in range(0, len(text), 2000)]
+            # Clean and prepare 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'))
+            
+            # 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)]
             
-            # Analyze each chunk
+            # Process chunks in batches
             chunk_scores = []
             flagged_phrases = []
             
             for chunk in chunks:
-                # Perform zero-shot classification
-                result = self.classifier(
+                # Analyze chunk as a whole first
+                chunk_result = self.classifier(
                     chunk,
                     bias_categories,
                     multi_label=True
@@ -154,21 +169,43 @@ class BiasAnalyzer:
                 
                 chunk_scores.append({
                     label: score 
-                    for label, score in zip(result['labels'], result['scores'])
+                    for label, score in zip(chunk_result['labels'], chunk_result['scores'])
                 })
                 
-                # Identify strongly biased phrases
-                sentences = chunk.split('.')
-                for sentence in sentences:
-                    if len(sentence.strip()) > 10:  # Ignore very short sentences
-                        sentence_result = self.classifier(
-                            sentence.strip(),
-                            bias_categories,
-                            multi_label=False
-                        )
-                        max_score = max(sentence_result['scores'])
-                        if max_score > 0.8 and sentence_result['labels'][0] != "neutral/balanced perspective":
-                            flagged_phrases.append(sentence.strip())
+                # Only analyze individual sentences if chunk shows strong bias
+                max_chunk_score = max(chunk_result['scores'])
+                if max_chunk_score > 0.6:
+                    sentences = sent_tokenize(chunk)
+                    # Filter sentences for analysis (longer, potentially more meaningful ones)
+                    relevant_sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+                    
+                    # Process sentences in batches of 8
+                    for i in range(0, len(relevant_sentences), 8):
+                        batch = relevant_sentences[i:i+8]
+                        try:
+                            batch_results = self.classifier(
+                                batch,
+                                bias_categories,
+                                multi_label=False
+                            )
+                            
+                            # Handle single or multiple results
+                            if not isinstance(batch_results, list):
+                                batch_results = [batch_results]
+                            
+                            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":
+                                    flagged_phrases.append({
+                                        "text": sentence,
+                                        "type": result['labels'][0],
+                                        "score": max_score,
+                                        "highlight": f"[{result['labels'][0].upper()}] (Score: {round(max_score * 100, 1)}%) \"{sentence}\""
+                                    })
+                                    
+                        except Exception as batch_error:
+                            logger.warning(f"Batch processing error: {str(batch_error)}")
+                            continue
 
             # Aggregate scores across chunks
             aggregated_scores = {
@@ -184,7 +221,7 @@ class BiasAnalyzer:
             right_score = aggregated_scores["right-wing bias"]
             neutral_score = aggregated_scores["neutral/balanced perspective"]
             
-            # Calculate bias score (-1 to 1, where negative is left and positive is right)
+            # Calculate bias score (-1 to 1)
             bias_score = (right_score - left_score) / max(right_score + left_score, 0.0001)
             
             # Determine bias label
@@ -206,11 +243,23 @@ class BiasAnalyzer:
             # Calculate bias percentage (0-100)
             bias_percentage = min(100, abs(bias_score * 100))
             
+            # Sort and limit flagged phrases
+            sorted_phrases = sorted(flagged_phrases, key=lambda x: x['score'], reverse=True)
+            unique_phrases = []
+            seen = set()
+            
+            for phrase in sorted_phrases:
+                if phrase['text'] not in seen:
+                    unique_phrases.append(phrase)
+                    seen.add(phrase['text'])
+                if len(unique_phrases) >= 5:
+                    break
+            
             return {
                 "bias": bias,
                 "bias_score": round(bias_score, 2),
                 "bias_percentage": round(bias_percentage, 1),
-                "flagged_phrases": list(set(flagged_phrases))[:5],  # Limit to top 5 unique phrases
+                "flagged_phrases": unique_phrases,
                 "detailed_scores": {
                     "left_bias": round(left_score * 100, 1),
                     "right_bias": round(right_score * 100, 1),

mediaunmasked/analyzers/evidence_analyzer.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 from transformers import pipeline
 import numpy as np
 import nltk
@@ -8,26 +8,35 @@ from nltk.tokenize import sent_tokenize
 logger = logging.getLogger(__name__)
 
 class EvidenceAnalyzer:
-    def __init__(self, use_ai: bool = True):
+    def __init__(self, use_ai: bool = True, model_registry: Optional[Any] = None):
         """
         Initialize evidence analyzer with LLM and traditional approaches.
         
         Args:
             use_ai: Boolean indicating whether to use AI-powered analysis (True) or traditional analysis (False)
+            model_registry: Optional shared model registry for better performance
         """
         self.use_ai = use_ai
         self.llm_available = False
+        self.model_registry = model_registry
         
         if use_ai:
             try:
-                # Zero-shot classifier for evidence analysis
-                self.classifier = pipeline(
-                    "zero-shot-classification",
-                    model="facebook/bart-large-mnli",
-                    device=-1
-                )
-                self.llm_available = True
-                logger.info("LLM pipeline initialized successfully for evidence analysis")
+                if model_registry and model_registry.is_available:
+                    # Use shared models
+                    self.classifier = model_registry.zero_shot
+                    self.llm_available = True
+                    logger.info("Using shared model pipeline for evidence analysis")
+                else:
+                    # Initialize own pipeline
+                    self.classifier = pipeline(
+                        "zero-shot-classification",
+                        model="facebook/bart-large-mnli",
+                        device=-1,
+                        batch_size=8
+                    )
+                    self.llm_available = True
+                    logger.info("Initialized dedicated model pipeline for evidence analysis")
             except Exception as e:
                 logger.warning(f"Failed to initialize LLM pipeline: {str(e)}")
                 self.llm_available = False

mediaunmasked/analyzers/headline_analyzer.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 from transformers import pipeline, AutoTokenizer
 import numpy as np
 import nltk
@@ -8,32 +8,46 @@ from nltk.tokenize import sent_tokenize
 logger = logging.getLogger(__name__)
 
 class HeadlineAnalyzer:
-    def __init__(self, use_ai: bool = True):
+    def __init__(self, use_ai: bool = True, model_registry: Optional[Any] = None):
         """
         Initialize the analyzers for headline analysis.
         
         Args:
             use_ai: Boolean indicating whether to use AI-powered analysis (True) or traditional analysis (False)
+            model_registry: Optional shared model registry for better performance
         """
         self.use_ai = use_ai
         self.llm_available = False
+        self.model_registry = model_registry
         
         if use_ai:
             try:
-                # NLI model for contradiction/entailment
-                self.nli_pipeline = pipeline("text-classification", model="roberta-large-mnli")
+                if model_registry and model_registry.is_available:
+                    # Use shared models
+                    self.nli_pipeline = model_registry.nli
+                    self.zero_shot = model_registry.zero_shot
+                    self.tokenizer = AutoTokenizer.from_pretrained("roberta-large-mnli")
+                    self.llm_available = True
+                    logger.info("Using shared model pipelines for headline analysis")
+                else:
+                    # Initialize own pipelines
+                    self.nli_pipeline = pipeline(
+                        "text-classification", 
+                        model="roberta-large-mnli",
+                        batch_size=16
+                    )
+                    self.zero_shot = pipeline(
+                        "zero-shot-classification",
+                        model="facebook/bart-large-mnli",
+                        device=-1,
+                        batch_size=8
+                    )
+                    self.tokenizer = AutoTokenizer.from_pretrained("roberta-large-mnli")
+                    self.llm_available = True
+                    logger.info("Initialized dedicated model pipelines for headline analysis")
                 
-                # Zero-shot classifier for clickbait and sensationalism
-                self.zero_shot = pipeline(
-                    "zero-shot-classification",
-                    model="facebook/bart-large-mnli",
-                    device=-1
-                )
-                
-                self.tokenizer = AutoTokenizer.from_pretrained("roberta-large-mnli")
                 self.max_length = 512
-                self.llm_available = True
-                logger.info("LLM pipelines initialized successfully for headline analysis")
+                
             except Exception as e:
                 logger.warning(f"Failed to initialize LLM pipelines: {str(e)}")
                 self.llm_available = False
@@ -51,24 +65,17 @@ class HeadlineAnalyzer:
         sep_tokens = len(self.tokenizer.encode("[SEP]")) - 2
         max_content_tokens = self.max_length - headline_tokens - sep_tokens
         
-        # Process words into sections
+        # Process words into sections with 4000 character chunks
+        current_text = ""
         for word in content_words:
-            current_section.append(word)
-            
-            # Check if current section is approaching token limit
-            current_text = " ".join(current_section)
-            if len(self.tokenizer.encode(current_text)) >= max_content_tokens:
-                current_section.pop()
-                sections.append(" ".join(current_section))
-                
-                # Start new section with 20% overlap for context
-                overlap_start = max(0, len(current_section) - int(len(current_section) * 0.2))
-                current_section = current_section[overlap_start:]
-                current_section.append(word)
+            if len(current_text) + len(word) + 1 <= 4000:
+                current_text += " " + word
+            else:
+                sections.append(current_text.strip())
+                current_text = word
         
-        # Add any remaining content
-        if current_section:
-            sections.append(" ".join(current_section))
+        if current_text:
+            sections.append(current_text.strip())
         
         return sections
 
@@ -82,10 +89,16 @@ class HeadlineAnalyzer:
                 nltk.download('punkt')
             
             sentences = sent_tokenize(section)
-            
-            # Analyze headline against content for contradiction/entailment
-            nli_scores = []
-            flagged_phrases = []
+            if not sentences:
+                logger.warning("No sentences found in section")
+                return {
+                    "accuracy_score": 50.0,  # Neutral score
+                    "flagged_phrases": [],
+                    "detailed_scores": {
+                        "nli": {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0},
+                        "sensationalism": {"factual reporting": 0.5, "accurate headline": 0.5}
+                    }
+                }
             
             # Categories for sensationalism check
             sensationalism_categories = [
@@ -108,44 +121,96 @@ class HeadlineAnalyzer:
                 for label, score in zip(sensationalism_result['labels'], sensationalism_result['scores'])
             }
             
-            # Analyze each sentence for contradiction/support
-            for sentence in sentences:
-                if len(sentence.strip()) > 10:
-                    # Check for contradiction/entailment
-                    input_text = f"{headline} [SEP] {sentence}"
-                    nli_result = self.nli_pipeline(input_text, top_k=None)
-                    scores = {item['label']: item['score'] for item in nli_result}
-                    nli_scores.append(scores)
-                    
-                    # Flag contradictory or highly sensationalized content
-                    if scores.get('CONTRADICTION', 0) > 0.4:
-                        flagged_phrases.append({
-                            'text': sentence.strip(),
-                            'type': 'contradiction',
-                            'score': scores['CONTRADICTION']
-                        })
+            # Filter relevant sentences (longer than 20 chars)
+            relevant_sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
             
-            # Calculate aggregate scores
-            avg_scores = {
-                label: np.mean([score[label] for score in nli_scores]) 
-                for label in ['ENTAILMENT', 'CONTRADICTION', 'NEUTRAL']
-            }
+            if not relevant_sentences:
+                logger.warning("No relevant sentences found in section")
+                return {
+                    "accuracy_score": 50.0,  # Neutral score
+                    "flagged_phrases": [],
+                    "detailed_scores": {
+                        "nli": {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0},
+                        "sensationalism": sensationalism_scores
+                    }
+                }
             
-            # Calculate headline accuracy score
-            accuracy_components = {
-                'entailment': avg_scores['ENTAILMENT'] * 0.4,
-                'non_contradiction': (1 - avg_scores['CONTRADICTION']) * 0.3,
-                'non_sensational': (
-                    sensationalism_scores.get('factual reporting', 0) +
-                    sensationalism_scores.get('accurate headline', 0)
-                ) * 0.15,
-                'non_clickbait': (
-                    1 - sensationalism_scores.get('clickbait', 0) -
-                    sensationalism_scores.get('sensationalized', 0)
-                ) * 0.15
-            }
+            # Process sentences in batches for contradiction/support
+            nli_scores = []
+            flagged_phrases = []
+            batch_size = 8
+            
+            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]
+                
+                try:
+                    # Get NLI scores for batch
+                    batch_results = self.nli_pipeline(batch_inputs, top_k=None)
+                    if not isinstance(batch_results, list):
+                        batch_results = [batch_results]
+                    
+                    for sentence, result in zip(batch, batch_results):
+                        scores = {item['label']: item['score'] for item in result}
+                        nli_scores.append(scores)
+                        
+                        # Flag contradictory content
+                        if scores.get('CONTRADICTION', 0) > 0.4:
+                            flagged_phrases.append({
+                                'text': sentence,
+                                'type': 'Contradiction',
+                                'score': scores['CONTRADICTION'],
+                                'highlight': f"[CONTRADICTION] (Score: {round(scores['CONTRADICTION'] * 100, 1)}%) \"{sentence}\""
+                            })
+                            
+                except Exception as batch_error:
+                    logger.warning(f"Batch processing error: {str(batch_error)}")
+                    continue
+            
+            # Calculate aggregate scores with validation
+            if not nli_scores:
+                logger.warning("No NLI scores available")
+                avg_scores = {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0}
+            else:
+                try:
+                    avg_scores = {
+                        label: float(np.mean([
+                            score.get(label, 0.0) 
+                            for score in nli_scores
+                        ])) 
+                        for label in ['ENTAILMENT', 'CONTRADICTION', 'NEUTRAL']
+                    }
+                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}
             
-            accuracy_score = sum(accuracy_components.values()) * 100
+            # Calculate headline accuracy score with validation
+            try:
+                accuracy_components = {
+                    'entailment': avg_scores.get('ENTAILMENT', 0.0) * 0.4,
+                    'non_contradiction': (1 - avg_scores.get('CONTRADICTION', 0.0)) * 0.3,
+                    'non_sensational': (
+                        sensationalism_scores.get('factual reporting', 0.0) +
+                        sensationalism_scores.get('accurate headline', 0.0)
+                    ) * 0.15,
+                    'non_clickbait': (
+                        1 - sensationalism_scores.get('clickbait', 0.0) -
+                        sensationalism_scores.get('sensationalized', 0.0)
+                    ) * 0.15
+                }
+                
+                accuracy_score = sum(accuracy_components.values()) * 100
+                
+                # Validate final score
+                if np.isnan(accuracy_score) or not np.isfinite(accuracy_score):
+                    logger.warning("Invalid accuracy score calculated, using default")
+                    accuracy_score = 50.0
+                else:
+                    accuracy_score = float(accuracy_score)
+                    
+            except Exception as score_error:
+                logger.error(f"Error calculating accuracy score: {str(score_error)}")
+                accuracy_score = 50.0
             
             # Sort and limit flagged phrases
             sorted_phrases = sorted(
@@ -153,11 +218,19 @@ class HeadlineAnalyzer:
                 key=lambda x: x['score'],
                 reverse=True
             )
-            top_phrases = [phrase['text'] for phrase in sorted_phrases[:5]]
+            unique_phrases = []
+            seen = set()
+            
+            for phrase in sorted_phrases:
+                if phrase['text'] not in seen:
+                    unique_phrases.append(phrase)
+                    seen.add(phrase['text'])
+                if len(unique_phrases) >= 5:
+                    break
             
             return {
                 "accuracy_score": accuracy_score,
-                "flagged_phrases": top_phrases,
+                "flagged_phrases": unique_phrases,
                 "detailed_scores": {
                     "nli": avg_scores,
                     "sensationalism": sensationalism_scores
@@ -167,9 +240,12 @@ class HeadlineAnalyzer:
         except Exception as e:
             logger.error(f"Section analysis failed: {str(e)}")
             return {
-                "accuracy_score": 0,
+                "accuracy_score": 50.0,  # Neutral score for errors
                 "flagged_phrases": [],
-                "detailed_scores": {}
+                "detailed_scores": {
+                    "nli": {"ENTAILMENT": 0.0, "CONTRADICTION": 0.0, "NEUTRAL": 1.0},
+                    "sensationalism": {}
+                }
             }
 
     def _analyze_traditional(self, headline: str, content: str) -> Dict[str, Any]:
@@ -266,13 +342,23 @@ class HeadlineAnalyzer:
                 accuracy_scores = [r['accuracy_score'] for r in section_results]
                 final_score = np.mean(accuracy_scores)
                 
-                # Combine flagged phrases from all sections
+                # Combine and deduplicate flagged phrases
                 all_phrases = []
                 for result in section_results:
-                    all_phrases.extend(result['flagged_phrases'])
+                    if 'flagged_phrases' in result:
+                        all_phrases.extend(result['flagged_phrases'])
+                
+                # Sort by score and get unique phrases
+                sorted_phrases = sorted(all_phrases, key=lambda x: x['score'], reverse=True)
+                unique_phrases = []
+                seen = set()
                 
-                # Remove duplicates and limit to top 5
-                unique_phrases = list(dict.fromkeys(all_phrases))[:5]
+                for phrase in sorted_phrases:
+                    if phrase['text'] not in seen:
+                        unique_phrases.append(phrase)
+                        seen.add(phrase['text'])
+                    if len(unique_phrases) >= 5:
+                        break
                 
                 return {
                     "headline_vs_content_score": round(final_score, 1),

mediaunmasked/analyzers/scoring.py

@@ -1,5 +1,8 @@
 from typing import Dict, Any, Literal
 import logging
+from transformers import pipeline
+import torch
+import numpy as np
 
 from .headline_analyzer import HeadlineAnalyzer
 from .sentiment_analyzer import SentimentAnalyzer
@@ -11,6 +14,64 @@ logger = logging.getLogger(__name__)
 # Define analysis mode type
 AnalysisMode = Literal['ai', 'traditional']
 
+class ModelRegistry:
+    """Singleton class to manage shared model pipelines."""
+    _instance = None
+    _initialized = False
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ModelRegistry, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if not self._initialized:
+            try:
+                # Use GPU if available
+                self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+                logger.info(f"Using device: {self.device}")
+                
+                # Initialize shared models with larger batch sizes
+                self.zero_shot = pipeline(
+                    "zero-shot-classification",
+                    model="facebook/bart-large-mnli",
+                    device=self.device,
+                    batch_size=8
+                )
+                
+                self.sentiment = pipeline(
+                    "text-classification",
+                    model="SamLowe/roberta-base-go_emotions",
+                    device=self.device,
+                    batch_size=16
+                )
+                
+                self.nli = pipeline(
+                    "text-classification",
+                    model="roberta-large-mnli",
+                    device=self.device,
+                    batch_size=16
+                )
+                
+                # Add toxicity pipeline
+                self.toxicity = pipeline(
+                    "text-classification",
+                    model="unitary/toxic-bert",
+                    device=self.device,
+                    batch_size=16
+                )
+                
+                logger.info("Successfully initialized shared model pipelines")
+                self._initialized = True
+                
+            except Exception as e:
+                logger.error(f"Failed to initialize shared models: {str(e)}")
+                self._initialized = False
+    
+    @property
+    def is_available(self):
+        return self._initialized
+
 class MediaScorer:
     def __init__(self, use_ai: bool = True):
         """
@@ -23,11 +84,31 @@ class MediaScorer:
         self.analysis_mode: AnalysisMode = 'ai' if use_ai else 'traditional'
         logger.info(f"Initializing MediaScorer with {self.analysis_mode} analysis")
         
-        # Initialize analyzers with analysis mode preference
-        self.headline_analyzer = HeadlineAnalyzer(use_ai=use_ai)
-        self.sentiment_analyzer = SentimentAnalyzer(use_ai=use_ai)
-        self.bias_analyzer = BiasAnalyzer(use_ai=use_ai)
-        self.evidence_analyzer = EvidenceAnalyzer(use_ai=use_ai)
+        # Initialize shared model registry if using AI
+        if use_ai:
+            self.model_registry = ModelRegistry()
+            if not self.model_registry.is_available:
+                logger.warning("Shared models not available, falling back to traditional analysis")
+                self.use_ai = False
+                self.analysis_mode = 'traditional'
+        
+        # Initialize analyzers with analysis mode preference and shared models
+        self.headline_analyzer = HeadlineAnalyzer(
+            use_ai=self.use_ai,
+            model_registry=self.model_registry if self.use_ai else None
+        )
+        self.sentiment_analyzer = SentimentAnalyzer(
+            use_ai=self.use_ai,
+            model_registry=self.model_registry if self.use_ai else None
+        )
+        self.bias_analyzer = BiasAnalyzer(
+            use_ai=self.use_ai,
+            model_registry=self.model_registry if self.use_ai else None
+        )
+        self.evidence_analyzer = EvidenceAnalyzer(
+            use_ai=self.use_ai,
+            model_registry=self.model_registry if self.use_ai else None
+        )
         
         logger.info(f"All analyzers initialized in {self.analysis_mode} mode")
 
@@ -53,32 +134,58 @@ class MediaScorer:
             """)
             logger.info(f"Evidence Analysis: {evidence_analysis}")
             
-            # Calculate component scores
+            # Calculate component scores with NaN handling
             # For headline: 20% contradiction = 20% score (don't invert)
-            headline_score = headline_analysis["headline_vs_content_score"] / 100
+            headline_score = headline_analysis.get("headline_vs_content_score", 0)
+            if isinstance(headline_score, (int, float)) and not np.isnan(headline_score):
+                headline_score = headline_score / 100
+            else:
+                headline_score = 0.5  # Default to neutral if score is invalid
+                logger.warning("Invalid headline score, using default value of 0.5")
             
             # For manipulation: 0% = good (use directly), 100% = bad
-            manipulation_score = (100 - sentiment_analysis["manipulation_score"]) / 100
+            manipulation_score = sentiment_analysis.get("manipulation_score", 0)
+            if isinstance(manipulation_score, (int, float)) and not np.isnan(manipulation_score):
+                manipulation_score = (100 - manipulation_score) / 100
+            else:
+                manipulation_score = 0.5
+                logger.warning("Invalid manipulation score, using default value of 0.5")
             
             # For bias: 0% = good (use directly), 100% = bad
-            bias_score = (100 - bias_analysis["bias_percentage"]) / 100
+            bias_percentage = bias_analysis.get("bias_percentage", 0)
+            if isinstance(bias_percentage, (int, float)) and not np.isnan(bias_percentage):
+                bias_score = (100 - bias_percentage) / 100
+            else:
+                bias_score = 0.5
+                logger.warning("Invalid bias score, using default value of 0.5")
             
-            evidence_score = evidence_analysis["evidence_based_score"] / 100  # Higher is better
+            # For evidence: higher is better
+            evidence_score = evidence_analysis.get("evidence_based_score", 0)
+            if isinstance(evidence_score, (int, float)) and not np.isnan(evidence_score):
+                evidence_score = evidence_score / 100
+            else:
+                evidence_score = 0.5
+                logger.warning("Invalid evidence score, using default value of 0.5")
             
             logger.info(f"""Component Scores:
-                Headline: {headline_score * 100:.1f}% (from {headline_analysis["headline_vs_content_score"]}%)
+                Headline: {headline_score * 100:.1f}% (from {headline_analysis.get("headline_vs_content_score", 0)})
                 Evidence: {evidence_score * 100:.1f}%
-                Manipulation: {manipulation_score * 100:.1f}% (100 - {sentiment_analysis["manipulation_score"]}%)
-                Bias: {bias_score * 100:.1f}% (100 - {bias_analysis["bias_percentage"]}%)
+                Manipulation: {manipulation_score * 100:.1f}% (100 - {sentiment_analysis.get("manipulation_score", 0)}%)
+                Bias: {bias_score * 100:.1f}% (100 - {bias_analysis.get("bias_percentage", 0)}%)
             """)
             
             # Calculate final score
-            final_score = (
+            final_score = float((
                 (headline_score * 0.25) +
                 (manipulation_score * 0.25) +
                 (bias_score * 0.25) +
                 (evidence_score * 0.25)
-            ) * 100
+            ) * 100)
+            
+            # Ensure final score is valid
+            if np.isnan(final_score) or not np.isfinite(final_score):
+                final_score = 50.0  # Default to neutral
+                logger.warning("Invalid final score calculated, using default value of 50.0")
             
             # Determine rating
             if final_score >= 80:
@@ -89,27 +196,27 @@ class MediaScorer:
                 rating = "Misleading"
             
             result = {
-                "media_unmasked_score": round(final_score, 1),
+                "media_unmasked_score": round(float(final_score), 1),
                 "rating": rating,
                 "analysis_mode": self.analysis_mode,
                 "details": {
                     "headline_analysis": {
-                        "headline_vs_content_score": headline_analysis["headline_vs_content_score"],
+                        "headline_vs_content_score": float(headline_analysis.get("headline_vs_content_score", 0)),
                         "flagged_phrases": headline_analysis.get("flagged_phrases", [])
                     },
                     "sentiment_analysis": {
-                        "sentiment": sentiment_analysis["sentiment"],
-                        "manipulation_score": sentiment_analysis["manipulation_score"],
+                        "sentiment": str(sentiment_analysis.get("sentiment", "Neutral")),
+                        "manipulation_score": float(sentiment_analysis.get("manipulation_score", 0)),
                         "flagged_phrases": sentiment_analysis.get("flagged_phrases", [])
                     },
                     "bias_analysis": {
-                        "bias": bias_analysis["bias"],
-                        "bias_score": bias_analysis["bias_score"],
-                        "bias_percentage": bias_analysis["bias_percentage"],
+                        "bias": str(bias_analysis.get("bias", "Neutral")),
+                        "bias_score": float(bias_analysis.get("bias_score", 0)),
+                        "bias_percentage": float(bias_analysis.get("bias_percentage", 0)),
                         "flagged_phrases": bias_analysis.get("flagged_phrases", [])
                     },
                     "evidence_analysis": {
-                        "evidence_based_score": evidence_analysis["evidence_based_score"],
+                        "evidence_based_score": float(evidence_analysis.get("evidence_based_score", 0)),
                         "flagged_phrases": evidence_analysis.get("flagged_phrases", [])
                     }
                 }

mediaunmasked/analyzers/sentiment_analyzer.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 from textblob import TextBlob
 from transformers import pipeline
 import numpy as np
@@ -7,15 +7,18 @@ import numpy as np
 logger = logging.getLogger(__name__)
 
 class SentimentAnalyzer:
-    def __init__(self, use_ai: bool = True):
+    def __init__(self, use_ai: bool = True, model_registry: Optional[Any] = None):
         """
         Initialize sentiment analyzer with both traditional and LLM-based approaches.
         
         Args:
             use_ai: Boolean indicating whether to use AI-powered analysis (True) or traditional analysis (False)
+            model_registry: Optional shared model registry for better performance
         """
         self.use_ai = use_ai
         self.llm_available = False
+        self.model_registry = model_registry
+        self.toxicity_available = False
         
         # Traditional manipulation patterns
         self.manipulative_patterns = [
@@ -32,24 +35,47 @@ class SentimentAnalyzer:
         
         if use_ai:
             try:
-                # Initialize LLM pipelines
-                self.sentiment_pipeline = pipeline(
-                    "text-classification",
-                    model="SamLowe/roberta-base-go_emotions",
-                    top_k=None
-                )
-                self.toxicity_pipeline = pipeline(
-                    "text-classification",
-                    model="martin-ha/toxic-comment-model",
-                    top_k=None
-                )
-                self.manipulation_pipeline = pipeline(
-                    "zero-shot-classification",
-                    model="facebook/bart-large-mnli",
-                    device=-1
-                )
-                self.llm_available = True
-                logger.info("LLM pipelines initialized successfully")
+                if model_registry and model_registry.is_available:
+                    # Use shared models
+                    self.sentiment_pipeline = model_registry.sentiment
+                    self.zero_shot = model_registry.zero_shot
+                    self.toxicity_pipeline = getattr(model_registry, 'toxicity', None)
+                    self.toxicity_available = self.toxicity_pipeline is not None
+                    self.llm_available = True
+                    logger.info("Using shared model pipelines for sentiment analysis")
+                    if self.toxicity_available:
+                        logger.info("Toxicity analysis enabled")
+                    else:
+                        logger.info("Toxicity analysis not available")
+                else:
+                    # Initialize own pipelines
+                    self.sentiment_pipeline = pipeline(
+                        "text-classification",
+                        model="SamLowe/roberta-base-go_emotions",
+                        device=-1,
+                        batch_size=16
+                    )
+                    self.zero_shot = pipeline(
+                        "zero-shot-classification",
+                        model="facebook/bart-large-mnli",
+                        device=-1,
+                        batch_size=8
+                    )
+                    try:
+                        self.toxicity_pipeline = pipeline(
+                            "text-classification",
+                            model="unitary/toxic-bert",
+                            device=-1,
+                            batch_size=16
+                        )
+                        self.toxicity_available = True
+                        logger.info("Toxicity analysis enabled")
+                    except Exception as tox_error:
+                        logger.warning(f"Toxicity pipeline initialization failed: {str(tox_error)}")
+                        self.toxicity_available = False
+                    
+                    self.llm_available = True
+                    logger.info("Initialized dedicated model pipelines for sentiment analysis")
             except Exception as e:
                 logger.warning(f"Failed to initialize LLM pipelines: {str(e)}")
                 self.llm_available = False
@@ -107,18 +133,22 @@ class SentimentAnalyzer:
                         sentiment_scores.append(emotions)
                     logger.debug(f"Processed emotion scores: {sentiment_scores}")
                     
-                    # Get toxicity scores
-                    logger.debug(f"Analyzing toxicity for chunk {i}")
-                    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}")
+                    # Get toxicity scores if available
+                    if self.toxicity_available:
+                        logger.debug(f"Analyzing toxicity for chunk {i}")
+                        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}")
+                        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}")
-                    manipulation = self.manipulation_pipeline(
+                    manipulation = self.zero_shot(
                         chunk,
                         manipulation_categories,
                         multi_label=True
@@ -135,7 +165,7 @@ class SentimentAnalyzer:
                     sentences = chunk.split('.')
                     for sentence in sentences:
                         if len(sentence.strip()) > 10:
-                            sent_result = self.manipulation_pipeline(
+                            sent_result = self.zero_shot(
                                 sentence.strip(),
                                 manipulation_categories,
                                 multi_label=False
@@ -157,6 +187,10 @@ class SentimentAnalyzer:
             # Aggregate scores with error handling
             def aggregate_scores(scores_list, score_type: str):
                 try:
+                    if not scores_list:
+                        logger.warning(f"No {score_type} scores to aggregate")
+                        return {}
+                        
                     all_scores = {}
                     for scores in scores_list:
                         if isinstance(scores, dict):
@@ -181,23 +215,24 @@ class SentimentAnalyzer:
                             if isinstance(score, (int, float)):
                                 all_scores[label].append(score)
                                 
-                    return {k: np.mean(v) for k, v in all_scores.items() if v}
+                    return {k: float(np.mean(v)) for k, v in all_scores.items() if v}
                 except Exception as agg_error:
                     logger.error(f"Error aggregating {score_type} scores: {str(agg_error)}")
                     return {}
             
             emotion_scores = aggregate_scores(sentiment_scores, "emotion")
-            toxicity_scores = aggregate_scores(toxicity_scores, "toxicity")
+            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}")
             
             # Aggregate manipulation scores
             manipulation_agg = {
-                category: np.mean([
+                category: float(np.mean([
                     scores.get(category, 0) 
                     for scores in manipulation_scores
-                ]) 
+                ])) 
                 for category in manipulation_categories
+                if manipulation_scores  # Only process if we have scores
             }
             logger.debug(f"Aggregated manipulation scores: {manipulation_agg}")
             
@@ -205,18 +240,28 @@ class SentimentAnalyzer:
             manipulation_indicators = {
                 'emotional manipulation': 0.4,
                 'fear mongering': 0.3,
-                'propaganda': 0.3,
-                'toxic': 0.2,
-                'severe_toxic': 0.3,
-                'threat': 0.2
+                'propaganda': 0.3
             }
             
+            if self.toxicity_available:
+                manipulation_indicators.update({
+                    'toxic': 0.2,
+                    'severe_toxic': 0.3,
+                    'threat': 0.2
+                })
+            
             # Combine toxicity and manipulation scores
             combined_scores = {**toxicity_scores, **manipulation_agg}
-            manipulation_score = min(100, sum(
-                combined_scores.get(k, 0) * weight 
-                for k, weight in manipulation_indicators.items()
-            ) * 100)
+            
+            # Calculate manipulation score with fallback
+            if combined_scores:
+                manipulation_score = min(100, sum(
+                    combined_scores.get(k, 0) * weight 
+                    for k, weight in manipulation_indicators.items()
+                ) * 100)
+            else:
+                # 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}")
             
@@ -258,7 +303,7 @@ class SentimentAnalyzer:
             
             return {
                 "sentiment": sentiment,
-                "manipulation_score": manipulation_score,
+                "manipulation_score": round(manipulation_score, 1),
                 "flagged_phrases": unique_phrases,
                 "detailed_scores": {
                     "emotions": emotion_scores,