autogluon.timeseries 1.4.1b20250824__tar.gz → 1.4.1b20250828__tar.gz

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250828}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.4.1b20250824
+Version: 1.4.1b20250828
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

autogluon.timeseries-1.4.1b20250828/src/autogluon/timeseries/configs/__init__.py

@@ -0,0 +1,4 @@
+from .hyperparameter_presets import get_hyperparameter_presets
+from .predictor_presets import get_predictor_presets
+
+__all__ = ["get_hyperparameter_presets", "get_predictor_presets"]

autogluon.timeseries-1.4.1b20250828/src/autogluon/timeseries/configs/hyperparameter_presets.py

@@ -0,0 +1,62 @@
+from typing import Any, Union
+
+
+def get_hyperparameter_presets() -> dict[str, dict[str, Union[dict[str, Any], list[dict[str, Any]]]]]:
+    return {
+        "very_light": {
+            "Naive": {},
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {"max_num_samples": 100_000},
+            "DirectTabular": {"max_num_samples": 100_000},
+        },
+        "light": {
+            "Naive": {},
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "Chronos": {"model_path": "bolt_small"},
+        },
+        "light_inference": {
+            "SeasonalNaive": {},
+            "DirectTabular": {},
+            "RecursiveTabular": {},
+            "TemporalFusionTransformer": {},
+            "PatchTST": {},
+        },
+        "default": {
+            "SeasonalNaive": {},
+            "AutoETS": {},
+            "NPTS": {},
+            "DynamicOptimizedTheta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "PatchTST": {},
+            "DeepAR": {},
+            "Chronos": [
+                {
+                    "ag_args": {"name_suffix": "ZeroShot"},
+                    "model_path": "bolt_base",
+                },
+                {
+                    "ag_args": {"name_suffix": "FineTuned"},
+                    "model_path": "bolt_small",
+                    "fine_tune": True,
+                    "target_scaler": "standard",
+                    "covariate_regressor": {"model_name": "CAT", "model_hyperparameters": {"iterations": 1_000}},
+                },
+            ],
+            "TiDE": {
+                "encoder_hidden_dim": 256,
+                "decoder_hidden_dim": 256,
+                "temporal_hidden_dim": 64,
+                "num_batches_per_epoch": 100,
+                "lr": 1e-4,
+            },
+        },
+    }

autogluon.timeseries-1.4.1b20250828/src/autogluon/timeseries/configs/predictor_presets.py

@@ -0,0 +1,84 @@
+"""Preset configurations for autogluon.timeseries Predictors"""
+
+from typing import Any
+
+from . import get_hyperparameter_presets
+
+TIMESERIES_PRESETS_ALIASES = dict(
+    chronos="chronos_small",
+    best="best_quality",
+    high="high_quality",
+    medium="medium_quality",
+    bq="best_quality",
+    hq="high_quality",
+    mq="medium_quality",
+)
+
+
+def get_predictor_presets() -> dict[str, Any]:
+    hp_presets = get_hyperparameter_presets()
+
+    predictor_presets = dict(
+        best_quality={"hyperparameters": "default", "num_val_windows": 2},
+        high_quality={"hyperparameters": "default"},
+        medium_quality={"hyperparameters": "light"},
+        fast_training={"hyperparameters": "very_light"},
+        # Chronos-Bolt models
+        bolt_tiny={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_tiny"}},
+            "skip_model_selection": True,
+        },
+        bolt_mini={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_mini"}},
+            "skip_model_selection": True,
+        },
+        bolt_small={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_small"}},
+            "skip_model_selection": True,
+        },
+        bolt_base={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_base"}},
+            "skip_model_selection": True,
+        },
+        # Original Chronos models
+        chronos_tiny={
+            "hyperparameters": {"Chronos": {"model_path": "tiny"}},
+            "skip_model_selection": True,
+        },
+        chronos_mini={
+            "hyperparameters": {"Chronos": {"model_path": "mini"}},
+            "skip_model_selection": True,
+        },
+        chronos_small={
+            "hyperparameters": {"Chronos": {"model_path": "small"}},
+            "skip_model_selection": True,
+        },
+        chronos_base={
+            "hyperparameters": {"Chronos": {"model_path": "base"}},
+            "skip_model_selection": True,
+        },
+        chronos_large={
+            "hyperparameters": {"Chronos": {"model_path": "large", "batch_size": 8}},
+            "skip_model_selection": True,
+        },
+        chronos_ensemble={
+            "hyperparameters": {
+                "Chronos": {"model_path": "small"},
+                **hp_presets["light_inference"],
+            }
+        },
+        chronos_large_ensemble={
+            "hyperparameters": {
+                "Chronos": {"model_path": "large", "batch_size": 8},
+                **hp_presets["light_inference"],
+            }
+        },
+    )
+
+    # update with aliases
+    predictor_presets = {
+        **predictor_presets,
+        **{k: predictor_presets[v].copy() for k, v in TIMESERIES_PRESETS_ALIASES.items()},
+    }
+
+    return predictor_presets

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250828}/src/autogluon/timeseries/metrics/abstract.py

@@ -2,7 +2,6 @@ import warnings
 from typing import Optional, Sequence, Union, overload
 
 import numpy as np
-import numpy.typing as npt
 import pandas as pd
 
 from autogluon.timeseries import TimeSeriesDataFrame
@@ -242,12 +241,12 @@ class TimeSeriesScorer:
     @staticmethod
     def check_get_horizon_weight(
         horizon_weight: Union[Sequence[float], np.ndarray], prediction_length: int
-    ) -> npt.NDArray[np.float64]: ...
+    ) -> np.ndarray: ...
 
     @staticmethod
     def check_get_horizon_weight(
         horizon_weight: Union[Sequence[float], np.ndarray, None], prediction_length: int
-    ) -> Optional[npt.NDArray[np.float64]]:
+    ) -> Optional[np.ndarray]:
         """Convert horizon_weight to a non-negative numpy array that sums up to prediction_length.
         Raises an exception if horizon_weight has an invalid shape or contains invalid values.
 

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250828}/src/autogluon/timeseries/models/__init__.py

@@ -27,6 +27,7 @@ from .local import (
     ThetaModel,
     ZeroModel,
 )
+from .registry import ModelRegistry
 
 __all__ = [
     "ADIDAModel",
@@ -43,6 +44,7 @@ __all__ = [
     "ETSModel",
     "IMAPAModel",
     "ChronosModel",
+    "ModelRegistry",
     "NPTSModel",
     "NaiveModel",
     "PatchTSTModel",

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250828}/src/autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -7,6 +7,7 @@ import time
 from typing import Any, Optional, Type, Union
 
 import numpy as np
+from typing_extensions import Self
 
 import autogluon.core as ag
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
@@ -73,10 +74,6 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def supports_past_covariates(self) -> bool:
         return self.model_base.supports_past_covariates
 
-    @property
-    def supports_cat_covariates(self) -> bool:
-        return self.model_base.supports_cat_covariates
-
     def _get_model_base(self):
         return self.model_base
 
@@ -86,15 +83,18 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def _is_gpu_available(self) -> bool:
         return self._get_model_base()._is_gpu_available()
 
-    def get_minimum_resources(self, is_gpu_available: bool = False) -> bool:
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, Union[int, float]]:
         return self._get_model_base().get_minimum_resources(is_gpu_available)
 
     def _fit(
         self,
         train_data: TimeSeriesDataFrame,
         val_data: Optional[TimeSeriesDataFrame] = None,
-        time_limit: Optional[int] = None,
-        val_splitter: AbstractWindowSplitter = None,
+        time_limit: Optional[float] = None,
+        num_cpus: Optional[int] = None,
+        num_gpus: Optional[int] = None,
+        verbosity: int = 2,
+        val_splitter: Optional[AbstractWindowSplitter] = None,
         refit_every_n_windows: Optional[int] = 1,
         **kwargs,
     ):
@@ -111,11 +111,15 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
 
         oof_predictions_per_window = []
         global_fit_start_time = time.time()
+        model: Optional[AbstractTimeSeriesModel] = None
 
         for window_index, (train_fold, val_fold) in enumerate(val_splitter.split(train_data)):
             logger.debug(f"\tWindow {window_index}")
+
             # refit_this_window is always True for the 0th window
             refit_this_window = window_index % refit_every_n_windows == 0
+            assert window_index != 0 or refit_this_window
+
             if time_limit is None:
                 time_left_for_window = None
             else:
@@ -148,6 +152,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
             else:
                 time_left_for_prediction = time_limit - (time.time() - global_fit_start_time)
 
+            assert model is not None
             model.score_and_cache_oof(
                 val_fold, store_val_score=True, store_predict_time=True, time_limit=time_left_for_prediction
             )
@@ -172,11 +177,13 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
 
         # Only the model trained on most recent data is saved & used for prediction
         self.most_recent_model = model
-        self.most_recent_model_folder = most_recent_refit_window
+        assert self.most_recent_model is not None
+
+        self.most_recent_model_folder = most_recent_refit_window  # type: ignore
         self.predict_time = self.most_recent_model.predict_time
-        self.fit_time = time.time() - global_fit_start_time - self.predict_time
+        self.fit_time = time.time() - global_fit_start_time - self.predict_time  # type: ignore
         self._oof_predictions = oof_predictions_per_window
-        self.val_score = np.mean([info["val_score"] for info in self.info_per_val_window])
+        self.val_score = np.mean([info["val_score"] for info in self.info_per_val_window])  # type: ignore
 
     def get_info(self) -> dict:
         info = super().get_info()
@@ -227,7 +234,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         train_fn_kwargs["init_params"]["model_base_kwargs"] = self.get_params()
         return train_fn_kwargs
 
-    def save(self, path: str = None, verbose=True) -> str:
+    def save(self, path: Optional[str] = None, verbose: bool = True) -> str:
         most_recent_model = self.most_recent_model
         self.most_recent_model = None
         save_path = super().save(path, verbose)
@@ -238,32 +245,36 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
             most_recent_model.save()
         return save_path
 
-    def persist(self):
+    def persist(self) -> Self:
         if self.most_recent_model is None:
             raise ValueError(f"{self.name} must be fit before persisting")
         self.most_recent_model.persist()
+        return self
 
     @classmethod
     def load(
         cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True
     ) -> AbstractTimeSeriesModel:
         model = super().load(path=path, reset_paths=reset_paths, load_oof=load_oof, verbose=verbose)
-        most_recent_model_path = os.path.join(model.path, model.most_recent_model_folder)
-        model.most_recent_model = model.model_base_type.load(
-            most_recent_model_path,
-            reset_paths=reset_paths,
-            verbose=verbose,
-        )
+        if model.most_recent_model_folder is not None:
+            most_recent_model_path = os.path.join(model.path, model.most_recent_model_folder)
+            model.most_recent_model = model.model_base_type.load(
+                most_recent_model_path,
+                reset_paths=reset_paths,
+                verbose=verbose,
+            )
         return model
 
     def convert_to_refit_full_template(self) -> AbstractTimeSeriesModel:
         # refit_model is an instance of base model type, not MultiWindowBacktestingModel
+        assert self.most_recent_model is not None, "Most recent model is None. Model must be fit first."
         refit_model = self.most_recent_model.convert_to_refit_full_template()
         refit_model.rename(self.name + ag.constants.REFIT_FULL_SUFFIX)
         return refit_model
 
     def convert_to_refit_full_via_copy(self) -> AbstractTimeSeriesModel:
         # refit_model is an instance of base model type, not MultiWindowBacktestingModel
+        assert self.most_recent_model is not None, "Most recent model is None. Model must be fit first."
         refit_model = self.most_recent_model.convert_to_refit_full_via_copy()
         refit_model.rename(self.name + ag.constants.REFIT_FULL_SUFFIX)
         return refit_model

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250828}/src/autogluon/timeseries/predictor.py

@@ -21,7 +21,7 @@ from autogluon.core.utils.decorators import apply_presets
 from autogluon.core.utils.loaders import load_pkl, load_str
 from autogluon.core.utils.savers import save_pkl, save_str
 from autogluon.timeseries import __version__ as current_ag_version
-from autogluon.timeseries.configs import TIMESERIES_PRESETS_CONFIGS
+from autogluon.timeseries.configs import get_predictor_presets
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 from autogluon.timeseries.learner import TimeSeriesLearner
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
@@ -432,7 +432,7 @@ class TimeSeriesPredictor:
             )
         return train_data
 
-    @apply_presets(TIMESERIES_PRESETS_CONFIGS)
+    @apply_presets(get_predictor_presets())
     def fit(
         self,
         train_data: Union[TimeSeriesDataFrame, pd.DataFrame, Path, str],

autogluon.timeseries-1.4.1b20250828/src/autogluon/timeseries/trainer/__init__.py

@@ -0,0 +1,3 @@
+from .trainer import TimeSeriesTrainer
+
+__all__ = ["TimeSeriesTrainer"]

autogluon.timeseries-1.4.1b20250828/src/autogluon/timeseries/trainer/model_set_builder.py

@@ -0,0 +1,256 @@
+import copy
+import logging
+import re
+from collections import defaultdict
+from typing import Any, Optional, Type, Union
+
+from autogluon.common import space
+from autogluon.core import constants
+from autogluon.timeseries.configs import get_hyperparameter_presets
+from autogluon.timeseries.metrics import TimeSeriesScorer
+from autogluon.timeseries.models import ModelRegistry
+from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
+from autogluon.timeseries.models.multi_window import MultiWindowBacktestingModel
+from autogluon.timeseries.utils.features import CovariateMetadata
+
+logger = logging.getLogger(__name__)
+
+
+ModelKey = Union[str, Type[AbstractTimeSeriesModel]]
+ModelHyperparameters = dict[str, Any]
+TrainerHyperparameterSpec = dict[ModelKey, list[ModelHyperparameters]]
+
+
+class TrainableModelSetBuilder:
+    """Responsible for building a list of model objects, in priority order, that will be trained by the
+    Trainer."""
+
+    VALID_AG_ARGS_KEYS = {
+        "name",
+        "name_prefix",
+        "name_suffix",
+    }
+
+    def __init__(
+        self,
+        path: str,
+        freq: Optional[str],
+        prediction_length: int,
+        eval_metric: TimeSeriesScorer,
+        target: str,
+        quantile_levels: list[float],
+        covariate_metadata: CovariateMetadata,
+        multi_window: bool,
+    ):
+        self.path = path
+        self.freq = freq
+        self.prediction_length = prediction_length
+        self.eval_metric = eval_metric
+        self.target = target
+        self.quantile_levels = quantile_levels
+        self.covariate_metadata = covariate_metadata
+        self.multi_window = multi_window
+
+    def get_model_set(
+        self,
+        hyperparameters: Union[str, dict, None],
+        hyperparameter_tune: bool,
+        excluded_model_types: Optional[list[str]],
+        banned_model_names: Optional[list[str]] = None,
+    ) -> list[AbstractTimeSeriesModel]:
+        """Resolve hyperparameters and create the requested list of models"""
+        models = []
+        banned_model_names = [] if banned_model_names is None else banned_model_names.copy()
+
+        # resolve and normalize hyperparameters
+        model_hp_map: TrainerHyperparameterSpec = HyperparameterBuilder(
+            hyperparameters=hyperparameters,
+            hyperparameter_tune=hyperparameter_tune,
+            excluded_model_types=excluded_model_types,
+        ).get_hyperparameters()
+
+        for k in model_hp_map.keys():
+            if isinstance(k, type) and not issubclass(k, AbstractTimeSeriesModel):
+                raise ValueError(f"Custom model type {k} must inherit from `AbstractTimeSeriesModel`.")
+
+        model_priority_list = sorted(
+            model_hp_map.keys(), key=lambda x: ModelRegistry.get_model_priority(x), reverse=True
+        )
+
+        for model_key in model_priority_list:
+            model_type = self._get_model_type(model_key)
+
+            for model_hps in model_hp_map[model_key]:
+                ag_args = model_hps.pop(constants.AG_ARGS, {})
+
+                for key in ag_args:
+                    if key not in self.VALID_AG_ARGS_KEYS:
+                        raise ValueError(
+                            f"Model {model_type} received unknown ag_args key: {key} (valid keys {self.VALID_AG_ARGS_KEYS})"
+                        )
+                model_name_base = self._get_model_name(ag_args, model_type)
+
+                model_type_kwargs: dict[str, Any] = dict(
+                    name=model_name_base,
+                    hyperparameters=model_hps,
+                    **self._get_default_model_init_kwargs(),
+                )
+
+                # add models while preventing name collisions
+                model = model_type(**model_type_kwargs)
+                model_type_kwargs.pop("name", None)
+
+                increment = 1
+                while model.name in banned_model_names:
+                    increment += 1
+                    model = model_type(name=f"{model_name_base}_{increment}", **model_type_kwargs)
+
+                if self.multi_window:
+                    model = MultiWindowBacktestingModel(model_base=model, name=model.name, **model_type_kwargs)  # type: ignore
+
+                banned_model_names.append(model.name)
+                models.append(model)
+
+        return models
+
+    def _get_model_type(self, model: ModelKey) -> Type[AbstractTimeSeriesModel]:
+        if isinstance(model, str):
+            model_type: Type[AbstractTimeSeriesModel] = ModelRegistry.get_model_class(model)
+        elif isinstance(model, type):
+            model_type = model
+        else:
+            raise ValueError(
+                f"Keys of the `hyperparameters` dictionary must be strings or types, received {type(model)}."
+            )
+
+        return model_type
+
+    def _get_default_model_init_kwargs(self) -> dict[str, Any]:
+        return dict(
+            path=self.path,
+            freq=self.freq,
+            prediction_length=self.prediction_length,
+            eval_metric=self.eval_metric,
+            target=self.target,
+            quantile_levels=self.quantile_levels,
+            covariate_metadata=self.covariate_metadata,
+        )
+
+    def _get_model_name(self, ag_args: dict[str, Any], model_type: Type[AbstractTimeSeriesModel]) -> str:
+        name = ag_args.get("name")
+        if name is None:
+            name_stem = re.sub(r"Model$", "", model_type.__name__)
+            name_prefix = ag_args.get("name_prefix", "")
+            name_suffix = ag_args.get("name_suffix", "")
+            name = name_prefix + name_stem + name_suffix
+        return name
+
+
+class HyperparameterBuilder:
+    """Given user hyperparameter specifications, this class resolves them against presets, removes
+    excluded model types and canonicalizes the hyperparameter specification.
+    """
+
+    def __init__(
+        self,
+        hyperparameters: Union[str, dict, None],
+        hyperparameter_tune: bool,
+        excluded_model_types: Optional[list[str]],
+    ):
+        self.hyperparameters = hyperparameters
+        self.hyperparameter_tune = hyperparameter_tune
+        self.excluded_model_types = excluded_model_types
+
+    def get_hyperparameters(self) -> TrainerHyperparameterSpec:
+        hyperparameter_dict = {}
+        hp_presets = get_hyperparameter_presets()
+
+        if self.hyperparameters is None:
+            hyperparameter_dict = hp_presets["default"]
+        elif isinstance(self.hyperparameters, str):
+            try:
+                hyperparameter_dict = hp_presets[self.hyperparameters]
+            except KeyError:
+                raise ValueError(f"{self.hyperparameters} is not a valid preset.")
+        elif isinstance(self.hyperparameters, dict):
+            hyperparameter_dict = copy.deepcopy(self.hyperparameters)
+        else:
+            raise ValueError(
+                f"hyperparameters must be a dict, a string or None (received {type(self.hyperparameters)}). "
+                f"Please see the documentation for TimeSeriesPredictor.fit"
+            )
+
+        return self._check_and_clean_hyperparameters(hyperparameter_dict)  # type: ignore
+
+    def _check_and_clean_hyperparameters(
+        self,
+        hyperparameters: dict[ModelKey, Union[ModelHyperparameters, list[ModelHyperparameters]]],
+    ) -> TrainerHyperparameterSpec:
+        """Convert the hyperparameters dictionary to a unified format:
+        - Remove 'Model' suffix from model names, if present
+        - Make sure that each value in the hyperparameters dict is a list with model configurations
+        - Checks if hyperparameters contain searchspaces
+        """
+        excluded_models = self._get_excluded_models()
+        hyperparameters_clean = defaultdict(list)
+        for model_name, model_hyperparameters in hyperparameters.items():
+            # Handle model names ending with "Model", e.g., "DeepARModel" is mapped to "DeepAR"
+            if isinstance(model_name, str):
+                model_name = self._normalize_model_type_name(model_name)
+                if model_name in excluded_models:
+                    logger.info(
+                        f"\tFound '{model_name}' model in `hyperparameters`, but '{model_name}' "
+                        "is present in `excluded_model_types` and will be removed."
+                    )
+                    continue
+            if not isinstance(model_hyperparameters, list):
+                model_hyperparameters = [model_hyperparameters]
+            hyperparameters_clean[model_name].extend(model_hyperparameters)
+
+        self._verify_searchspaces(hyperparameters_clean)
+
+        return dict(hyperparameters_clean)
+
+    def _get_excluded_models(self) -> set[str]:
+        excluded_models = set()
+        if self.excluded_model_types is not None and len(self.excluded_model_types) > 0:
+            if not isinstance(self.excluded_model_types, list):
+                raise ValueError(f"`excluded_model_types` must be a list, received {type(self.excluded_model_types)}")
+            logger.info(f"Excluded model types: {self.excluded_model_types}")
+            for model in self.excluded_model_types:
+                if not isinstance(model, str):
+                    raise ValueError(f"Each entry in `excluded_model_types` must be a string, received {type(model)}")
+                excluded_models.add(self._normalize_model_type_name(model))
+        return excluded_models
+
+    @staticmethod
+    def _normalize_model_type_name(model_name: str) -> str:
+        return model_name.removesuffix("Model")
+
+    def _verify_searchspaces(self, hyperparameters: dict[str, list[ModelHyperparameters]]):
+        if self.hyperparameter_tune:
+            for model, model_hps_list in hyperparameters.items():
+                for model_hps in model_hps_list:
+                    if contains_searchspace(model_hps):
+                        return
+
+            raise ValueError(
+                "Hyperparameter tuning specified, but no model contains a hyperparameter search space. "
+                "Please disable hyperparameter tuning with `hyperparameter_tune_kwargs=None` or provide a search space "
+                "for at least one model."
+            )
+        else:
+            for model, model_hps_list in hyperparameters.items():
+                for model_hps in model_hps_list:
+                    if contains_searchspace(model_hps):
+                        raise ValueError(
+                            f"Hyperparameter tuning not specified, so hyperparameters must have fixed values. "
+                            f"However, for model {model} hyperparameters {model_hps} contain a search space."
+                        )
+
+
+def contains_searchspace(model_hyperparameters: ModelHyperparameters) -> bool:
+    for hp_value in model_hyperparameters.values():
+        if isinstance(hp_value, space.Space):
+            return True
+    return False