Update utils/visualization.py

utils/visualization.py

@@ -11,31 +11,15 @@ import logging
 logger = logging.getLogger(__name__)
 
 class GraphVisualizer:
-    """
-    Advanced graph visualization utilities
-    Enterprise-grade with comprehensive error handling
-    """
+    """Advanced graph visualization utilities"""
     
     @staticmethod
     def create_graph_plot(data, max_nodes=500, layout_algorithm='spring', node_size_factor=1.0):
-        """
-        Create interactive graph visualization with robust error handling
-        
-        Args:
-            data: PyTorch Geometric data object
-            max_nodes: Maximum number of nodes to display
-            layout_algorithm: Layout algorithm ('spring', 'circular', 'kamada_kawai', 'spectral')
-            node_size_factor: Factor to scale node sizes
-            
-        Returns:
-            Plotly figure object
-        """
+        """Create interactive graph visualization"""
         try:
-            # Validate inputs
             if not hasattr(data, 'edge_index') or not hasattr(data, 'num_nodes'):
                 raise ValueError("Data must have edge_index and num_nodes attributes")
             
-            # Limit nodes for performance
             num_nodes = min(data.num_nodes, max_nodes)
             if num_nodes <= 0:
                 raise ValueError("No nodes to visualize")
@@ -45,8 +29,6 @@ class GraphVisualizer:
             
             if data.edge_index.size(1) > 0:
                 edge_list = data.edge_index.t().cpu().numpy()
-                
-                # Filter edges to include only first max_nodes
                 edge_list = edge_list[
                     (edge_list[:, 0] < num_nodes) & (edge_list[:, 1] < num_nodes)
                 ]
@@ -54,25 +36,30 @@ class GraphVisualizer:
                 if len(edge_list) > 0:
                     G.add_edges_from(edge_list)
             
-            # Add isolated nodes
             G.add_nodes_from(range(num_nodes))
             
-            # Choose layout algorithm with fallback
-            pos = GraphVisualizer._compute_layout(G, layout_algorithm)
+            # Layout
+            pos = nx.spring_layout(G, seed=42)
             
-            # Node colors and sizes
-            node_colors, color_map = GraphVisualizer._get_node_colors(data, num_nodes)
-            node_sizes = GraphVisualizer._get_node_sizes(G, node_size_factor)
+            # Node colors
+            if hasattr(data, 'y') and data.y is not None:
+                node_colors = data.y.cpu().numpy()[:num_nodes]
+            else:
+                node_colors = [0] * num_nodes
             
             # Create edge traces
-            edge_x, edge_y, edge_info = GraphVisualizer._create_edge_traces(G, pos)
+            edge_x, edge_y = [], []
+            for edge in G.edges():
+                if edge[0] in pos and edge[1] in pos:
+                    x0, y0 = pos[edge[0]]
+                    x1, y1 = pos[edge[1]]
+                    edge_x.extend([x0, x1, None])
+                    edge_y.extend([y0, y1, None])
             
             # Create node traces
-            node_x, node_y, node_text, node_info = GraphVisualizer._create_node_traces(
-                G, pos, node_colors, data
-            )
+            node_x = [pos[node][0] for node in G.nodes()]
+            node_y = [pos[node][1] for node in G.nodes()]
             
-            # Create figure
             fig = go.Figure()
             
             # Add edges
@@ -82,7 +69,6 @@ class GraphVisualizer:
                     line=dict(width=0.8, color='rgba(125,125,125,0.5)'),
                     hoverinfo='none',
                     mode='lines',
-                    name='Edges',
                     showlegend=False
                 ))
             
@@ -90,41 +76,23 @@ class GraphVisualizer:
             fig.add_trace(go.Scatter(
                 x=node_x, y=node_y,
                 mode='markers',
-                hoverinfo='text',
-                hovertext=node_info,
-                text=node_text,
                 marker=dict(
-                    size=node_sizes,
+                    size=8,
                     color=node_colors,
                     colorscale='Viridis',
                     line=dict(width=2, color='white'),
-                    opacity=0.8,
-                    colorbar=dict(title="Node Label") if hasattr(data, 'y') and data.y is not None else None
+                    opacity=0.8
                 ),
-                name='Nodes',
+                text=[f"Node {i}" for i in range(len(node_x))],
+                hoverinfo='text',
                 showlegend=False
             ))
             
-            # Update layout
             fig.update_layout(
-                title=dict(
-                    text=f'Graph Visualization ({num_nodes} nodes, {len(edge_x)//3 if edge_x else 0} edges)',
-                    x=0.5,
-                    font=dict(size=16)
-                ),
+                title=f'Graph Visualization ({num_nodes} nodes)',
                 showlegend=False,
                 hovermode='closest',
                 margin=dict(b=20, l=5, r=5, t=40),
-                annotations=[
-                    dict(
-                        text=f"Layout: {layout_algorithm.title()}",
-                        showarrow=False,
-                        xref="paper", yref="paper",
-                        x=0.005, y=-0.002,
-                        xanchor='left', yanchor='bottom',
-                        font=dict(color="gray", size=10)
-                    )
-                ],
                 xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
                 yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
                 plot_bgcolor='white',
@@ -138,126 +106,10 @@ class GraphVisualizer:
             logger.error(f"Graph visualization error: {e}")
             return GraphVisualizer._create_error_figure(f"Visualization error: {str(e)}")
     
-    @staticmethod
-    def _compute_layout(G, algorithm):
-        """Compute graph layout with fallback options"""
-        try:
-            if algorithm == 'spring':
-                if len(G.nodes()) > 100:
-                    return nx.spring_layout(G, k=0.5, iterations=20, seed=42)
-                else:
-                    return nx.spring_layout(G, k=1, iterations=50, seed=42)
-            elif algorithm == 'circular':
-                return nx.circular_layout(G)
-            elif algorithm == 'kamada_kawai':
-                if len(G.nodes()) <= 500:  # Too slow for large graphs
-                    return nx.kamada_kawai_layout(G)
-                else:
-                    raise ValueError("Too many nodes for Kamada-Kawai")
-            elif algorithm == 'spectral':
-                if len(G.edges()) > 0:
-                    return nx.spectral_layout(G)
-                else:
-                    return nx.circular_layout(G)
-            else:
-                return nx.spring_layout(G, seed=42)
-        except Exception as e:
-            logger.warning(f"Layout algorithm {algorithm} failed: {e}, using spring layout")
-            return nx.spring_layout(G, seed=42)
-    
-    @staticmethod
-    def _get_node_colors(data, num_nodes):
-        """Get node colors based on labels"""
-        try:
-            if hasattr(data, 'y') and data.y is not None:
-                node_colors = data.y.cpu().numpy()[:num_nodes]
-                unique_labels = np.unique(node_colors)
-                color_map = px.colors.qualitative.Set3[:len(unique_labels)]
-            else:
-                node_colors = [0] * num_nodes
-                color_map = ['lightblue']
-            
-            return node_colors, color_map
-        except Exception as e:
-            logger.warning(f"Node color computation failed: {e}")
-            return [0] * num_nodes, ['lightblue']
-    
-    @staticmethod
-    def _get_node_sizes(G, size_factor):
-        """Get node sizes based on degree"""
-        try:
-            node_sizes = []
-            for node in G.nodes():
-                degree = G.degree(node)
-                size = max(5, min(20, 5 + degree * 2)) * size_factor
-                node_sizes.append(size)
-            return node_sizes
-        except Exception as e:
-            logger.warning(f"Node size computation failed: {e}")
-            return [8] * len(G.nodes())
-    
-    @staticmethod
-    def _create_edge_traces(G, pos):
-        """Create edge traces for plotting"""
-        try:
-            edge_x, edge_y, edge_info = [], [], []
-            
-            for edge in G.edges():
-                if edge[0] in pos and edge[1] in pos:
-                    x0, y0 = pos[edge[0]]
-                    x1, y1 = pos[edge[1]]
-                    edge_x.extend([x0, x1, None])
-                    edge_y.extend([y0, y1, None])
-                    edge_info.append(f"Edge: {edge[0]} - {edge[1]}")
-            
-            return edge_x, edge_y, edge_info
-        except Exception as e:
-            logger.warning(f"Edge trace creation failed: {e}")
-            return [], [], []
-    
-    @staticmethod
-    def _create_node_traces(G, pos, node_colors, data):
-        """Create node traces for plotting"""
-        try:
-            node_x, node_y, node_text, node_info = [], [], [], []
-            
-            for node in G.nodes():
-                if node in pos:
-                    x, y = pos[node]
-                    node_x.append(x)
-                    node_y.append(y)
-                    
-                    # Node info
-                    degree = G.degree(node)
-                    label = node_colors[node] if node < len(node_colors) else 0
-                    node_text.append(f"Node {node}")
-                    
-                    # Enhanced node info
-                    info = f"Node: {node}<br>Degree: {degree}<br>Label: {label}"
-                    if hasattr(data, 'x') and data.x is not None and node < data.x.size(0):
-                        feature_sum = data.x[node].sum().item()
-                        info += f"<br>Feature Sum: {feature_sum:.2f}"
-                    
-                    node_info.append(info)
-            
-            return node_x, node_y, node_text, node_info
-        except Exception as e:
-            logger.warning(f"Node trace creation failed: {e}")
-            return [], [], [], []
-    
     @staticmethod
     def create_metrics_plot(metrics):
-        """
-        Create comprehensive metrics visualization
-        
-        Args:
-            metrics: Dictionary of metrics
-            
-        Returns:
-            Plotly figure object
-        """
+        """Create comprehensive metrics visualization"""
         try:
-            # Filter and validate numeric metrics
             metric_names = []
             metric_values = []
             
@@ -270,505 +122,202 @@ class GraphVisualizer:
             if not metric_names:
                 return GraphVisualizer._create_error_figure("No valid metrics to display")
             
-            # Create subplots
-            fig = make_subpl
-            # Create subplots
-           fig = make_subplots(
-               rows=1, cols=2,
-               subplot_titles=('Performance Metrics', 'Metric Radar Chart'),
-               specs=[[{"type": "bar"}, {"type": "polar"}]]
-           )
-           
-           # Bar chart
-           colors = px.colors.qualitative.Set3[:len(metric_names)]
-           
-           fig.add_trace(
-               go.Bar(
-                   x=metric_names,
-                   y=metric_values,
-                   marker_color=colors,
-                   text=[f'{v:.3f}' for v in metric_values],
-                   textposition='auto',
-                   name='Metrics',
-                   showlegend=False
-               ),
-               row=1, col=1
-           )
-           
-           # Radar chart
-           fig.add_trace(
-               go.Scatterpolar(
-                   r=metric_values + [metric_values[0]],  # Close the polygon
-                   theta=metric_names + [metric_names[0]],
-                   fill='toself',
-                   name='Performance',
-                   line=dict(color='blue'),
-                   marker=dict(size=8),
-                   showlegend=False
-               ),
-               row=1, col=2
-           )
-           
-           fig.update_layout(
-               title=dict(
-                   text='Model Performance Dashboard',
-                   x=0.5,
-                   font=dict(size=18)
-               ),
-               height=400,
-               showlegend=False
-           )
-           
-           # Update bar chart axes
-           fig.update_xaxes(title_text="Metrics", tickangle=45, row=1, col=1)
-           fig.update_yaxes(title_text="Score", range=[0, 1], row=1, col=1)
-           
-           # Update polar chart
-           fig.update_polars(
-               radialaxis=dict(range=[0, 1], showticklabels=True, tickfont=dict(size=10)),
-               angularaxis=dict(tickfont=dict(size=10)),
-               row=1, col=2
-           )
-           
-           return fig
-           
-       except Exception as e:
-           logger.error(f"Metrics plot error: {e}")
-           return GraphVisualizer._create_error_figure(f"Metrics plot error: {str(e)}")
-   
-   @staticmethod
-   def create_training_history_plot(history):
-       """
-       Create comprehensive training history visualization
-       
-       Args:
-           history: Training history dictionary
-           
-       Returns:
-           Plotly figure object
-       """
-       try:
-           if not isinstance(history, dict) or not history:
-               return GraphVisualizer._create_error_figure("No training history available")
-           
-           # Validate history data
-           required_keys = ['train_loss', 'train_acc']
-           for key in required_keys:
-               if key not in history or not history[key]:
-                   return GraphVisualizer._create_error_figure(f"Missing {key} in training history")
-           
-           epochs = list(range(len(history['train_loss'])))
-           
-           # Create subplots
-           fig = make_subplots(
-               rows=2, cols=2,
-               subplot_titles=('Loss Over Time', 'Accuracy Over Time', 'Learning Rate', 'Training Progress'),
-               specs=[[{"secondary_y": False}, {"secondary_y": False}],
-                      [{"secondary_y": False}, {"secondary_y": False}]]
-           )
-           
-           # Training loss
-           fig.add_trace(
-               go.Scatter(
-                   x=epochs, y=history['train_loss'],
-                   mode='lines', name='Train Loss',
-                   line=dict(color='blue', width=2),
-                   showlegend=False
-               ),
-               row=1, col=1
-           )
-           
-           if 'val_loss' in history and history['val_loss']:
-               fig.add_trace(
-                   go.Scatter(
-                       x=epochs, y=history['val_loss'],
-                       mode='lines', name='Val Loss',
-                       line=dict(color='red', width=2),
-                       showlegend=False
-                   ),
-                   row=1, col=1
-               )
-           
-           # Training accuracy
-           fig.add_trace(
-               go.Scatter(
-                   x=epochs, y=history['train_acc'],
-                   mode='lines', name='Train Acc',
-                   line=dict(color='green', width=2),
-                   showlegend=False
-               ),
-               row=1, col=2
-           )
-           
-           if 'val_acc' in history and history['val_acc']:
-               fig.add_trace(
-                   go.Scatter(
-                       x=epochs, y=history['val_acc'],
-                       mode='lines', name='Val Acc',
-                       line=dict(color='orange', width=2),
-                       showlegend=False
-                   ),
-                   row=1, col=2
-               )
-           
-           # Learning rate
-           if 'lr' in history and history['lr']:
-               fig.add_trace(
-                   go.Scatter(
-                       x=epochs, y=history['lr'],
-                       mode='lines', name='Learning Rate',
-                       line=dict(color='purple', width=2),
-                       showlegend=False
-                   ),
-                   row=2, col=1
-               )
-           
-           # Training progress summary
-           final_metrics = {
-               'Final Train Acc': history['train_acc'][-1] if history['train_acc'] else 0,
-               'Final Train Loss': history['train_loss'][-1] if history['train_loss'] else 0,
-           }
-           
-           if 'val_acc' in history and history['val_acc']:
-               final_metrics['Final Val Acc'] = history['val_acc'][-1]
-               final_metrics['Best Val Acc'] = max(history['val_acc'])
-           
-           metric_names = list(final_metrics.keys())
-           metric_values = list(final_metrics.values())
-           
-           fig.add_trace(
-               go.Bar(
-                   x=metric_names,
-                   y=metric_values,
-                   marker_color=['lightblue', 'lightcoral', 'lightgreen', 'gold'],
-                   text=[f'{v:.3f}' for v in metric_values],
-                   textposition='auto',
-                   showlegend=False
-               ),
-               row=2, col=2
-           )
-           
-           fig.update_layout(
-               title=dict(
-                   text='Training History Dashboard',
-                   x=0.5,
-                   font=dict(size=18)
-               ),
-               height=600,
-               showlegend=True
-           )
-           
-           # Update axes
-           fig.update_xaxes(title_text="Epoch", row=1, col=1)
-           fig.update_xaxes(title_text="Epoch", row=1, col=2)
-           fig.update_xaxes(title_text="Epoch", row=2, col=1)
-           fig.update_xaxes(title_text="Metric", tickangle=45, row=2, col=2)
-           
-           fig.update_yaxes(title_text="Loss", row=1, col=1)
-           fig.update_yaxes(title_text="Accuracy", range=[0, 1], row=1, col=2)
-           fig.update_yaxes(title_text="Learning Rate", type="log", row=2, col=1)
-           fig.update_yaxes(title_text="Value", row=2, col=2)
-           
-           return fig
-           
-       except Exception as e:
-           logger.error(f"Training history plot error: {e}")
-           return GraphVisualizer._create_error_figure(f"Training history plot error: {str(e)}")
-   
-   @staticmethod
-   def create_dataset_stats_plot(dataset_info):
-       """
-       Create dataset statistics visualization
-       
-       Args:
-           dataset_info: Dictionary containing dataset statistics
-           
-       Returns:
-           Plotly figure object
-       """
-       try:
-           if not isinstance(dataset_info, dict) or not dataset_info:
-               return GraphVisualizer._create_error_figure("No dataset information available")
-           
-           # Prepare data
-           stats_data = []
-           for key, value in dataset_info.items():
-               if isinstance(value, (int, float)) and not np.isnan(value) and np.isfinite(value):
-                   stats_data.append({
-                       'Metric': key.replace('_', ' ').title(),
-                       'Value': value
-                   })
-           
-           if not stats_data:
-               return GraphVisualizer._create_error_figure("No valid statistics to display")
-           
-           df = pd.DataFrame(stats_data)
-           
-           # Create subplots
-           fig = make_subplots(
-               rows=2, cols=2,
-               subplot_titles=('Dataset Overview', 'Graph Size Distribution', 'Feature Statistics', 'Connectivity'),
-               specs=[[{"type": "bar"}, {"type": "histogram"}],
-                      [{"type": "bar"}, {"type": "bar"}]]
-           )
-           
-           # Main statistics bar chart
-           main_metrics = ['Num Features', 'Num Classes', 'Num Graphs', 'Total Nodes', 'Total Edges']
-           main_data = df[df['Metric'].isin(main_metrics)]
-           
-           if not main_data.empty:
-               fig.add_trace(
-                   go.Bar(
-                       x=main_data['Metric'],
-                       y=main_data['Value'],
-                       marker_color=px.colors.qualitative.Pastel1[:len(main_data)],
-                       text=[f'{int(v):,}' if v >= 1 else f'{v:.2f}' for v in main_data['Value']],
-                       textposition='auto',
-                       showlegend=False
-                   ),
-                   row=1, col=1
-               )
-           
-           # Graph size distribution
-           if 'num_graphs' in dataset_info and dataset_info['num_graphs'] > 1:
-               # Simulate distribution based on min/max/avg
-               avg_nodes = dataset_info.get('avg_nodes', 100)
-               min_nodes = dataset_info.get('min_nodes', avg_nodes * 0.5)
-               max_nodes = dataset_info.get('max_nodes', avg_nodes * 1.5)
-               
-               # Generate realistic distribution
-               np.random.seed(42)
-               if max_nodes > min_nodes:
-                   node_dist = np.random.lognormal(
-                       mean=np.log(avg_nodes), 
-                       sigma=0.5, 
-                       size=min(100, int(dataset_info['num_graphs']))
-                   )
-                   node_dist = np.clip(node_dist, min_nodes, max_nodes)
-               else:
-                   node_dist = [avg_nodes] * min(100, int(dataset_info['num_graphs']))
-               
-               fig.add_trace(
-                   go.Histogram(
-                       x=node_dist,
-                       nbinsx=20,
-                       marker_color='lightblue',
-                       opacity=0.7,
-                       showlegend=False
-                   ),
-                   row=1, col=2
-               )
-           else:
-               # Single graph - show as point
-               fig.add_trace(
-                   go.Scatter(
-                       x=['Nodes'],
-                       y=[dataset_info.get('avg_nodes', 0)],
-                       mode='markers',
-                       marker=dict(size=20, color='blue'),
-                       showlegend=False
-                   ),
-                   row=1, col=2
-               )
-           
-           # Feature statistics
-           feature_metrics = ['Avg Nodes', 'Avg Edges', 'Avg Degree']
-           feature_data = df[df['Metric'].isin(feature_metrics)]
-           
-           if not feature_data.empty:
-               fig.add_trace(
-                   go.Bar(
-                       x=feature_data['Metric'],
-                       y=feature_data['Value'],
-                       marker_color=['lightgreen', 'lightcoral', 'lightyellow'],
-                       text=[f'{v:.1f}' for v in feature_data['Value']],
-                       textposition='auto',
-                       showlegend=False
-                   ),
-                   row=2, col=1
-               )
-           
-           # Connectivity analysis
-           connectivity_data = []
-           if 'total_nodes' in dataset_info and 'total_edges' in dataset_info:
-               total_nodes = dataset_info['total_nodes']
-               total_edges = dataset_info['total_edges']
-               
-               if total_nodes > 0:
-                   max_possible_edges = total_nodes * (total_nodes - 1) / 2
-                   density = total_edges / max_possible_edges if max_possible_edges > 0 else 0
-                   avg_degree = dataset_info.get('avg_degree', 0)
-                   
-                   connectivity_data = [
-                       {'Metric': 'Graph Density', 'Value': density},
-                       {'Metric': 'Avg Degree', 'Value': avg_degree / total_nodes if total_nodes > 0 else 0},
-                       {'Metric': 'Edge Ratio', 'Value': total_edges / total_nodes if total_nodes > 0 else 0}
-                   ]
-           
-           if connectivity_data:
-               conn_df = pd.DataFrame(connectivity_data)
-               fig.add_trace(
-                   go.Bar(
-                       x=conn_df['Metric'],
-                       y=conn_df['Value'],
-                       marker_color=['lightpink', 'lightsteelblue', 'lightgoldenrodyellow'],
-                       text=[f'{v:.3f}' for v in conn_df['Value']],
-                       textposition='auto',
-                       showlegend=False
-                   ),
-                   row=2, col=2
-               )
-           
-           fig.update_layout(
-               title=dict(
-                   text='Dataset Statistics Dashboard',
-                   x=0.5,
-                   font=dict(size=16)
-               ),
-               height=600,
-               showlegend=False
-           )
-           
-           # Update axes
-           fig.update_xaxes(title_text="Metrics", tickangle=45, row=1, col=1)
-           fig.update_xaxes(title_text="Number of Nodes", row=1, col=2)
-           fig.update_xaxes(title_text="Statistics", tickangle=45, row=2, col=1)
-           fig.update_xaxes(title_text="Connectivity Metrics", tickangle=45, row=2, col=2)
-           
-           fig.update_yaxes(title_text="Count", row=1, col=1)
-           fig.update_yaxes(title_text="Frequency", row=1, col=2)
-           fig.update_yaxes(title_text="Average Value", row=2, col=1)
-           fig.update_yaxes(title_text="Ratio", row=2, col=2)
-           
-           return fig
-           
-       except Exception as e:
-           logger.error(f"Dataset stats plot error: {e}")
-           return GraphVisualizer._create_error_figure(f"Dataset stats error: {str(e)}")
-   
-   @staticmethod
-   def _create_error_figure(error_message):
-       """Create an error figure with message"""
-       fig = go.Figure()
-       fig.add_annotation(
-           text=error_message,
-           x=0.5, y=0.5,
-           xref="paper", yref="paper",
-           showarrow=False,
-           font=dict(size=14, color="red"),
-           bgcolor="rgba(255,255,255,0.8)",
-           bordercolor="red",
-           borderwidth=1
-       )
-       fig.update_layout(
-           title="Visualization Error",
-           xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-           yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-           plot_bgcolor='white',
-           width=600,
-           height=400
-       )
-       return fig
-   
-   @staticmethod
-   def create_comparison_plot(results_dict):
-       """
-       Create model comparison visualization
-       
-       Args:
-           results_dict: Dictionary mapping model names to their results
-           
-       Returns:
-           Plotly figure object
-       """
-       try:
-           if not isinstance(results_dict, dict) or not results_dict:
-               return GraphVisualizer._create_error_figure("No comparison data available")
-           
-           # Extract metrics for comparison
-           models = []
-           accuracies = []
-           f1_scores = []
-           losses = []
-           
-           for model_name, metrics in results_dict.items():
-               if isinstance(metrics, dict):
-                   models.append(model_name)
-                   accuracies.append(metrics.get('accuracy', 0))
-                   f1_scores.append(metrics.get('f1_macro', 0))
-                   losses.append(metrics.get('loss', float('inf')))
-           
-           if not models:
-               return GraphVisualizer._create_error_figure("No valid model results to compare")
-           
-           # Create comparison figure
-           fig = make_subplots(
-               rows=1, cols=3,
-               subplot_titles=('Accuracy Comparison', 'F1 Score Comparison', 'Loss Comparison')
-           )
-           
-           # Accuracy comparison
-           fig.add_trace(
-               go.Bar(
-                   x=models,
-                   y=accuracies,
-                   name='Accuracy',
-                   marker_color='lightblue',
-                   text=[f'{acc:.3f}' for acc in accuracies],
-                   textposition='auto',
-                   showlegend=False
-               ),
-               row=1, col=1
-           )
-           
-           # F1 Score comparison
-           fig.add_trace(
-               go.Bar(
-                   x=models,
-                   y=f1_scores,
-                   name='F1 Score',
-                   marker_color='lightgreen',
-                   text=[f'{f1:.3f}' for f1 in f1_scores],
-                   textposition='auto',
-                   showlegend=False
-               ),
-               row=1, col=2
-           )
-           
-           # Loss comparison (filter out infinite values)
-           finite_losses = [loss if np.isfinite(loss) else 0 for loss in losses]
-           fig.add_trace(
-               go.Bar(
-                   x=models,
-                   y=finite_losses,
-                   name='Loss',
-                   marker_color='lightcoral',
-                   text=[f'{loss:.3f}' if np.isfinite(loss) else 'inf' for loss in losses],
-                   textposition='auto',
-                   showlegend=False
-               ),
-               row=1, col=3
-           )
-           
-           fig.update_layout(
-               title=dict(
-                   text='Model Performance Comparison',
-                   x=0.5,
-                   font=dict(size=18)
-               ),
-               height=400
-           )
-           
-           # Update axes
-           fig.update_xaxes(tickangle=45, row=1, col=1)
-           fig.update_xaxes(tickangle=45, row=1, col=2)
-           fig.update_xaxes(tickangle=45, row=1, col=3)
-           
-           fig.update_yaxes(range=[0, 1], row=1, col=1)
-           fig.update_yaxes(range=[0, 1], row=1, col=2)
-           
-           return fig
-           
-       except Exception as e:
-           logger.error(f"Comparison plot error: {e}")
-           return GraphVisualizer._create_error_figure(f"Comparison plot error: {str(e)}")
+            fig = make_subplots(
+                rows=1, cols=2,
+                subplot_titles=('Performance Metrics', 'Metric Radar Chart'),
+                specs=[[{"type": "bar"}, {"type": "polar"}]]
+            )
+            
+            colors = px.colors.qualitative.Set3[:len(metric_names)]
+            
+            fig.add_trace(
+                go.Bar(
+                    x=metric_names,
+                    y=metric_values,
+                    marker_color=colors,
+                    text=[f'{v:.3f}' for v in metric_values],
+                    textposition='auto',
+                    showlegend=False
+                ),
+                row=1, col=1
+            )
+            
+            fig.add_trace(
+                go.Scatterpolar(
+                    r=metric_values + [metric_values[0]],
+                    theta=metric_names + [metric_names[0]],
+                    fill='toself',
+                    line=dict(color='blue'),
+                    marker=dict(size=8),
+                    showlegend=False
+                ),
+                row=1, col=2
+            )
+            
+            fig.update_layout(
+                title='Model Performance Dashboard',
+                height=400,
+                showlegend=False
+            )
+            
+            fig.update_xaxes(title_text="Metrics", tickangle=45, row=1, col=1)
+            fig.update_yaxes(title_text="Score", range=[0, 1], row=1, col=1)
+            
+            fig.update_polars(
+                radialaxis=dict(range=[0, 1], showticklabels=True),
+                row=1, col=2
+            )
+            
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Metrics plot error: {e}")
+            return GraphVisualizer._create_error_figure(f"Metrics plot error: {str(e)}")
+    
+    @staticmethod
+    def create_training_history_plot(history):
+        """Create comprehensive training history visualization"""
+        try:
+            if not isinstance(history, dict) or not history:
+                return GraphVisualizer._create_error_figure("No training history available")
+            
+            required_keys = ['train_loss', 'train_acc']
+            for key in required_keys:
+                if key not in history or not history[key]:
+                    return GraphVisualizer._create_error_figure(f"Missing {key} in training history")
+            
+            epochs = list(range(len(history['train_loss'])))
+            
+            fig = make_subplots(
+                rows=2, cols=2,
+                subplot_titles=('Loss Over Time', 'Accuracy Over Time', 'Learning Rate', 'Training Progress'),
+                specs=[[{"secondary_y": False}, {"secondary_y": False}],
+                       [{"secondary_y": False}, {"secondary_y": False}]]
+            )
+            
+            # Training loss
+            fig.add_trace(
+                go.Scatter(
+                    x=epochs, y=history['train_loss'],
+                    mode='lines', name='Train Loss',
+                    line=dict(color='blue', width=2),
+                    showlegend=False
+                ),
+                row=1, col=1
+            )
+            
+            if 'val_loss' in history and history['val_loss']:
+                fig.add_trace(
+                    go.Scatter(
+                        x=epochs, y=history['val_loss'],
+                        mode='lines', name='Val Loss',
+                        line=dict(color='red', width=2),
+                        showlegend=False
+                    ),
+                    row=1, col=1
+                )
+            
+            # Training accuracy
+            fig.add_trace(
+                go.Scatter(
+                    x=epochs, y=history['train_acc'],
+                    mode='lines', name='Train Acc',
+                    line=dict(color='green', width=2),
+                    showlegend=False
+                ),
+                row=1, col=2
+            )
+            
+            if 'val_acc' in history and history['val_acc']:
+                fig.add_trace(
+                    go.Scatter(
+                        x=epochs, y=history['val_acc'],
+                        mode='lines', name='Val Acc',
+                        line=dict(color='orange', width=2),
+                        showlegend=False
+                    ),
+                    row=1, col=2
+                )
+            
+            # Learning rate
+            if 'lr' in history and history['lr']:
+                fig.add_trace(
+                    go.Scatter(
+                        x=epochs, y=history['lr'],
+                        mode='lines', name='Learning Rate',
+                        line=dict(color='purple', width=2),
+                        showlegend=False
+                    ),
+                    row=2, col=1
+                )
+            
+            # Training progress summary
+            final_metrics = {
+                'Final Train Acc': history['train_acc'][-1] if history['train_acc'] else 0,
+                'Final Train Loss': history['train_loss'][-1] if history['train_loss'] else 0,
+            }
+            
+            if 'val_acc' in history and history['val_acc']:
+                final_metrics['Final Val Acc'] = history['val_acc'][-1]
+                final_metrics['Best Val Acc'] = max(history['val_acc'])
+            
+            metric_names = list(final_metrics.keys())
+            metric_values = list(final_metrics.values())
+            
+            fig.add_trace(
+                go.Bar(
+                    x=metric_names,
+                    y=metric_values,
+                    marker_color=['lightblue', 'lightcoral', 'lightgreen', 'gold'],
+                    text=[f'{v:.3f}' for v in metric_values],
+                    textposition='auto',
+                    showlegend=False
+                ),
+                row=2, col=2
+            )
+            
+            fig.update_layout(
+                title='Training History Dashboard',
+                height=600,
+                showlegend=True
+            )
+            
+            fig.update_xaxes(title_text="Epoch", row=1, col=1)
+            fig.update_xaxes(title_text="Epoch", row=1, col=2)
+            fig.update_xaxes(title_text="Epoch", row=2, col=1)
+            fig.update_xaxes(title_text="Metric", tickangle=45, row=2, col=2)
+            
+            fig.update_yaxes(title_text="Loss", row=1, col=1)
+            fig.update_yaxes(title_text="Accuracy", range=[0, 1], row=1, col=2)
+            fig.update_yaxes(title_text="Learning Rate", type="log", row=2, col=1)
+            fig.update_yaxes(title_text="Value", row=2, col=2)
+            
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Training history plot error: {e}")
+            return GraphVisualizer._create_error_figure(f"Training history plot error: {str(e)}")
+    
+    @staticmethod
+    def _create_error_figure(error_message):
+        """Create an error figure with message"""
+        fig = go.Figure()
+        fig.add_annotation(
+            text=error_message,
+            x=0.5, y=0.5,
+            xref="paper", yref="paper",
+            showarrow=False,
+            font=dict(size=14, color="red"),
+            bgcolor="rgba(255,255,255,0.8)",
+            bordercolor="red",
+            borderwidth=1
+        )
+        fig.update_layout(
+            title="Visualization Error",
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            plot_bgcolor='white',
+            width=600,
+            height=400
+        )
+        return fig