update

app.py

@@ -586,25 +586,27 @@ def create_app():
                         gr.update(visible=True, value=f"❌ **Error during analysis:**\n\n```\n{str(e)}\n```")  # status_message
                     )
         
-        # RoBERTa Sentiment Analysis Tab (NEW)
+        # RoBERTa Sentiment Analysis Tab (FIXED)
         with gr.Tab("RoBERTa Sentiment"):
             # Create the RoBERTa analysis UI components
             run_roberta_btn, roberta_output, sentence_level, visualization_style, visualization_container, roberta_status = create_roberta_screen()
             
-            # Container for visualization results
+            # Create a container for visualization results
             with gr.Column() as roberta_viz_container:
-                roberta_viz_components = []
+                # We'll create placeholder components to update
+                roberta_viz_title = gr.Markdown("## RoBERTa Sentiment Analysis Results", visible=False)
+                roberta_viz_content = gr.HTML("", visible=False)
             
-            # Function to run RoBERTa sentiment analysis
+            # Function to run RoBERTa sentiment analysis (FIXED)
             def run_roberta_analysis(dataset, sentence_level, visualization_style):
                 try:
                     if not dataset or "entries" not in dataset or not dataset["entries"]:
                         return (
                             {},  # roberta_results_state
-                            True,  # status_message_visible
-                            gr.update(visible=True, value="❌ **Error:** No dataset loaded. Please create or load a dataset first."),  # status_message
-                            False,  # roberta_output visibility
-                            []  # empty visualization components
+                            gr.update(visible=True, value="❌ **Error:** No dataset loaded. Please create or load a dataset first."),  # roberta_status
+                            gr.update(visible=False),  # roberta_output
+                            gr.update(visible=False),  # roberta_viz_title
+                            gr.update(visible=False)   # roberta_viz_content
                         )
                     
                     print(f"Running RoBERTa sentiment analysis with sentence-level={sentence_level}, style={visualization_style}")
@@ -616,23 +618,40 @@ def create_app():
                     if "error" in roberta_results:
                         return (
                             roberta_results,  # Store in state anyway for debugging
-                            True,  # status_message_visible
-                            gr.update(visible=True, value=f"❌ **Error:** {roberta_results['error']}"),  # status_message
-                            False,  # Hide raw output
-                            []  # empty visualization components
+                            gr.update(visible=True, value=f"❌ **Error:** {roberta_results['error']}"),  # roberta_status
+                            gr.update(visible=False),  # Hide raw output
+                            gr.update(visible=False),  # roberta_viz_title
+                            gr.update(visible=False)   # roberta_viz_content
                         )
                     
-                    # Create visualization components
+                    # Process the visualization
                     viz_components = process_and_visualize_sentiment_analysis(roberta_results)
                     
+                    # Convert the visualization components to HTML
+                    html_content = "<div class='sentiment-visualization'>"
+                    
+                    for component in viz_components:
+                        if isinstance(component, gr.Markdown):
+                            # Convert Markdown to HTML
+                            html_content += f"<div class='markdown-content'>{component.value}</div>"
+                        elif isinstance(component, gr.Plot):
+                            # For Plot components, add a placeholder message
+                            html_content += "<div class='plot-placeholder'>Sentiment plot will appear here</div>"
+                        elif isinstance(component, gr.HTML):
+                            # Directly include HTML components
+                            html_content += component.value
+                    
+                    html_content += "</div>"
+                    
+                    # Return updated values
                     return (
                         roberta_results,  # roberta_results_state
-                        False,  # status_message_visible 
-                        gr.update(visible=False),  # status_message
-                        False,  # roberta_output visibility (hide raw output)
-                        viz_components  # visualization components
+                        gr.update(visible=False),  # roberta_status (hide status message)
+                        gr.update(visible=False),  # roberta_output (hide raw output)
+                        gr.update(visible=True),   # roberta_viz_title (show title)
+                        gr.update(visible=True, value=html_content)  # roberta_viz_content (show content)
                     )
-                
+                    
                 except Exception as e:
                     import traceback
                     error_msg = f"Error in RoBERTa analysis: {str(e)}\n{traceback.format_exc()}"
@@ -640,22 +659,22 @@ def create_app():
                     
                     return (
                         {"error": error_msg},  # roberta_results_state
-                        True,  # status_message_visible
-                        gr.update(visible=True, value=f"❌ **Error during RoBERTa analysis:**\n\n```\n{str(e)}\n```"),  # status_message
-                        False,  # Hide raw output
-                        []  # empty visualization components
+                        gr.update(visible=True, value=f"❌ **Error during RoBERTa analysis:**\n\n```\n{str(e)}\n```"),  # roberta_status
+                        gr.update(visible=False),  # Hide raw output
+                        gr.update(visible=False),  # roberta_viz_title
+                        gr.update(visible=False)   # roberta_viz_content
                     )
             
-            # Connect the run button to the analysis function
+            # Connect the run button to the analysis function (FIXED)
             run_roberta_btn.click(
                 fn=run_roberta_analysis,
                 inputs=[dataset_state, sentence_level, visualization_style],
                 outputs=[
                     roberta_results_state,
-                    gr.Checkbox(visible=False, value=False),  # Hidden checkbox for status visibility
                     roberta_status,
                     roberta_output,
-                    roberta_viz_container
+                    roberta_viz_title,
+                    roberta_viz_content
                 ]
             )
         

ui/roberta_screen.py

@@ -9,7 +9,7 @@ def create_roberta_screen():
     Create the RoBERTa sentiment analysis screen components
     
     Returns:
-        tuple: (run_roberta_btn, roberta_output, other components...)
+        tuple: (run_roberta_btn, roberta_output, sentence_level, visualization_style, visualization_container, roberta_status)
     """
     with gr.Column() as roberta_screen:
         gr.Markdown("## RoBERTa Sentiment Analysis")
@@ -42,14 +42,17 @@ def create_roberta_screen():
                 # Run button in its own column for better visibility
                 run_roberta_btn = gr.Button("Run Sentiment Analysis", variant="primary", size="large")
         
+        # Status message area
+        roberta_status = gr.Markdown(visible=False)
+        
         # Hidden output to store raw analysis results
         roberta_output = gr.JSON(label="Sentiment Analysis Results", visible=False)
         
-        # Pre-create visualization components (all initially hidden)
+        # Placeholder for visualization container - this won't be directly updated
+        # but is included for backward compatibility
         visualization_container = gr.Markdown(visible=False)
-        status_message = gr.Markdown(visible=False)
         
-    return run_roberta_btn, roberta_output, sentence_level, visualization_style, visualization_container, status_message
+    return run_roberta_btn, roberta_output, sentence_level, visualization_style, visualization_container, roberta_status
 
 def process_roberta_request(dataset, sentence_level=True, visualization_style="Standard"):
     """
@@ -122,4 +125,4 @@ def process_roberta_request(dataset, sentence_level=True, visualization_style="S
                     }
                 }
             }
-        }
+        }

visualization/roberta_visualizer.py

@@ -43,89 +43,83 @@ def create_sentiment_visualization(analysis_results):
             if len(models) >= 2:
                 output_components.append(gr.Markdown(f"### RoBERTa Sentiment Analysis: Comparing {models[0]} and {models[1]}"))
                 
-                # Create a sentiment comparison chart
+                # Create text-based summary of sentiment scores
                 sa_data = sentiment_results.get("sentiment_analysis", {})
                 if sa_data and len(models) >= 2:
                     # Extract sentiment scores and labels for comparison
                     model_data = []
                     
+                    summary_html = "<div style='margin: 20px 0; padding: 15px; background-color: #f8f9fa; border-radius: 5px;'>"
+                    summary_html += "<h4 style='margin-top: 0;'>Sentiment Score Comparison</h4>"
+                    summary_html += "<table style='width: 100%; border-collapse: collapse;'>"
+                    summary_html += "<tr><th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd;'>Model</th>"
+                    summary_html += "<th style='text-align: center; padding: 8px; border-bottom: 1px solid #ddd;'>Sentiment Score</th>"
+                    summary_html += "<th style='text-align: center; padding: 8px; border-bottom: 1px solid #ddd;'>Label</th></tr>"
+                    
                     for model_name in models:
                         if model_name in sa_data:
                             model_result = sa_data[model_name]
-                            model_data.append({
-                                "model": model_name,
-                                "sentiment_score": model_result.get("sentiment_score", 0),
-                                "label": model_result.get("label", "neutral"),
-                                "contradiction": model_result.get("scores", {}).get("contradiction", 0),
-                                "neutral": model_result.get("scores", {}).get("neutral", 0),
-                                "entailment": model_result.get("scores", {}).get("entailment", 0)
-                            })
+                            score = model_result.get("sentiment_score", 0)
+                            label = model_result.get("label", "neutral").capitalize()
+                            
+                            # Set color based on sentiment
+                            if label.lower() == "positive":
+                                color = "green"
+                            elif label.lower() == "negative":
+                                color = "red"
+                            else:
+                                color = "gray"
+                                
+                            summary_html += f"<tr>"
+                            summary_html += f"<td style='padding: 8px; border-bottom: 1px solid #ddd;'>{model_name}</td>"
+                            summary_html += f"<td style='text-align: center; padding: 8px; border-bottom: 1px solid #ddd;'>{score:.2f}</td>"
+                            summary_html += f"<td style='text-align: center; padding: 8px; border-bottom: 1px solid #ddd; color: {color}; font-weight: bold;'>{label}</td>"
+                            summary_html += f"</tr>"
                     
-                    if model_data:
-                        df = pd.DataFrame(model_data)
+                    summary_html += "</table></div>"
+                    output_components.append(gr.HTML(summary_html))
+                    
+                    # Create HTML-based score comparison gauge
+                    model_scores = []
+                    for model_name in models:
+                        if model_name in sa_data:
+                            score = sa_data[model_name].get("sentiment_score", 0)
+                            model_scores.append((model_name, score))
+                    
+                    if len(model_scores) >= 2:
+                        gauge_html = "<div style='margin: 20px 0; padding: 15px; background-color: #f8f9fa; border-radius: 5px;'>"
+                        gauge_html += "<h4 style='text-align: center; margin-top: 0;'>Sentiment Scale</h4>"
+                        gauge_html += "<div style='display: flex; justify-content: space-between; margin-bottom: 5px;'>"
+                        gauge_html += "<span>Very Negative (-2.0)</span>"
+                        gauge_html += "<span>Neutral (0.0)</span>"
+                        gauge_html += "<span>Very Positive (2.0)</span>"
+                        gauge_html += "</div>"
                         
-                        # Create gauge chart for sentiment scores
-                        fig = go.Figure()
+                        # Create the gauge background
+                        gauge_html += "<div style='position: relative; width: 100%; height: 30px; background: linear-gradient(to right, #d73027, #f46d43, #fdae61, #fee08b, #ffffbf, #d9ef8b, #a6d96a, #66bd63, #1a9850); border-radius: 5px;'>"
                         
-                        # Add gauge for each model
-                        for i, row in df.iterrows():
-                            # Set color based on sentiment
-                            color = "green" if row["sentiment_score"] > 0.5 else "red" if row["sentiment_score"] < -0.5 else "gray"
+                        # Add model markers
+                        for model_name, score in model_scores:
+                            # Calculate position (0-100%)
+                            position = ((score + 2.0) / 4.0) * 100
+                            position = max(0, min(100, position))  # Clamp between 0-100%
                             
-                            fig.add_trace(go.Indicator(
-                                mode="gauge+number",
-                                value=row["sentiment_score"],
-                                title={"text": f"{row['model']}<br><span style='font-size:0.8em;color:{color}'>{row['label'].capitalize()}</span>"},
-                                gauge={
-                                    "axis": {"range": [-2, 2], "tickmode": "array", "tickvals": [-2, -1, 0, 1, 2], 
-                                             "ticktext": ["Very Negative", "Negative", "Neutral", "Positive", "Very Positive"]},
-                                    "bar": {"color": color},
-                                    "threshold": {
-                                        "line": {"color": "black", "width": 2},
-                                        "thickness": 0.75,
-                                        "value": row["sentiment_score"]
-                                    },
-                                    "steps": [
-                                        {"range": [-2, -0.5], "color": "rgba(255, 0, 0, 0.2)"},
-                                        {"range": [-0.5, 0.5], "color": "rgba(128, 128, 128, 0.2)"},
-                                        {"range": [0.5, 2], "color": "rgba(0, 128, 0, 0.2)"}
-                                    ]
-                                },
-                                domain={"row": 0, "column": i}
-                            ))
-                        
-                        # Layout adjustments
-                        fig.update_layout(
-                            title="Sentiment Score Comparison",
-                            grid={"rows": 1, "columns": len(df), "pattern": "independent"},
-                            height=300,
-                            margin=dict(t=70, b=30, l=30, r=30)
-                        )
-                        
-                        output_components.append(gr.Plot(value=fig))
-                        
-                        # Create detailed scores visualization
-                        fig2 = make_subplots(rows=1, cols=len(df), 
-                                           subplot_titles=[f"{row['model']} Detailed Scores" for i, row in df.iterrows()])
-                        
-                        for i, row in df.iterrows():
-                            fig2.add_trace(
-                                go.Bar(
-                                    x=["Contradiction (Negative)", "Neutral", "Entailment (Positive)"],
-                                    y=[row["contradiction"], row["neutral"], row["entailment"]],
-                                    marker_color=["rgba(255, 0, 0, 0.6)", "rgba(128, 128, 128, 0.6)", "rgba(0, 128, 0, 0.6)"]
-                                ),
-                                row=1, col=i+1
-                            )
+                            # Calculate color
+                            if score > 0.5:
+                                color = "#006400"  # Dark green
+                            elif score < -0.5:
+                                color = "#8B0000"  # Dark red
+                            else:
+                                color = "#000000"  # Black
+                            
+                            gauge_html += f"<div style='position: absolute; left: {position}%; transform: translateX(-50%); top: 0;'>"
+                            gauge_html += f"<div style='width: 3px; height: 30px; background-color: {color};'></div>"
+                            gauge_html += f"<div style='position: absolute; top: 100%; left: 50%; transform: translateX(-50%); white-space: nowrap; font-weight: bold; color: {color};'>{model_name}: {score:.2f}</div>"
+                            gauge_html += "</div>"
                         
-                        fig2.update_layout(
-                            title="RoBERTa Classification Scores",
-                            showlegend=False,
-                            height=350,
-                            margin=dict(t=70, b=30, l=30, r=30)
-                        )
+                        gauge_html += "</div></div>"
                         
-                        output_components.append(gr.Plot(value=fig2))
+                        output_components.append(gr.HTML(gauge_html))
                 
                 # Display comparison summary
                 if "comparison" in sentiment_results:
@@ -237,4 +231,8 @@ def process_and_visualize_sentiment_analysis(analysis_results):
         import traceback
         error_msg = f"Sentiment visualization error: {str(e)}\n{traceback.format_exc()}"
         print(error_msg)
-        return [gr.Markdown(f"**Error during sentiment visualization:**\n\n```\n{str(e)}\n```")]
+        return [
+            gr.Markdown(f"**Error during sentiment visualization:**"),
+            gr.HTML(f"<div style='background-color: #FEE; padding: 10px; border-radius: 5px; border: 1px solid #F88;'>" +
+                   f"<pre style='white-space: pre-wrap; overflow-wrap: break-word;'>{str(e)}</pre></div>")
+        ]