openstef-foundation-models 4.1.0__tar.gz

openstef_foundation_models-4.1.0/.gitignore

@@ -0,0 +1,147 @@
+# SPDX-FileCopyrightText: 2017-2025 Contributors to the OpenSTEF project <openstef@lfenergy.org> # noqa E501>
+# SPDX-License-Identifier: MPL-2.0
+
+# Core
+config.user.yaml
+git-template
+.DS_Store
+tmp
+
+# Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Packaging and build artifacts
+.Python
+build/
+dist/
+downloads/
+wheels/
+share/python-wheels/
+sdist/
+.eggs/
+*.egg-info/
+*.egg
+.installed.cfg
+MANIFEST
+
+# uv
+.uv/
+
+# Ruff
+.ruff_cache/
+
+# Test, coverage, tox
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.cover/
+cover/
+pytest-report.xml
+.tox/
+.nox/
+coverage.xml
+
+# Hypothesis
+.hypothesis/
+
+# Cython
+cython_debug/
+
+# Type checkers (misc)
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pytype/
+.pyre/
+
+# Sphinx
+docs/_build/
+docs/source/api/generated/
+docs/source/tutorials/
+docs/source/benchmarks/
+# Community health files materialized from OpenSTEF/.github at build time
+docs/source/contribute/_community/
+docs/source/user_guide/**/quick_start_tutorial.py
+docs/source/user_guide/**/feature_engineering_tutorial.py
+docs/source/user_guide/**/datasets_tutorial.py
+docs/source/user_guide/**/backtesting_tutorial.py
+
+# docs/_doctrees/
+# docs/_static_gen/
+
+# Editors: JetBrains
+.idea/
+
+# Editors: VS Code (allow shared configs)
+.vscode/*
+
+# Jupyter / IPython
+.ipynb_checkpoints
+profile_default/
+ipython_config.py
+
+# Spyder / Rope
+.spyderproject
+.spyproject
+.ropeproject
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# PEP 582
+__pypackages__/
+
+# web frameworks / services
+*.sqlite
+*.sqlite3
+*.log
+instance/
+.webassets-cache
+celerybeat-schedule
+celerybeat.pid
+*.sage.py
+tmp/
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Project outputs
+output/
+prof/
+certificates/
+
+# Output artifacts
+*.html
+*.pkl
+
+# Benchmark outputs
+benchmark_results*/
+
+# Local dataset files
+liander_dataset/
+
+# Deployment example run artifacts (MLflow store, forecasts, dataset, Celery/Airflow state)
+openstef_deployment_runs/
+
+# Mlflow
+/mlflow
+/mlflow_artifacts_local
+
+.github/instructions
+
+# Jupyter notebook cache (myst-nb execution outputs)
+.jupyter_cache/
+docs/build.zip

openstef_foundation_models-4.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: openstef-foundation-models
+Version: 4.1.0
+Summary: Foundation model support for OpenSTEF
+Project-URL: Documentation, https://openstef.github.io/openstef/index.html
+Project-URL: Homepage, https://lfenergy.org/projects/openstef/
+Project-URL: Issues, https://github.com/OpenSTEF/openstef/issues
+Project-URL: Repository, https://github.com/OpenSTEF/openstef
+Author-email: "Alliander N.V" <openstef@lfenergy.org>
+License-Expression: MPL-2.0
+Keywords: energy,forecasting,foundationmodels,machinelearning,onnx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <4.0,>=3.12
+Requires-Dist: huggingface-hub>=1.2.2
+Requires-Dist: openstef-beam<5,>=4
+Requires-Dist: openstef-core<5,>=4
+Requires-Dist: openstef-models<5,>=4
+Provides-Extra: cpu
+Requires-Dist: onnxruntime>=1.20; extra == 'cpu'
+Provides-Extra: gpu
+Requires-Dist: nvidia-cublas-cu12<13,>=12; extra == 'gpu'
+Requires-Dist: nvidia-cuda-runtime-cu12<13,>=12; extra == 'gpu'
+Requires-Dist: nvidia-cudnn-cu12<10,>=9; extra == 'gpu'
+Requires-Dist: nvidia-cufft-cu12<12,>=11; extra == 'gpu'
+Requires-Dist: nvidia-curand-cu12<11,>=10; extra == 'gpu'
+Requires-Dist: onnxruntime-gpu>=1.21; extra == 'gpu'
+Description-Content-Type: text/markdown
+
+<!--
+SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+
+SPDX-License-Identifier: MPL-2.0
+-->
+
+# openstef-foundation-models
+
+Foundation model support for OpenSTEF — bringing pre-trained, ONNX-based forecasting models to the OpenSTEF ecosystem.
+
+## Installation
+
+Pick exactly one ONNX runtime — `[cpu]` and `[gpu]` are mutually exclusive.
+
+CPU (default — the meta-package `openstef` installs this for you):
+
+```bash
+pip install "openstef-foundation-models[cpu]"
+```
+
+GPU (CUDA):
+
+```bash
+pip install "openstef-foundation-models[gpu]"
+```
+
+> **Note:** Do **not** install both `[cpu]` and `[gpu]` in the same environment —
+> `onnxruntime` and `onnxruntime-gpu` collide. They're declared as conflicting
+> extras so uv enforces the choice; `pip` does not, so pick one yourself.
+
+## Selecting a checkpoint
+
+OpenSTEF publishes its checkpoints to the HuggingFace Hub. Pick a model size and
+variant from the catalog instead of hand-writing repo ids and filenames:
+
+```python
+from openstef_foundation_models.models import Chronos2, CheckpointVariant
+from openstef_foundation_models.presets import ForecastingWorkflowConfig
+
+# Default: the base Chronos-2, dynamic shapes — runs on any provider.
+config = ForecastingWorkflowConfig()
+
+# The smaller model, static shapes — enables the CoreML provider on macOS.
+config = ForecastingWorkflowConfig(
+    checkpoint=Chronos2.SMALL.checkpoint(CheckpointVariant.STATIC),
+)
+
+# Let the host decide: static on macOS, dynamic elsewhere.
+config = ForecastingWorkflowConfig(
+    checkpoint=Chronos2.BASE.checkpoint(CheckpointVariant.recommended()),
+)
+```
+
+Available sizes are `Chronos2.BASE` (`chronos-2`) and `Chronos2.SMALL`
+(`chronos-2-small`); variants are `DYNAMIC` (portable) and `STATIC` (frozen shapes,
+the macOS/CoreML path in the default provider fallback chain).

openstef_foundation_models-4.1.0/README.md

@@ -0,0 +1,56 @@
+<!--
+SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+
+SPDX-License-Identifier: MPL-2.0
+-->
+
+# openstef-foundation-models
+
+Foundation model support for OpenSTEF — bringing pre-trained, ONNX-based forecasting models to the OpenSTEF ecosystem.
+
+## Installation
+
+Pick exactly one ONNX runtime — `[cpu]` and `[gpu]` are mutually exclusive.
+
+CPU (default — the meta-package `openstef` installs this for you):
+
+```bash
+pip install "openstef-foundation-models[cpu]"
+```
+
+GPU (CUDA):
+
+```bash
+pip install "openstef-foundation-models[gpu]"
+```
+
+> **Note:** Do **not** install both `[cpu]` and `[gpu]` in the same environment —
+> `onnxruntime` and `onnxruntime-gpu` collide. They're declared as conflicting
+> extras so uv enforces the choice; `pip` does not, so pick one yourself.
+
+## Selecting a checkpoint
+
+OpenSTEF publishes its checkpoints to the HuggingFace Hub. Pick a model size and
+variant from the catalog instead of hand-writing repo ids and filenames:
+
+```python
+from openstef_foundation_models.models import Chronos2, CheckpointVariant
+from openstef_foundation_models.presets import ForecastingWorkflowConfig
+
+# Default: the base Chronos-2, dynamic shapes — runs on any provider.
+config = ForecastingWorkflowConfig()
+
+# The smaller model, static shapes — enables the CoreML provider on macOS.
+config = ForecastingWorkflowConfig(
+    checkpoint=Chronos2.SMALL.checkpoint(CheckpointVariant.STATIC),
+)
+
+# Let the host decide: static on macOS, dynamic elsewhere.
+config = ForecastingWorkflowConfig(
+    checkpoint=Chronos2.BASE.checkpoint(CheckpointVariant.recommended()),
+)
+```
+
+Available sizes are `Chronos2.BASE` (`chronos-2`) and `Chronos2.SMALL`
+(`chronos-2-small`); variants are `DYNAMIC` (portable) and `STATIC` (frozen shapes,
+the macOS/CoreML path in the default provider fallback chain).

openstef_foundation_models-4.1.0/pyproject.toml

@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+[build-system]
+build-backend = "hatchling.build"
+requires = [ "hatchling" ]
+
+[project]
+name = "openstef-foundation-models"
+version = "4.1.0"
+description = "Foundation model support for OpenSTEF"
+readme = "README.md"
+keywords = [ "energy", "forecasting", "foundationmodels", "machinelearning", "onnx" ]
+license = "MPL-2.0"
+authors = [
+  { name = "Alliander N.V", email = "openstef@lfenergy.org" },
+]
+requires-python = ">=3.12,<4.0"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+  # huggingface-hub resolves published checkpoints from the Hub — the default
+  # checkpoint source — and is pure Python, so it is a base dependency rather
+  # than an extra. openstef-beam (the backtesting integration target) is already
+  # a hard transitive dependency via openstef-models, so it is declared directly.
+  "huggingface-hub>=1.2.2",
+  "openstef-beam>=4,<5",
+  "openstef-core>=4,<5",
+  "openstef-models>=4,<5",
+]
+# Exactly one of [cpu] or [gpu] must be installed — they are declared as
+# conflicting extras (see [tool.uv]) so uv refuses to resolve both at once.
+# The root `openstef` package (and the dev group) depend on
+# `openstef-foundation-models[cpu]`, so the default install gets the CPU
+# runtime without the caller having to choose.
+optional-dependencies.cpu = [
+  "onnxruntime>=1.20",
+]
+# onnxruntime-gpu ships only the CUDA execution-provider plugin, not the CUDA/cuDNN
+# runtime it loads at session creation. We pull the matching nvidia CUDA-12 / cuDNN-9
+# wheels explicitly (rather than via onnxruntime-gpu's own [cuda,cudnn] extras, whose
+# nested-extra markers don't resolve through our conflicting cpu/gpu extras); >=1.21
+# auto-preloads them from site-packages, so GPU works without a system CUDA install.
+optional-dependencies.gpu = [
+  "nvidia-cublas-cu12>=12,<13",
+  "nvidia-cuda-runtime-cu12>=12,<13",
+  "nvidia-cudnn-cu12>=9,<10",
+  "nvidia-cufft-cu12>=11,<12",
+  "nvidia-curand-cu12>=10,<11",
+  "onnxruntime-gpu>=1.21",
+]
+urls.Documentation = "https://openstef.github.io/openstef/index.html"
+urls.Homepage = "https://lfenergy.org/projects/openstef/"
+urls.Issues = "https://github.com/OpenSTEF/openstef/issues"
+urls.Repository = "https://github.com/OpenSTEF/openstef"
+
+[tool.hatch]
+build.targets.wheel.packages = [ "src/openstef_foundation_models" ]
+
+[tool.uv]
+sources.openstef-beam = { workspace = true }
+sources.openstef-core = { workspace = true }
+sources.openstef-models = { workspace = true }
+conflicts = [
+  [
+    { extra = "cpu" },
+    { extra = "gpu" },
+  ],
+]

openstef_foundation_models-4.1.0/src/openstef_foundation_models/__init__.py

@@ -0,0 +1,12 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+"""Foundation model support for OpenSTEF."""
+
+import logging
+
+root_logger = logging.getLogger(name=__name__)
+if not root_logger.handlers:
+    root_logger.addHandler(logging.NullHandler())
+
+__all__: list[str] = []

openstef_foundation_models-4.1.0/src/openstef_foundation_models/inference/__init__.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Inference backends for foundation-model forecasters.
+
+An :class:`InferenceBackend` isolates how a checkpoint is executed behind a
+single named-tensor contract; forecasters compose a backend rather than
+inheriting execution behaviour. Only the dependency-free surface (the protocol
+and the execution-provider configs) is re-exported here; a concrete backend
+lives in its own submodule and imports its heavy runtime at module top level.
+"""
+
+from openstef_foundation_models.inference.backend import InferenceBackend
+from openstef_foundation_models.inference.providers import (
+    CoreMLProvider,
+    CpuProvider,
+    CudaProvider,
+    ExecutionProvider,
+    SessionOptionsConfig,
+    TensorRTProvider,
+)
+
+__all__ = [
+    "CoreMLProvider",
+    "CpuProvider",
+    "CudaProvider",
+    "ExecutionProvider",
+    "InferenceBackend",
+    "SessionOptionsConfig",
+    "TensorRTProvider",
+]

openstef_foundation_models-4.1.0/src/openstef_foundation_models/inference/backend.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""The :class:`InferenceBackend` contract shared by all execution backends."""
+
+from collections.abc import Mapping
+from typing import Protocol, runtime_checkable
+
+import numpy as np
+
+from openstef_foundation_models.models.checkpoint import CheckpointMetadata
+
+
+@runtime_checkable
+class InferenceBackend(Protocol):
+    """A model-agnostic execution backend.
+
+    A backend takes a mapping of named input tensors to a mapping of named
+    output tensors. It owns whatever runtime resources are needed (e.g. an ONNX
+    Runtime session) and is loaded once, then reused across an entire backtest.
+    Model-family specifics live in :attr:`metadata`, not in the backend itself.
+    """
+
+    @property
+    def metadata(self) -> CheckpointMetadata:
+        """Metadata describing the checkpoint this backend executes."""
+        ...
+
+    def run(self, inputs: Mapping[str, np.ndarray]) -> Mapping[str, np.ndarray]:
+        """Execute the model on a batch of named input tensors.
+
+        Args:
+            inputs: Named input tensors. Keys must match ``metadata.input_names``.
+
+        Returns:
+            Named output tensors, including ``metadata.output_name``.
+        """
+        ...
+
+    def close(self) -> None:
+        """Release any runtime resources held by the backend."""
+        ...

openstef_foundation_models-4.1.0/src/openstef_foundation_models/inference/onnx_backend.py

@@ -0,0 +1,237 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project <openstef@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""ONNX Runtime execution backend.
+
+Importing this module requires ONNX Runtime (the ``[cpu]`` or ``[gpu]`` extra)
+and raises :class:`MissingExtraError` if it is missing.
+"""
+
+import logging
+from collections.abc import Mapping, Sequence
+from typing import Self
+
+import numpy as np
+
+from openstef_core.exceptions import MissingExtraError
+from openstef_foundation_models.inference.provider_selection import (
+    DefaultProviderPolicy,
+    HostCapabilities,
+    ProviderPolicy,
+)
+from openstef_foundation_models.inference.providers import (
+    ExecutionProvider,
+    SessionOptionsConfig,
+)
+from openstef_foundation_models.models.checkpoint import CheckpointMetadata, ResolvedCheckpoint
+
+try:
+    import onnxruntime as ort
+except ImportError as e:
+    raise MissingExtraError("onnxruntime", "openstef-foundation-models", install_extra="cpu") from e
+
+# onnxruntime-gpu ships the CUDA execution-provider plugin but loads the CUDA/cuDNN
+# runtime (the nvidia-*-cu12 wheels the [gpu] extra pulls) lazily at session creation.
+# preload_dlls() loads them from the nvidia site-packages so the CUDA provider can be
+# realized without a system CUDA install or LD_LIBRARY_PATH. It is a no-op on the CPU
+# runtime; the guard covers onnxruntime < 1.21, which predates the API.
+if hasattr(ort, "preload_dlls"):
+    ort.preload_dlls()
+
+logger = logging.getLogger(__name__)
+
+
+class OnnxBackend:
+    """An :class:`~openstef_foundation_models.inference.backend.InferenceBackend` backed by ONNX Runtime.
+
+    The session is built once on construction and reused for every
+    :meth:`run` call, so a single backend instance can be shared across an
+    entire backtest. Users may either let the backend build a session from a
+    resolved checkpoint and provider chain, or pass a pre-built session they own.
+    """
+
+    def __init__(
+        self,
+        metadata: CheckpointMetadata,
+        session: ort.InferenceSession,
+    ) -> None:
+        """Wrap a pre-built ONNX Runtime session.
+
+        Prefer :meth:`from_checkpoint` unless you need to own the session
+        lifecycle yourself.
+
+        Args:
+            metadata: Metadata describing the checkpoint the session executes.
+            session: A pre-built ONNX Runtime inference session.
+        """
+        self._metadata = metadata
+        self._session: ort.InferenceSession | None = session
+
+    @classmethod
+    def from_checkpoint(
+        cls,
+        checkpoint: ResolvedCheckpoint,
+        providers: Sequence[ExecutionProvider] | None = None,
+        session_options: SessionOptionsConfig | None = None,
+        *,
+        policy: ProviderPolicy | None = None,
+    ) -> Self:
+        """Build a backend by loading a checkpoint into a new ONNX Runtime session.
+
+        With ``providers=None`` the *policy* selects a chain from the checkpoint
+        and host; an explicit ``providers`` list is used as given and *policy* is
+        ignored. See :class:`~openstef_foundation_models.inference.provider_selection.ProviderPolicy`
+        for how a chain is chosen and how strictly its realization is enforced.
+
+        Args:
+            checkpoint: The resolved checkpoint (weights + metadata) to load.
+            providers: Ordered execution providers to try. ``None`` lets the policy
+                pick a host-appropriate chain from the checkpoint metadata.
+            session_options: Optional ONNX Runtime session options.
+            policy: Selection policy used when ``providers is None``. Defaults to
+                :class:`DefaultProviderPolicy`.
+
+        Returns:
+            A backend wrapping the newly built session.
+        """
+        metadata = checkpoint.metadata
+        if providers is not None:
+            provider_configs = list(providers)
+            explicit = True
+            logger.info(
+                "Using explicit execution-provider chain %s for checkpoint '%s'.",
+                [config.to_ort()[0] for config in provider_configs],
+                metadata.model_family,
+            )
+        else:
+            selector = policy or DefaultProviderPolicy()
+            host = HostCapabilities.detect()
+            provider_configs = selector.select(metadata, host)
+            explicit = False
+            logger.debug(
+                "Detected host: platform=%s, available_providers=%s",
+                host.platform,
+                sorted(host.available_providers),
+            )
+            logger.info(
+                "%s selected execution-provider chain %s for checkpoint '%s' (precision=%s, static_shapes=%s) on %s.",
+                type(selector).__name__,
+                [config.to_ort()[0] for config in provider_configs],
+                metadata.model_family,
+                metadata.precision,
+                metadata.static_shapes,
+                host.platform,
+            )
+        ort_providers = [config.to_ort() for config in provider_configs]
+        so = _build_session_options(session_options) if session_options else None
+
+        session = ort.InferenceSession(
+            str(checkpoint.weights_path),
+            sess_options=so,
+            providers=ort_providers,
+        )
+        logger.info("ONNX Runtime session built; realized providers: %s.", session.get_providers())
+        _check_provider_fallback(
+            requested=provider_configs,
+            realized=session.get_providers(),
+            strict=explicit,
+        )
+        return cls(metadata=checkpoint.metadata, session=session)
+
+    @property
+    def metadata(self) -> CheckpointMetadata:
+        """Metadata describing the checkpoint this backend executes."""
+        return self._metadata
+
+    def run(self, inputs: Mapping[str, np.ndarray]) -> Mapping[str, np.ndarray]:
+        """Execute the ONNX model on a batch of named input tensors.
+
+        Args:
+            inputs: Named input tensors. Keys must match ``metadata.input_names``.
+
+        Returns:
+            Named output tensors keyed by the model's output names.
+
+        Raises:
+            RuntimeError: If the backend has been closed.
+        """
+        if self._session is None:
+            msg = "OnnxBackend has been closed."
+            raise RuntimeError(msg)
+        output_names = [out.name for out in self._session.get_outputs()]
+        results = self._session.run(output_names, dict(inputs))
+        return {name: np.asarray(result) for name, result in zip(output_names, results, strict=True)}
+
+    def close(self) -> None:
+        """Release the underlying ONNX Runtime session.
+
+        ONNX Runtime frees native resources on garbage collection, so dropping
+        the reference is the supported way to release them.
+        """
+        self._session = None
+
+
+def _build_session_options(config: SessionOptionsConfig) -> ort.SessionOptions:
+    """Translate a :class:`SessionOptionsConfig` into ONNX Runtime session options.
+
+    Args:
+        config: The typed session-options configuration.
+
+    Returns:
+        The corresponding ONNX Runtime ``SessionOptions``.
+    """
+    so = ort.SessionOptions()
+    so.graph_optimization_level = getattr(
+        ort.GraphOptimizationLevel,
+        f"ORT_{config.graph_optimization_level}",
+    )
+    if config.intra_op_num_threads is not None:
+        so.intra_op_num_threads = config.intra_op_num_threads
+    if config.inter_op_num_threads is not None:
+        so.inter_op_num_threads = config.inter_op_num_threads
+    return so
+
+
+def _check_provider_fallback(
+    requested: Sequence[ExecutionProvider],
+    realized: Sequence[str],
+    *,
+    strict: bool,
+) -> None:
+    """Detect and report a silent fallback to the CPU execution provider.
+
+    Compares the requested chain against what ONNX Runtime actually realized. See
+    :class:`~openstef_foundation_models.inference.provider_selection.ProviderPolicy`
+    for the strict-vs-graceful contract this enforces.
+
+    Args:
+        requested: The execution providers that were requested.
+        realized: The provider names ONNX Runtime actually loaded.
+        strict: When ``True``, raise on any missing accelerator; otherwise warn
+            only on a full fallback to CPU.
+
+    Raises:
+        RuntimeError: If ``strict`` is set and a requested accelerator is missing.
+    """
+    requested_names = {config.to_ort()[0] for config in requested}
+    accelerators = requested_names - {"CPUExecutionProvider"}
+    if not accelerators:
+        return
+    realized_set = set(realized)
+    missing = accelerators - realized_set
+    if strict:
+        if missing:
+            msg = (
+                f"Requested execution provider(s) {sorted(missing)} were not realized; "
+                f"ONNX Runtime fell back to {realized}."
+            )
+            raise RuntimeError(msg)
+        return
+    if accelerators & realized_set:
+        return
+    logger.warning(
+        "No requested accelerator (%s) was realized; ONNX Runtime fell back to %s. Inference will run on CPU.",
+        sorted(accelerators),
+        realized,
+    )