Update core/plot.py

core/plot.py

@@ -2,6 +2,7 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 import pandas as pd
 import numpy as np
+import networkx as nx
 
 
 def plot_forecast(result):
@@ -60,24 +61,21 @@ def plot_future_forecast(df, result, future_df):
 
 def plot_metrics_precision(result):
     fig, ax = plt.subplots(figsize=(8, 5))
-    metrics = {k: v for k, v in result['metrics'].items() if k in ['R2', 'Explained Variance', 'MDA (%)'] and v is not None}
+    metrics = {k: v for k, v in result['metrics'].items() if k in ['R² (%)', 'Explained Variance (%)', 'MDA (%)'] and v is not None}
     if not metrics:
         ax.text(0.5, 0.5, "No valid precision metrics available", ha='center', va='center')
         ax.set_title("Precision Metrics (Model Accuracy)")
         return fig
     
     sns.barplot(x=list(metrics.keys()), y=list(metrics.values()), ax=ax, palette="Blues_d")
-    # Add labels on bars
     for i, v in enumerate(metrics.values()):
-        ax.text(i, v + 0.01 * max(metrics.values(), default=1), f"{v:.4f}", ha='center', va='bottom', fontsize=10)
+        ax.text(i, v + 0.01 * max(metrics.values(), default=100), f"{v:.2f}%", ha='center', va='bottom', fontsize=10)
     
-    # Dynamic y-axis scaling
-    max_val = max(metrics.values(), default=1)
+    max_val = max(metrics.values(), default=100)
     min_val = min(metrics.values(), default=0)
-    ax.set_ylim(min(min_val - 0.1 * abs(min_val), -0.1), max_val + 0.2 * max_val)
-    
+    ax.set_ylim(min(min_val - 5, -10), max_val + 10)
+    ax.set_ylabel("Value (%)")
     ax.set_title("Precision Metrics (Model Accuracy)")
-    ax.set_ylabel("Value")
     ax.grid(True, axis='y')
     plt.tight_layout()
     return fig
@@ -92,16 +90,13 @@ def plot_metrics_risk(result):
         return fig
     
     sns.barplot(x=list(metrics.keys()), y=list(metrics.values()), ax=ax, palette="Reds_d")
-    # Add labels on bars
     for i, v in enumerate(metrics.values()):
-        ax.text(i, v + 0.01 * max(metrics.values(), default=1), f"{v:.4f}", ha='center', va='bottom', fontsize=10)
+        ax.text(i, v + 0.01 * max(metrics.values(), default=1), f"{v:.2f}", ha='center', va='bottom', fontsize=10)
     
-    # Dynamic y-axis scaling
     max_val = max(metrics.values(), default=1)
     ax.set_ylim(0, max_val + 0.2 * max_val)
-    
-    ax.set_title("Risk Metrics (Error Magnitude)")
     ax.set_ylabel("Value")
+    ax.set_title("Risk Metrics (Error Magnitude)")
     ax.grid(True, axis='y')
     plt.tight_layout()
     return fig
@@ -119,5 +114,121 @@ def plot_loss_curve(result):
     ax.set_ylabel('Loss (MSE)')
     ax.legend()
     ax.grid(True)
+    plt.tight_layout()
+    return fig
+
+
+def plot_model_architecture(result):
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.axis('off')  # Hide axes for clean visualization
+    G = nx.DiGraph()
+
+    if "architecture" not in result:
+        ax.text(0.5, 0.5, "No architecture details available", ha='center', va='center', fontsize=12)
+        ax.set_title("Model Architecture")
+        plt.tight_layout()
+        return fig
+
+    arch = result["architecture"]
+    model_name = arch["model_name"]
+    num_layers = arch["num_layers"]
+    hidden_units = arch["hidden_units"]
+    dropout = arch["dropout"]
+    batch_size = arch["batch_size"]
+    input_size = arch["input_size"]
+    output_size = arch["output_size"]
+
+    # Simplify node counts for visualization (limit to 5 nodes per layer to avoid clutter)
+    max_nodes_display = 5
+    input_nodes = min(input_size, max_nodes_display)
+    hidden_nodes = min(hidden_units, max_nodes_display)
+    output_nodes = min(output_size, max_nodes_display)
+
+    # Add nodes for each layer
+    nodes = []
+    pos = {}
+    layer_width = 1.0 / (num_layers + 2)  # Space layers evenly
+    y_pos = 0.5  # Center vertically
+
+    # Input layer
+    for i in range(input_nodes):
+        node = f"input_{i}"
+        G.add_node(node, layer="input")
+        pos[node] = (0, y_pos + (i - input_nodes / 2) * 0.1)
+    nodes.append([f"input_{i}" for i in range(input_nodes)])
+
+    # Hidden layers
+    for layer in range(num_layers):
+        layer_nodes = []
+        for i in range(hidden_nodes):
+            node = f"hidden_{layer}_{i}"
+            G.add_node(node, layer=f"hidden_{layer+1}")
+            pos[node] = ((layer + 1) * layer_width, y_pos + (i - hidden_nodes / 2) * 0.1)
+            layer_nodes.append(node)
+        nodes.append(layer_nodes)
+
+    # Output layer
+    output_layer_nodes = []
+    for i in range(output_nodes):
+        node = f"output_{i}"
+        G.add_node(node, layer="output")
+        pos[node] = ((num_layers + 1) * layer_width, y_pos + (i - output_nodes / 2) * 0.1)
+        output_layer_nodes.append(node)
+    nodes.append(output_layer_nodes)
+
+    # Add edges between layers
+    for layer in range(len(nodes) - 1):
+        for src in nodes[layer]:
+            for dst in nodes[layer + 1]:
+                G.add_edge(src, dst)
+
+    # Handle special cases for complex models
+    if model_name in ["CNNModel", "HybridModel", "CNN_GRU"]:
+        # Simplified representation for CNN-based models
+        G = nx.DiGraph()
+        pos = {}
+        nodes = []
+        x_pos = 0
+        if model_name == "CNNModel":
+            components = ["Input", "Conv1D (32 filters)", "Output"]
+            component_sizes = [input_size, 32, output_size]
+        elif model_name == "HybridModel":
+            components = ["Input", "Conv1D (32 filters)", f"BiLSTM ({num_layers} layers)", "Output"]
+            component_sizes = [input_size, 32, hidden_units * 2, output_size]
+        elif model_name == "CNN_GRU":
+            components = ["Input", "Conv1D (32 filters)", f"GRU ({num_layers} layers)", "Output"]
+            component_sizes = [input_size, 32, hidden_units, output_size]
+        
+        for i, comp in enumerate(components):
+            G.add_node(comp, layer=comp)
+            pos[comp] = (i * layer_width * (num_layers + 2) / len(components), y_pos)
+            nodes.append([comp])
+            if i > 0:
+                G.add_edge(components[i-1], comp)
+
+    # Draw the graph
+    nx.draw(G, pos, ax=ax, with_labels=False, node_color='lightblue', edge_color='gray', node_size=500, arrowsize=10)
+    
+    # Add layer labels
+    for node in G.nodes(data=True):
+        layer = node[1]['layer']
+        x, y = pos[node[0]]
+        if layer.startswith("hidden"):
+            label = f"Layer {layer.split('_')[1]}: {hidden_units} units"
+        elif layer == "input":
+            label = f"Input: {input_size} units"
+        elif layer == "output":
+            label = f"Output: {output_size} units"
+        else:
+            label = layer  # For CNN/Hybrid/CNN-GRU components
+        ax.text(x, y + 0.05, label, ha='center', va='bottom', fontsize=8)
+
+    # Add model details as title and annotation
+    title = f"{model_name} Architecture"
+    details = f"Dropout: {dropout:.2f}\nBatch Size: {batch_size}"
+    ax.set_title(title, fontsize=12, pad=20)
+    ax.text(0.5, 0.05, details, ha='center', va='bottom', fontsize=10, transform=ax.transAxes,
+            bbox=dict(facecolor='white', alpha=0.8, edgecolor='black'))
+
     plt.tight_layout()
     return fig