analyze_predictions.py

#!/usr/bin/env python3
"""
RouteNet-Fermi Prediction Results Analyzer

This script analyzes the prediction results stored in NPY files generated by the predict.py script.
It provides statistics and visualizations of the model's performance on different traffic models.
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from pathlib import Path
import sys

def load_predictions(npy_file):
    """Load predictions from NPY file"""
    try:
        predictions = np.load(npy_file)
        print(f"Loaded predictions from {npy_file}")
        print(f"Shape: {predictions.shape}")
        print(f"Data type: {predictions.dtype}")
        return predictions
    except Exception as e:
        print(f"Error loading {npy_file}: {e}")
        return None

def analyze_predictions(predictions, traffic_model):
    """Analyze prediction results"""
    print(f"\n{'='*50}")
    print(f"Analysis for {traffic_model}")
    print(f"{'='*50}")
    
    if predictions is None:
        return
    
    # Basic statistics
    print(f"Total samples: {len(predictions)}")
    print(f"Min value: {np.min(predictions):.6f}")
    print(f"Max value: {np.max(predictions):.6f}")
    print(f"Mean value: {np.mean(predictions):.6f}")
    print(f"Median value: {np.median(predictions):.6f}")
    print(f"Std deviation: {np.std(predictions):.6f}")
    
    # Percentiles
    percentiles = [1, 5, 10, 25, 50, 75, 90, 95, 99]
    print(f"\nPercentiles:")
    for p in percentiles:
        value = np.percentile(predictions, p)
        print(f"  {p:2d}th percentile: {value:.6f}")
    
    # Check for negative or zero values
    negative_count = np.sum(predictions < 0)
    zero_count = np.sum(predictions == 0)
    positive_count = np.sum(predictions > 0)
    
    print(f"\nValue distribution:")
    print(f"  Negative values: {negative_count} ({negative_count/len(predictions)*100:.2f}%)")
    print(f"  Zero values: {zero_count} ({zero_count/len(predictions)*100:.2f}%)")
    print(f"  Positive values: {positive_count} ({positive_count/len(predictions)*100:.2f}%)")
    
    return predictions

def create_visualizations(predictions_dict):
    """Create visualizations for the predictions"""
    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
    fig.suptitle('RouteNet-Fermi Prediction Results Analysis', fontsize=16)
    
    # Histogram of predictions
    ax1 = axes[0, 0]
    for traffic_model, predictions in predictions_dict.items():
        if predictions is not None:
            ax1.hist(predictions, bins=50, alpha=0.7, label=traffic_model, density=True)
    ax1.set_xlabel('Predicted Delay')
    ax1.set_ylabel('Density')
    ax1.set_title('Distribution of Predicted Delays')
    ax1.legend()
    ax1.set_yscale('log')
    
    # Box plot
    ax2 = axes[0, 1]
    box_data = []
    labels = []
    for traffic_model, predictions in predictions_dict.items():
        if predictions is not None:
            box_data.append(predictions)
            labels.append(traffic_model)
    
    if box_data:
        ax2.boxplot(box_data, labels=labels)
        ax2.set_ylabel('Predicted Delay')
        ax2.set_title('Box Plot of Predicted Delays')
        ax2.tick_params(axis='x', rotation=45)
    
    # Log-scale histogram
    ax3 = axes[1, 0]
    for traffic_model, predictions in predictions_dict.items():
        if predictions is not None and np.all(predictions > 0):
            ax3.hist(np.log10(predictions), bins=50, alpha=0.7, label=traffic_model, density=True)
    ax3.set_xlabel('Log10(Predicted Delay)')
    ax3.set_ylabel('Density')
    ax3.set_title('Log-scale Distribution of Predicted Delays')
    ax3.legend()
    
    # Cumulative distribution
    ax4 = axes[1, 1]
    for traffic_model, predictions in predictions_dict.items():
        if predictions is not None:
            sorted_pred = np.sort(predictions)
            cumulative = np.arange(1, len(sorted_pred) + 1) / len(sorted_pred)
            ax4.plot(sorted_pred, cumulative, label=traffic_model, linewidth=2)
    ax4.set_xlabel('Predicted Delay')
    ax4.set_ylabel('Cumulative Probability')
    ax4.set_title('Cumulative Distribution of Predicted Delays')
    ax4.legend()
    ax4.set_xscale('log')
    
    plt.tight_layout()
    plt.savefig('prediction_analysis.png', dpi=300, bbox_inches='tight')
    print("\n✓ Visualization saved as 'prediction_analysis.png'")
    plt.show()

def compare_traffic_models(predictions_dict):
    """Compare different traffic models"""
    print(f"\n{'='*60}")
    print(f"TRAFFIC MODEL COMPARISON")
    print(f"{'='*60}")
    
    comparison_data = []
    
    for traffic_model, predictions in predictions_dict.items():
        if predictions is not None:
            stats = {
                'Traffic Model': traffic_model,
                'Count': len(predictions),
                'Mean': np.mean(predictions),
                'Median': np.median(predictions),
                'Std': np.std(predictions),
                'Min': np.min(predictions),
                'Max': np.max(predictions),
                'Q25': np.percentile(predictions, 25),
                'Q75': np.percentile(predictions, 75)
            }
            comparison_data.append(stats)
    
    if comparison_data:
        df = pd.DataFrame(comparison_data)
        print(df.to_string(index=False, float_format='%.6f'))
        
        # Save to CSV
        df.to_csv('prediction_comparison.csv', index=False)
        print(f"\n✓ Comparison data saved as 'prediction_comparison.csv'")

def main():
    # Find all prediction NPY files
    delay_dir = Path('traffic_models/delay')
    
    if not delay_dir.exists():
        print(f"Error: Directory {delay_dir} not found")
        sys.exit(1)
    
    npy_files = list(delay_dir.glob('predictions_*.npy'))
    
    if not npy_files:
        print(f"No prediction NPY files found in {delay_dir}")
        sys.exit(1)
    
    print(f"Found {len(npy_files)} prediction files:")
    for file in npy_files:
        print(f"  - {file.name}")
    
    # Load and analyze each file
    predictions_dict = {}
    
    for npy_file in npy_files:
        # Extract traffic model name from filename
        filename = npy_file.stem
        if 'constant_bitrate' in filename:
            traffic_model = 'Constant Bitrate'
        elif 'autocorrelated' in filename:
            traffic_model = 'Autocorrelated'
        elif 'onoff' in filename:
            traffic_model = 'ON-OFF'
        elif 'modulated' in filename:
            traffic_model = 'Modulated'
        else:
            traffic_model = filename.replace('predictions_delay_', '').replace('_', ' ').title()
        
        predictions = load_predictions(npy_file)
        if predictions is not None:
            predictions_dict[traffic_model] = predictions
            analyze_predictions(predictions, traffic_model)
    
    # Compare traffic models
    if predictions_dict:
        compare_traffic_models(predictions_dict)
        
        # Create visualizations
        try:
            create_visualizations(predictions_dict)
        except Exception as e:
            print(f"Warning: Could not create visualizations: {e}")
            print("This might be due to missing matplotlib or display issues")
    
    print(f"\n{'='*60}")
    print(f"ANALYSIS COMPLETE")
    print(f"{'='*60}")
    print(f"Results have been saved to:")
    print(f"  - prediction_comparison.csv")
    print(f"  - prediction_analysis.png (if matplotlib is available)")

if __name__ == "__main__":
    main()