app.sections.model_evaluation

   1#!/usr/bin/env python3
   2# -*- coding: utf-8 -*-
   3"""
   4Model Evaluation and Inference Interface for Gradio Application.
   5
   6This module provides comprehensive model evaluation tools and inference
   7capabilities through a Gradio interface. It includes visualization of
   8model performance metrics, confusion matrices, calibration curves, and
   9both single-image and batch prediction functionality.
  10
  11Key features include:
  12- Multi-model support (best model and latest trained model)
  13- Cached computation of expensive metrics (confusion matrices, calibration)
  14- Automatic cache invalidation based on model modification time
  15- Real-time inference with carbon emissions tracking
  16- Training metrics visualization (loss/accuracy curves)
  17
  18Notes
  19-----
  20Cache files are stored in `app/sections/cached_data/` and are automatically
  21invalidated when the corresponding model file is updated. This ensures
  22that evaluation metrics reflect the current model state while avoiding
  23redundant computation.
  24"""
  25__docformat__ = "numpy"
  26
  27import gradio as gr
  28from source.utils.carbon_utils import format_total_emissions_display
  29from source.utils import config as cfg
  30from source.utils.custom_classes.EvalAnalyzer import GarbageModelAnalyzer
  31from source.predict import (
  32    predict_image,
  33    predict_batch,
  34    load_model_for_inference
  35)
  36from pathlib import Path
  37import matplotlib.pyplot as plt
  38import numpy as np
  39import json
  40import pandas as pd
  41import pickle
  42
  43
  44def get_emissions_path():
  45    """
  46    Get the path to the emissions CSV file.
  47
  48    Returns
  49    -------
  50    pathlib.Path
  51        Path object pointing to the emissions.csv file in the model directory.
  52
  53    Notes
  54    -----
  55    The emissions file is stored in the same directory as the trained model
  56    checkpoint, as defined in the global configuration.
  57    """
  58    return Path(cfg.MODEL_PATH).parent / "emissions.csv"
  59
  60
  61def get_available_models():
  62    """
  63    Get dictionary of available trained models.
  64
  65    Returns
  66    -------
  67    dict of {str: str}
  68        Dictionary mapping model display names to their checkpoint file paths.
  69        Includes both the best provided model and the latest trained model.
  70
  71    Examples
  72    --------
  73    >>> models = get_available_models()
  74    >>> models
  75    {
  76        'Best Model (Provided)': 'models/best/model_resnet18_garbage.ckpt',
  77        'Latest Trained Model': 'models/resnet18_garbage.ckpt'
  78    }
  79    """
  80    models_dict = {
  81        "Best Model (Provided)": str(Path(
  82            "models/best/model_resnet18_garbage.ckpt"
  83        )),
  84        "Latest Trained Model": str(cfg.MODEL_PATH),
  85    }
  86    return models_dict
  87
  88
  89# Setup cache directory
  90CACHE_DIR = Path("app/sections/cached_data")
  91CACHE_DIR.mkdir(parents=True, exist_ok=True)
  92
  93
  94def is_cache_valid(cache_file, model_path):
  95    """
  96    Check if cached file is newer than the model checkpoint.
  97
  98    Validates cache by comparing modification timestamps. Cache is considered
  99    valid only if it was created/modified after the model checkpoint.
 100
 101    Parameters
 102    ----------
 103    cache_file : pathlib.Path
 104        Path to the cached file to validate.
 105    model_path : str or pathlib.Path
 106        Path to the model checkpoint file.
 107
 108    Returns
 109    -------
 110    bool
 111        True if cache exists and is newer than the model, False otherwise.
 112
 113    Notes
 114    -----
 115    This function implements automatic cache invalidation to ensure that
 116    evaluation metrics are regenerated when a model is retrained.
 117
 118    Examples
 119    --------
 120    >>> cache_file = Path("cached_data/cm_raw_Latest.pkl")
 121    >>> model_path = "models/resnet18_garbage.ckpt"
 122    >>> is_cache_valid(cache_file, model_path)
 123    False  # Cache doesn't exist or is older than model
 124    """
 125    if not cache_file.exists():
 126        return False
 127
 128    if not Path(model_path).exists():
 129        return False
 130
 131    cache_time = cache_file.stat().st_mtime
 132    model_time = Path(model_path).stat().st_mtime
 133
 134    print(cache_file, model_path)
 135    print(cache_time, model_time)
 136
 137    return cache_time > model_time  # Cache is valid if newer than model
 138
 139
 140# State to hold both confusion matrices
 141confusion_matrices_state = {
 142    "raw": None,
 143    "normalized": None,
 144    "model_choice": None,  # Track which model generated these
 145}
 146
 147
 148# ========================
 149# METRICS FUNCTIONS
 150# ========================
 151
 152
 153def generate_confusion_matrix(
 154    model_choice,
 155    show_normalized,
 156    progress=gr.Progress()
 157):
 158    """
 159    Generate and cache both raw and normalized confusion matrices.
 160
 161    This function generates confusion matrices for the validation set,
 162    caching both raw and normalized versions to enable instant toggling
 163    without recomputation. Implements three-tier caching: memory, disk,
 164    and automatic invalidation.
 165
 166    Parameters
 167    ----------
 168    model_choice : str
 169        Name of the selected model (from get_available_models()).
 170    show_normalized : bool
 171        Whether to display the normalized version initially.
 172    progress : gr.Progress, optional
 173        Gradio progress tracker for UI updates.
 174
 175    Returns
 176    -------
 177    tuple of (matplotlib.figure.Figure or None, str, gr.update)
 178        - Figure: The confusion matrix plot (raw or normalized)
 179        - str: Status message describing the operation result
 180        - gr.update: Gradio update object to control checkbox visibility
 181
 182    Notes
 183    -----
 184    Caching strategy:
 185    1. Check memory cache (fastest)
 186    2. Check disk cache with validation (fast)
 187    3. Regenerate if cache invalid or missing (slow)
 188
 189    Both raw and normalized matrices are always generated together and
 190    stored separately to enable instant toggling via the checkbox.
 191
 192    The cache is automatically invalidated when the model file is modified,
 193    ensuring metrics reflect the current model state.
 194
 195    See Also
 196    --------
 197    toggle_confusion_matrix : Switch between raw/normalized without
 198    regenerating.
 199    is_cache_valid : Cache validation logic
 200    """
 201    # global confusion_matrices_state # TODO: Revert this (uncomment)
 202
 203    if not model_choice:
 204        return None, "Please select a model first", gr.update(visible=False)
 205
 206    # Get model path
 207    models_dict = get_available_models()
 208    model_path = models_dict.get(model_choice)
 209
 210    # Check if we already have matrices for this model in memory
 211    if (
 212        confusion_matrices_state["model_choice"] == model_choice
 213        and confusion_matrices_state["raw"] is not None
 214        and confusion_matrices_state["normalized"] is not None
 215    ):
 216
 217        selected_matrix = (
 218            confusion_matrices_state["normalized"]
 219            if show_normalized
 220            else confusion_matrices_state["raw"]
 221        )
 222        matrix_type = "Normalized" if show_normalized else "Raw"
 223        return (
 224            selected_matrix,
 225            f"✅ {matrix_type} confusion matrix (from memory)",
 226            gr.update(visible=True, interactive=True),
 227        )
 228
 229    # Check disk cache
 230    cache_file_raw = \
 231        CACHE_DIR / f"cm_raw_{model_choice.replace(' ', '_')}.pkl"
 232    cache_file_norm = \
 233        CACHE_DIR / f"cm_norm_{model_choice.replace(' ', '_')}.pkl"
 234
 235    if is_cache_valid(cache_file_raw, model_path) and is_cache_valid(
 236        cache_file_norm, model_path
 237    ):
 238        try:
 239            progress(0.2, desc="Loading from cache...")
 240            with open(cache_file_raw, "rb") as f:
 241                fig_raw = pickle.load(f)
 242            with open(cache_file_norm, "rb") as f:
 243                fig_norm = pickle.load(f)
 244
 245            confusion_matrices_state["raw"] = fig_raw
 246            confusion_matrices_state["normalized"] = fig_norm
 247            confusion_matrices_state["model_choice"] = model_choice
 248
 249            selected_matrix = fig_norm if show_normalized else fig_raw
 250            matrix_type = "Normalized" if show_normalized else "Raw"
 251            progress(1.0, desc="Done!")
 252            return (
 253                selected_matrix,
 254                f"✅ {matrix_type} confusion matrix loaded from cache",
 255                gr.update(visible=True, interactive=True),
 256            )
 257        except Exception as e:
 258            print(f"[WARN] Failed to load cache: {e}")
 259
 260    # Generate new matrices
 261    try:
 262        progress(0.1, desc="Loading model...")
 263        analyzer = GarbageModelAnalyzer()
 264        analyzer.load_model(checkpoint_path=model_path)
 265
 266        progress(0.3, desc="Setting up data...")
 267        analyzer.setup_data(batch_size=32)
 268
 269        progress(0.5, desc="Evaluating model...")
 270        val_loader = analyzer.data_module.val_dataloader()
 271        preds, labels, probs = analyzer.evaluate_loader(val_loader)
 272
 273        progress(0.7, desc="Generating confusion matrices...")
 274
 275        from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
 276
 277        num_classes = cfg.NUM_CLASSES
 278        cm_raw = confusion_matrix(
 279            labels.cpu().numpy(),
 280            preds.cpu().numpy(),
 281            labels=range(num_classes)
 282        )
 283        cm_norm = cm_raw.astype("float") / cm_raw.sum(axis=1)[:, np.newaxis]
 284
 285        # Generate RAW matrix figure
 286        fig_raw, ax_raw = plt.subplots(figsize=(10, 8))
 287        disp_raw = ConfusionMatrixDisplay(
 288            confusion_matrix=cm_raw, display_labels=cfg.CLASS_NAMES
 289        )
 290        disp_raw.plot(cmap=plt.cm.Blues, ax=ax_raw)
 291        ax_raw.set_title("Confusion Matrix - Validation Set")
 292        plt.tight_layout()
 293
 294        # Generate NORMALIZED matrix figure
 295        fig_norm, ax_norm = plt.subplots(figsize=(10, 8))
 296        disp_norm = ConfusionMatrixDisplay(
 297            confusion_matrix=cm_norm, display_labels=cfg.CLASS_NAMES
 298        )
 299        disp_norm.plot(cmap=plt.cm.Blues, ax=ax_norm)
 300        ax_norm.set_title("Normalized Confusion Matrix - Validation Set")
 301        plt.tight_layout()
 302
 303        # Save to cache
 304        progress(0.9, desc="Saving to cache...")
 305        with open(cache_file_raw, "wb") as f:
 306            pickle.dump(fig_raw, f)
 307        with open(cache_file_norm, "wb") as f:
 308            pickle.dump(fig_norm, f)
 309
 310        # Update state
 311        confusion_matrices_state["raw"] = fig_raw
 312        confusion_matrices_state["normalized"] = fig_norm
 313        confusion_matrices_state["model_choice"] = model_choice
 314
 315        selected_matrix = fig_norm if show_normalized else fig_raw
 316        matrix_type = "Normalized" if show_normalized else "Raw"
 317
 318        progress(1.0, desc="Done!")
 319        return (
 320            selected_matrix,
 321            f"✅ {matrix_type} confusion matrix generated and cached",
 322            gr.update(visible=True, interactive=True),
 323        )
 324
 325    except Exception as e:
 326        return None, f"❌ Error: {str(e)}", gr.update(visible=False)
 327
 328
 329def toggle_confusion_matrix(show_normalized):
 330    """
 331    Toggle between raw and normalized confusion matrices instantly.
 332
 333    Switches the displayed confusion matrix without regenerating, using
 334    cached versions from memory. This enables instant UI response to the
 335    normalization checkbox.
 336
 337    Parameters
 338    ----------
 339    show_normalized : bool
 340        If True, return normalized matrix; if False, return raw matrix.
 341
 342    Returns
 343    -------
 344    matplotlib.figure.Figure or None
 345        The requested confusion matrix figure, or None if not available
 346        in memory cache.
 347
 348    Notes
 349    -----
 350    This function only accesses the in-memory cache. If matrices are not
 351    yet generated, it returns None. The generate_confusion_matrix function
 352    should be called first to populate the cache.
 353
 354    See Also
 355    --------
 356    generate_confusion_matrix : Generate and cache both matrix versions
 357    """
 358    # global confusion_matrices_state # TODO: Revert this (uncomment)
 359
 360    if show_normalized:
 361        if confusion_matrices_state["normalized"] is not None:
 362            return confusion_matrices_state["normalized"]
 363    else:
 364        if confusion_matrices_state["raw"] is not None:
 365            return confusion_matrices_state["raw"]
 366
 367    return None
 368
 369
 370def generate_calibration_curves(model_choice, progress=gr.Progress()):
 371    """
 372    Generate and cache calibration curves for the selected model.
 373
 374    Calibration curves show how well predicted probabilities match actual
 375    outcomes. This function generates curves for all classes and caches
 376    the result for faster subsequent access.
 377
 378    Parameters
 379    ----------
 380    model_choice : str
 381        Name of the selected model (from get_available_models()).
 382    progress : gr.Progress, optional
 383        Gradio progress tracker for UI updates.
 384
 385    Returns
 386    -------
 387    tuple of (matplotlib.figure.Figure or None, str)
 388        - Figure: The calibration curves plot
 389        - str: Status message describing the operation result
 390
 391    Notes
 392    -----
 393    The calibration plot is generated using GarbageModelAnalyzer's
 394    plot_calibration_curves method and cached to disk. Cache is
 395    automatically invalidated when the model is retrained.
 396
 397    Well-calibrated models should have curves close to the diagonal,
 398    indicating that predicted probabilities match actual frequencies.
 399
 400    See Also
 401    --------
 402    is_cache_valid : Cache validation logic
 403    GarbageModelAnalyzer.plot_calibration_curves : Core plotting function
 404    """
 405    if not model_choice:
 406        return None, "Please select a model first"
 407
 408    # Get model path
 409    models_dict = get_available_models()
 410    model_path = models_dict.get(model_choice)
 411
 412    # Check disk cache
 413    cache_file = CACHE_DIR / f"calib_{model_choice.replace(' ', '_')}.pkl"
 414
 415    if is_cache_valid(cache_file, model_path):
 416        try:
 417            progress(0.2, desc="Loading from cache...")
 418            with open(cache_file, "rb") as f:
 419                fig = pickle.load(f)
 420            progress(1.0, desc="Done!")
 421            return fig, "✅ Calibration curves loaded from cache"
 422        except Exception as e:
 423            print(f"[WARN] Failed to load cache: {e}")
 424
 425    try:
 426        progress(0.1, desc="Loading model...")
 427        analyzer = GarbageModelAnalyzer()
 428        analyzer.load_model(checkpoint_path=model_path)
 429
 430        progress(0.3, desc="Setting up data...")
 431        analyzer.setup_data(batch_size=32)
 432
 433        progress(0.5, desc="Evaluating model...")
 434        val_loader = analyzer.data_module.val_dataloader()
 435        preds, labels, probs = analyzer.evaluate_loader(val_loader)
 436
 437        progress(0.8, desc="Generating calibration curves...")
 438
 439        analyzer.plot_calibration_curves(labels, probs)
 440        fig = plt.gcf()
 441
 442        # Save to cache
 443        progress(0.9, desc="Saving to cache...")
 444        with open(cache_file, "wb") as f:
 445            pickle.dump(fig, f)
 446
 447        progress(1.0, desc="Done!")
 448        return fig, "✅ Calibration curves generated and cached"
 449
 450    except Exception as e:
 451        return None, f"❌ Error: {str(e)}"
 452
 453
 454def get_metrics_path_for_model(model_choice):
 455    """
 456    Get the correct metrics.json path for the selected model.
 457
 458    Different models store their training metrics in different locations.
 459    This function maps model choices to their corresponding metrics files.
 460
 461    Parameters
 462    ----------
 463    model_choice : str
 464        Name of the selected model (from get_available_models()).
 465
 466    Returns
 467    -------
 468    pathlib.Path
 469        Path to the metrics.json file for the selected model.
 470
 471    Notes
 472    -----
 473    The best provided model has metrics in a fixed location, while the
 474    latest trained model uses the configured loss curves path.
 475    """
 476    if model_choice == "Best Model (Provided)":
 477        return Path("models/best/performance/loss_curves/metrics.json")
 478    else:
 479        return Path(cfg.LOSS_CURVES_PATH) / "metrics.json"
 480
 481
 482def load_loss_curves(model_choice):
 483    """
 484    Load and plot training/validation loss curves from metrics.json.
 485
 486    Parameters
 487    ----------
 488    model_choice : str
 489        Name of the selected model (from get_available_models()).
 490
 491    Returns
 492    -------
 493    tuple of (matplotlib.figure.Figure or None, str)
 494        - Figure: Loss curves plot showing train and validation loss
 495        - str: Status message describing the operation result
 496
 497    Notes
 498    -----
 499    Loss curves show how training and validation loss evolved during
 500    training. Diverging curves may indicate overfitting, while parallel
 501    curves suggest good generalization.
 502
 503    The plot includes:
 504    - Blue line with circles: Training loss
 505    - Red line with squares: Validation loss
 506    - Grid for easier reading
 507
 508    See Also
 509    --------
 510    load_accuracy_curves : Load accuracy metrics instead of loss
 511    get_metrics_path_for_model : Determine metrics file location
 512    """
 513    try:
 514        metrics_path = get_metrics_path_for_model(model_choice)
 515
 516        if not metrics_path.exists():
 517            return (
 518                None,
 519                f"❌ No training metrics found for \
 520                    {model_choice}. Path: {metrics_path}",
 521            )
 522
 523        with open(metrics_path, "r") as f:
 524            data = json.load(f)
 525
 526        train_losses = data.get("train_losses", [])
 527        val_losses = data.get("val_losses", [])
 528
 529        if not train_losses and not val_losses:
 530            return None, "❌ No loss data available"
 531
 532        fig, ax = plt.subplots(figsize=(10, 6))
 533        epochs = range(1, len(train_losses) + 1)
 534
 535        if train_losses:
 536            ax.plot(
 537                epochs,
 538                train_losses,
 539                "b-o",
 540                label="Train Loss",
 541                linewidth=2
 542            )
 543        if val_losses:
 544            ax.plot(
 545                epochs,
 546                val_losses,
 547                "r-s",
 548                label="Validation Loss",
 549                linewidth=2
 550            )
 551
 552        ax.set_xlabel("Epoch", fontsize=12)
 553        ax.set_ylabel("Loss", fontsize=12)
 554        ax.set_title(f"Loss Curves - \
 555            {model_choice}", fontsize=14, fontweight="bold")
 556        ax.legend(fontsize=10)
 557        ax.grid(True, alpha=0.3)
 558        plt.tight_layout()
 559
 560        return fig, f"✅ Loss curves loaded successfully from {model_choice}"
 561
 562    except Exception as e:
 563        return None, f"❌ Error loading loss curves: {str(e)}"
 564
 565
 566def load_accuracy_curves(model_choice):
 567    """
 568    Load and plot training/validation accuracy curves from metrics.json.
 569
 570    Parameters
 571    ----------
 572    model_choice : str
 573        Name of the selected model (from get_available_models()).
 574
 575    Returns
 576    -------
 577    tuple of (matplotlib.figure.Figure or None, str)
 578        - Figure: Accuracy curves plot showing train and validation accuracy
 579        - str: Status message describing the operation result
 580
 581    Notes
 582    -----
 583    Accuracy curves show how classification accuracy evolved during training.
 584    The plot includes:
 585    - Blue line with circles: Training accuracy
 586    - Red line with squares: Validation accuracy
 587    - Y-axis limited to [0, 1] for consistency
 588    - Grid for easier reading
 589
 590    A large gap between train and validation accuracy indicates overfitting.
 591
 592    See Also
 593    --------
 594    load_loss_curves : Load loss metrics instead of accuracy
 595    get_metrics_path_for_model : Determine metrics file location
 596    """
 597    try:
 598        metrics_path = get_metrics_path_for_model(model_choice)
 599
 600        if not metrics_path.exists():
 601            return (
 602                None,
 603                f"❌ No training metrics found for \
 604                    {model_choice}. Path: {metrics_path}",
 605            )
 606
 607        with open(metrics_path, "r") as f:
 608            data = json.load(f)
 609
 610        train_accs = data.get("train_accs", [])
 611        val_accs = data.get("val_accs", [])
 612
 613        if not train_accs and not val_accs:
 614            return None, "❌ No accuracy data available"
 615
 616        fig, ax = plt.subplots(figsize=(10, 6))
 617
 618        if train_accs:
 619            ax.plot(
 620                range(1, len(train_accs) + 1),
 621                train_accs,
 622                "b-o",
 623                label="Train Accuracy",
 624                linewidth=2,
 625            )
 626        if val_accs:
 627            ax.plot(
 628                range(1, len(val_accs) + 1),
 629                val_accs,
 630                "r-s",
 631                label="Validation Accuracy",
 632                linewidth=2,
 633            )
 634
 635        ax.set_xlabel("Epoch", fontsize=12)
 636        ax.set_ylabel("Accuracy", fontsize=12)
 637        ax.set_title(
 638            f"Accuracy Curves - \
 639                {model_choice}", fontsize=14, fontweight="bold"
 640        )
 641        ax.legend(fontsize=10)
 642        ax.grid(True, alpha=0.3)
 643        ax.set_ylim([0, 1])
 644        plt.tight_layout()
 645
 646        return fig, f"✅ Accuracy curves \
 647            loaded successfully from {model_choice}"
 648
 649    except Exception as e:
 650        return None, f"❌ Error loading \
 651            accuracy curves: {str(e)}"
 652
 653
 654# ========================
 655# PREDICTION FUNCTIONS
 656# ========================
 657
 658
 659def predict_single_image_gradio(
 660    model_choice, image, carbon_display_text, track_carbon=True
 661):
 662    """
 663    Gradio wrapper for single image prediction with visualization.
 664
 665    Performs inference on a single image and generates a horizontal bar
 666    chart of class probabilities, highlighting the predicted class.
 667
 668    Parameters
 669    ----------
 670    model_choice : str
 671        Name of the selected model (from get_available_models()).
 672    image : np.ndarray
 673        Input image as numpy array (from gr.Image component).
 674    carbon_display_text : str
 675        Current HTML string for the carbon display (to be updated).
 676    track_carbon : bool, optional
 677        Whether to track carbon emissions for this prediction,
 678        by default True.
 679
 680    Returns
 681    -------
 682    tuple of (matplotlib.figure.Figure or None, str, str)
 683        - Figure: Bar chart of class probabilities
 684        - str: Markdown-formatted prediction results and statistics
 685        - str: Updated HTML for carbon display
 686
 687    Notes
 688    -----
 689    The probability bar chart uses:
 690    - Green bar for the predicted class
 691    - Sky blue bars for other classes
 692    - Percentage labels on each bar
 693
 694    If carbon tracking is enabled, emissions are added to the cumulative
 695    total and the carbon display is updated.
 696
 697    See Also
 698    --------
 699    predict_batch : Batch prediction on multiple images
 700    source.predict.predict_image : Core prediction function
 701    """
 702    if image is None:
 703        return None, "Please upload an image", carbon_display_text
 704
 705    if not model_choice:
 706        return None, "Please select a model first", carbon_display_text
 707
 708    try:
 709        models_dict = get_available_models()
 710        model_path = models_dict.get(model_choice)
 711        model, device, transform = load_model_for_inference(
 712            model_path=model_path
 713        )
 714
 715        result = predict_image(
 716            image,
 717            model=model,
 718            transform=transform,
 719            device=device,
 720            track_carbon=track_carbon,
 721        )
 722
 723        fig, ax = plt.subplots(figsize=(10, 6))
 724        probs_list = [result["probabilities"][cls] for cls in cfg.CLASS_NAMES]
 725        pred_idx = result["predicted_idx"]
 726        aux_list = range(len(cfg.CLASS_NAMES))
 727        colors = [
 728            "green" if i == pred_idx else "skyblue" for i in aux_list
 729        ]
 730        bars = ax.barh(cfg.CLASS_NAMES, probs_list, color=colors)
 731        ax.set_xlabel("Probability", fontsize=12)
 732        ax.set_title(
 733            f'Prediction Probabilities\nPredicted Class: \
 734                {result["predicted_class"]}',
 735            fontsize=14,
 736            fontweight="bold",
 737        )
 738        ax.set_xlim([0, 1])
 739
 740        for i, (bar, prob) in enumerate(zip(bars, probs_list)):
 741            ax.text(
 742                prob + 0.02,
 743                bar.get_y() + bar.get_height() / 2,
 744                f"{prob*100:.1f}%",
 745                va="center",
 746                fontsize=10,
 747            )
 748
 749        plt.tight_layout()
 750
 751        result_text = f"### 🎯 Prediction: \
 752        **{result['predicted_class']}**\n\n"
 753        result_text += f"**Confidence:** {result['confidence']*100:.2f}%\n\n"
 754        result_text += "**All Probabilities:**\n"
 755        for class_name, prob in result["probabilities"].items():
 756            emoji = "🏆" if class_name == result["predicted_class"] \
 757                else "  "
 758            result_text += f"{emoji} {class_name}: {prob*100:.2f}%\n"
 759
 760        updated_carbon_display = carbon_display_text
 761        if result["emissions"]:
 762            emissions = result["emissions"]
 763            result_text += "\n\n### 🌍 Carbon Footprint\n"
 764            result_text += f"- **Emissions:** \
 765                {emissions['emissions_g']:.4f}g CO₂eq\n"
 766            result_text += f"- **🚗 Car equivalent:** \
 767                {emissions['car_distance_formatted']} driven\n"
 768            updated_carbon_display = format_total_emissions_display(
 769                get_emissions_path()
 770            )
 771
 772        return fig, result_text, updated_carbon_display
 773
 774    except Exception as e:
 775        return None, f"❌ Error: {str(e)}", carbon_display_text
 776
 777
 778def predict_folder_gradio(
 779    model_choice, files, carbon_display_text, track_carbon=True
 780):
 781    """
 782    Gradio wrapper for batch prediction on multiple images.
 783
 784    Performs inference on multiple images simultaneously and returns
 785    results in a tabular format with per-image predictions and overall
 786    statistics.
 787
 788    Parameters
 789    ----------
 790    model_choice : str
 791        Name of the selected model (from get_available_models()).
 792    files : list of gr.File
 793        List of uploaded file objects from Gradio file input.
 794    carbon_display_text : str
 795        Current HTML string for the carbon display (to be updated).
 796    track_carbon : bool, optional
 797        Whether to track carbon emissions for this batch, by default True.
 798
 799    Returns
 800    -------
 801    tuple of (pd.DataFrame or None, str, str)
 802        - DataFrame: Table with filename, predicted class, and confidence
 803          for each image
 804        - str: Markdown-formatted summary statistics and carbon footprint
 805        - str: Updated HTML for carbon display
 806
 807    Notes
 808    -----
 809    The results table includes:
 810    - Filename: Original image filename
 811    - Predicted Class: Predicted garbage category
 812    - Confidence (%): Prediction confidence as percentage
 813
 814    Summary statistics include:
 815    - Total images processed
 816    - Number of successful predictions
 817    - Total carbon emissions (if tracked)
 818    - Average emissions per image
 819    - Car distance equivalent
 820
 821    Failed predictions are marked as "Error" in the table with the
 822    error message in the confidence column.
 823
 824    See Also
 825    --------
 826    predict_single_image_gradio : Single image prediction
 827    source.predict.predict_batch : Core batch prediction function
 828    """
 829    if not files or len(files) == 0:
 830        return None, "Please upload images", carbon_display_text
 831
 832    if not model_choice:
 833        return None, "Please select a model first", carbon_display_text
 834
 835    try:
 836        models_dict = get_available_models()
 837        model_path = models_dict.get(model_choice)
 838        model, device, transform = load_model_for_inference(
 839            model_path=model_path
 840        )
 841
 842        image_paths = [file.name for file in files]
 843
 844        batch_result = predict_batch(
 845            image_paths,
 846            model=model,
 847            transform=transform,
 848            device=device,
 849            track_carbon=track_carbon,
 850        )
 851
 852        df_data = []
 853        for result in batch_result["results"]:
 854            if result["status"] == "success":
 855                df_data.append(
 856                    {
 857                        "Filename": result["filename"],
 858                        "Predicted Class": result["predicted_class"],
 859                        "Confidence (%)": f"{result['confidence']*100:.2f}",
 860                    }
 861                )
 862            else:
 863                df_data.append(
 864                    {
 865                        "Filename": result["filename"],
 866                        "Predicted Class": "Error",
 867                        "Confidence (%)": result["error"],
 868                    }
 869                )
 870
 871        df_results = pd.DataFrame(df_data)
 872
 873        summary = batch_result["summary"]
 874        result_text = "### 📊 Batch Prediction Results\n\n"
 875        result_text += f"**Total images processed:** \
 876            {summary['total_images']}\n"
 877        result_text += f"**Successful predictions:** \
 878            {summary['successful']}\n\n"
 879
 880        updated_carbon_display = carbon_display_text
 881        if batch_result["emissions"]:
 882            emissions = batch_result["emissions"]
 883            result_text += "### 🌍 Carbon Footprint\n"
 884            result_text += f"- **Emissions:** \
 885                {emissions['emissions_g']:.4f}g CO₂eq\n"
 886            result_text += f"- **🚗 Car equivalent:** \
 887                {emissions['car_distance_formatted']} driven\n"
 888            result_text += f"- **Avg per image:** \
 889                {emissions['emissions_per_image_g']:.4f}g CO₂eq\n"
 890            updated_carbon_display = format_total_emissions_display(
 891                get_emissions_path()
 892            )
 893
 894        return df_results, result_text, updated_carbon_display
 895
 896    except Exception as e:
 897        return None, f"❌ Error: {str(e)}", carbon_display_text
 898
 899
 900# ========================
 901# UI LAYOUT
 902# ========================
 903
 904
 905def model_evaluation_tab(carbon_display):
 906    """
 907    Create the Model Evaluation and Inference UI section.
 908
 909    Builds a comprehensive Gradio interface for model evaluation, metrics
 910    visualization, and real-time inference. Organized into three main areas:
 911    model selection, metrics visualization, and image prediction.
 912
 913    Parameters
 914    ----------
 915    carbon_display : gr.HTML
 916        The carbon counter display component to update after inference
 917        operations. Shows cumulative emissions across all tracked operations.
 918
 919    Returns
 920    -------
 921    list
 922        Empty list (kept for API consistency).
 923
 924    Notes
 925    -----
 926    The interface is organized into sections:
 927
 928    1. **Model Selection:**
 929       - Radio buttons to choose between best model and latest trained model
 930
 931    2. **Metrics Visualization Tabs:**
 932       - Confusion Matrix: Raw and normalized versions with instant toggle
 933       - Loss Curves: Training and validation loss over epochs
 934       - Accuracy Curves: Training and validation accuracy over epochs
 935       - Calibration Curves: Per-class calibration analysis
 936
 937    3. **Inference Tabs:**
 938       - Single Image: Upload and classify individual images
 939       - Batch Prediction: Process multiple images simultaneously
 940
 941    All expensive computations (confusion matrices, calibration curves) are
 942    cached and automatically invalidated when models are retrained.
 943
 944    Carbon emissions can be optionally tracked for all inference operations
 945    and are displayed in both absolute terms and car distance equivalents.
 946
 947    Examples
 948    --------
 949    >>> with gr.Blocks() as demo:
 950    ...     carbon_display = gr.HTML()
 951    ...     model_evaluation_tab(carbon_display)
 952    """
 953    with gr.Column():
 954        gr.Markdown("### 🔬 Model Evaluation & Inference")
 955        gr.Markdown(
 956            "Evaluate trained models, visualize metrics, \
 957                and make predictions on new images."
 958        )
 959
 960        gr.Markdown("#### 🧠 Model Selection")
 961        model_choice = gr.Radio(
 962            choices=list(get_available_models().keys()),
 963            value=list(get_available_models().keys())[0],
 964            label="Select Model",
 965            info="Choose between the best provided model or \
 966                your latest trained model",
 967        )
 968
 969        gr.Markdown("---")
 970
 971        gr.Markdown("#### 📈 Model Metrics & Visualizations")
 972
 973        with gr.Tabs():
 974            with gr.Tab("Confusion Matrix"):
 975                show_normalized = gr.Checkbox(
 976                    label="Show Normalized",
 977                    value=False,
 978                    info="Toggle between raw counts and normalized \
 979                        percentages",
 980                    visible=False,
 981                )
 982                cm_button = gr.Button(
 983                    "Generate Confusion Matrix", variant="primary"
 984                )
 985                cm_plot = gr.Plot(label="Confusion Matrix")
 986                cm_status = gr.Markdown("")
 987
 988                cm_button.click(
 989                    fn=generate_confusion_matrix,
 990                    inputs=[model_choice, show_normalized],
 991                    outputs=[cm_plot, cm_status, show_normalized],
 992                )
 993
 994                show_normalized.change(
 995                    fn=toggle_confusion_matrix,
 996                    inputs=[show_normalized],
 997                    outputs=[cm_plot],
 998                )
 999
1000            with gr.Tab("Loss Curves"):
1001                loss_button = gr.Button("Load Loss Curves", variant="primary")
1002                loss_plot = gr.Plot(label="Loss Curves")
1003                loss_status = gr.Markdown("")
1004
1005                loss_button.click(
1006                    fn=load_loss_curves,
1007                    inputs=[model_choice],
1008                    outputs=[loss_plot, loss_status],
1009                )
1010
1011            with gr.Tab("Accuracy Curves"):
1012                acc_button = gr.Button(
1013                    "Load Accuracy Curves", variant="primary"
1014                )
1015                acc_plot = gr.Plot(label="Accuracy Curves")
1016                acc_status = gr.Markdown("")
1017
1018                acc_button.click(
1019                    fn=load_accuracy_curves,
1020                    inputs=[model_choice],
1021                    outputs=[acc_plot, acc_status],
1022                )
1023
1024            with gr.Tab("Calibration Curves"):
1025                calib_button = gr.Button(
1026                    "Generate Calibration Curves", variant="primary"
1027                )
1028                calib_plot = gr.Plot(label="Calibration Curves")
1029                calib_status = gr.Markdown("")
1030
1031                calib_button.click(
1032                    fn=generate_calibration_curves,
1033                    inputs=[model_choice],
1034                    outputs=[calib_plot, calib_status],
1035                )
1036
1037        gr.Markdown("---")
1038
1039        gr.Markdown("#### 🔍 Image Prediction")
1040
1041        with gr.Tabs():
1042            with gr.Tab("Single Image"):
1043                gr.Markdown(
1044                    "Upload an image to classify it into one of \
1045                        the garbage categories."
1046                )
1047
1048                with gr.Row():
1049                    with gr.Column(scale=1):
1050                        single_image_input = gr.Image(
1051                            label="Upload Image", type="numpy", height=400
1052                        )
1053                        single_track_carbon = gr.Checkbox(
1054                            label="🌍 Track Carbon Emissions", value=True
1055                        )
1056                        single_predict_button = gr.Button(
1057                            "🔍 Predict", variant="primary", size="lg"
1058                        )
1059
1060                    with gr.Column(scale=1):
1061                        single_probs_plot = gr.Plot(
1062                            label="Class Probabilities"
1063                        )
1064
1065                single_result_text = gr.Markdown(
1066                    "Upload an image and click 'Predict'"
1067                )
1068
1069                single_predict_button.click(
1070                    fn=predict_single_image_gradio,
1071                    inputs=[
1072                        model_choice,
1073                        single_image_input,
1074                        carbon_display,
1075                        single_track_carbon,
1076                    ],
1077                    outputs=[
1078                        single_probs_plot,
1079                        single_result_text,
1080                        carbon_display
1081                    ],
1082                )
1083
1084            with gr.Tab("Batch Prediction"):
1085                gr.Markdown("Upload multiple images \
1086                    to classify them all at once.")
1087
1088                batch_image_input = gr.File(
1089                    label="Upload Images",
1090                    file_count="multiple", file_types=["image"]
1091                )
1092                batch_track_carbon = gr.Checkbox(
1093                    label="🌍 Track Carbon Emissions", value=True
1094                )
1095                batch_predict_button = gr.Button(
1096                    "🔍 Predict All", variant="primary", size="lg"
1097                )
1098
1099                batch_result_text = gr.Markdown(
1100                    "Upload images and click 'Predict All'"
1101                )
1102                batch_results_table = gr.Dataframe(
1103                    label="Prediction Results",
1104                    interactive=False, wrap=True
1105                )
1106
1107                batch_predict_button.click(
1108                    fn=predict_folder_gradio,
1109                    inputs=[
1110                        model_choice,
1111                        batch_image_input,
1112                        carbon_display,
1113                        batch_track_carbon,
1114                    ],
1115                    outputs=[
1116                        batch_results_table,
1117                        batch_result_text,
1118                        carbon_display
1119                    ],
1120                )
1121
1122        gr.Markdown("---")
1123        gr.Markdown(
1124            "**ℹ️ Info:** Carbon emissions are tracked for \
1125                inference operations and added to the total \
1126                    carbon footprint."
1127        )
1128
1129    return []