perf: add LRU caching layers and Gradio queue for concurrency

app.py

@@ -65,5 +65,7 @@ with gr.Blocks(css=custom_css, head=custom_head) as demo:
         #     init_archive_tab(demo)
 
 
+demo.queue(default_concurrency_limit=5)
+
 if __name__ == "__main__":
     demo.launch()

src/leaderboard.py

@@ -10,6 +10,7 @@ from src.about import DATASETS_DF, OVERALL_TABLE_COLUMNS, ALL_MODELS, RESULTS_RO
 from src.hf_config import get_datasets_root, get_config_root
 from src.utils import normalize_by_seasonal_naive
 import ast
+from functools import lru_cache
 from timebench.evaluation.data import Dataset, get_dataset_settings, load_dataset_config
 from pathlib import Path
 
@@ -83,6 +84,113 @@ def find_dataset_term_path(results_root, model_name, display_name):
 
     return None
 
+
+# =============================================================================
+# Cached Helpers (Layer 1 & Layer 2)
+# =============================================================================
+
+@lru_cache(maxsize=20)
+def _get_dataset_metadata(dataset_term, horizon):
+    """
+    Load and cache Dataset metadata (series names, variate names, etc.).
+
+    This is the **Layer 1 cache** — the single most impactful optimization.
+    Creating a Dataset object loads an HF dataset from disk, which takes
+    hundreds of milliseconds.  By caching the result, subsequent calls for
+    the same (dataset_term, horizon) return instantly.
+
+    Args:
+        dataset_term: Dataset term path, e.g. "Traffic/15T"
+        horizon: Horizon name ("short", "medium", "long")
+
+    Returns:
+        dict with keys: dataset_obj, series_names, variate_names, is_uts,
+             series_name_to_idx, variate_name_to_idx, num_windows, freq
+        or None on failure.
+    """
+    try:
+        hf_dataset_root = str(get_datasets_root())
+        config_root = get_config_root()
+        config_path = config_root / "datasets.yaml"
+
+        config = load_dataset_config(config_path) if config_path.exists() else {}
+        settings = get_dataset_settings(dataset_term, horizon, config)
+
+        dataset_obj = Dataset(
+            name=dataset_term,
+            term=horizon,
+            prediction_length=settings.get("prediction_length"),
+            test_length=settings.get("test_length"),
+            storage_path=hf_dataset_root,
+        )
+
+        # Get series names
+        if "item_id" in dataset_obj.hf_dataset.column_names:
+            series_names = list(dataset_obj.hf_dataset["item_id"])
+        else:
+            series_names = [dataset_obj.hf_dataset[i].get("item_id", f"item_{i}")
+                            for i in range(len(dataset_obj.hf_dataset))]
+
+        # Get variate names
+        variate_names = dataset_obj.get_variate_names()
+        is_uts = (variate_names is None)
+        if variate_names is not None:
+            variate_names = list(variate_names)
+
+        # Build name-to-index mappings
+        series_name_to_idx = {name: idx for idx, name in enumerate(series_names)}
+        variate_name_to_idx = {}
+        if variate_names is not None:
+            variate_name_to_idx = {name: idx for idx, name in enumerate(variate_names)}
+
+        # Window count & frequency
+        num_windows = dataset_obj.windows
+        freq = dataset_obj.freq
+
+        return {
+            "dataset_obj": dataset_obj,
+            "series_names": series_names,
+            "variate_names": variate_names,      # None for UTS
+            "is_uts": is_uts,
+            "series_name_to_idx": series_name_to_idx,
+            "variate_name_to_idx": variate_name_to_idx,  # empty dict for UTS
+            "num_windows": num_windows,
+            "freq": freq,
+        }
+    except Exception as e:
+        print(f"[_get_dataset_metadata] Error for {dataset_term}/{horizon}: {e}")
+        return None
+
+
+@lru_cache(maxsize=100)
+def _load_metrics_cached(model_name, dataset_term, horizon):
+    """
+    Load and cache metrics.npz arrays for a specific (model, dataset, horizon).
+
+    This is the **Layer 2 cache**.  Each call to np.load opens a file and
+    reads arrays from disk.  In get_window_leaderboard, load_test_windows
+    is called once per model (~15 times), each loading the same-format
+    file.  Caching avoids repeated disk I/O.
+
+    Args:
+        model_name: Model name (e.g. "moirai_small")
+        dataset_term: Dataset term path (e.g. "Traffic/15T")
+        horizon: Horizon name ("short", "medium", "long")
+
+    Returns:
+        dict mapping metric names to numpy arrays, or None if file missing.
+    """
+    results_root = str(RESULTS_ROOT)
+    metrics_path = os.path.join(results_root, model_name, dataset_term, horizon, "metrics.npz")
+    if not os.path.exists(metrics_path):
+        return None
+    npz = np.load(metrics_path)
+    # Materialise into a plain dict so the NpzFile handle can be closed
+    result = {k: npz[k] for k in npz.files}
+    npz.close()
+    return result
+
+
 def load_test_windows(display_name, horizon, model_name="moirai_small", series=None, variate=None, window_id=None, parse_series=False):
     """
     Load test window results from TIME NPZ files.
@@ -107,65 +215,30 @@ def load_test_windows(display_name, horizon, model_name="moirai_small", series=N
     if dataset_term is None:
         return None
 
-    horizon_dir = os.path.join(results_root, model_name, dataset_term, horizon)
-    metrics_path = os.path.join(horizon_dir, "metrics.npz")
-
-    # Load data
-    metrics = np.load(metrics_path)
+    # --- Layer 2 cache: metrics npz ---
+    metrics_dict = _load_metrics_cached(model_name, dataset_term, horizon)
+    if metrics_dict is None:
+        return None
 
-    # Get array shapes
-    mase_arr = metrics["MASE"]  # (num_series, num_windows, num_variates)
+    mase_arr = metrics_dict["MASE"]  # (num_series, num_windows, num_variates)
     num_series, num_windows, num_variates = mase_arr.shape
 
-    # Load Dataset to get actual names
+    # --- Layer 1 cache: dataset metadata ---
+    metadata = _get_dataset_metadata(dataset_term, horizon)
     series_names = None
     variate_names = None
-    try:
-        # Use HF config to get dataset root (handles both local and HF Hub)
-        hf_dataset_root = str(get_datasets_root())
-
-        if os.path.exists(hf_dataset_root):
-            # Use HF config to get config root
-            config_root = get_config_root()
-            config_path = config_root / "datasets.yaml"
-
-            config = load_dataset_config(config_path) if config_path.exists() else {}
-            settings = get_dataset_settings(dataset_term, horizon, config)
-
-            prediction_length = settings.get("prediction_length")
-            test_length = settings.get("test_length")
-
-            # Load dataset with storage_path parameter
-            dataset_obj = Dataset(
-                name=dataset_term,
-                term=horizon,
-                prediction_length=prediction_length,
-                test_length=test_length,
-                storage_path=hf_dataset_root,
-            )
-
-            # Get series names (item_id)
-            if "item_id" in dataset_obj.hf_dataset.column_names:
-                series_names = dataset_obj.hf_dataset["item_id"]
-            else:
-                series_names = [dataset_obj.hf_dataset[i].get("item_id", f"item_{i}")
-                               for i in range(len(dataset_obj.hf_dataset))]
-
-            # Get variate names
-            variate_names = dataset_obj.get_variate_names()
-            if variate_names is None:
-                # Univariate mode: variate names are same as series names
-                variate_names = series_names
-    except Exception as e:
-        print(f"Error loading Dataset for names: {e}")
-
-    # Create name to index mappings
     series_name_to_idx = {}
     variate_name_to_idx = {}
-    if series_names is not None:
-        series_name_to_idx = {name: idx for idx, name in enumerate(series_names)}
-    if variate_names is not None:
-        variate_name_to_idx = {name: idx for idx, name in enumerate(variate_names)}
+    if metadata is not None:
+        series_names = metadata["series_names"]
+        variate_names = metadata["variate_names"]
+        series_name_to_idx = metadata["series_name_to_idx"]
+        if metadata["is_uts"]:
+            # UTS mode: variate names are same as series names
+            variate_names = series_names
+            variate_name_to_idx = {name: idx for idx, name in enumerate(variate_names)}
+        else:
+            variate_name_to_idx = metadata["variate_name_to_idx"]
 
     # Convert series and variate names to indices if they are names
     series_idx_filter = None
@@ -219,9 +292,9 @@ def load_test_windows(display_name, horizon, model_name="moirai_small", series=N
                     "variate_name": variate_name,
                     "window_id": window_idx,
                     "MASE": float(mase_arr[series_idx, window_idx, variate_idx]),
-                    "CRPS": float(metrics["CRPS"][series_idx, window_idx, variate_idx]),
-                    "MAE": float(metrics["MAE"][series_idx, window_idx, variate_idx]),
-                    "MSE": float(metrics["MSE"][series_idx, window_idx, variate_idx]),
+                    "CRPS": float(metrics_dict["CRPS"][series_idx, window_idx, variate_idx]),
+                    "MAE": float(metrics_dict["MAE"][series_idx, window_idx, variate_idx]),
+                    "MSE": float(metrics_dict["MSE"][series_idx, window_idx, variate_idx]),
                     "model": model_name,
                     "series_idx": series_idx,  # Keep for reference
                     "variate_idx": variate_idx,  # Keep for reference
@@ -416,60 +489,22 @@ def get_dataset_leaderboard(
     if df_filtered.empty:
         return f"No results found for dataset '{display_name}' with horizons {horizons}.", pd.DataFrame(columns=["model"])
 
-    # Get dataset information (series count, variate count, freq)
+    # Get dataset information (series count, variate count, freq) via cached metadata
     dataset_info_msg = ""
     try:
-        # Parse dataset_id to get freq
-        if "/" in dataset_id:
-            _, freq = dataset_id.split("/", 1)
-        else:
-            freq = "unknown"
-
-        # Load Dataset to get series and variate counts
-        hf_dataset_root = str(get_datasets_root())
-        config_root = get_config_root()
-        config_path = config_root / "datasets.yaml"
-
-        if os.path.exists(hf_dataset_root) and config_path.exists():
-            config = load_dataset_config(config_path)
-            settings = get_dataset_settings(dataset_id, horizons[0] if horizons else "short", config)
-
-            dataset_obj = Dataset(
-                name=dataset_id,
-                term=horizons[0] if horizons else "short",
-                prediction_length=settings.get("prediction_length"),
-                test_length=settings.get("test_length"),
-                storage_path=hf_dataset_root,
-            )
-
-            # Get series count
-            if "item_id" in dataset_obj.hf_dataset.column_names:
-                series_names = dataset_obj.hf_dataset["item_id"]
-                # Convert to list if it's an array/Series to avoid ambiguity in boolean check
-                if isinstance(series_names, (np.ndarray, pd.Series)):
-                    series_names = list(series_names)
-                elif not isinstance(series_names, list):
-                    series_names = list(series_names) if hasattr(series_names, '__iter__') else [series_names]
-                # Use len() check instead of boolean check to avoid ambiguity
-                if len(series_names) > 0:
-                    num_series = len(set(series_names))
-                else:
-                    num_series = len(dataset_obj.hf_dataset)
-            else:
-                num_series = len(dataset_obj.hf_dataset)
-
-            # Get variate count
-            variate_names = dataset_obj.get_variate_names()
-            if variate_names is not None:
-                num_variates = len(variate_names)
-            else:
-                # UTS: each series is one variate
-                num_variates = 1
-
+        horizon_for_meta = horizons[0] if horizons else "short"
+        metadata = _get_dataset_metadata(dataset_id, horizon_for_meta)
+        if metadata is not None:
+            num_series = len(set(metadata["series_names"]))
+            num_variates = len(metadata["variate_names"]) if metadata["variate_names"] is not None else 1
+            freq = metadata["freq"]
             dataset_info_msg = f"📊 Dataset Info: {num_series} series, {num_variates} variates, freq={freq}"
+        else:
+            if "/" in dataset_id:
+                _, freq = dataset_id.split("/", 1)
+                dataset_info_msg = f"📊 Dataset Info: freq={freq}"
     except Exception as e:
         print(f"Error getting dataset info: {e}")
-        # If we can't get info, try to extract freq from dataset_id
         if "/" in dataset_id:
             _, freq = dataset_id.split("/", 1)
             dataset_info_msg = f"📊 Dataset Info: freq={freq}"
@@ -577,6 +612,16 @@ def get_dataset_leaderboard(
 def get_dataset_multilevel_leaderboard(display_name, series, variate, horizons, metric: str = "MASE"):
     """
     Get leaderboard based on dataset, series, and variate selections.
+    Thin wrapper that converts mutable args to hashable types for caching.
+    """
+    horizons_key = tuple(sorted(horizons)) if horizons else ()
+    return _get_dataset_multilevel_leaderboard_cached(display_name, series, variate, horizons_key, metric)
+
+
+@lru_cache(maxsize=30)
+def _get_dataset_multilevel_leaderboard_cached(display_name, series, variate, horizons_key, metric: str = "MASE"):
+    """
+    Cached implementation of get_dataset_multilevel_leaderboard.
 
     Logic:
     0. If only dataset selected (series="---", variate="---"): return dataset-level results
@@ -587,12 +632,14 @@ def get_dataset_multilevel_leaderboard(display_name, series, variate, horizons,
         display_name: Dataset display name from UI (will be converted to dataset_id)
         series: Series name or "---" if not selected
         variate: Variate name or "---" if not selected
-        horizons: List of horizons to include
+        horizons_key: Tuple of horizons (hashable)
         metric: Metric for sorting
 
     Returns:
         tuple: (message, DataFrame)
     """
+    horizons = list(horizons_key)
+
     # Case 0: Only dataset selected - return both original and normalized metrics
     if (series is None or series == "---" or series == "") and (variate is None or variate == "---" or variate == ""):
         return get_dataset_leaderboard(display_name, horizons, metric)
@@ -606,28 +653,13 @@ def get_dataset_multilevel_leaderboard(display_name, series, variate, horizons,
     if dataset_term is None:
         return f"Dataset '{display_name}' not found.", pd.DataFrame(columns=["model", "MASE", "CRPS", "MAE", "MSE"])
 
-    # Check if dataset is UTS or MTS
+    # Check if dataset is UTS or MTS using cached metadata
     is_uts = False
     try:
-        hf_dataset_root = str(get_datasets_root())
-
-        if os.path.exists(hf_dataset_root):
-            config_root = get_config_root()
-            config_path = config_root / "datasets.yaml"
-
-            config = load_dataset_config(config_path) if config_path.exists() else {}
-            settings = get_dataset_settings(dataset_term, horizons[0] if horizons else "short", config)
-
-            dataset_obj = Dataset(
-                name=dataset_term,
-                term=horizons[0] if horizons else "short",
-                prediction_length=settings.get("prediction_length"),
-                test_length=settings.get("test_length"),
-                storage_path=hf_dataset_root,
-            )
-
-            variate_names = dataset_obj.get_variate_names()
-            is_uts = (variate_names is None)
+        horizon_for_meta = horizons[0] if horizons else "short"
+        metadata = _get_dataset_metadata(dataset_term, horizon_for_meta)
+        if metadata is not None:
+            is_uts = metadata["is_uts"]
     except Exception as e:
         print(f"Error checking UTS/MTS: {e}")
 
@@ -678,9 +710,11 @@ def get_dataset_multilevel_leaderboard(display_name, series, variate, horizons,
 
 
 
+@lru_cache(maxsize=30)
 def get_window_leaderboard(display_name, series, variate, window_id, horizon, metric: str = "MASE"):
     """
     Get leaderboard for a specific test window.
+    Cached because all arguments are hashable strings.
 
     Args:
         display_name: Dataset display name from UI (will be converted to dataset_id)
@@ -723,24 +757,35 @@ def get_pattern_leaderboard(
 ) -> tuple[str, pd.DataFrame]:
     """
     Filter variates by selected patterns and compute average metrics per model.
+    Thin wrapper that converts mutable args to hashable types for caching.
+    """
+    filters_key = frozenset(pattern_filters.items()) if pattern_filters else frozenset()
+    horizons_key = tuple(sorted(selected_horizons)) if selected_horizons else ()
+    return _get_pattern_leaderboard_cached(filters_key, horizons_key)
+
+
+@lru_cache(maxsize=30)
+def _get_pattern_leaderboard_cached(
+        filters_key: frozenset,
+        horizons_key: tuple,
+) -> tuple[str, pd.DataFrame]:
+    """
+    Cached implementation of get_pattern_leaderboard.
 
     Uses FEATURES_BOOL_DF (binarized features) to filter variates,
     then joins with VARIATES_DF to get metrics.
 
     Args:
-        pattern_filters: Dict mapping pattern names to required values.
-            - {feature_name: required_value} where required_value is 0 or 1.
-            - Features with "Any" selection are not included in the dict.
-            - Example: {"T_strength": 1, "S_strength": 0} means:
-                - T_strength must be 1 (has the feature)
-                - S_strength must be 0 (does not have the feature)
-        selected_horizons: List of horizons to include (e.g., ["short", "medium"])
+        filters_key: frozenset of (pattern_name, required_value) pairs
+        horizons_key: tuple of horizon strings
 
     Returns:
         tuple: (message, leaderboard_df)
-            - message: Status message with matching count
-            - leaderboard_df: DataFrame with model metrics, sorted by MASE
     """
+    # Convert back from hashable types
+    pattern_filters = dict(filters_key)
+    selected_horizons = list(horizons_key)
+
     from src.about import VARIATES_DF, FEATURES_DF, FEATURES_BOOL_DF, PATTERN_MAP
 
     # Check if data is available

src/tab.py

@@ -31,9 +31,10 @@ import json
 import gradio as gr
 from src.about import DATASET_CHOICES, ALL_MODELS, RESULTS_ROOT, FEATURES_DF, FEATURES_BOOL_DF, PATTERN_MAP
 from src.leaderboard import (get_overall_leaderboard, get_dataset_multilevel_leaderboard,
-                            get_window_leaderboard, get_pattern_leaderboard, resolve_dataset_id)
+                            get_window_leaderboard, get_pattern_leaderboard, resolve_dataset_id,
+                            _get_dataset_metadata)
 from src.about import DATASETS_DF, ALL_HORIZONS
-from src.hf_config import get_datasets_root, get_config_root
+# get_datasets_root, get_config_root no longer needed here — handled by _get_dataset_metadata
 import numpy as np
 import pandas as pd
 from pathlib import Path
@@ -43,7 +44,7 @@ matplotlib.use('Agg')  # Use non-interactive backend for Gradio
 import yaml
 import tempfile
 
-from timebench.evaluation.data import Dataset, get_dataset_settings, load_dataset_config
+# Dataset, get_dataset_settings, load_dataset_config no longer needed here — handled by _get_dataset_metadata
 from src.leaderboard import find_dataset_term_path
 
 
@@ -86,42 +87,17 @@ def update_series_and_variate(display_name):
             gr.Dropdown(choices=["---"], value="---", label="Select Variate", interactive=True),
         )
 
-    # Load Dataset to get actual series and variate names
-    # Use HF config to get dataset root (handles both local and HF Hub)
-    hf_dataset_root = str(get_datasets_root())
-
-    # Use HF config to get config root
-    config_root = get_config_root()
-    config_path = config_root / "datasets.yaml"
-
-    # horizon doesn't affect series and variate values, so use "short" directly
-    config = load_dataset_config(config_path)
-    settings = get_dataset_settings(dataset_term, "short", config)
-
-    prediction_length = settings.get("prediction_length")
-    test_length = settings.get("test_length")
-
-    dataset_obj = Dataset(
-        name=dataset_term,
-        term="short",
-        prediction_length=prediction_length,
-        test_length=test_length,
-        storage_path=hf_dataset_root,  # Pass storage path directly
-    )
-
-    # Get series names
-    if "item_id" in dataset_obj.hf_dataset.column_names:
-        series_names = dataset_obj.hf_dataset["item_id"]
-    else:
-        series_names = [dataset_obj.hf_dataset[i].get("item_id", f"item_{i}")
-                        for i in range(len(dataset_obj.hf_dataset))]
-
-    series_list = ["---"] + [str(name) for name in series_names]
+    # Use cached metadata (horizon doesn't affect series/variate values)
+    metadata = _get_dataset_metadata(dataset_term, "short")
+    if metadata is None:
+        return (
+            gr.Dropdown(choices=["---"], value="---", label="Select Series", interactive=True),
+            gr.Dropdown(choices=["---"], value="---", label="Select Variate", interactive=True),
+        )
 
-    # Get variate names
-    variate_names = dataset_obj.get_variate_names()
+    series_list = ["---"] + [str(name) for name in metadata["series_names"]]
 
-    if variate_names is None:
+    if metadata["is_uts"]:
         # UTS mode: variate dropdown should be disabled
         return (
             gr.Dropdown(choices=series_list, value="---", label="Select Series", interactive=True),
@@ -129,7 +105,7 @@ def update_series_and_variate(display_name):
         )
     else:
         # MTS mode: both dropdowns are enabled
-        variates_list = ["---"] + [str(name) for name in variate_names]
+        variates_list = ["---"] + [str(name) for name in metadata["variate_names"]]
         return (
             gr.Dropdown(choices=series_list, value="---", label="Select Series", interactive=True),
             gr.Dropdown(choices=variates_list, value="---", label="Select Variate", interactive=True),
@@ -234,52 +210,20 @@ def update_series_variate_and_window(display_name, horizon):
             gr.Dropdown(choices=[], value=None, label="Select Testing Window", interactive=False),
         )
 
-    # Parse dataset_name and freq from dataset_term (format: "dataset_name/freq")
-    dataset_name, freq = dataset_term.split("/", 1)
-
-    # Load Dataset to get actual series and variate names
-    # Use HF config to get dataset root (handles both local and HF Hub)
-    hf_dataset_root = str(get_datasets_root())
-
-    # Use HF config to get config root
-    config_root = get_config_root()
-    config_path = config_root / "datasets.yaml"
-
-    config = load_dataset_config(config_path) if config_path.exists() else {}
-    settings = get_dataset_settings(dataset_term, horizon, config)
-
-    prediction_length = settings.get("prediction_length")
-    test_length = settings.get("test_length")
-
-    # Load dataset
-    dataset_obj = Dataset(
-        name=dataset_term,
-        term=horizon,
-        prediction_length=prediction_length,
-        test_length=test_length,
-        storage_path=hf_dataset_root,  # Pass storage path directly
-    )
-
-    # Get series names (item_id) from hf_dataset
-    if "item_id" in dataset_obj.hf_dataset.column_names:
-        series_names = dataset_obj.hf_dataset["item_id"]
-    else:
-        # Fallback: get from iterating
-        series_names = [dataset_obj.hf_dataset[i].get("item_id", f"item_{i}")
-                        for i in range(len(dataset_obj.hf_dataset))]
-
-    # Get variate names
-    variate_names = dataset_obj.get_variate_names()
-
-    # Get window count
-    num_windows = dataset_obj.windows
-    windows = [str(i) for i in range(num_windows)]
+    # Use cached metadata
+    metadata = _get_dataset_metadata(dataset_term, horizon)
+    if metadata is None:
+        return (
+            gr.Dropdown(choices=[], value=None, label="Select Series", interactive=False),
+            gr.Dropdown(choices=[], value=None, label="Select Variate", interactive=False),
+            gr.Dropdown(choices=[], value=None, label="Select Testing Window", interactive=False),
+        )
 
-    # Convert to lists and maintain order (no sorting)
-    series_list = [str(name) for name in series_names]
+    windows = [str(i) for i in range(metadata["num_windows"])]
+    series_list = [str(name) for name in metadata["series_names"]]
 
     # Handle UTS (Univariate Time Series) vs MTS (Multivariate Time Series)
-    if variate_names is None:
+    if metadata["is_uts"]:
         # UTS mode: each series is a single variate, so variate is always 0
         return (
             gr.Dropdown(choices=series_list, value=series_list[0], label="Select Series", interactive=True),
@@ -288,7 +232,7 @@ def update_series_variate_and_window(display_name, horizon):
         )
     else:
         # MTS mode: multiple variates per series
-        variates_list = [str(name) for name in variate_names]
+        variates_list = [str(name) for name in metadata["variate_names"]]
         return (
             gr.Dropdown(choices=series_list, value=series_list[0], label="Select Series", interactive=True),
             gr.Dropdown(choices=variates_list, value=variates_list[0], label="Select Variate", interactive=True),
@@ -358,51 +302,25 @@ def plot_window_series(display_name, series, variate, window_id, horizon, select
         print(f"📊 Applying inverse scale factor: {prediction_scale_factor}")
         predictions_quantiles = predictions_quantiles.astype(np.float32) * prediction_scale_factor
 
-    # Convert series and variate names to indices
-    series_idx = None
-    variate_idx = None
-    dataset_obj = None
-
-    # Load Dataset to get name-to-index mappings and full time series
-    # Use HF config to get dataset root (handles both local and HF Hub)
-    hf_dataset_root = str(get_datasets_root())
-    print(f"📁 hf_dataset_root: {hf_dataset_root}, exists: {os.path.exists(hf_dataset_root)}")
-
-    # Use HF config to get config root
-    config_root = get_config_root()
-    config_path_yaml = config_root / "datasets.yaml"
-    print(f"📁 config_path_yaml: {config_path_yaml}, exists: {config_path_yaml.exists()}")
-
-    config = load_dataset_config(config_path_yaml) if config_path_yaml.exists() else {}
-    settings = get_dataset_settings(dataset_term, horizon, config)
-    print(f"⚙️ settings: {settings}")
-
-    prediction_length = settings.get("prediction_length")
-    test_length = settings.get("test_length")
-
-    print(f"📥 Loading Dataset: name={dataset_term}, term={horizon}, storage_path={hf_dataset_root}")
-    dataset_obj = Dataset(
-        name=dataset_term,
-        term=horizon,
-        prediction_length=prediction_length,
-        test_length=test_length,
-        storage_path=hf_dataset_root,  # Pass storage path directly
-    )
-    print(f"✅ Dataset loaded: {len(dataset_obj.hf_dataset)} series")
+    # Use cached metadata for name-to-index mappings and Dataset object
+    metadata = _get_dataset_metadata(dataset_term, horizon)
+    if metadata is None:
+        print("❌ Failed to load dataset metadata")
+        fig = go.Figure()
+        fig.update_layout(title="Failed to load dataset metadata")
+        return fig, ""
 
-    # Get frequency from dataset
-    dataset_freq = dataset_obj.freq
-    print(f"📅 Dataset frequency: {dataset_freq}")
+    dataset_obj = metadata["dataset_obj"]
+    dataset_freq = metadata["freq"]
+    test_length = dataset_obj._test_length
+    series_name_to_idx = metadata["series_name_to_idx"]
+    variate_name_to_idx = metadata["variate_name_to_idx"]
 
-    # Get series names and create mapping
-    if "item_id" in dataset_obj.hf_dataset.column_names:
-        series_names = dataset_obj.hf_dataset["item_id"]
-    else:
-        series_names = [dataset_obj.hf_dataset[i].get("item_id", f"item_{i}")
-                        for i in range(len(dataset_obj.hf_dataset))]
+    print(f"✅ Dataset loaded from cache: {len(dataset_obj.hf_dataset)} series")
+    print(f"📅 Dataset frequency: {dataset_freq}")
 
-    print(f"📋 series_names: {list(series_names)}")
-    series_name_to_idx = {name: idx for idx, name in enumerate(series_names)}
+    # Convert series name to index
+    series_idx = None
     if series in series_name_to_idx:
         series_idx = series_name_to_idx[series]
         print(f"✅ Found series '{series}' at index {series_idx}")
@@ -410,27 +328,21 @@ def plot_window_series(display_name, series, variate, window_id, horizon, select
         series_idx = int(series)
         print(f"⚠️ Series '{series}' not found in names, using int index {series_idx}")
 
-    # Get variate names and create mapping
-    variate_names = dataset_obj.get_variate_names()
-    print(f"📋 variate_names: {variate_names}")
-    if variate_names is not None:
-        # MTS mode: multiple variates per series
-        variate_name_to_idx = {name: idx for idx, name in enumerate(variate_names)}
-        if variate in variate_name_to_idx:
-            variate_idx = variate_name_to_idx[variate]
-            print(f"✅ Found variate '{variate}' at index {variate_idx}")
-        else:
-            variate_idx = int(variate)
-            print(f"⚠️ Variate '{variate}' not found in names, using int index {variate_idx}")
-    else:
-        # UTS mode: each series is a single variate, so variate_idx is always 0
+    # Convert variate name to index
+    variate_idx = None
+    if metadata["is_uts"]:
         variate_idx = 0
         print(f"ℹ️ UTS mode, variate_idx=0")
+    elif variate in variate_name_to_idx:
+        variate_idx = variate_name_to_idx[variate]
+        print(f"✅ Found variate '{variate}' at index {variate_idx}")
+    else:
+        variate_idx = int(variate)
+        print(f"⚠️ Variate '{variate}' not found in names, using int index {variate_idx}")
 
     if series_idx is None:
         series_idx = int(series)
     if variate_idx is None:
-        # For UTS mode, variate_idx should be 0
         try:
             variate_idx = int(variate) if variate is not None else 0
         except (ValueError, TypeError):