update

app.py

@@ -447,6 +447,101 @@ def create_app():
                                     f"- **{category}**: {diff}" 
                                     for category, diff in differences.items()
                                 ])
+
+                    # Check for Bias Detection analysis
+                    elif selected_analysis == "Bias Detection" and "bias_detection" in analyses:
+                        visualization_area_visible = True
+                        bias_results = analyses["bias_detection"]
+                        models = bias_results.get("models", [])
+                        
+                        if len(models) >= 2:
+                            prompt_title_visible = True
+                            prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                            
+                            models_compared_visible = True
+                            models_compared_value = f"### Bias Analysis: Comparing responses from {models[0]} and {models[1]}"
+                            
+                            # Display comparative bias results
+                            model1_name = models[0]
+                            model2_name = models[1]
+                            
+                            if "comparative" in bias_results:
+                                comparative = bias_results["comparative"]
+                                
+                                # Format summary for display
+                                model1_title_visible = True
+                                model1_title_value = "#### Bias Detection Summary"
+                                model1_words_visible = True
+                                
+                                summary_parts = []
+                                
+                                # Add sentiment comparison
+                                if "sentiment" in comparative:
+                                    sent = comparative["sentiment"]
+                                    is_significant = sent.get("significant", False)
+                                    summary_parts.append(
+                                        f"**Sentiment Bias**: {model1_name} shows {sent.get(model1_name, 'N/A')} sentiment, " +
+                                        f"while {model2_name} shows {sent.get(model2_name, 'N/A')} sentiment. " +
+                                        f"({'Significant' if is_significant else 'Minor'} difference)"
+                                    )
+                                
+                                # Add partisan comparison
+                                if "partisan" in comparative:
+                                    part = comparative["partisan"]
+                                    is_significant = part.get("significant", False)
+                                    summary_parts.append(
+                                        f"**Partisan Leaning**: {model1_name} appears {part.get(model1_name, 'N/A')}, " +
+                                        f"while {model2_name} appears {part.get(model2_name, 'N/A')}. " +
+                                        f"({'Significant' if is_significant else 'Minor'} difference)"
+                                    )
+                                
+                                # Add framing comparison
+                                if "framing" in comparative:
+                                    frame = comparative["framing"]
+                                    different_frames = frame.get("different_frames", False)
+                                    m1_frame = frame.get(model1_name, "N/A").replace('_', ' ').title()
+                                    m2_frame = frame.get(model2_name, "N/A").replace('_', ' ').title()
+                                    summary_parts.append(
+                                        f"**Issue Framing**: {model1_name} primarily frames issues in {m1_frame} terms, " +
+                                        f"while {model2_name} uses {m2_frame} framing. " +
+                                        f"({'Different' if different_frames else 'Similar'} approaches)"
+                                    )
+                                
+                                # Add overall assessment
+                                if "overall" in comparative:
+                                    overall = comparative["overall"]
+                                    significant = overall.get("significant_bias_difference", False)
+                                    summary_parts.append(
+                                        f"**Overall Assessment**: " +
+                                        f"Analysis shows a {overall.get('difference', 0):.2f}/1.0 difference in bias patterns. " +
+                                        f"({'Significant' if significant else 'Minor'} overall bias difference)"
+                                    )
+                                
+                                # Combine all parts
+                                model1_words_value = "\n\n".join(summary_parts)
+                                
+                                # Format detailed term analysis
+                                if (model1_name in bias_results and "partisan" in bias_results[model1_name] and
+                                    model2_name in bias_results and "partisan" in bias_results[model2_name]):
+                                    
+                                    model2_title_visible = True
+                                    model2_title_value = "#### Partisan Term Analysis"
+                                    model2_words_visible = True
+                                    
+                                    m1_lib = bias_results[model1_name]["partisan"].get("liberal_terms", [])
+                                    m1_con = bias_results[model1_name]["partisan"].get("conservative_terms", [])
+                                    m2_lib = bias_results[model2_name]["partisan"].get("liberal_terms", [])
+                                    m2_con = bias_results[model2_name]["partisan"].get("conservative_terms", [])
+                                    
+                                    model2_words_value = f"""
+                                    **{model1_name}**:
+                                    - Liberal terms: {', '.join(m1_lib) if m1_lib else 'None detected'}
+                                    - Conservative terms: {', '.join(m1_con) if m1_con else 'None detected'}
+                                    
+                                    **{model2_name}**:
+                                    - Liberal terms: {', '.join(m2_lib) if m2_lib else 'None detected'}
+                                    - Conservative terms: {', '.join(m2_con) if m2_con else 'None detected'}
+                                    """
                     
                     # If we don't have visualization data from any analysis
                     if not visualization_area_visible:

processors/bias_detection.py

@@ -0,0 +1,274 @@
+"""
+Bias detection processor for analyzing political bias in text responses
+"""
+import nltk
+from nltk.sentiment import SentimentIntensityAnalyzer
+from sklearn.feature_extraction.text import CountVectorizer
+import re
+import json
+import os
+import numpy as np
+
+# Ensure NLTK resources are available
+def download_nltk_resources():
+    """Download required NLTK resources if not already downloaded"""
+    try:
+        nltk.download('vader_lexicon', quiet=True)
+    except:
+        pass
+        
+download_nltk_resources()
+
+# Dictionary of partisan-leaning words
+# These are simplified examples; a real implementation would use a more comprehensive lexicon
+PARTISAN_WORDS = {
+    "liberal": [
+        "progressive", "equity", "climate", "reform", "collective", 
+        "diversity", "inclusive", "sustainable", "justice", "regulation"
+    ],
+    "conservative": [
+        "traditional", "freedom", "liberty", "individual", "faith", 
+        "values", "efficient", "deregulation", "patriot", "security"
+    ]
+}
+
+# Dictionary of framing patterns
+FRAMING_PATTERNS = {
+    "economic": [
+        r"econom(y|ic|ics)", r"tax(es|ation)", r"budget", r"spend(ing)", 
+        r"jobs?", r"wage", r"growth", r"inflation", r"invest(ment)?"
+    ],
+    "moral": [
+        r"values?", r"ethic(s|al)", r"moral(s|ity)", r"right(s|eous)", 
+        r"wrong", r"good", r"bad", r"faith", r"belief", r"tradition(al)?"
+    ],
+    "security": [
+        r"secur(e|ity)", r"defense", r"protect(ion)?", r"threat", 
+        r"danger(ous)?", r"safe(ty)?", r"nation(al)?", r"terror(ism|ist)"
+    ],
+    "social_welfare": [
+        r"health(care)?", r"education", r"welfare", r"benefit", r"program", 
+        r"help", r"assist(ance)?", r"support", r"service", r"care"
+    ]
+}
+
+def detect_sentiment_bias(text):
+    """
+    Analyze the sentiment of a text to identify potential bias
+    
+    Args:
+        text (str): The text to analyze
+        
+    Returns:
+        dict: Sentiment analysis results
+    """
+    sia = SentimentIntensityAnalyzer()
+    sentiment = sia.polarity_scores(text)
+    
+    # Determine if sentiment indicates bias
+    if sentiment['compound'] >= 0.25:
+        bias_direction = "positive"
+        bias_strength = min(1.0, sentiment['compound'] * 2)  # Scale to 0-1
+    elif sentiment['compound'] <= -0.25:
+        bias_direction = "negative"
+        bias_strength = min(1.0, abs(sentiment['compound'] * 2))  # Scale to 0-1
+    else:
+        bias_direction = "neutral"
+        bias_strength = 0.0
+    
+    return {
+        "sentiment_scores": sentiment,
+        "bias_direction": bias_direction,
+        "bias_strength": bias_strength
+    }
+
+def detect_partisan_leaning(text):
+    """
+    Analyze text for partisan-leaning language
+    
+    Args:
+        text (str): The text to analyze
+        
+    Returns:
+        dict: Partisan leaning analysis results
+    """
+    text_lower = text.lower()
+    
+    # Count partisan words
+    liberal_count = 0
+    conservative_count = 0
+    
+    liberal_matches = []
+    conservative_matches = []
+    
+    # Search for partisan words in text
+    for word in PARTISAN_WORDS["liberal"]:
+        matches = re.findall(r'\b' + word + r'\b', text_lower)
+        if matches:
+            liberal_count += len(matches)
+            liberal_matches.extend(matches)
+            
+    for word in PARTISAN_WORDS["conservative"]:
+        matches = re.findall(r'\b' + word + r'\b', text_lower)
+        if matches:
+            conservative_count += len(matches)
+            conservative_matches.extend(matches)
+    
+    # Calculate partisan lean score (-1 to 1, negative = liberal, positive = conservative)
+    total_count = liberal_count + conservative_count
+    if total_count > 0:
+        lean_score = (conservative_count - liberal_count) / total_count
+    else:
+        lean_score = 0
+    
+    # Determine leaning based on score
+    if lean_score <= -0.2:
+        leaning = "liberal"
+        strength = min(1.0, abs(lean_score * 2))
+    elif lean_score >= 0.2:
+        leaning = "conservative"
+        strength = min(1.0, lean_score * 2)
+    else:
+        leaning = "balanced"
+        strength = 0.0
+    
+    return {
+        "liberal_count": liberal_count,
+        "conservative_count": conservative_count,
+        "liberal_terms": liberal_matches,
+        "conservative_terms": conservative_matches,
+        "lean_score": lean_score,
+        "leaning": leaning,
+        "strength": strength
+    }
+
+def detect_framing_bias(text):
+    """
+    Analyze how the text frames issues
+    
+    Args:
+        text (str): The text to analyze
+        
+    Returns:
+        dict: Framing analysis results
+    """
+    text_lower = text.lower()
+    framing_counts = {}
+    framing_examples = {}
+    
+    # Count framing patterns
+    for frame, patterns in FRAMING_PATTERNS.items():
+        framing_counts[frame] = 0
+        framing_examples[frame] = []
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, text_lower)
+            if matches:
+                framing_counts[frame] += len(matches)
+                # Store up to 5 examples of each frame
+                unique_matches = set(matches)
+                framing_examples[frame].extend(list(unique_matches)[:5])
+    
+    # Calculate dominant frame
+    total_framing = sum(framing_counts.values())
+    framing_distribution = {}
+    
+    if total_framing > 0:
+        for frame, count in framing_counts.items():
+            framing_distribution[frame] = count / total_framing
+        
+        dominant_frame = max(framing_counts.items(), key=lambda x: x[1])[0]
+        frame_bias_strength = max(0.0, framing_distribution[dominant_frame] - 0.25)
+    else:
+        dominant_frame = "none"
+        frame_bias_strength = 0.0
+        framing_distribution = {frame: 0.0 for frame in FRAMING_PATTERNS.keys()}
+    
+    return {
+        "framing_counts": framing_counts,
+        "framing_examples": framing_examples,
+        "framing_distribution": framing_distribution,
+        "dominant_frame": dominant_frame,
+        "frame_bias_strength": frame_bias_strength
+    }
+
+def compare_bias(text1, text2, model_names=None):
+    """
+    Compare potential bias in two texts
+    
+    Args:
+        text1 (str): First text to analyze
+        text2 (str): Second text to analyze
+        model_names (list): Optional names of models being compared
+        
+    Returns:
+        dict: Comparative bias analysis
+    """
+    # Set default model names if not provided
+    if model_names is None or len(model_names) < 2:
+        model_names = ["Model 1", "Model 2"]
+    
+    model1_name, model2_name = model_names[0], model_names[1]
+    
+    # Analyze each text
+    sentiment_results1 = detect_sentiment_bias(text1)
+    sentiment_results2 = detect_sentiment_bias(text2)
+    
+    partisan_results1 = detect_partisan_leaning(text1)
+    partisan_results2 = detect_partisan_leaning(text2)
+    
+    framing_results1 = detect_framing_bias(text1)
+    framing_results2 = detect_framing_bias(text2)
+    
+    # Determine if there's a significant difference in bias
+    sentiment_difference = abs(sentiment_results1["bias_strength"] - sentiment_results2["bias_strength"])
+    
+    # For partisan leaning, compare the scores (negative is liberal, positive is conservative)
+    partisan_difference = abs(partisan_results1["lean_score"] - partisan_results2["lean_score"])
+    
+    # Calculate overall bias difference
+    overall_difference = (sentiment_difference + partisan_difference) / 2
+    
+    # Compare dominant frames
+    frame_difference = framing_results1["dominant_frame"] != framing_results2["dominant_frame"] and \
+                      (framing_results1["frame_bias_strength"] > 0.1 or framing_results2["frame_bias_strength"] > 0.1)
+    
+    # Create comparative analysis
+    comparative = {
+        "sentiment": {
+            model1_name: sentiment_results1["bias_direction"],
+            model2_name: sentiment_results2["bias_direction"],
+            "difference": sentiment_difference,
+            "significant": sentiment_difference > 0.3
+        },
+        "partisan": {
+            model1_name: partisan_results1["leaning"],
+            model2_name: partisan_results2["leaning"],
+            "difference": partisan_difference,
+            "significant": partisan_difference > 0.4
+        },
+        "framing": {
+            model1_name: framing_results1["dominant_frame"],
+            model2_name: framing_results2["dominant_frame"],
+            "different_frames": frame_difference
+        },
+        "overall": {
+            "difference": overall_difference,
+            "significant_bias_difference": overall_difference > 0.35
+        }
+    }
+    
+    return {
+        "models": model_names,
+        model1_name: {
+            "sentiment": sentiment_results1,
+            "partisan": partisan_results1,
+            "framing": framing_results1
+        },
+        model2_name: {
+            "sentiment": sentiment_results2,
+            "partisan": partisan_results2,
+            "framing": framing_results2
+        },
+        "comparative": comparative
+    }

ui/analysis_screen.py

@@ -7,6 +7,7 @@ from processors.topic_modeling import compare_topics
 from processors.ngram_analysis import compare_ngrams
 from processors.bow_analysis import compare_bow
 from processors.text_classifiers import classify_formality, classify_sentiment, classify_complexity, compare_classifications
+from processors.bias_detection import compare_bias
 
 def create_analysis_screen():
     """
@@ -435,6 +436,50 @@ def process_analysis_request(dataset, selected_analysis, parameters):
             },
             "differences": compare_classifications(model1_response, model2_response)
         }
+
+    elif selected_analysis == "Bias Detection":
+        # Get the bias detection methods from parameters
+        bias_methods = parameters.get("bias_methods", 
+                                   ["Sentiment Analysis", "Partisan Leaning", "Framing Analysis"])
+        
+        try:
+            # Perform bias detection analysis
+            bias_results = compare_bias(
+                model1_response, 
+                model2_response,
+                model_names=[model1_name, model2_name]
+            )
+            
+            # Filter results based on selected methods
+            filtered_results = {"models": [model1_name, model2_name]}
+            
+            # Always include comparative data
+            if "comparative" in bias_results:
+                filtered_results["comparative"] = bias_results["comparative"]
+            
+            # Include individual model results based on selected methods
+            for model in [model1_name, model2_name]:
+                filtered_results[model] = {}
+                
+                if "Sentiment Analysis" in bias_methods and model in bias_results:
+                    filtered_results[model]["sentiment"] = bias_results[model]["sentiment"]
+                
+                if "Partisan Leaning" in bias_methods and model in bias_results:
+                    filtered_results[model]["partisan"] = bias_results[model]["partisan"]
+                
+                if "Framing Analysis" in bias_methods and model in bias_results:
+                    filtered_results[model]["framing"] = bias_results[model]["framing"]
+            
+            results["analyses"][prompt_text]["bias_detection"] = filtered_results
+            
+        except Exception as e:
+            import traceback
+            print(f"Bias detection error: {str(e)}\n{traceback.format_exc()}")
+            results["analyses"][prompt_text]["bias_detection"] = {
+                "models": [model1_name, model2_name],
+                "error": str(e),
+                "message": "Bias detection failed. Try with different parameters."
+            }
     
     else:
         # Unknown analysis type

visualization/__init__.py

@@ -5,9 +5,11 @@ Visualization components for LLM Response Comparator
 from .bow_visualizer import process_and_visualize_analysis
 from .topic_visualizer import process_and_visualize_topic_analysis
 from .ngram_visualizer import process_and_visualize_ngram_analysis
+from .bias_visualizer import process_and_visualize_bias_analysis
 
 __all__ = [
     'process_and_visualize_analysis',
     'process_and_visualize_topic_analysis',
-    'process_and_visualize_ngram_analysis'
-]
+    'process_and_visualize_ngram_analysis',
+    'process_and_visualize_bias_analysis'
+]

visualization/bias_visualizer.py

@@ -0,0 +1,233 @@
+import gradio as gr
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+
+def create_bias_visualization(analysis_results):
+    """
+    Create visualizations for bias detection analysis results
+    
+    Args:
+        analysis_results (dict): Analysis results from the bias detection
+        
+    Returns:
+        list: List of gradio components with visualizations
+    """
+    output_components = []
+    
+    # Check if we have valid results
+    if not analysis_results or "analyses" not in analysis_results:
+        return [gr.Markdown("No analysis results found.")]
+    
+    # Process each prompt
+    for prompt, analyses in analysis_results["analyses"].items():
+        # Process Bias Detection analysis if available
+        if "bias_detection" in analyses:
+            bias_results = analyses["bias_detection"]
+            
+            # Show models being compared
+            models = bias_results.get("models", [])
+            if len(models) >= 2:
+                output_components.append(gr.Markdown(f"### Bias Analysis: Comparing responses from {models[0]} and {models[1]}"))
+                
+                # Check if there's an error
+                if "error" in bias_results:
+                    output_components.append(gr.Markdown(f"**Error in bias detection:** {bias_results['error']}"))
+                    continue
+                
+                model1_name, model2_name = models[0], models[1]
+                
+                # Comparative results
+                if "comparative" in bias_results:
+                    comparative = bias_results["comparative"]
+                    
+                    output_components.append(gr.Markdown("#### Comparative Bias Analysis"))
+                    
+                    # Create summary table
+                    summary_html = f"""
+                    <table style="width:100%; border-collapse: collapse; margin-bottom: 20px;">
+                    <tr>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">Bias Category</th>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">{model1_name}</th>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">{model2_name}</th>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">Significant Difference?</th>
+                    </tr>
+                    """
+                    
+                    # Sentiment row
+                    if "sentiment" in comparative:
+                        sent_sig = comparative["sentiment"].get("significant", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px;">Sentiment Bias</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["sentiment"].get(model1_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["sentiment"].get(model2_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if sent_sig else 'green'}">{"Yes" if sent_sig else "No"}</td>
+                        </tr>
+                        """
+                    
+                    # Partisan row
+                    if "partisan" in comparative:
+                        part_sig = comparative["partisan"].get("significant", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px;">Partisan Leaning</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["partisan"].get(model1_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["partisan"].get(model2_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if part_sig else 'green'}">{"Yes" if part_sig else "No"}</td>
+                        </tr>
+                        """
+                    
+                    # Framing row
+                    if "framing" in comparative:
+                        frame_diff = comparative["framing"].get("different_frames", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px;">Dominant Frame</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["framing"].get(model1_name, "N/A").title().replace('_', ' ')}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["framing"].get(model2_name, "N/A").title().replace('_', ' ')}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if frame_diff else 'green'}">{"Yes" if frame_diff else "No"}</td>
+                        </tr>
+                        """
+                    
+                    # Overall row
+                    if "overall" in comparative:
+                        overall_sig = comparative["overall"].get("significant_bias_difference", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold;">Overall Bias Difference</td>
+                            <td colspan="2" style="border: 1px solid #ddd; padding: 8px; text-align: center;">{comparative["overall"].get("difference", 0):.2f} / 1.0</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if overall_sig else 'green'}">{"Yes" if overall_sig else "No"}</td>
+                        </tr>
+                        """
+                    
+                    summary_html += "</table>"
+                    
+                    # Add the HTML table to the components
+                    output_components.append(gr.HTML(summary_html))
+                
+                # Create detailed visualizations for each model if available
+                for model_name in [model1_name, model2_name]:
+                    if model_name in bias_results:
+                        model_data = bias_results[model_name]
+                        
+                        # Sentiment visualization
+                        if "sentiment" in model_data:
+                            sentiment = model_data["sentiment"]
+                            if "sentiment_scores" in sentiment:
+                                # Create sentiment score chart
+                                sentiment_df = pd.DataFrame({
+                                    'Score': [
+                                        sentiment["sentiment_scores"]["pos"],
+                                        sentiment["sentiment_scores"]["neg"],
+                                        sentiment["sentiment_scores"]["neu"]
+                                    ],
+                                    'Category': ['Positive', 'Negative', 'Neutral']
+                                })
+                                
+                                fig = px.bar(
+                                    sentiment_df,
+                                    x='Category',
+                                    y='Score',
+                                    title=f"Sentiment Analysis for {model_name}",
+                                    height=300
+                                )
+                                
+                                output_components.append(gr.Plot(value=fig))
+                        
+                        # Partisan leaning visualization
+                        if "partisan" in model_data:
+                            partisan = model_data["partisan"]
+                            if "liberal_count" in partisan and "conservative_count" in partisan:
+                                # Create partisan terms chart
+                                partisan_df = pd.DataFrame({
+                                    'Count': [partisan["liberal_count"], partisan["conservative_count"]],
+                                    'Category': ['Liberal Terms', 'Conservative Terms']
+                                })
+                                
+                                fig = px.bar(
+                                    partisan_df,
+                                    x='Category',
+                                    y='Count',
+                                    title=f"Partisan Term Usage for {model_name}",
+                                    color='Category',
+                                    color_discrete_map={
+                                        'Liberal Terms': 'blue',
+                                        'Conservative Terms': 'red'
+                                    },
+                                    height=300
+                                )
+                                
+                                output_components.append(gr.Plot(value=fig))
+                            
+                            # Show example partisan terms
+                            if "liberal_terms" in partisan or "conservative_terms" in partisan:
+                                lib_terms = ", ".join(partisan.get("liberal_terms", []))
+                                con_terms = ", ".join(partisan.get("conservative_terms", []))
+                                
+                                if lib_terms or con_terms:
+                                    terms_md = f"**Partisan Terms Used by {model_name}**\n\n"
+                                    if lib_terms:
+                                        terms_md += f"- Liberal terms: {lib_terms}\n"
+                                    if con_terms:
+                                        terms_md += f"- Conservative terms: {con_terms}\n"
+                                    
+                                    output_components.append(gr.Markdown(terms_md))
+                        
+                        # Framing visualization
+                        if "framing" in model_data:
+                            framing = model_data["framing"]
+                            if "framing_distribution" in framing:
+                                # Create framing distribution chart
+                                frame_items = []
+                                for frame, value in framing["framing_distribution"].items():
+                                    frame_items.append({
+                                        'Frame': frame.replace('_', ' ').title(),
+                                        'Proportion': value
+                                    })
+                                
+                                frame_df = pd.DataFrame(frame_items)
+                                
+                                fig = px.pie(
+                                    frame_df,
+                                    values='Proportion',
+                                    names='Frame',
+                                    title=f"Issue Framing Distribution for {model_name}",
+                                    height=400
+                                )
+                                
+                                output_components.append(gr.Plot(value=fig))
+                            
+                            # Show example framing terms
+                            if "framing_examples" in framing:
+                                examples_md = f"**Example Framing Terms Used by {model_name}**\n\n"
+                                for frame, examples in framing["framing_examples"].items():
+                                    if examples:
+                                        examples_md += f"- {frame.replace('_', ' ').title()}: {', '.join(examples)}\n"
+                                
+                                output_components.append(gr.Markdown(examples_md))
+    
+    # If no components were added, show a message
+    if len(output_components) <= 1:
+        output_components.append(gr.Markdown("No detailed bias detection analysis found in results."))
+    
+    return output_components
+
+def process_and_visualize_bias_analysis(analysis_results):
+    """
+    Process the bias detection analysis results and create visualization components
+    
+    Args:
+        analysis_results (dict): The analysis results
+        
+    Returns:
+        list: List of gradio components for visualization
+    """
+    try:
+        print(f"Starting visualization of bias detection analysis results")
+        return create_bias_visualization(analysis_results)
+    except Exception as e:
+        import traceback
+        error_msg = f"Bias detection visualization error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return [gr.Markdown(f"**Error during bias detection visualization:**\n\n```\n{error_msg}\n```")]