Delete core/plot.py

core/plot.py

@@ -1,523 +0,0 @@
-import matplotlib.pyplot as plt
-import seaborn as sns
-import pandas as pd
-import numpy as np
-import networkx as nx
-from matplotlib.backends.backend_tkagg import NavigationToolbar2Tk
-
-def plot_forecast(result):
-    """Interactive backtest plot with zoom and pan functionality"""
-    forecast = result["forecast"]
-    actual = result["actual"]
-
-    # Convert to numpy arrays and flatten if needed
-    forecast = np.array(forecast).flatten()
-    actual = np.array(actual).flatten()
-    
-    # Ensure both arrays have the same length
-    min_len = min(len(forecast), len(actual))
-    forecast = forecast[:min_len]
-    actual = actual[:min_len]
-
-    # Create figure with adjusted size for better visibility
-    fig = plt.figure(figsize=(10, 6))
-    ax = fig.add_subplot(111)
-    plt.ion()  # Turn on interactive mode
-    
-    if len(actual) == 0 or len(forecast) == 0:
-        ax.text(0.5, 0.5, "No data available for plotting", ha='center', va='center')
-        return fig
-    
-    # Create time indices
-    time_indices = np.arange(len(actual))
-    
-    # Plot full historical actual
-    ax.plot(time_indices, actual, label="Historical Actual", color="blue", linewidth=2, alpha=0.7)
-    
-    # Plot full historical forecast
-    ax.plot(time_indices, forecast, label="Historical Forecast", color="orange", linestyle="--", linewidth=2, alpha=0.7)
-    
-    if len(actual) > 1 and len(forecast) > 1:
-        last_idx = len(actual) - 1
-        
-        # Highlight only the last day actual segment
-        last_actual_segment = [float(actual[last_idx-1]), float(actual[last_idx])]
-        last_time_segment = [time_indices[last_idx-1], time_indices[last_idx]]
-        ax.plot(last_time_segment, last_actual_segment, 
-                color="blue", linewidth=4, alpha=1.0)
-        
-        # Add markers for the last day comparison
-        ax.scatter([last_idx], [float(actual[last_idx])], color="blue", s=150, zorder=5, edgecolors='darkblue', linewidth=2)
-        ax.scatter([last_idx], [float(forecast[last_idx])], color="red", s=150, zorder=5, edgecolors='darkred', linewidth=2)
-        
-        # Add value annotations for last day
-        actual_val = float(actual[last_idx])
-        forecast_val = float(forecast[last_idx])
-        annotation1 = ax.annotate(f'Actual: {actual_val:.2f}', 
-                                   xy=(last_idx, actual_val), 
-                                   xytext=(10, 10), textcoords='offset points',
-                                   bbox=dict(boxstyle='round,pad=0.3', facecolor='blue', alpha=0.8, edgecolor='darkblue'),
-                                   color='white', fontsize=10, fontweight='bold')
-        annotation2 = ax.annotate(f'Predicted: {forecast_val:.2f}', 
-                                   xy=(last_idx, forecast_val), 
-                                   xytext=(10, -25), textcoords='offset points',
-                                   bbox=dict(boxstyle='round,pad=0.3', facecolor='red', alpha=0.8, edgecolor='darkred'),
-                                   color='white', fontsize=10, fontweight='bold')
-    elif len(actual) == 1:
-        # Handle single point case
-        ax.scatter([0], [float(actual[0])], color="blue", s=150, zorder=5)
-        ax.scatter([0], [float(forecast[0])], color="red", s=150, zorder=5)
-
-    # Enhanced legend with interactive features, moved to top
-    legend = ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15), ncol=3, frameon=True, fancybox=True, shadow=True)
-    legend.set_draggable(True)  # Make legend draggable
-    
-    # Enhanced styling
-    ax.set_xlabel("Time Index", fontsize=12)
-    ax.set_ylabel("Value", fontsize=12)
-    ax.grid(True, alpha=0.3, linestyle=':', linewidth=0.8)
-    
-    # Add hover functionality
-    def on_hover(event):
-        if event.inaxes == ax and len(actual) > 0:
-            closest_idx = int(round(event.xdata)) if event.xdata is not None else 0
-            if 0 <= closest_idx < len(actual):
-                ax.set_xlabel(f"Time Index: {closest_idx}, Actual={float(actual[closest_idx]):.2f}, Forecast={float(forecast[closest_idx]):.2f}", 
-                              fontsize=12)
-                fig.canvas.draw_idle()
-            else:
-                ax.set_xlabel("Time Index", fontsize=12)
-                fig.canvas.draw_idle()
-
-    # Connect hover event
-    fig.canvas.mpl_connect('motion_notify_event', on_hover)
-    
-    # Explicitly enable navigation toolbar
-    toolbar = NavigationToolbar2Tk(fig.canvas, fig.canvas.get_tk_widget().master)
-    toolbar.update()
-    fig.canvas.toolbar_visible = True
-    
-    # Adjust layout to ensure toolbar visibility
-    plt.tight_layout(rect=[0, 0, 1, 0.95])
-    return fig
-
-
-def plot_future_forecast(df, result, future_df):
-    """Interactive future forecast plot with zoom, pan and hover functionality"""
-    # Create figure with adjusted size for better visibility
-    fig = plt.figure(figsize=(10, 6))
-    ax = fig.add_subplot(111)
-    plt.ion()  # Turn on interactive mode
-    
-    # Validate and convert data
-    if df.empty or 'Date' not in df.columns or 'value' not in df.columns:
-        ax.text(0.5, 0.5, "No valid historical data available", ha='center', va='center')
-        return fig
-    
-    # Plot historical data
-    dates = pd.to_datetime(df['Date'])
-    values = np.array(df['value']).flatten()
-    historical_line, = ax.plot(dates, values, label="Historical Data", color="blue", linewidth=2.5, alpha=0.9)
-    
-    # Store data for hover functionality
-    plot_data = {
-        'historical_dates': dates,
-        'historical_values': values,
-        'future_dates': None,
-        'predictions': None,
-        'actual_future_dates': None,
-        'actual_future_values': None
-    }
-    
-    if "latest_prediction" in result and len(result["latest_prediction"]) > 0:
-        # Convert predictions to flat array
-        predictions = np.array(result["latest_prediction"]).flatten()
-        
-        # Create future dates
-        last_date = dates.iloc[-1] if len(dates) > 0 else pd.Timestamp.now()
-        horizon = len(predictions)
-        
-        try:
-            future_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=horizon, freq='B')
-        except:
-            # Fallback to daily frequency if business day fails
-            future_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=horizon, freq='D')
-        
-        # Store for hover
-        plot_data['future_dates'] = future_dates
-        plot_data['predictions'] = predictions
-        
-        if len(values) > 0 and len(predictions) > 0:
-            # Create connection from last historical point to first prediction
-            connection_dates = [last_date, future_dates[0]]
-            connection_values = [float(values[-1]), float(predictions[0])]
-            connection_line, = ax.plot(connection_dates, connection_values, color="orange", linestyle=":", linewidth=2, alpha=0.7)
-        
-        # Plot forecast with fine connecting lines
-        predictions_float = [float(p) for p in predictions]
-        forecast_line, = ax.plot(future_dates, predictions_float, 
-                                 label="Forecast", color="orange", linewidth=3, 
-                                 linestyle="-", marker='o', markersize=8, markerfacecolor='orange', 
-                                 markeredgecolor='darkorange', markeredgewidth=2, alpha=0.9)
-        
-        # Add value annotations for predictions (initially hidden for cleaner zoom)
-        prediction_annotations = []
-        for i, val in enumerate(predictions_float):
-            ann = ax.annotate(f"{val:.2f}", 
-                              xy=(future_dates[i], val), 
-                              xytext=(0, 15), textcoords='offset points',
-                              ha='center', va='bottom',
-                              bbox=dict(boxstyle='round,pad=0.3', facecolor='orange', alpha=0.9, edgecolor='darkorange'),
-                              color='white', fontsize=9, fontweight='bold',
-                              visible=False)  # Initially hidden
-            prediction_annotations.append(ann)
-        
-        # Plot actual future values if available
-        if not future_df.empty and "future_actuals" in result and 'Date' in future_df.columns and 'value' in future_df.columns:
-            actual_future_dates = pd.to_datetime(future_df['Date'])
-            actual_future_values = np.array(future_df['value']).flatten()
-            actual_future_values_float = [float(v) for v in actual_future_values]
-            
-            # Store for hover
-            plot_data['actual_future_dates'] = actual_future_dates
-            plot_data['actual_future_values'] = actual_future_values_float
-            
-            # Connect to actual future values
-            actual_line, = ax.plot(actual_future_dates, actual_future_values_float, 
-                                   label="Actual Future", color="green", linewidth=3,
-                                   linestyle="-", marker='s', markersize=8, markerfacecolor='green',
-                                   markeredgecolor='darkgreen', markeredgewidth=2, alpha=0.9)
-            
-            # Add value annotations for actuals (initially hidden)
-            actual_annotations = []
-            for i, val in enumerate(actual_future_values_float):
-                date_val = actual_future_dates.iloc[i] if hasattr(actual_future_dates, 'iloc') else actual_future_dates[i]
-                ann = ax.annotate(f"{val:.2f}", 
-                                  xy=(date_val, val), 
-                                  xytext=(0, -25), textcoords='offset points',
-                                  ha='center', va='top',
-                                  bbox=dict(boxstyle='round,pad=0.3', facecolor='green', alpha=0.9, edgecolor='darkgreen'),
-                                  color='white', fontsize=9, fontweight='bold',
-                                  visible=False)  # Initially hidden
-                actual_annotations.append(ann)
-
-    # Enhanced legend with interactive features, moved to top
-    legend = ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15), ncol=3, frameon=True, fancybox=True, shadow=True, fontsize=11)
-    legend.set_draggable(True)  # Make legend draggable
-    
-    ax.set_xlabel("Date", fontsize=13, fontweight='bold')
-    ax.set_ylabel("Stock Price", fontsize=13, fontweight='bold')
-    ax.grid(True, alpha=0.4, linestyle=':', linewidth=0.8)
-    
-    # Add crosshair cursor
-    cursor_lines = {
-        'h': ax.axhline(y=0, color='gray', linestyle='--', alpha=0.5, visible=False),
-        'v': ax.axvline(x=dates.iloc[0], color='gray', linestyle='--', alpha=0.5, visible=False)
-    }
-    
-    # Enhanced hover functionality with crosshair
-    def on_hover(event):
-        if event.inaxes == ax and event.xdata is not None and event.ydata is not None:
-            # Show crosshair
-            cursor_lines['h'].set_ydata([event.ydata])
-            cursor_lines['v'].set_xdata([event.xdata])
-            cursor_lines['h'].set_visible(True)
-            cursor_lines['v'].set_visible(True)
-            
-            # Find closest point and display info
-            hover_date = pd.to_datetime(event.xdata)
-            info_text = f"Date: {hover_date.strftime('%Y-%m-%d')}, Price: {event.ydata:.2f}"
-            
-            # Check if hovering over historical data
-            if plot_data['historical_dates'] is not None:
-                hist_diff = abs((plot_data['historical_dates'] - hover_date).days)
-                if len(hist_diff) > 0 and hist_diff.min() < 5:  # Within 5 days
-                    closest_idx = hist_diff.argmin()
-                    closest_val = float(plot_data['historical_values'][closest_idx])
-                    info_text = f"Historical - {plot_data['historical_dates'].iloc[closest_idx].strftime('%Y-%m-%d')}: ${closest_val:.2f}"
-            
-            # Check if hovering over predictions
-            if plot_data['future_dates'] is not None:
-                future_diff = abs((plot_data['future_dates'] - hover_date).days)
-                if len(future_diff) > 0 and future_diff.min() < 2:  # Within 2 days
-                    closest_idx = future_diff.argmin()
-                    closest_val = float(plot_data['predictions'][closest_idx])
-                    info_text = f"Prediction - {plot_data['future_dates'][closest_idx].strftime('%Y-%m-%d')}: ${closest_val:.2f}"
-            
-            # Check if hovering over actual future
-            if plot_data['actual_future_dates'] is not None:
-                actual_diff = abs((plot_data['actual_future_dates'] - hover_date).days)
-                if len(actual_diff) > 0 and actual_diff.min() < 2:
-                    closest_idx = actual_diff.argmin()
-                    closest_val = float(plot_data['actual_future_values'][closest_idx])
-                    date_val = plot_data['actual_future_dates'].iloc[closest_idx] if hasattr(plot_data['actual_future_dates'], 'iloc') else plot_data['actual_future_dates'][closest_idx]
-                    info_text = f"Actual Future - {date_val.strftime('%Y-%m-%d')}: ${closest_val:.2f}"
-            
-            ax.set_xlabel(f"{info_text}", fontsize=13, fontweight='bold')
-            fig.canvas.draw_idle()
-    
-    def on_leave(event):
-        # Hide crosshair when leaving plot area
-        cursor_lines['h'].set_visible(False)
-        cursor_lines['v'].set_visible(False)
-        ax.set_xlabel("Date", fontsize=13, fontweight='bold')
-        fig.canvas.draw_idle()
-    
-    # Toggle annotations on double click
-    def on_double_click(event):
-        if event.inaxes == ax:
-            # Toggle prediction annotations visibility
-            if 'prediction_annotations' in locals():
-                for ann in prediction_annotations:
-                    ann.set_visible(not ann.get_visible())
-            if 'actual_annotations' in locals():
-                for ann in actual_annotations:
-                    ann.set_visible(not ann.get_visible())
-            fig.canvas.draw_idle()
-    
-    # Connect events
-    fig.canvas.mpl_connect('motion_notify_event', on_hover)
-    fig.canvas.mpl_connect('axes_leave_event', on_leave)
-    fig.canvas.mpl_connect('button_press_event', on_double_click)
-    
-    # Improve date formatting on x-axis
-    fig.autofmt_xdate(rotation=45)
-    
-    # Explicitly enable navigation toolbar
-    toolbar = NavigationToolbar2Tk(fig.canvas, fig.canvas.get_tk_widget().master)
-    toolbar.update()
-    fig.canvas.toolbar_visible = True
-    
-    # Adjust layout to ensure toolbar visibility
-    plt.tight_layout(rect=[0, 0, 1, 0.95])
-    return fig
-
-
-def plot_metrics_precision(result):
-    fig = plt.figure(figsize=(8, 5))
-    ax = fig.add_subplot(111)
-    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')
-        return fig
-    
-    sns.barplot(x=list(metrics.keys()), y=list(metrics.values()), ax=ax, palette="Blues_d")
-    for i, v in enumerate(metrics.values()):
-        ax.text(i, v + 0.01 * max(metrics.values(), default=100), f"{v:.2f}%", ha='center', va='bottom', fontsize=10)
-    
-    max_val = max(metrics.values(), default=100)
-    min_val = min(metrics.values(), default=0)
-    ax.set_ylim(min(min_val - 5, -10), max_val + 10)
-    ax.set_ylabel("Value (%)")
-    ax.grid(True, axis='y')
-    
-    # Explicitly enable navigation toolbar
-    toolbar = NavigationToolbar2Tk(fig.canvas, fig.canvas.get_tk_widget().master)
-    toolbar.update()
-    fig.canvas.toolbar_visible = True
-    
-    plt.tight_layout()
-    return fig
-
-
-def plot_metrics_risk(result):
-    fig = plt.figure(figsize=(8, 5))
-    ax = fig.add_subplot(111)
-    metrics = {k: v for k, v in result['metrics'].items() if k in ['RMSE', 'MAE', 'MAPE (%)', 'MASE'] and v is not None}
-    if not metrics:
-        ax.text(0.5, 0.5, "No valid risk metrics available", ha='center', va='center')
-        return fig
-    
-    sns.barplot(x=list(metrics.keys()), y=list(metrics.values()), ax=ax, palette="Reds_d")
-    for i, v in enumerate(metrics.values()):
-        ax.text(i, v + 0.01 * max(metrics.values(), default=1), f"{v:.2f}", ha='center', va='bottom', fontsize=10)
-    
-    max_val = max(metrics.values(), default=1)
-    ax.set_ylim(0, max_val + 0.2 * max_val)
-    ax.set_ylabel("Value")
-    ax.grid(True, axis='y')
-    
-    # Explicitly enable navigation toolbar
-    toolbar = NavigationToolbar2Tk(fig.canvas, fig.canvas.get_tk_widget().master)
-    toolbar.update()
-    fig.canvas.toolbar_visible = True
-    
-    plt.tight_layout()
-    return fig
-
-
-def plot_loss_curve(result):
-    train_losses = result.get('train_loss', [])
-    val_losses = result.get('val_loss', [])
-    fig = plt.figure(figsize=(8, 5))
-    ax = fig.add_subplot(111)
-    ax.plot(train_losses, label='Train Loss', color='blue', linewidth=2)
-    if val_losses:
-        ax.plot(val_losses, label='Validation Loss', color='orange', linewidth=2)
-    ax.set_xlabel('Epoch')
-    ax.set_ylabel('Loss (MSE)')
-    ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15), ncol=2)
-    ax.grid(True)
-    
-    # Explicitly enable navigation toolbar
-    toolbar = NavigationToolbar2Tk(fig.canvas, fig.canvas.get_tk_widget().master)
-    toolbar.update()
-    fig.canvas.toolbar_visible = True
-    
-    plt.tight_layout()
-    return fig
-
-
-def plot_model_architecture(result):
-    fig = plt.figure(figsize=(10, 6))
-    ax = fig.add_subplot(111)
-    ax.axis('off')
-    G = nx.DiGraph()
-
-    if "architecture" not in result:
-        ax.text(0.5, 0.5, "No architecture details available", ha='center', va='center', fontsize=12)
-        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"]
-
-    # Handle model-specific hidden units for visualization
-    if model_name == "MLPModel":
-        hidden_nodes = min(hidden_units[0], 5)  # Use first hidden layer size
-        units_label = f"{hidden_units[0]},{hidden_units[1]}"  # Show both sizes
-    elif model_name == "CNNModel":
-        hidden_nodes = 5  # Simplified for visualization
-        units_label = f"{hidden_units} filters"  # num_filters
-    elif model_name == "TransformerModel":
-        hidden_nodes = min(hidden_units, 5)  # d_model
-        units_label = f"{hidden_units}"
-    else:
-        hidden_nodes = min(hidden_units, 5)  # hidden_size
-        units_label = f"{hidden_units}"
-
-    # Simplified block diagram for complex models
-    if model_name in ["CNNModel", "HybridModel", "CNN_GRU"]:
-        G = nx.DiGraph()
-        pos = {}
-        nodes = []
-        y_pos = 0.5
-        layer_width = 1.0 / 4  # Fixed for 3–4 blocks
-
-        # Define components for each complex model
-        if model_name == "CNNModel":
-            components = [
-                ("Input", f"{input_size} units"),
-                ("Conv1D", f"{hidden_units} filters"),
-                ("MaxPool", ""),
-                ("Output", f"{output_size} units")
-            ]
-        elif model_name == "HybridModel":
-            components = [
-                ("Input", f"{input_size} units"),
-                ("Conv1D", "32 filters"),
-                (f"BiLSTM ({num_layers} layers)", f"{hidden_units*2} units"),
-                ("Output", f"{output_size} units")
-            ]
-        elif model_name == "CNN_GRU":
-            components = [
-                ("Input", f"{input_size} units"),
-                ("Conv1D", "32 filters"),
-                (f"GRU ({num_layers} layers)", f"{hidden_units} units"),
-                ("Output", f"{output_size} units")
-            ]
-
-        # Add nodes and positions
-        for i, (comp, label) in enumerate(components):
-            G.add_node(comp, layer=comp)
-            pos[comp] = (i * layer_width, y_pos)
-            nodes.append([comp])
-            if i > 0:
-                G.add_edge(components[i-1][0], comp)
-
-        # Draw the graph
-        nx.draw(G, pos, ax=ax, with_labels=False, node_color='lightblue', edge_color='gray', 
-                node_size=2000, node_shape='s', arrowsize=10)
-
-        # Add labels for each block
-        for node, (x, y) in pos.items():
-            label = [comp[1] for comp in components if comp[0] == node][0]
-            ax.text(x, y + 0.05, f"{node}\n{label}", ha='center', va='bottom', fontsize=8,
-                    bbox=dict(facecolor='white', alpha=0.8, edgecolor='black'))
-
-    else:
-        # Node-based graph for RNN, LSTM, GRU, BiLSTM, MLP, Transformer
-        max_nodes_display = 5
-        input_nodes = min(input_size, max_nodes_display)
-        output_nodes = min(output_size, max_nodes_display)
-
-        nodes = []
-        pos = {}
-        layer_width = 1.0 / (num_layers + 2)
-        y_pos = 0.5
-
-        # 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)
-
-        # 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]}: {units_label} units"
-            elif layer == "input":
-                label = f"Input: {input_size} units"
-            elif layer == "output":
-                label = f"Output: {output_size} units"
-            ax.text(x, y + 0.05, label, ha='center', va='bottom', fontsize=8)
-
-    # Add model details as annotation
-    details = f"Dropout: {dropout:.2f}\nBatch Size: {batch_size}"
-    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'))
-
-    # Explicitly enable navigation toolbar
-    toolbar = NavigationToolbar2Tk(fig.canvas, fig.canvas.get_tk_widget().master)
-    toolbar.update()
-    fig.canvas.toolbar_visible = True
-    
-    plt.tight_layout()
-    return fig