From 5789a9964a47b0a9758e5b66ee58265247654250 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 10 Feb 2026 16:01:23 +0100 Subject: [PATCH 001/154] draft MVP --- darts/utils/mlflow.py | 804 ++++++++++++++++++++++++++++++++++++++++++ darts/utils/utils.py | 7 + pyproject.toml | 1 + 3 files changed, 812 insertions(+) create mode 100644 darts/utils/mlflow.py diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py new file mode 100644 index 0000000000..c15846fc91 --- /dev/null +++ b/darts/utils/mlflow.py @@ -0,0 +1,804 @@ +""" +MLflow Integration for Darts +----------------------------- + +Custom MLflow model flavor for darts forecasting models. Supports saving, loading, +logging and autolog for any darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) +to MLflow, including a pyfunc wrapper for MLflow's generic inference API. +""" + +import importlib +import os +import sys +import tempfile +from functools import wraps +from typing import Any, Optional, Union + +import mlflow +import pandas as pd +import yaml +from mlflow.models import Model +from mlflow.tracking.artifact_utils import _download_artifact_from_uri + +import darts +from darts.logging import get_logger +from darts.models.forecasting.forecasting_model import ForecastingModel +from darts.utils.utils import PL_AVAILABLE + +logger = get_logger(__name__) + +FLAVOR_NAME = "darts" +_MODEL_DATA_SUBFOLDER = "data" + + +class _ModelLogInfo: + """Lightweight container returned by :func:`log_model` with essential metadata. + + Attributes + ---------- + model_uri : str + The full MLflow model URI (e.g., "runs:/run_id/model"). + run_id : str + The MLflow run ID that logged the model. + artifact_path : str + The artifact path where the model was logged within the run. + """ + + def __init__(self, model_uri: str, run_id: str, artifact_path: str): + self.model_uri = model_uri + self.run_id = run_id + self.artifact_path = artifact_path + + +_MODEL_FILE_STAT = "model.pkl" +_MODEL_FILE_TORCH = "model.pt" +_MODEL_FILE_TORCH_CKPT = "model.pt.ckpt" + + +def _is_torch_model(model) -> bool: + """Check if a model is a TorchForecastingModel. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + bool + True if the model is a TorchForecastingModel, False otherwise. + """ + try: + from darts.models.forecasting.torch_forecasting_model import ( + TorchForecastingModel, + ) + + return isinstance(model, TorchForecastingModel) + except ImportError: + return False + + +def _get_model_class_path(model) -> tuple[str, str]: + """Extract the module path and class name from a model instance. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + tuple[str, str] + A tuple containing (module_path, class_name). + """ + cls = type(model) + return cls.__module__, cls.__name__ + + +def _import_model_class(module_path: str, class_name: str): + """Dynamically import and return a model class. + + Parameters + ---------- + module_path : str + The fully qualified module path (e.g., "darts.models.exponential_smoothing"). + class_name : str + The name of the class to import (e.g., "ExponentialSmoothing"). + + Returns + ------- + type + The imported model class. + """ + module = importlib.import_module(module_path) + return getattr(module, class_name) + + +def get_default_pip_requirements(is_torch: bool = False) -> list[str]: + """Return the default pip requirements for logging a darts model. + + Parameters + ---------- + is_torch + Whether the model is a PyTorch-based model. If ``True``, adds + ``torch`` and ``pytorch-lightning`` to the requirements. + + Returns + ------- + list[str] + A list of pip requirement strings. + """ + reqs = [f"darts=={darts.__version__}"] + if is_torch: + reqs.extend(["torch>=2.0.0", "pytorch-lightning>=2.0.0"]) + return reqs + + +def get_default_conda_env(is_torch: bool = False) -> dict: + """Return a default conda environment dict for a darts model. + + Parameters + ---------- + is_torch + Whether the model is a PyTorch-based model. + + Returns + ------- + dict + A conda environment specification dictionary. + """ + return { + "channels": ["defaults", "conda-forge"], + "dependencies": [ + "python", + "pip", + { + "pip": get_default_pip_requirements(is_torch=is_torch), + }, + ], + "name": "darts_env", + } + + +def save_model( + model, + path: str, + conda_env: Optional[Union[dict, str]] = None, + pip_requirements: Optional[list[str]] = None, + signature=None, + input_example=None, + metadata: Optional[dict] = None, +) -> None: + """Save a darts forecasting model in MLflow format. + + Produces an MLflow model directory at ``path`` containing: + + * The serialised darts model (delegated to the model's own ``save()`` method). + * An ``MLmodel`` YAML file with flavor metadata. + * ``conda.yaml`` and ``requirements.txt`` environment files. + + Parameters + ---------- + model + A fitted darts ``ForecastingModel`` instance. + path + Local filesystem path where the model directory will be created. + conda_env + A conda environment specification (dict or path to a ``conda.yaml``). + If ``None``, a default environment is generated. + pip_requirements + A list of pip requirement strings. Overrides ``conda_env`` pip section + when provided. + signature + An ``mlflow.models.ModelSignature`` instance describing model input/output. + input_example + An example input for the model (used by MLflow UI). + metadata + Optional dictionary of custom metadata to store in the ``MLmodel`` file. + """ + data_dir = os.path.join(path, _MODEL_DATA_SUBFOLDER) + + is_torch = _is_torch_model(model) + + os.makedirs(path, exist_ok=True) + os.makedirs(data_dir, exist_ok=True) + + if is_torch: + model_file = _MODEL_FILE_TORCH + model.save(os.path.join(data_dir, model_file)) + else: + model_file = _MODEL_FILE_STAT + model.save(os.path.join(data_dir, model_file)) + + module_path, class_name = _get_model_class_path(model) + + darts_flavor_conf = { + "darts_version": darts.__version__, + "model_class_module": module_path, + "model_class_name": class_name, + "model_file": model_file, + "is_torch_model": is_torch, + "data": _MODEL_DATA_SUBFOLDER, + } + + if pip_requirements is not None: + pip_reqs = pip_requirements + else: + pip_reqs = get_default_pip_requirements(is_torch=is_torch) + + if conda_env is not None: + if isinstance(conda_env, str): + with open(conda_env) as f: + conda_env_dict = yaml.safe_load(f) + else: + conda_env_dict = conda_env + else: + conda_env_dict = get_default_conda_env(is_torch=is_torch) + + conda_path = os.path.join(path, "conda.yaml") + with open(conda_path, "w") as f: + yaml.dump(conda_env_dict, f, default_flow_style=False) + + reqs_path = os.path.join(path, "requirements.txt") + with open(reqs_path, "w") as f: + f.write("\n".join(pip_reqs) + "\n") + + python_env_path = os.path.join(path, "python_env.yaml") + python_env = { + "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}", + "build_dependencies": ["pip"], + "dependencies": ["requirements.txt"], + } + with open(python_env_path, "w") as f: + yaml.dump(python_env, f, default_flow_style=False) + pyfunc_conf = { + "loader_module": "darts.utils.mlflow", + "python_model": None, + "data": _MODEL_DATA_SUBFOLDER, + "env": {"conda": "conda.yaml", "virtualenv": "python_env.yaml"}, + } + + mlmodel = Model() + mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) + mlmodel.add_flavor("python_function", **pyfunc_conf) + + if signature is not None: + mlmodel.signature = signature + + if input_example is not None: + mlmodel.input_example = input_example + + if metadata is not None: + mlmodel.metadata = metadata + + mlmodel.save(os.path.join(path, "MLmodel")) + + +def load_model( + model_uri: str, + dst_path: Optional[str] = None, + **kwargs, +): + """Load a darts model from an MLflow model URI. + + Parameters + ---------- + model_uri + An MLflow model URI, e.g. ``"runs://model"``, + ``"models://"``, or a local ``file:///...`` path. + dst_path + Optional local path for downloading remote artifacts. + **kwargs + Additional keyword arguments forwarded to the model's ``load()`` method + (e.g. ``map_location`` for Torch models). + + Returns + ------- + ForecastingModel + The loaded darts forecasting model. + """ + local_path = _download_artifact_from_uri( + artifact_uri=model_uri, output_path=dst_path + ) + mlmodel_path = os.path.join(local_path, "MLmodel") + mlmodel = Model.load(mlmodel_path) + + if FLAVOR_NAME not in mlmodel.flavors: + raise ValueError( + f"The MLflow model at '{model_uri}' does not have a '{FLAVOR_NAME}' flavor. " + f"Available flavors: {list(mlmodel.flavors.keys())}" + ) + + flavor_conf = mlmodel.flavors[FLAVOR_NAME] + module_path = flavor_conf["model_class_module"] + class_name = flavor_conf["model_class_name"] + model_file = flavor_conf["model_file"] + is_torch = flavor_conf.get("is_torch_model", False) + + model_cls = _import_model_class(module_path, class_name) + + data_dir = os.path.join(local_path, flavor_conf.get("data", _MODEL_DATA_SUBFOLDER)) + model_path = os.path.join(data_dir, model_file) + + if is_torch: + loaded_model = model_cls.load(model_path, **kwargs) + else: + loaded_model = model_cls.load(model_path) + + return loaded_model + + +def log_model( + model, + artifact_path: Optional[str] = None, + name: Optional[str] = None, + registered_model_name: Optional[str] = None, + conda_env: Optional[Union[dict, str]] = None, + pip_requirements: Optional[list[str]] = None, + signature=None, + input_example=None, + metadata: Optional[dict] = None, + log_params: bool = True, +): + """Log a darts model to the current MLflow run. + + Parameters + ---------- + model + A fitted darts ``ForecastingModel`` instance. + artifact_path + The run-relative artifact path under which to log the model. + Defaults to ``"model"``. Deprecated in favour of ``name``. + name + The name for the model artifact. If provided, takes precedence over + ``artifact_path``. + registered_model_name + If provided, the model is registered in the MLflow Model Registry + under this name. + conda_env + Conda environment specification (dict or path). + pip_requirements + Pip requirements list. + signature + An ``mlflow.models.ModelSignature``. + input_example + An example model input. + metadata + Optional dict of custom metadata. + log_params + If ``True`` (default), log the model's creation parameters via + ``mlflow.log_params()``. + + Returns + ------- + _ModelLogInfo + A lightweight object with ``model_uri``, ``run_id``, and + ``artifact_path`` attributes. + """ + artifact_name = name or artifact_path or "model" + + if log_params: + _log_model_params(model) + + with tempfile.TemporaryDirectory() as tmp_dir: + model_dir = os.path.join(tmp_dir, artifact_name) + save_model( + model=model, + path=model_dir, + conda_env=conda_env, + pip_requirements=pip_requirements, + signature=signature, + input_example=input_example, + metadata=metadata, + ) + mlflow.log_artifacts(model_dir, artifact_path=artifact_name) + + run_id = mlflow.active_run().info.run_id + model_uri = f"runs:/{run_id}/{artifact_name}" + + if registered_model_name is not None: + mlflow.register_model(model_uri, registered_model_name) + + return _ModelLogInfo( + model_uri=model_uri, + run_id=run_id, + artifact_path=artifact_name, + ) + + +def _log_model_params(model) -> None: + """Log model creation parameters to MLflow. + + Extracts model parameters from ``model.model_params`` and logs them to the active + MLflow run. Logs non-serializable values as "" and truncates long parameter values + to fit MLflow's 500-character limit. + + Parameters + ---------- + model + A Darts forecasting model instance with a ``model_params`` attribute. + """ + try: + params = model.model_params + except AttributeError: + logger.debug("Model has no model_params attribute; skipping parameter logging.") + return + + safe_params = {} + for key, value in params.items(): + try: + str_val = str(value) + if len(str_val) > 500: # MLflow param value limit + str_val = str_val[:497] + "..." + safe_params[key] = str_val + except Exception: + safe_params[key] = "" + + if safe_params: + mlflow.log_params(safe_params) + + +# --------------------------------------------------------------------------- +# PyFunc interface +# --------------------------------------------------------------------------- + + +class _DartsModelWrapper: + """A pyfunc-compatible wrapper around a darts ``ForecastingModel``. + + MLflow's generic pyfunc inference API requires a ``predict(model_input)`` + method that accepts a ``pandas.DataFrame``. This wrapper translates that + call into a darts ``model.predict(n=...)`` call and returns the forecast + as a ``pandas.DataFrame``. + + The forecast horizon ``n`` is determined from (in order of precedence): + + 1. A key ``"n"`` in the ``params`` dict, or + 2. A column named ``"n"`` in ``model_input`` (first value is used), or + 3. A default of ``1``. + + Parameters + ---------- + model : ForecastingModel + A fitted Darts forecasting model instance. + + Attributes + ---------- + model : ForecastingModel + The wrapped Darts forecasting model. + """ + + def __init__(self, model): + self.model = model + + def predict( + self, + model_input: pd.DataFrame, + params: Optional[dict[str, Any]] = None, + ) -> pd.DataFrame: + """Generate forecasts. + + Parameters + ---------- + model_input + A ``pandas.DataFrame``. If it contains a column ``"n"``, the first + value is used as the forecast horizon. Additional columns + (``"num_samples"``) are forwarded if present. + params + Optional dict; ``params["n"]`` overrides the horizon from the + DataFrame. + + Returns + ------- + pd.DataFrame + Forecasted values with a ``DatetimeIndex`` (or ``RangeIndex``) + and one column per component of the target series. + """ + n = 1 + if params and "n" in params: + n = int(params["n"]) + elif "n" in model_input.columns: + n = int(model_input["n"].iloc[0]) + + num_samples = 1 + if params and "num_samples" in params: + num_samples = int(params["num_samples"]) + elif "num_samples" in model_input.columns: + num_samples = int(model_input["num_samples"].iloc[0]) + + prediction = self.model.predict(n=n, num_samples=num_samples) + return prediction.to_dataframe() + + +def _load_pyfunc(path: str): + """Load a darts model as a pyfunc-compatible wrapper. + + This function is called by ``mlflow.pyfunc.load_model()`` when loading a model + saved with the darts flavor. It reconstructs the original Darts model and wraps + it in a ``_DartsModelWrapper`` for MLflow's generic inference API. + + Parameters + ---------- + path : str + Path to the model directory containing the MLmodel file. + + Returns + ------- + _DartsModelWrapper + A wrapper with a ``predict()`` method compatible with MLflow's + pyfunc inference API. + + Raises + ------ + FileNotFoundError + If the MLmodel file cannot be found at the specified path. + """ + mlmodel_path = os.path.join(path, "..", "MLmodel") + if os.path.exists(mlmodel_path): + parent_path = os.path.dirname(os.path.abspath(mlmodel_path)) + else: + parent_path = path + + mlmodel_file = os.path.join(parent_path, "MLmodel") + if not os.path.exists(mlmodel_file): + raise FileNotFoundError( + f"Cannot find MLmodel file. Searched at: {mlmodel_file}" + ) + + with open(mlmodel_file) as f: + mlmodel_dict = yaml.safe_load(f) + + flavor_conf = mlmodel_dict["flavors"][FLAVOR_NAME] + module_path = flavor_conf["model_class_module"] + class_name = flavor_conf["model_class_name"] + model_file = flavor_conf["model_file"] + is_torch = flavor_conf.get("is_torch_model", False) + + model_cls = _import_model_class(module_path, class_name) + + data_dir = os.path.join(parent_path, flavor_conf.get("data", _MODEL_DATA_SUBFOLDER)) + model_path = os.path.join(data_dir, model_file) + + if is_torch: + loaded_model = model_cls.load(model_path) + else: + loaded_model = model_cls.load(model_path) + + return _DartsModelWrapper(loaded_model) + + +# stores original (unpatched) `fit` methods so they can be restored. +_ORIGINAL_FIT_METHODS: dict[type, Any] = {} + +if PL_AVAILABLE: + import pytorch_lightning as pl + + class _DartsMlflowCallback(pl.Callback): + """PyTorch Lightning callback that logs epoch-level metrics to MLflow. + + This callback automatically logs training and validation metrics (such as + loss values) to the active MLflow run at the end of each epoch. + + Notes + ----- + The callback is automatically injected into TorchForecastingModel instances + when ``autolog()`` is enabled with PyTorch-based models. + """ + + def on_train_epoch_end(self, trainer, pl_module): + """Log training metrics at the end of each training epoch.""" + self._log_epoch_metrics(trainer) + + def on_validation_epoch_end(self, trainer, pl_module): + """Log validation metrics at the end of each validation epoch.""" + self._log_epoch_metrics(trainer) + + def _log_epoch_metrics(self, trainer) -> None: + """Extract and log metrics from the trainer to MLflow. + + Parameters + ---------- + trainer + PyTorch Lightning Trainer instance containing metrics. + """ + if mlflow.active_run() is None: + return + + epoch = trainer.current_epoch + metrics: dict[str, float] = {} + + for source in (trainer.callback_metrics, trainer.logged_metrics): + for key, value in source.items(): + try: + metrics[key] = float(value) + except (TypeError, ValueError): + pass + + if metrics: + mlflow.log_metrics(metrics, step=epoch) + +else: + _DartsMlflowCallback = None + + +def _get_mlflow_callback(): + """Create and return a ``_DartsMlflowCallback`` instance. + + Returns + ------- + _DartsMlflowCallback or None + A callback instance if PyTorch Lightning is available, None otherwise. + """ + if not PL_AVAILABLE: + return None + + return _DartsMlflowCallback() + + +def _inject_mlflow_callback(model) -> None: + """Inject the MLflow callback into a ``TorchForecastingModel``'s trainer params. + + Adds a ``_DartsMlflowCallback`` to the model's PyTorch Lightning trainer callbacks + if not already present. This enables automatic logging of training metrics to MLflow. + + Parameters + ---------- + model + A TorchForecastingModel instance with a ``trainer_params`` attribute. + + Notes + ----- + This is a no-op if the callback is already present or PyTorch Lightning is unavailable. + """ + callback = _get_mlflow_callback() + if callback is None: + return + + if not hasattr(model, "trainer_params"): + return + + existing_callbacks = model.trainer_params.get("callbacks", []) + + cb_type = type(callback) + for existing in existing_callbacks: + if type(existing).__name__ == cb_type.__name__: + return + + existing_callbacks.append(callback) + model.trainer_params["callbacks"] = existing_callbacks + + +def autolog( + log_models: bool = True, + log_params: bool = True, + disable: bool = False, +) -> None: + """Enable (or disable) automatic MLflow logging for darts models. + + When enabled, every call to ``model.fit()`` on any darts forecasting model + will automatically: + + 1. Start an MLflow run (or reuse the currently active one). + 2. Log model creation parameters (``model.model_params``). + 3. For PyTorch-based models: inject a callback that logs per-epoch + ``train_loss`` / ``val_loss`` metrics. + 4. Log the trained model artifact at the end of training. + + Parameters + ---------- + log_models + If ``True`` (default), log the trained model artifact after ``fit()``. + log_params + If ``True`` (default), log model creation parameters. + disable + If ``True``, restore the original ``fit()`` methods and stop + autologging. + + Examples + -------- + .. code-block:: python + + from darts.utils.mlflow import autolog + from darts.models import ExponentialSmoothing + from darts.datasets import AirPassengersDataset + + autolog() # enable + + series = AirPassengersDataset().load() + model = ExponentialSmoothing() + model.fit(series) # automatically logged to MLflow + + autolog(disable=True) # disable + """ + if disable: + _restore_original_fit_methods() + return + + _patch_fit(ForecastingModel, log_models=log_models, log_params=log_params) + + try: + from darts.models.forecasting.torch_forecasting_model import ( + TorchForecastingModel, + ) + + _patch_fit( + TorchForecastingModel, + log_models=log_models, + log_params=log_params, + inject_callback=True, + ) + except ImportError: + pass + + +def _patch_fit( + cls, + *, + log_models: bool, + log_params: bool, + inject_callback: bool = False, +) -> None: + """Replace a model class's ``fit`` method with an MLflow logging wrapper. + + Parameters + ---------- + cls : type + The model class to patch (e.g., ForecastingModel, TorchForecastingModel). + log_models : bool + Whether to log the trained model artifact after fitting. + log_params : bool + Whether to log model creation parameters. + inject_callback : bool, optional + Whether to inject the MLflow callback for PyTorch Lightning models. + Default is False. + """ + if cls in _ORIGINAL_FIT_METHODS: + return + + original_fit = cls.fit + _ORIGINAL_FIT_METHODS[cls] = original_fit + + @wraps(original_fit) + def _patched_fit(self, *args, **kwargs): + run_started_here = False + if mlflow.active_run() is None: + mlflow.start_run() + run_started_here = True + + try: + mlflow.set_tag("darts.model_class", type(self).__name__) + + if log_params: + _log_model_params(self) + + if inject_callback: + _inject_mlflow_callback(self) + + result = original_fit(self, *args, **kwargs) + + if log_models: + try: + log_model(self, name="model", log_params=False) + except Exception as e: + logger.warning(f"Failed to autolog model artifact: {e}") + + return result + + except Exception: + raise + finally: + if run_started_here: + mlflow.end_run() + + cls.fit = _patched_fit + + +def _restore_original_fit_methods() -> None: + """Restore all patched ``fit()`` methods to their original implementations. + + This function is called when ``autolog(disable=True)`` is invoked to remove + all MLflow logging functionality added by autologging. + """ + for cls, original_fit in _ORIGINAL_FIT_METHODS.items(): + cls.fit = original_fit + _ORIGINAL_FIT_METHODS.clear() diff --git a/darts/utils/utils.py b/darts/utils/utils.py index 5e559cc9da..49749dbad0 100644 --- a/darts/utils/utils.py +++ b/darts/utils/utils.py @@ -37,6 +37,13 @@ except ImportError: TORCH_AVAILABLE = False +try: + import pytorch_lightning as pl # noqa: F401 + + PL_AVAILABLE = True +except ImportError: + PL_AVAILABLE = False + logger = get_logger(__name__) MAX_TORCH_SEED_VALUE = (1 << 31) - 1 # to accommodate 32-bit architectures diff --git a/pyproject.toml b/pyproject.toml index b232c33668..c09ad39edc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -70,6 +70,7 @@ notorch = [ "statsforecast>=1.4", "xgboost>=2.1.4", ] +mlflow = ["mlflow>=2.0"] all = ["darts[torch,notorch]"] [tool.uv.sources] From dc48b97a8d4c5bb79dcad0080bdcb4505808b9af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 12 Feb 2026 11:46:30 +0100 Subject: [PATCH 002/154] covariate support --- darts/utils/mlflow.py | 78 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index c15846fc91..e20b15ebe3 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -8,6 +8,7 @@ """ import importlib +import json import os import sys import tempfile @@ -379,6 +380,7 @@ def log_model( if log_params: _log_model_params(model) + _log_covariate_info(model) with tempfile.TemporaryDirectory() as tmp_dir: model_dir = os.path.join(tmp_dir, artifact_name) @@ -438,6 +440,79 @@ def _log_model_params(model) -> None: mlflow.log_params(safe_params) +def _log_covariate_info(model) -> None: + """Log covariate usage information to MLflow. + + Extracts information about past, future, and static covariates used during + training and logs them as tags, parameters, and a JSON artifact for easy + filtering, comparison, and documentation. + + Logs three types of information: + - Tags: Boolean flags for filtering (e.g., "uses_past_covariates") + - Parameters: Feature counts and names (truncated to 500 chars) + - Artifact: Complete covariate metadata as JSON file + + Parameters + ---------- + model + A fitted Darts forecasting model instance. + """ + covariate_types = [ + ( + "past_covariates", + "_uses_past_covariates", + "past_covariate_series", + "components", + ), + ( + "future_covariates", + "_uses_future_covariates", + "future_covariate_series", + "components", + ), + ( + "static_covariates", + "_uses_static_covariates", + "static_covariates", + "columns", + ), + ] + + covariate_info = {} + + for cov_key, uses_attr, series_attr, names_attr in covariate_types: + info = {"used": False, "count": 0, "names": []} + + if getattr(model, uses_attr, False): + info["used"] = True + series = getattr(model, series_attr, None) + if series is not None: + names = getattr(series, names_attr).tolist() + info["names"] = names + info["count"] = len(names) + + covariate_info[cov_key] = info + + mlflow.set_tag(f"uses_{cov_key}", str(info["used"]).lower()) + mlflow.log_param(f"n_{cov_key}", info["count"]) + + if info["names"]: + names_str = ",".join(info["names"]) + if len(names_str) > 500: + names_str = names_str[:497] + "..." + mlflow.log_param(f"{cov_key.split('_')[0]}_cov_names", names_str) + + # log complete information as JSON artifact + with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f: + json.dump(covariate_info, f, indent=2) + temp_path = f.name + + try: + mlflow.log_artifact(temp_path, "covariates.json") + finally: + os.remove(temp_path) + + # --------------------------------------------------------------------------- # PyFunc interface # --------------------------------------------------------------------------- @@ -776,6 +851,9 @@ def _patched_fit(self, *args, **kwargs): result = original_fit(self, *args, **kwargs) + if log_params: + _log_covariate_info(self) + if log_models: try: log_model(self, name="model", log_params=False) From 0cc488e9989f8eecaadc10e16c2d9820ba568dfb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 12 Feb 2026 11:47:14 +0100 Subject: [PATCH 003/154] pyfunc series info extension --- darts/utils/mlflow.py | 219 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 194 insertions(+), 25 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index e20b15ebe3..6cdeb880e5 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -19,9 +19,11 @@ import pandas as pd import yaml from mlflow.models import Model +from mlflow.models import infer_signature as mlflow_infer_signature from mlflow.tracking.artifact_utils import _download_artifact_from_uri import darts +from darts import TimeSeries from darts.logging import get_logger from darts.models.forecasting.forecasting_model import ForecastingModel from darts.utils.utils import PL_AVAILABLE @@ -192,8 +194,10 @@ def save_model( when provided. signature An ``mlflow.models.ModelSignature`` instance describing model input/output. + Use :func:`infer_signature` to automatically generate from example inputs. input_example - An example input for the model (used by MLflow UI). + An example input for the model (used by MLflow UI). Should be a DataFrame + created with :func:`prepare_pyfunc_input`. metadata Optional dictionary of custom metadata to store in the ``MLmodel`` file. """ @@ -361,9 +365,11 @@ def log_model( pip_requirements Pip requirements list. signature - An ``mlflow.models.ModelSignature``. + An ``mlflow.models.ModelSignature``. Use :func:`infer_signature` + to automatically generate from example inputs. input_example - An example model input. + An example model input. Should be a DataFrame created with + :func:`prepare_pyfunc_input`. metadata Optional dict of custom metadata. log_params @@ -518,19 +524,151 @@ def _log_covariate_info(model) -> None: # --------------------------------------------------------------------------- -class _DartsModelWrapper: - """A pyfunc-compatible wrapper around a darts ``ForecastingModel``. +def _serialize_timeseries_for_pyfunc( + ts: Union["TimeSeries", list["TimeSeries"]], +) -> str: + """Serialize TimeSeries to JSON string for pyfunc. + + Parameters + ---------- + ts : Union[TimeSeries, list[TimeSeries]] + Single TimeSeries or list of TimeSeries objects. + + Returns + ------- + str + JSON string representation. For a single TimeSeries, returns a JSON object. + For a list, returns a JSON array. + """ + if isinstance(ts, TimeSeries): + return ts.to_json() + elif isinstance(ts, (list, tuple)): + serialized = [t.to_json() for t in ts] + return "[" + ",".join(serialized) + "]" + else: + raise TypeError(f"Expected TimeSeries or list of TimeSeries, got {type(ts)}") + + +def _deserialize_timeseries_from_pyfunc( + json_str: str, +) -> Union["TimeSeries", list["TimeSeries"]]: + """Deserialize TimeSeries from JSON string. + + Parameters + ---------- + json_str : str + JSON string representation (single object or array). - MLflow's generic pyfunc inference API requires a ``predict(model_input)`` - method that accepts a ``pandas.DataFrame``. This wrapper translates that - call into a darts ``model.predict(n=...)`` call and returns the forecast - as a ``pandas.DataFrame``. + Returns + ------- + Union[TimeSeries, list[TimeSeries]] + Single TimeSeries or list of TimeSeries objects. + """ + json_str = json_str.strip() + if json_str.startswith("["): + array_data = json.loads(json_str) + return [TimeSeries.from_json(json.dumps(item)) for item in array_data] + else: + return TimeSeries.from_json(json_str) - The forecast horizon ``n`` is determined from (in order of precedence): - 1. A key ``"n"`` in the ``params`` dict, or - 2. A column named ``"n"`` in ``model_input`` (first value is used), or - 3. A default of ``1``. +def prepare_pyfunc_input( + n: int, + series: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, + past_covariates: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, + future_covariates: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, + num_samples: int = 1, +) -> pd.DataFrame: + """Prepare input DataFrame for MLflow pyfunc prediction. + + Creates a DataFrame for use with models loaded via ``mlflow.pyfunc.load_model()``. + Serializes TimeSeries to JSON in special columns. + + Parameters + ---------- + n : int + Forecast horizon. + series : Optional[Union[TimeSeries, list[TimeSeries]]] + Target series for prediction (required for global models on new data). + past_covariates : Optional[Union[TimeSeries, list[TimeSeries]]] + Past covariates. + future_covariates : Optional[Union[TimeSeries, list[TimeSeries]]] + Future covariates. + num_samples : int + Number of samples for probabilistic models. + + Returns + ------- + pd.DataFrame + Input DataFrame for pyfunc ``predict()`` method. + """ + data = {"n": [n], "num_samples": [num_samples]} + + if series is not None: + data["_darts_series"] = [_serialize_timeseries_for_pyfunc(series)] + + if past_covariates is not None: + data["_darts_past_covariates"] = [ + _serialize_timeseries_for_pyfunc(past_covariates) + ] + + if future_covariates is not None: + data["_darts_future_covariates"] = [ + _serialize_timeseries_for_pyfunc(future_covariates) + ] + + return pd.DataFrame(data) + + +def infer_signature( + model, + series: Optional["TimeSeries"] = None, + past_covariates: Optional["TimeSeries"] = None, + future_covariates: Optional["TimeSeries"] = None, + n: int = 1, +) -> "mlflow.models.ModelSignature": + """Infer MLflow ModelSignature from a darts model and example inputs. + + Generates a signature describing input/output schemas for the pyfunc interface. + The ``_darts_series`` and covariate columns are marked as optional. + + Parameters + ---------- + model + A fitted darts ``ForecastingModel`` instance. + series : Optional[TimeSeries] + Example target series for signature inference. + past_covariates : Optional[TimeSeries] + Example past covariates. + future_covariates : Optional[TimeSeries] + Example future covariates. + n : int + Forecast horizon for generating example output. + + Returns + ------- + mlflow.models.ModelSignature + Signature describing the model's input/output interface. + """ + input_example = prepare_pyfunc_input( + n=n, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + num_samples=1, + ) + + wrapper = _DartsModelWrapper(model) + output_example = wrapper.predict(input_example) + + return mlflow_infer_signature(input_example, output_example) + + +class _DartsModelWrapper: + """A pyfunc-compatible wrapper around a darts ``ForecastingModel``. + + Deserializes TimeSeries from JSON-encoded columns and calls the model's + ``predict()`` method. Input should be created using :func:`prepare_pyfunc_input`. Parameters ---------- @@ -551,23 +689,23 @@ def predict( model_input: pd.DataFrame, params: Optional[dict[str, Any]] = None, ) -> pd.DataFrame: - """Generate forecasts. + """Generate forecasts from pyfunc input. + + Input should be created using :func:`prepare_pyfunc_input`. Deserializes + TimeSeries from JSON columns and passes to model.predict(). Parameters ---------- - model_input - A ``pandas.DataFrame``. If it contains a column ``"n"``, the first - value is used as the forecast horizon. Additional columns - (``"num_samples"``) are forwarded if present. - params - Optional dict; ``params["n"]`` overrides the horizon from the - DataFrame. + model_input : pd.DataFrame + Input DataFrame with columns: ``n``, ``num_samples``, and optionally + ``_darts_series``, ``_darts_past_covariates``, ``_darts_future_covariates``. + params : Optional[dict[str, Any]] + Override parameters (e.g., ``{"n": 20}``). Returns ------- pd.DataFrame - Forecasted values with a ``DatetimeIndex`` (or ``RangeIndex``) - and one column per component of the target series. + Forecasted values. For multiple series, includes a ``series_id`` column. """ n = 1 if params and "n" in params: @@ -581,8 +719,39 @@ def predict( elif "num_samples" in model_input.columns: num_samples = int(model_input["num_samples"].iloc[0]) - prediction = self.model.predict(n=n, num_samples=num_samples) - return prediction.to_dataframe() + predict_kwargs = {"n": n, "num_samples": num_samples} + + if "_darts_series" in model_input.columns: + series_json = model_input["_darts_series"].iloc[0] + if pd.notna(series_json) and series_json: + series = _deserialize_timeseries_from_pyfunc(series_json) + predict_kwargs["series"] = series + + if "_darts_past_covariates" in model_input.columns: + past_cov_json = model_input["_darts_past_covariates"].iloc[0] + if pd.notna(past_cov_json) and past_cov_json: + predict_kwargs["past_covariates"] = _deserialize_timeseries_from_pyfunc( + past_cov_json + ) + + if "_darts_future_covariates" in model_input.columns: + future_cov_json = model_input["_darts_future_covariates"].iloc[0] + if pd.notna(future_cov_json) and future_cov_json: + predict_kwargs["future_covariates"] = ( + _deserialize_timeseries_from_pyfunc(future_cov_json) + ) + + prediction = self.model.predict(**predict_kwargs) + + if isinstance(prediction, TimeSeries): + return prediction.to_dataframe() + else: + dfs = [] + for i, pred in enumerate(prediction): + df = pred.to_dataframe() + df["series_id"] = i + dfs.append(df) + return pd.concat(dfs, axis=0) def _load_pyfunc(path: str): From b6ce5381e194e5ec527089af8df898fb772aa11f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 12 Feb 2026 13:52:54 +0100 Subject: [PATCH 004/154] unit tests --- darts/tests/optional_deps/test_mlflow.py | 607 +++++++++++++++++++++++ 1 file changed, 607 insertions(+) create mode 100644 darts/tests/optional_deps/test_mlflow.py diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py new file mode 100644 index 0000000000..05af8f7b88 --- /dev/null +++ b/darts/tests/optional_deps/test_mlflow.py @@ -0,0 +1,607 @@ +import os + +import numpy as np +import pandas as pd +import pytest + +import darts.utils.timeseries_generation as tg +from darts import TimeSeries +from darts.tests.conftest import MLFLOW_AVAILABLE, TORCH_AVAILABLE, tfm_kwargs_dev +from darts.utils.mlflow import _DartsModelWrapper + +if not MLFLOW_AVAILABLE: + pytest.skip( + f"MLflow not available. {__name__} tests will be skipped.", + allow_module_level=True, + ) + +import mlflow + +from darts.models import ExponentialSmoothing, LinearRegressionModel +from darts.utils.mlflow import ( + _deserialize_timeseries_from_pyfunc, + _serialize_timeseries_for_pyfunc, + autolog, + infer_signature, + load_model, + log_model, + prepare_pyfunc_input, + save_model, +) + +if TORCH_AVAILABLE: + from darts.models import NBEATSModel + + +class TestMLflow: + ts_univariate = tg.linear_timeseries( + start_value=10, end_value=50, length=50 + ).astype("float32") + ts_multivariate = ts_univariate.stack(ts_univariate * 1.5) + ts_with_static = ts_univariate.with_static_covariates( + pd.DataFrame({"static_feat": [1.0]}) + ) + ts_past_cov = tg.sine_timeseries(length=62).astype("float32") + ts_future_cov = tg.constant_timeseries(value=1.0, length=62).astype("float32") + + def test_serialize_deserialize_single(self): + """Test serialization of single TimeSeries""" + json_str = _serialize_timeseries_for_pyfunc(self.ts_univariate) + assert isinstance(json_str, str) + assert json_str.startswith("{") + + ts_restored = _deserialize_timeseries_from_pyfunc(json_str) + assert isinstance(ts_restored, TimeSeries) + np.testing.assert_array_almost_equal( + self.ts_univariate.values(), ts_restored.values(), decimal=6 + ) + + def test_serialize_deserialize_list(self): + """Test serialization of list of TimeSeries""" + ts_list = [self.ts_univariate, self.ts_univariate * 2] + + json_str = _serialize_timeseries_for_pyfunc(ts_list) + assert isinstance(json_str, str) + assert json_str.startswith("[") + + ts_list_restored = _deserialize_timeseries_from_pyfunc(json_str) + assert isinstance(ts_list_restored, list) + assert len(ts_list_restored) == 2 + np.testing.assert_array_almost_equal( + ts_list[0].values(), ts_list_restored[0].values(), decimal=6 + ) + + def test_serialize_with_static_covariates(self): + """Test that static covariates are preserved through serialization""" + json_str = _serialize_timeseries_for_pyfunc(self.ts_with_static) + ts_restored = _deserialize_timeseries_from_pyfunc(json_str) + + assert ts_restored.static_covariates is not None + pd.testing.assert_frame_equal( + self.ts_with_static.static_covariates, + ts_restored.static_covariates, + check_dtype=False, + ) + + def test_serialize_multivariate(self): + """Test serialization of multivariate TimeSeries""" + json_str = _serialize_timeseries_for_pyfunc(self.ts_multivariate) + ts_restored = _deserialize_timeseries_from_pyfunc(json_str) + + assert ts_restored.n_components == 2 + np.testing.assert_array_almost_equal( + self.ts_multivariate.values(), ts_restored.values(), decimal=6 + ) + + def test_prepare_input_simple(self): + """Test prepare_pyfunc_input with only n parameter""" + input_df = prepare_pyfunc_input(n=10) + + assert isinstance(input_df, pd.DataFrame) + assert list(input_df.columns) == ["n", "num_samples"] + assert input_df["n"].iloc[0] == 10 + assert input_df["num_samples"].iloc[0] == 1 + + def test_prepare_input_with_series(self): + """Test prepare_pyfunc_input with series parameter""" + input_df = prepare_pyfunc_input(n=10, series=self.ts_univariate) + + assert "_darts_series" in input_df.columns + json_str = input_df["_darts_series"].iloc[0] + assert json_str.startswith("{") + + ts_restored = _deserialize_timeseries_from_pyfunc(json_str) + np.testing.assert_array_almost_equal( + self.ts_univariate.values(), ts_restored.values(), decimal=6 + ) + + def test_prepare_input_with_covariates(self): + """Test prepare_pyfunc_input with all covariate types""" + input_df = prepare_pyfunc_input( + n=10, + series=self.ts_univariate, + past_covariates=self.ts_past_cov, + future_covariates=self.ts_future_cov, + ) + + assert "_darts_series" in input_df.columns + assert "_darts_past_covariates" in input_df.columns + assert "_darts_future_covariates" in input_df.columns + + ts_restored = _deserialize_timeseries_from_pyfunc( + input_df["_darts_series"].iloc[0] + ) + past_cov_restored = _deserialize_timeseries_from_pyfunc( + input_df["_darts_past_covariates"].iloc[0] + ) + future_cov_restored = _deserialize_timeseries_from_pyfunc( + input_df["_darts_future_covariates"].iloc[0] + ) + + np.testing.assert_array_almost_equal( + self.ts_univariate.values(), ts_restored.values(), decimal=6 + ) + np.testing.assert_array_almost_equal( + self.ts_past_cov.values(), past_cov_restored.values(), decimal=6 + ) + np.testing.assert_array_almost_equal( + self.ts_future_cov.values(), future_cov_restored.values(), decimal=6 + ) + + def test_prepare_input_list_series(self): + """Test prepare_pyfunc_input with list of series""" + series_list = [self.ts_univariate, self.ts_univariate * 2] + input_df = prepare_pyfunc_input(n=5, series=series_list) + + assert "_darts_series" in input_df.columns + json_str = input_df["_darts_series"].iloc[0] + assert json_str.startswith("[") + + ts_list_restored = _deserialize_timeseries_from_pyfunc(json_str) + assert isinstance(ts_list_restored, list) + assert len(ts_list_restored) == 2 + np.testing.assert_array_almost_equal( + series_list[0].values(), ts_list_restored[0].values(), decimal=6 + ) + np.testing.assert_array_almost_equal( + series_list[1].values(), ts_list_restored[1].values(), decimal=6 + ) + + def test_wrapper_simple_prediction(self): + """Test PyFunc wrapper with simple statistical model""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + wrapper = _DartsModelWrapper(model) + input_df = prepare_pyfunc_input(n=12) + output_df = wrapper.predict(input_df) + + # Compare with direct model prediction + expected_df = model.predict(n=12).to_dataframe() + + assert isinstance(output_df, pd.DataFrame) + assert len(output_df) == 12 + assert list(output_df.columns) == list(expected_df.columns) + np.testing.assert_array_almost_equal( + output_df.values, expected_df.values, decimal=4 + ) + + def test_wrapper_with_series(self): + """Test PyFunc wrapper with global model and series parameter""" + train, test = self.ts_univariate.split_before(0.7) + + model = LinearRegressionModel(lags=5) + model.fit(train) + + wrapper = _DartsModelWrapper(model) + input_df = prepare_pyfunc_input(n=5, series=test) + output_df = wrapper.predict(input_df) + + # Compare with direct model prediction + expected_df = model.predict(n=5, series=test).to_dataframe() + + assert len(output_df) == 5 + assert list(output_df.columns) == list(expected_df.columns) + np.testing.assert_array_almost_equal( + output_df.values, expected_df.values, decimal=4 + ) + + def test_wrapper_params_override(self): + """Test that params dict overrides DataFrame values""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + wrapper = _DartsModelWrapper(model) + input_df = prepare_pyfunc_input(n=5) + + output_df = wrapper.predict(input_df, params={"n": 10}) + assert len(output_df) == 10 + + # Verify the override actually produced the right prediction (n=10, not n=5) + expected_df = model.predict(n=10).to_dataframe() + np.testing.assert_array_almost_equal( + output_df.values, expected_df.values, decimal=4 + ) + + def test_save_load_statistical_model(self, tmpdir_fn): + """Test save/load round-trip for statistical model""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + assert os.path.exists(os.path.join(model_path, "MLmodel")) + + loaded_model = load_model(f"file://{model_path}") + pred_original = model.predict(n=5) + pred_loaded = loaded_model.predict(n=5) + + np.testing.assert_array_almost_equal( + pred_original.values(), pred_loaded.values(), decimal=4 + ) + + def test_save_load_regression_model(self, tmpdir_fn): + """Test save/load round-trip for regression model""" + model = LinearRegressionModel(lags=5) + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + + loaded_model = load_model(f"file://{model_path}") + pred_original = model.predict(n=3) + pred_loaded = loaded_model.predict(n=3) + + np.testing.assert_array_almost_equal( + pred_original.values(), pred_loaded.values(), decimal=4 + ) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_save_load_torch_model(self, tmpdir_fn): + """Test save/load round-trip for torch model""" + model = NBEATSModel( + input_chunk_length=4, output_chunk_length=2, n_epochs=1, **tfm_kwargs_dev + ) + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + + loaded_model = load_model(f"file://{model_path}") + pred_original = model.predict(n=2) + pred_loaded = loaded_model.predict(n=2) + + np.testing.assert_array_almost_equal( + pred_original.values(), pred_loaded.values(), decimal=4 + ) + + def test_save_with_signature(self, tmpdir_fn): + """Test that signature is saved in MLmodel file""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + signature = infer_signature(model, n=5) + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path, signature=signature) + + mlmodel = mlflow.models.Model.load(os.path.join(model_path, "MLmodel")) + loaded_signature = mlmodel.signature + + assert loaded_signature is not None + assert loaded_signature.inputs is not None + assert loaded_signature.outputs is not None + + input_names = [spec.name for spec in loaded_signature.inputs.inputs] + assert input_names == ["n", "num_samples"] + + output_names = [spec.name for spec in loaded_signature.outputs.inputs] + expected_output_names = list(model.predict(n=5).to_dataframe().columns) + assert output_names == expected_output_names + + def test_log_model_basic(self, tmpdir_fn): + """Test basic log_model functionality""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + with mlflow.start_run(): + log_info = log_model(model, name="model") + + loaded_model = load_model(log_info.model_uri) + pred_loaded = loaded_model.predict(n=5) + pred_original = model.predict(n=5) + + assert len(pred_loaded) == 5 + np.testing.assert_array_almost_equal( + pred_original.values(), pred_loaded.values(), decimal=4 + ) + + def test_log_model_with_params(self, tmpdir_fn): + """Test that log_params=True logs model parameters""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) + + with mlflow.start_run(): + log_model(model, name="model", log_params=True) + run_id = mlflow.active_run().info.run_id + + run = mlflow.get_run(run_id) + assert run.data.params["lags"] == "5" + assert run.data.params["lags_past_covariates"] == "3" + assert run.data.params["n_past_covariates"] == "1" + assert run.data.params["n_future_covariates"] == "0" + assert run.data.params["n_static_covariates"] == "0" + + def test_log_model_with_covariates(self, tmpdir_fn): + """Test that covariate info is logged with correct values""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) + + with mlflow.start_run(): + log_model(model, name="model", log_params=True) + run_id = mlflow.active_run().info.run_id + + run = mlflow.get_run(run_id) + # Check covariate usage tags have the correct boolean values + assert run.data.tags["uses_past_covariates"] == "true" + assert run.data.tags["uses_future_covariates"] == "false" + assert run.data.tags["uses_static_covariates"] == "false" + # Check covariate count params + assert run.data.params["n_past_covariates"] == "1" + assert run.data.params["n_future_covariates"] == "0" + assert run.data.params["n_static_covariates"] == "0" + + def test_pyfunc_load_and_predict(self, tmpdir_fn): + """Test loading model as pyfunc and making predictions""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + with mlflow.start_run(): + log_info = log_model(model, name="model") + + pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) + input_df = prepare_pyfunc_input(n=10) + output_df = pyfunc_model.predict(input_df) + + # Compare with direct model prediction + expected_df = model.predict(n=10).to_dataframe() + + assert isinstance(output_df, pd.DataFrame) + assert len(output_df) == 10 + assert list(output_df.columns) == list(expected_df.columns) + np.testing.assert_array_almost_equal( + output_df.values, expected_df.values, decimal=4 + ) + + def test_pyfunc_with_covariates(self, tmpdir_fn): + """Test pyfunc with model that requires covariates""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + train = self.ts_univariate[:40] + past_cov_train = self.ts_past_cov[:52] + + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(train, past_covariates=past_cov_train) + + with mlflow.start_run(): + signature = infer_signature( + model, series=train, past_covariates=past_cov_train, n=5 + ) + log_info = log_model(model, name="model", signature=signature) + + pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) + test = self.ts_univariate[40:] + past_cov_test = self.ts_past_cov[40:] + + input_df = prepare_pyfunc_input(n=5, series=test, past_covariates=past_cov_test) + output_df = pyfunc_model.predict(input_df) + + # Compare with direct model prediction using same series/covariates + expected_df = model.predict( + n=5, series=test, past_covariates=past_cov_test + ).to_dataframe() + + assert len(output_df) == 5 + assert list(output_df.columns) == list(expected_df.columns) + np.testing.assert_array_almost_equal( + output_df.values, expected_df.values, decimal=4 + ) + + def test_infer_signature_simple(self): + """Test signature inference without series""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + signature = infer_signature(model, n=5) + + assert signature.inputs is not None + assert signature.outputs is not None + + input_cols = [spec.name for spec in signature.inputs.inputs] + assert input_cols == ["n", "num_samples"] + + output_cols = [spec.name for spec in signature.outputs.inputs] + expected_output_cols = list(model.predict(n=5).to_dataframe().columns) + assert output_cols == expected_output_cols + + def test_infer_signature_with_covariates(self): + """Test signature inference with covariates""" + train = self.ts_univariate[:40] + past_cov = self.ts_past_cov[:52] + + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(train, past_covariates=past_cov) + + signature = infer_signature(model, series=train, past_covariates=past_cov, n=5) + + input_cols = [spec.name for spec in signature.inputs.inputs] + assert "n" in input_cols + assert "num_samples" in input_cols + assert "_darts_series" in input_cols + assert "_darts_past_covariates" in input_cols + # future covariates were not provided, so should not appear + assert "_darts_future_covariates" not in input_cols + + output_cols = [spec.name for spec in signature.outputs.inputs] + expected_output_cols = list( + model.predict(n=5, series=train, past_covariates=past_cov) + .to_dataframe() + .columns + ) + assert output_cols == expected_output_cols + + def test_autolog_enable_disable(self, tmpdir_fn): + """Test autolog can be enabled and disabled""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + autolog() + + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + runs = mlflow.search_runs() + assert len(runs) == 1 + + # Verify the run has the expected model class tag + assert runs.iloc[0]["tags.darts.model_class"] == "ExponentialSmoothing" + + autolog(disable=True) + + model2 = ExponentialSmoothing() + model2.fit(self.ts_univariate) + + runs_after_disable = mlflow.search_runs() + assert len(runs_after_disable) == 1 + + def test_autolog_parameters(self, tmpdir_fn): + """Test that autolog logs model parameters""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + autolog() + + model = ExponentialSmoothing(seasonal_periods=12) + model.fit(self.ts_univariate) + + runs = mlflow.search_runs() + assert len(runs) == 1 + + last_run = runs.iloc[0] + assert last_run["params.seasonal_periods"] == "12" + assert last_run["tags.darts.model_class"] == "ExponentialSmoothing" + + autolog(disable=True) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_torch_metrics(self, tmpdir_fn): + """Test that autolog logs training metrics for torch models""" + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + autolog() + + model = NBEATSModel( + input_chunk_length=4, output_chunk_length=2, n_epochs=2, **tfm_kwargs_dev + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) + + runs = mlflow.search_runs() + assert len(runs) == 1 + last_run_id = runs.iloc[0]["run_id"] + assert runs.iloc[0]["tags.darts.model_class"] == "NBEATSModel" + + client = mlflow.tracking.MlflowClient() + metrics = client.get_metric_history(last_run_id, "train_loss") + + assert len(metrics) > 0 + # All logged loss values should be finite and non-negative + for m in metrics: + assert np.isfinite(m.value), f"train_loss is not finite: {m.value}" + assert m.value >= 0, f"train_loss is negative: {m.value}" + + autolog(disable=True) + + def test_load_nonexistent_model(self): + """Test that loading nonexistent model raises appropriate error""" + with pytest.raises(Exception): + load_model("runs:/fake_run_id/model") + + def test_serialize_invalid_type(self): + """Test that serializing invalid type raises error""" + with pytest.raises(TypeError): + _serialize_timeseries_for_pyfunc("not_a_timeseries") + + @pytest.mark.parametrize( + "model_cls,fit_kwargs", + [ + (ExponentialSmoothing, {}), + (LinearRegressionModel, {"lags": 5}), + ], + ) + def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): + """Test save/load for multiple model types""" + if fit_kwargs: + model = model_cls(**fit_kwargs) + else: + model = model_cls() + + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + loaded = load_model(f"file://{model_path}") + + pred1 = model.predict(n=5) + pred2 = loaded.predict(n=5) + np.testing.assert_array_almost_equal(pred1.values(), pred2.values(), decimal=4) + + @pytest.mark.parametrize("use_torch", [False, True]) + def test_pyfunc_multiple_models(self, tmpdir_fn, use_torch): + """Test pyfunc for statistical and torch models""" + if use_torch and not TORCH_AVAILABLE: + pytest.skip("torch not available") + + mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_experiment("test_experiment") + + if use_torch: + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=1, + **tfm_kwargs_dev, + ) + else: + model = ExponentialSmoothing() + + model.fit(self.ts_univariate) + + with mlflow.start_run(): + log_info = log_model(model, name="model") + + pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) + input_df = prepare_pyfunc_input(n=2) + output_df = pyfunc_model.predict(input_df) + + # Compare with direct model prediction + expected_df = model.predict(n=2).to_dataframe() + + assert len(output_df) == 2 + assert list(output_df.columns) == list(expected_df.columns) + np.testing.assert_array_almost_equal( + output_df.values, expected_df.values, decimal=4 + ) From 605ecbef1c1b227c571e06bbd70179986e9cd42d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 12 Feb 2026 13:53:18 +0100 Subject: [PATCH 005/154] add mlflow to dependencies --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index c09ad39edc..353969d4e5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -149,6 +149,7 @@ dev = [ ] torch-cpu = ["torch>=2.0.0"] optional = [ + "mlflow>=2.0", "onnx>=1.20.1", "onnxruntime>=1.24.1; python_version >= '3.11'", "onnxruntime<1.24.1; python_version < '3.11'", # 1.24.1 dropped python 3.10 support From 3c2a2e21b5bb1d7f4c172478ef911e7deda27ac9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 12 Feb 2026 15:02:44 +0100 Subject: [PATCH 006/154] changed to sqlite --- darts/tests/conftest.py | 8 ++++++++ darts/tests/optional_deps/test_mlflow.py | 18 +++++++++--------- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/darts/tests/conftest.py b/darts/tests/conftest.py index 181854b84d..2c15f35a11 100644 --- a/darts/tests/conftest.py +++ b/darts/tests/conftest.py @@ -95,6 +95,14 @@ logger.warning("Ray not installed - Some tests will be skipped.") RAY_AVAILABLE = False +try: + import mlflow # noqa: F401 + + MLFLOW_AVAILABLE = True +except ImportError: + logger.warning("MLflow not installed - Some tests will be skipped.") + MLFLOW_AVAILABLE = False + try: import polars # noqa: F401 diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 05af8f7b88..a7e2021035 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -300,7 +300,7 @@ def test_save_with_signature(self, tmpdir_fn): def test_log_model_basic(self, tmpdir_fn): """Test basic log_model functionality""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") model = ExponentialSmoothing() @@ -320,7 +320,7 @@ def test_log_model_basic(self, tmpdir_fn): def test_log_model_with_params(self, tmpdir_fn): """Test that log_params=True logs model parameters""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") model = LinearRegressionModel(lags=5, lags_past_covariates=3) @@ -339,7 +339,7 @@ def test_log_model_with_params(self, tmpdir_fn): def test_log_model_with_covariates(self, tmpdir_fn): """Test that covariate info is logged with correct values""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") model = LinearRegressionModel(lags=5, lags_past_covariates=3) @@ -361,7 +361,7 @@ def test_log_model_with_covariates(self, tmpdir_fn): def test_pyfunc_load_and_predict(self, tmpdir_fn): """Test loading model as pyfunc and making predictions""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") model = ExponentialSmoothing() @@ -386,7 +386,7 @@ def test_pyfunc_load_and_predict(self, tmpdir_fn): def test_pyfunc_with_covariates(self, tmpdir_fn): """Test pyfunc with model that requires covariates""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") train = self.ts_univariate[:40] @@ -464,7 +464,7 @@ def test_infer_signature_with_covariates(self): def test_autolog_enable_disable(self, tmpdir_fn): """Test autolog can be enabled and disabled""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") autolog() @@ -488,7 +488,7 @@ def test_autolog_enable_disable(self, tmpdir_fn): def test_autolog_parameters(self, tmpdir_fn): """Test that autolog logs model parameters""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") autolog() @@ -508,7 +508,7 @@ def test_autolog_parameters(self, tmpdir_fn): @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_metrics(self, tmpdir_fn): """Test that autolog logs training metrics for torch models""" - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") autolog() @@ -575,7 +575,7 @@ def test_pyfunc_multiple_models(self, tmpdir_fn, use_torch): if use_torch and not TORCH_AVAILABLE: pytest.skip("torch not available") - mlflow.set_tracking_uri(f"file://{tmpdir_fn}") + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") mlflow.set_experiment("test_experiment") if use_torch: From 1750b11db87220246d086e264f5abaee946f7861 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 12 Feb 2026 15:44:19 +0100 Subject: [PATCH 007/154] kwargs pyfunc extension --- darts/tests/optional_deps/test_mlflow.py | 122 +++++++++++++++++++++++ darts/utils/mlflow.py | 110 +++++++++++++++++++- 2 files changed, 228 insertions(+), 4 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index a7e2021035..405fffad8b 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -605,3 +605,125 @@ def test_pyfunc_multiple_models(self, tmpdir_fn, use_torch): np.testing.assert_array_almost_equal( output_df.values, expected_df.values, decimal=4 ) + + def test_prepare_input_with_all_params(self): + """Test prepare_pyfunc_input with all new parameters""" + input_df = prepare_pyfunc_input( + n=10, + series=self.ts_univariate, + past_covariates=self.ts_past_cov, + num_samples=5, + verbose=True, + show_warnings=False, + random_state=42, + predict_likelihood_parameters=True, + mc_dropout=True, + batch_size=32, + ) + + assert "n" in input_df.columns + assert "num_samples" in input_df.columns + assert "verbose" in input_df.columns + assert "show_warnings" in input_df.columns + assert "random_state" in input_df.columns + assert "predict_likelihood_parameters" in input_df.columns + assert "_darts_series" in input_df.columns + assert "_darts_past_covariates" in input_df.columns + assert "_darts_kwargs" in input_df.columns + + assert input_df["n"].iloc[0] == 10 + assert input_df["num_samples"].iloc[0] == 5 + assert bool(input_df["verbose"].iloc[0]) is True + assert bool(input_df["show_warnings"].iloc[0]) is False + assert input_df["random_state"].iloc[0] == 42 + assert bool(input_df["predict_likelihood_parameters"].iloc[0]) is True + + import json + + kwargs = json.loads(input_df["_darts_kwargs"].iloc[0]) + assert kwargs["mc_dropout"] is True # JSON bools are Python bools + assert kwargs["batch_size"] == 32 + + def test_wrapper_with_standard_params(self): + """Test wrapper with standard prediction parameters""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + wrapper = _DartsModelWrapper(model) + input_df = prepare_pyfunc_input( + n=5, + verbose=False, + show_warnings=False, + random_state=42, + ) + + # Should not raise an error even with extra params + output_df = wrapper.predict(input_df) + + assert isinstance(output_df, pd.DataFrame) + assert len(output_df) == 5 + + def test_wrapper_with_kwargs(self): + """Test wrapper with model-specific kwargs""" + model = LinearRegressionModel(lags=3) + model.fit(self.ts_univariate) + + wrapper = _DartsModelWrapper(model) + + # Add kwargs that don't affect LinearRegressionModel but shouldn't cause errors + input_df = prepare_pyfunc_input( + n=5, + series=self.ts_univariate, + verbose=False, + ) + + output_df = wrapper.predict(input_df) + + assert isinstance(output_df, pd.DataFrame) + assert len(output_df) == 5 + + def test_pyfunc_with_all_params(self, tmpdir_fn): + """Test end-to-end pyfunc with all parameters""" + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") + mlflow.set_experiment("test_experiment") + + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + with mlflow.start_run(): + signature = infer_signature( + model, + n=5, + verbose=False, + show_warnings=False, + random_state=42, + ) + log_info = log_model(model, name="model", signature=signature) + + pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) + + input_df = prepare_pyfunc_input( + n=5, + verbose=False, + show_warnings=False, + random_state=42, + ) + + output_df = pyfunc_model.predict(input_df) + + assert isinstance(output_df, pd.DataFrame) + assert len(output_df) == 5 + + def test_params_override_with_new_params(self): + """Test that params dict overrides DataFrame values for new parameters""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + wrapper = _DartsModelWrapper(model) + input_df = prepare_pyfunc_input(n=5, random_state=10) + + # Override random_state via params + output_df = wrapper.predict(input_df, params={"random_state": 42}) + + # Should complete without error (random_state was overridden) + assert len(output_df) == 5 diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 6cdeb880e5..c945947b60 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -578,6 +578,11 @@ def prepare_pyfunc_input( past_covariates: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, future_covariates: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, num_samples: int = 1, + verbose: Optional[bool] = None, + show_warnings: bool = True, + random_state: Optional[int] = None, + predict_likelihood_parameters: bool = False, + **kwargs: Any, ) -> pd.DataFrame: """Prepare input DataFrame for MLflow pyfunc prediction. @@ -596,13 +601,39 @@ def prepare_pyfunc_input( Future covariates. num_samples : int Number of samples for probabilistic models. + verbose : Optional[bool] + Optionally, set the prediction verbosity. Not effective for all models. + show_warnings : bool + Optionally, control whether warnings are shown. Not effective for all models. + random_state : Optional[int] + Controls the randomness of probabilistic predictions. + predict_likelihood_parameters : bool + If set to True, the model predicts the parameters of its likelihood instead of + the target. Only supported for probabilistic models with a likelihood. + **kwargs : Any + Additional model-specific parameters (e.g., ``mc_dropout`` for torch models, + ``batch_size``, etc.). These are serialized as JSON and passed to the model's + ``predict()`` method. Returns ------- pd.DataFrame Input DataFrame for pyfunc ``predict()`` method. """ - data = {"n": [n], "num_samples": [num_samples]} + data = { + "n": [n], + "num_samples": [num_samples], + } + + # Only add optional parameters if explicitly set (not defaults) + if verbose is not None: + data["verbose"] = [verbose] + if show_warnings is not True: # Only add if not default + data["show_warnings"] = [show_warnings] + if random_state is not None: + data["random_state"] = [random_state] + if predict_likelihood_parameters is not False: # Only add if not default + data["predict_likelihood_parameters"] = [predict_likelihood_parameters] if series is not None: data["_darts_series"] = [_serialize_timeseries_for_pyfunc(series)] @@ -617,6 +648,10 @@ def prepare_pyfunc_input( _serialize_timeseries_for_pyfunc(future_covariates) ] + # Serialize kwargs as JSON string for model-specific parameters + if kwargs: + data["_darts_kwargs"] = [json.dumps(kwargs)] + return pd.DataFrame(data) @@ -626,6 +661,12 @@ def infer_signature( past_covariates: Optional["TimeSeries"] = None, future_covariates: Optional["TimeSeries"] = None, n: int = 1, + num_samples: int = 1, + verbose: Optional[bool] = None, + show_warnings: bool = True, + random_state: Optional[int] = None, + predict_likelihood_parameters: bool = False, + **kwargs: Any, ) -> "mlflow.models.ModelSignature": """Infer MLflow ModelSignature from a darts model and example inputs. @@ -644,6 +685,18 @@ def infer_signature( Example future covariates. n : int Forecast horizon for generating example output. + num_samples : int + Number of samples for probabilistic models. + verbose : Optional[bool] + Optionally, set the prediction verbosity. + show_warnings : bool + Optionally, control whether warnings are shown. + random_state : Optional[int] + Controls the randomness of probabilistic predictions. + predict_likelihood_parameters : bool + If set to True, the model predicts the parameters of its likelihood. + **kwargs : Any + Additional model-specific parameters. Returns ------- @@ -655,7 +708,12 @@ def infer_signature( series=series, past_covariates=past_covariates, future_covariates=future_covariates, - num_samples=1, + num_samples=num_samples, + verbose=verbose, + show_warnings=show_warnings, + random_state=random_state, + predict_likelihood_parameters=predict_likelihood_parameters, + **kwargs, ) wrapper = _DartsModelWrapper(model) @@ -698,9 +756,11 @@ def predict( ---------- model_input : pd.DataFrame Input DataFrame with columns: ``n``, ``num_samples``, and optionally - ``_darts_series``, ``_darts_past_covariates``, ``_darts_future_covariates``. + ``_darts_series``, ``_darts_past_covariates``, ``_darts_future_covariates``, + ``verbose``, ``show_warnings``, ``random_state``, + ``predict_likelihood_parameters``, ``_darts_kwargs``. params : Optional[dict[str, Any]] - Override parameters (e.g., ``{"n": 20}``). + Override parameters (e.g., ``{"n": 20, "random_state": 42}``). Returns ------- @@ -721,6 +781,41 @@ def predict( predict_kwargs = {"n": n, "num_samples": num_samples} + # Extract standard prediction parameters (only if present in DataFrame/params) + optional_params = [ + "verbose", + "show_warnings", + "random_state", + "predict_likelihood_parameters", + ] + + for param_name in optional_params: + value = None + if params and param_name in params: + value = params[param_name] + elif param_name in model_input.columns: + value = model_input[param_name].iloc[0] + # Handle NaN/None + if pd.isna(value): + continue + else: + # Parameter not provided + continue + + # Convert to appropriate Python type + if param_name in [ + "verbose", + "show_warnings", + "predict_likelihood_parameters", + ]: + value = bool(value) + elif param_name == "random_state": + value = int(value) if value is not None else None + + # Only add if not None + if value is not None: + predict_kwargs[param_name] = value + if "_darts_series" in model_input.columns: series_json = model_input["_darts_series"].iloc[0] if pd.notna(series_json) and series_json: @@ -741,6 +836,13 @@ def predict( _deserialize_timeseries_from_pyfunc(future_cov_json) ) + # Handle model-specific kwargs + if "_darts_kwargs" in model_input.columns: + kwargs_json = model_input["_darts_kwargs"].iloc[0] + if pd.notna(kwargs_json) and kwargs_json: + extra_kwargs = json.loads(kwargs_json) + predict_kwargs.update(extra_kwargs) + prediction = self.model.predict(**predict_kwargs) if isinstance(prediction, TimeSeries): From 30456f508e9fac1617addb1d29b37688d75113c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Mon, 16 Feb 2026 10:44:52 +0100 Subject: [PATCH 008/154] removing pyfunc draft support: tbd if to include in future --- darts/tests/optional_deps/test_mlflow.py | 475 ----------------------- darts/utils/mlflow.py | 422 +------------------- 2 files changed, 1 insertion(+), 896 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 405fffad8b..ae5bee4432 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -5,9 +5,7 @@ import pytest import darts.utils.timeseries_generation as tg -from darts import TimeSeries from darts.tests.conftest import MLFLOW_AVAILABLE, TORCH_AVAILABLE, tfm_kwargs_dev -from darts.utils.mlflow import _DartsModelWrapper if not MLFLOW_AVAILABLE: pytest.skip( @@ -19,13 +17,9 @@ from darts.models import ExponentialSmoothing, LinearRegressionModel from darts.utils.mlflow import ( - _deserialize_timeseries_from_pyfunc, - _serialize_timeseries_for_pyfunc, autolog, - infer_signature, load_model, log_model, - prepare_pyfunc_input, save_model, ) @@ -44,185 +38,6 @@ class TestMLflow: ts_past_cov = tg.sine_timeseries(length=62).astype("float32") ts_future_cov = tg.constant_timeseries(value=1.0, length=62).astype("float32") - def test_serialize_deserialize_single(self): - """Test serialization of single TimeSeries""" - json_str = _serialize_timeseries_for_pyfunc(self.ts_univariate) - assert isinstance(json_str, str) - assert json_str.startswith("{") - - ts_restored = _deserialize_timeseries_from_pyfunc(json_str) - assert isinstance(ts_restored, TimeSeries) - np.testing.assert_array_almost_equal( - self.ts_univariate.values(), ts_restored.values(), decimal=6 - ) - - def test_serialize_deserialize_list(self): - """Test serialization of list of TimeSeries""" - ts_list = [self.ts_univariate, self.ts_univariate * 2] - - json_str = _serialize_timeseries_for_pyfunc(ts_list) - assert isinstance(json_str, str) - assert json_str.startswith("[") - - ts_list_restored = _deserialize_timeseries_from_pyfunc(json_str) - assert isinstance(ts_list_restored, list) - assert len(ts_list_restored) == 2 - np.testing.assert_array_almost_equal( - ts_list[0].values(), ts_list_restored[0].values(), decimal=6 - ) - - def test_serialize_with_static_covariates(self): - """Test that static covariates are preserved through serialization""" - json_str = _serialize_timeseries_for_pyfunc(self.ts_with_static) - ts_restored = _deserialize_timeseries_from_pyfunc(json_str) - - assert ts_restored.static_covariates is not None - pd.testing.assert_frame_equal( - self.ts_with_static.static_covariates, - ts_restored.static_covariates, - check_dtype=False, - ) - - def test_serialize_multivariate(self): - """Test serialization of multivariate TimeSeries""" - json_str = _serialize_timeseries_for_pyfunc(self.ts_multivariate) - ts_restored = _deserialize_timeseries_from_pyfunc(json_str) - - assert ts_restored.n_components == 2 - np.testing.assert_array_almost_equal( - self.ts_multivariate.values(), ts_restored.values(), decimal=6 - ) - - def test_prepare_input_simple(self): - """Test prepare_pyfunc_input with only n parameter""" - input_df = prepare_pyfunc_input(n=10) - - assert isinstance(input_df, pd.DataFrame) - assert list(input_df.columns) == ["n", "num_samples"] - assert input_df["n"].iloc[0] == 10 - assert input_df["num_samples"].iloc[0] == 1 - - def test_prepare_input_with_series(self): - """Test prepare_pyfunc_input with series parameter""" - input_df = prepare_pyfunc_input(n=10, series=self.ts_univariate) - - assert "_darts_series" in input_df.columns - json_str = input_df["_darts_series"].iloc[0] - assert json_str.startswith("{") - - ts_restored = _deserialize_timeseries_from_pyfunc(json_str) - np.testing.assert_array_almost_equal( - self.ts_univariate.values(), ts_restored.values(), decimal=6 - ) - - def test_prepare_input_with_covariates(self): - """Test prepare_pyfunc_input with all covariate types""" - input_df = prepare_pyfunc_input( - n=10, - series=self.ts_univariate, - past_covariates=self.ts_past_cov, - future_covariates=self.ts_future_cov, - ) - - assert "_darts_series" in input_df.columns - assert "_darts_past_covariates" in input_df.columns - assert "_darts_future_covariates" in input_df.columns - - ts_restored = _deserialize_timeseries_from_pyfunc( - input_df["_darts_series"].iloc[0] - ) - past_cov_restored = _deserialize_timeseries_from_pyfunc( - input_df["_darts_past_covariates"].iloc[0] - ) - future_cov_restored = _deserialize_timeseries_from_pyfunc( - input_df["_darts_future_covariates"].iloc[0] - ) - - np.testing.assert_array_almost_equal( - self.ts_univariate.values(), ts_restored.values(), decimal=6 - ) - np.testing.assert_array_almost_equal( - self.ts_past_cov.values(), past_cov_restored.values(), decimal=6 - ) - np.testing.assert_array_almost_equal( - self.ts_future_cov.values(), future_cov_restored.values(), decimal=6 - ) - - def test_prepare_input_list_series(self): - """Test prepare_pyfunc_input with list of series""" - series_list = [self.ts_univariate, self.ts_univariate * 2] - input_df = prepare_pyfunc_input(n=5, series=series_list) - - assert "_darts_series" in input_df.columns - json_str = input_df["_darts_series"].iloc[0] - assert json_str.startswith("[") - - ts_list_restored = _deserialize_timeseries_from_pyfunc(json_str) - assert isinstance(ts_list_restored, list) - assert len(ts_list_restored) == 2 - np.testing.assert_array_almost_equal( - series_list[0].values(), ts_list_restored[0].values(), decimal=6 - ) - np.testing.assert_array_almost_equal( - series_list[1].values(), ts_list_restored[1].values(), decimal=6 - ) - - def test_wrapper_simple_prediction(self): - """Test PyFunc wrapper with simple statistical model""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - wrapper = _DartsModelWrapper(model) - input_df = prepare_pyfunc_input(n=12) - output_df = wrapper.predict(input_df) - - # Compare with direct model prediction - expected_df = model.predict(n=12).to_dataframe() - - assert isinstance(output_df, pd.DataFrame) - assert len(output_df) == 12 - assert list(output_df.columns) == list(expected_df.columns) - np.testing.assert_array_almost_equal( - output_df.values, expected_df.values, decimal=4 - ) - - def test_wrapper_with_series(self): - """Test PyFunc wrapper with global model and series parameter""" - train, test = self.ts_univariate.split_before(0.7) - - model = LinearRegressionModel(lags=5) - model.fit(train) - - wrapper = _DartsModelWrapper(model) - input_df = prepare_pyfunc_input(n=5, series=test) - output_df = wrapper.predict(input_df) - - # Compare with direct model prediction - expected_df = model.predict(n=5, series=test).to_dataframe() - - assert len(output_df) == 5 - assert list(output_df.columns) == list(expected_df.columns) - np.testing.assert_array_almost_equal( - output_df.values, expected_df.values, decimal=4 - ) - - def test_wrapper_params_override(self): - """Test that params dict overrides DataFrame values""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - wrapper = _DartsModelWrapper(model) - input_df = prepare_pyfunc_input(n=5) - - output_df = wrapper.predict(input_df, params={"n": 10}) - assert len(output_df) == 10 - - # Verify the override actually produced the right prediction (n=10, not n=5) - expected_df = model.predict(n=10).to_dataframe() - np.testing.assert_array_almost_equal( - output_df.values, expected_df.values, decimal=4 - ) - def test_save_load_statistical_model(self, tmpdir_fn): """Test save/load round-trip for statistical model""" model = ExponentialSmoothing() @@ -275,29 +90,6 @@ def test_save_load_torch_model(self, tmpdir_fn): pred_original.values(), pred_loaded.values(), decimal=4 ) - def test_save_with_signature(self, tmpdir_fn): - """Test that signature is saved in MLmodel file""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - signature = infer_signature(model, n=5) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path, signature=signature) - - mlmodel = mlflow.models.Model.load(os.path.join(model_path, "MLmodel")) - loaded_signature = mlmodel.signature - - assert loaded_signature is not None - assert loaded_signature.inputs is not None - assert loaded_signature.outputs is not None - - input_names = [spec.name for spec in loaded_signature.inputs.inputs] - assert input_names == ["n", "num_samples"] - - output_names = [spec.name for spec in loaded_signature.outputs.inputs] - expected_output_names = list(model.predict(n=5).to_dataframe().columns) - assert output_names == expected_output_names - def test_log_model_basic(self, tmpdir_fn): """Test basic log_model functionality""" mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") @@ -359,109 +151,6 @@ def test_log_model_with_covariates(self, tmpdir_fn): assert run.data.params["n_future_covariates"] == "0" assert run.data.params["n_static_covariates"] == "0" - def test_pyfunc_load_and_predict(self, tmpdir_fn): - """Test loading model as pyfunc and making predictions""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - with mlflow.start_run(): - log_info = log_model(model, name="model") - - pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) - input_df = prepare_pyfunc_input(n=10) - output_df = pyfunc_model.predict(input_df) - - # Compare with direct model prediction - expected_df = model.predict(n=10).to_dataframe() - - assert isinstance(output_df, pd.DataFrame) - assert len(output_df) == 10 - assert list(output_df.columns) == list(expected_df.columns) - np.testing.assert_array_almost_equal( - output_df.values, expected_df.values, decimal=4 - ) - - def test_pyfunc_with_covariates(self, tmpdir_fn): - """Test pyfunc with model that requires covariates""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - - train = self.ts_univariate[:40] - past_cov_train = self.ts_past_cov[:52] - - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(train, past_covariates=past_cov_train) - - with mlflow.start_run(): - signature = infer_signature( - model, series=train, past_covariates=past_cov_train, n=5 - ) - log_info = log_model(model, name="model", signature=signature) - - pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) - test = self.ts_univariate[40:] - past_cov_test = self.ts_past_cov[40:] - - input_df = prepare_pyfunc_input(n=5, series=test, past_covariates=past_cov_test) - output_df = pyfunc_model.predict(input_df) - - # Compare with direct model prediction using same series/covariates - expected_df = model.predict( - n=5, series=test, past_covariates=past_cov_test - ).to_dataframe() - - assert len(output_df) == 5 - assert list(output_df.columns) == list(expected_df.columns) - np.testing.assert_array_almost_equal( - output_df.values, expected_df.values, decimal=4 - ) - - def test_infer_signature_simple(self): - """Test signature inference without series""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - signature = infer_signature(model, n=5) - - assert signature.inputs is not None - assert signature.outputs is not None - - input_cols = [spec.name for spec in signature.inputs.inputs] - assert input_cols == ["n", "num_samples"] - - output_cols = [spec.name for spec in signature.outputs.inputs] - expected_output_cols = list(model.predict(n=5).to_dataframe().columns) - assert output_cols == expected_output_cols - - def test_infer_signature_with_covariates(self): - """Test signature inference with covariates""" - train = self.ts_univariate[:40] - past_cov = self.ts_past_cov[:52] - - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(train, past_covariates=past_cov) - - signature = infer_signature(model, series=train, past_covariates=past_cov, n=5) - - input_cols = [spec.name for spec in signature.inputs.inputs] - assert "n" in input_cols - assert "num_samples" in input_cols - assert "_darts_series" in input_cols - assert "_darts_past_covariates" in input_cols - # future covariates were not provided, so should not appear - assert "_darts_future_covariates" not in input_cols - - output_cols = [spec.name for spec in signature.outputs.inputs] - expected_output_cols = list( - model.predict(n=5, series=train, past_covariates=past_cov) - .to_dataframe() - .columns - ) - assert output_cols == expected_output_cols - def test_autolog_enable_disable(self, tmpdir_fn): """Test autolog can be enabled and disabled""" mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") @@ -540,11 +229,6 @@ def test_load_nonexistent_model(self): with pytest.raises(Exception): load_model("runs:/fake_run_id/model") - def test_serialize_invalid_type(self): - """Test that serializing invalid type raises error""" - with pytest.raises(TypeError): - _serialize_timeseries_for_pyfunc("not_a_timeseries") - @pytest.mark.parametrize( "model_cls,fit_kwargs", [ @@ -568,162 +252,3 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): pred1 = model.predict(n=5) pred2 = loaded.predict(n=5) np.testing.assert_array_almost_equal(pred1.values(), pred2.values(), decimal=4) - - @pytest.mark.parametrize("use_torch", [False, True]) - def test_pyfunc_multiple_models(self, tmpdir_fn, use_torch): - """Test pyfunc for statistical and torch models""" - if use_torch and not TORCH_AVAILABLE: - pytest.skip("torch not available") - - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - - if use_torch: - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=1, - **tfm_kwargs_dev, - ) - else: - model = ExponentialSmoothing() - - model.fit(self.ts_univariate) - - with mlflow.start_run(): - log_info = log_model(model, name="model") - - pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) - input_df = prepare_pyfunc_input(n=2) - output_df = pyfunc_model.predict(input_df) - - # Compare with direct model prediction - expected_df = model.predict(n=2).to_dataframe() - - assert len(output_df) == 2 - assert list(output_df.columns) == list(expected_df.columns) - np.testing.assert_array_almost_equal( - output_df.values, expected_df.values, decimal=4 - ) - - def test_prepare_input_with_all_params(self): - """Test prepare_pyfunc_input with all new parameters""" - input_df = prepare_pyfunc_input( - n=10, - series=self.ts_univariate, - past_covariates=self.ts_past_cov, - num_samples=5, - verbose=True, - show_warnings=False, - random_state=42, - predict_likelihood_parameters=True, - mc_dropout=True, - batch_size=32, - ) - - assert "n" in input_df.columns - assert "num_samples" in input_df.columns - assert "verbose" in input_df.columns - assert "show_warnings" in input_df.columns - assert "random_state" in input_df.columns - assert "predict_likelihood_parameters" in input_df.columns - assert "_darts_series" in input_df.columns - assert "_darts_past_covariates" in input_df.columns - assert "_darts_kwargs" in input_df.columns - - assert input_df["n"].iloc[0] == 10 - assert input_df["num_samples"].iloc[0] == 5 - assert bool(input_df["verbose"].iloc[0]) is True - assert bool(input_df["show_warnings"].iloc[0]) is False - assert input_df["random_state"].iloc[0] == 42 - assert bool(input_df["predict_likelihood_parameters"].iloc[0]) is True - - import json - - kwargs = json.loads(input_df["_darts_kwargs"].iloc[0]) - assert kwargs["mc_dropout"] is True # JSON bools are Python bools - assert kwargs["batch_size"] == 32 - - def test_wrapper_with_standard_params(self): - """Test wrapper with standard prediction parameters""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - wrapper = _DartsModelWrapper(model) - input_df = prepare_pyfunc_input( - n=5, - verbose=False, - show_warnings=False, - random_state=42, - ) - - # Should not raise an error even with extra params - output_df = wrapper.predict(input_df) - - assert isinstance(output_df, pd.DataFrame) - assert len(output_df) == 5 - - def test_wrapper_with_kwargs(self): - """Test wrapper with model-specific kwargs""" - model = LinearRegressionModel(lags=3) - model.fit(self.ts_univariate) - - wrapper = _DartsModelWrapper(model) - - # Add kwargs that don't affect LinearRegressionModel but shouldn't cause errors - input_df = prepare_pyfunc_input( - n=5, - series=self.ts_univariate, - verbose=False, - ) - - output_df = wrapper.predict(input_df) - - assert isinstance(output_df, pd.DataFrame) - assert len(output_df) == 5 - - def test_pyfunc_with_all_params(self, tmpdir_fn): - """Test end-to-end pyfunc with all parameters""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - with mlflow.start_run(): - signature = infer_signature( - model, - n=5, - verbose=False, - show_warnings=False, - random_state=42, - ) - log_info = log_model(model, name="model", signature=signature) - - pyfunc_model = mlflow.pyfunc.load_model(log_info.model_uri) - - input_df = prepare_pyfunc_input( - n=5, - verbose=False, - show_warnings=False, - random_state=42, - ) - - output_df = pyfunc_model.predict(input_df) - - assert isinstance(output_df, pd.DataFrame) - assert len(output_df) == 5 - - def test_params_override_with_new_params(self): - """Test that params dict overrides DataFrame values for new parameters""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - wrapper = _DartsModelWrapper(model) - input_df = prepare_pyfunc_input(n=5, random_state=10) - - # Override random_state via params - output_df = wrapper.predict(input_df, params={"random_state": 42}) - - # Should complete without error (random_state was overridden) - assert len(output_df) == 5 diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index c945947b60..44d3dde1f0 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -4,7 +4,7 @@ Custom MLflow model flavor for darts forecasting models. Supports saving, loading, logging and autolog for any darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) -to MLflow, including a pyfunc wrapper for MLflow's generic inference API. +to MLflow. """ import importlib @@ -16,14 +16,11 @@ from typing import Any, Optional, Union import mlflow -import pandas as pd import yaml from mlflow.models import Model -from mlflow.models import infer_signature as mlflow_infer_signature from mlflow.tracking.artifact_utils import _download_artifact_from_uri import darts -from darts import TimeSeries from darts.logging import get_logger from darts.models.forecasting.forecasting_model import ForecastingModel from darts.utils.utils import PL_AVAILABLE @@ -256,16 +253,9 @@ def save_model( } with open(python_env_path, "w") as f: yaml.dump(python_env, f, default_flow_style=False) - pyfunc_conf = { - "loader_module": "darts.utils.mlflow", - "python_model": None, - "data": _MODEL_DATA_SUBFOLDER, - "env": {"conda": "conda.yaml", "virtualenv": "python_env.yaml"}, - } mlmodel = Model() mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) - mlmodel.add_flavor("python_function", **pyfunc_conf) if signature is not None: mlmodel.signature = signature @@ -519,400 +509,6 @@ def _log_covariate_info(model) -> None: os.remove(temp_path) -# --------------------------------------------------------------------------- -# PyFunc interface -# --------------------------------------------------------------------------- - - -def _serialize_timeseries_for_pyfunc( - ts: Union["TimeSeries", list["TimeSeries"]], -) -> str: - """Serialize TimeSeries to JSON string for pyfunc. - - Parameters - ---------- - ts : Union[TimeSeries, list[TimeSeries]] - Single TimeSeries or list of TimeSeries objects. - - Returns - ------- - str - JSON string representation. For a single TimeSeries, returns a JSON object. - For a list, returns a JSON array. - """ - if isinstance(ts, TimeSeries): - return ts.to_json() - elif isinstance(ts, (list, tuple)): - serialized = [t.to_json() for t in ts] - return "[" + ",".join(serialized) + "]" - else: - raise TypeError(f"Expected TimeSeries or list of TimeSeries, got {type(ts)}") - - -def _deserialize_timeseries_from_pyfunc( - json_str: str, -) -> Union["TimeSeries", list["TimeSeries"]]: - """Deserialize TimeSeries from JSON string. - - Parameters - ---------- - json_str : str - JSON string representation (single object or array). - - Returns - ------- - Union[TimeSeries, list[TimeSeries]] - Single TimeSeries or list of TimeSeries objects. - """ - json_str = json_str.strip() - if json_str.startswith("["): - array_data = json.loads(json_str) - return [TimeSeries.from_json(json.dumps(item)) for item in array_data] - else: - return TimeSeries.from_json(json_str) - - -def prepare_pyfunc_input( - n: int, - series: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, - past_covariates: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, - future_covariates: Optional[Union["TimeSeries", list["TimeSeries"]]] = None, - num_samples: int = 1, - verbose: Optional[bool] = None, - show_warnings: bool = True, - random_state: Optional[int] = None, - predict_likelihood_parameters: bool = False, - **kwargs: Any, -) -> pd.DataFrame: - """Prepare input DataFrame for MLflow pyfunc prediction. - - Creates a DataFrame for use with models loaded via ``mlflow.pyfunc.load_model()``. - Serializes TimeSeries to JSON in special columns. - - Parameters - ---------- - n : int - Forecast horizon. - series : Optional[Union[TimeSeries, list[TimeSeries]]] - Target series for prediction (required for global models on new data). - past_covariates : Optional[Union[TimeSeries, list[TimeSeries]]] - Past covariates. - future_covariates : Optional[Union[TimeSeries, list[TimeSeries]]] - Future covariates. - num_samples : int - Number of samples for probabilistic models. - verbose : Optional[bool] - Optionally, set the prediction verbosity. Not effective for all models. - show_warnings : bool - Optionally, control whether warnings are shown. Not effective for all models. - random_state : Optional[int] - Controls the randomness of probabilistic predictions. - predict_likelihood_parameters : bool - If set to True, the model predicts the parameters of its likelihood instead of - the target. Only supported for probabilistic models with a likelihood. - **kwargs : Any - Additional model-specific parameters (e.g., ``mc_dropout`` for torch models, - ``batch_size``, etc.). These are serialized as JSON and passed to the model's - ``predict()`` method. - - Returns - ------- - pd.DataFrame - Input DataFrame for pyfunc ``predict()`` method. - """ - data = { - "n": [n], - "num_samples": [num_samples], - } - - # Only add optional parameters if explicitly set (not defaults) - if verbose is not None: - data["verbose"] = [verbose] - if show_warnings is not True: # Only add if not default - data["show_warnings"] = [show_warnings] - if random_state is not None: - data["random_state"] = [random_state] - if predict_likelihood_parameters is not False: # Only add if not default - data["predict_likelihood_parameters"] = [predict_likelihood_parameters] - - if series is not None: - data["_darts_series"] = [_serialize_timeseries_for_pyfunc(series)] - - if past_covariates is not None: - data["_darts_past_covariates"] = [ - _serialize_timeseries_for_pyfunc(past_covariates) - ] - - if future_covariates is not None: - data["_darts_future_covariates"] = [ - _serialize_timeseries_for_pyfunc(future_covariates) - ] - - # Serialize kwargs as JSON string for model-specific parameters - if kwargs: - data["_darts_kwargs"] = [json.dumps(kwargs)] - - return pd.DataFrame(data) - - -def infer_signature( - model, - series: Optional["TimeSeries"] = None, - past_covariates: Optional["TimeSeries"] = None, - future_covariates: Optional["TimeSeries"] = None, - n: int = 1, - num_samples: int = 1, - verbose: Optional[bool] = None, - show_warnings: bool = True, - random_state: Optional[int] = None, - predict_likelihood_parameters: bool = False, - **kwargs: Any, -) -> "mlflow.models.ModelSignature": - """Infer MLflow ModelSignature from a darts model and example inputs. - - Generates a signature describing input/output schemas for the pyfunc interface. - The ``_darts_series`` and covariate columns are marked as optional. - - Parameters - ---------- - model - A fitted darts ``ForecastingModel`` instance. - series : Optional[TimeSeries] - Example target series for signature inference. - past_covariates : Optional[TimeSeries] - Example past covariates. - future_covariates : Optional[TimeSeries] - Example future covariates. - n : int - Forecast horizon for generating example output. - num_samples : int - Number of samples for probabilistic models. - verbose : Optional[bool] - Optionally, set the prediction verbosity. - show_warnings : bool - Optionally, control whether warnings are shown. - random_state : Optional[int] - Controls the randomness of probabilistic predictions. - predict_likelihood_parameters : bool - If set to True, the model predicts the parameters of its likelihood. - **kwargs : Any - Additional model-specific parameters. - - Returns - ------- - mlflow.models.ModelSignature - Signature describing the model's input/output interface. - """ - input_example = prepare_pyfunc_input( - n=n, - series=series, - past_covariates=past_covariates, - future_covariates=future_covariates, - num_samples=num_samples, - verbose=verbose, - show_warnings=show_warnings, - random_state=random_state, - predict_likelihood_parameters=predict_likelihood_parameters, - **kwargs, - ) - - wrapper = _DartsModelWrapper(model) - output_example = wrapper.predict(input_example) - - return mlflow_infer_signature(input_example, output_example) - - -class _DartsModelWrapper: - """A pyfunc-compatible wrapper around a darts ``ForecastingModel``. - - Deserializes TimeSeries from JSON-encoded columns and calls the model's - ``predict()`` method. Input should be created using :func:`prepare_pyfunc_input`. - - Parameters - ---------- - model : ForecastingModel - A fitted Darts forecasting model instance. - - Attributes - ---------- - model : ForecastingModel - The wrapped Darts forecasting model. - """ - - def __init__(self, model): - self.model = model - - def predict( - self, - model_input: pd.DataFrame, - params: Optional[dict[str, Any]] = None, - ) -> pd.DataFrame: - """Generate forecasts from pyfunc input. - - Input should be created using :func:`prepare_pyfunc_input`. Deserializes - TimeSeries from JSON columns and passes to model.predict(). - - Parameters - ---------- - model_input : pd.DataFrame - Input DataFrame with columns: ``n``, ``num_samples``, and optionally - ``_darts_series``, ``_darts_past_covariates``, ``_darts_future_covariates``, - ``verbose``, ``show_warnings``, ``random_state``, - ``predict_likelihood_parameters``, ``_darts_kwargs``. - params : Optional[dict[str, Any]] - Override parameters (e.g., ``{"n": 20, "random_state": 42}``). - - Returns - ------- - pd.DataFrame - Forecasted values. For multiple series, includes a ``series_id`` column. - """ - n = 1 - if params and "n" in params: - n = int(params["n"]) - elif "n" in model_input.columns: - n = int(model_input["n"].iloc[0]) - - num_samples = 1 - if params and "num_samples" in params: - num_samples = int(params["num_samples"]) - elif "num_samples" in model_input.columns: - num_samples = int(model_input["num_samples"].iloc[0]) - - predict_kwargs = {"n": n, "num_samples": num_samples} - - # Extract standard prediction parameters (only if present in DataFrame/params) - optional_params = [ - "verbose", - "show_warnings", - "random_state", - "predict_likelihood_parameters", - ] - - for param_name in optional_params: - value = None - if params and param_name in params: - value = params[param_name] - elif param_name in model_input.columns: - value = model_input[param_name].iloc[0] - # Handle NaN/None - if pd.isna(value): - continue - else: - # Parameter not provided - continue - - # Convert to appropriate Python type - if param_name in [ - "verbose", - "show_warnings", - "predict_likelihood_parameters", - ]: - value = bool(value) - elif param_name == "random_state": - value = int(value) if value is not None else None - - # Only add if not None - if value is not None: - predict_kwargs[param_name] = value - - if "_darts_series" in model_input.columns: - series_json = model_input["_darts_series"].iloc[0] - if pd.notna(series_json) and series_json: - series = _deserialize_timeseries_from_pyfunc(series_json) - predict_kwargs["series"] = series - - if "_darts_past_covariates" in model_input.columns: - past_cov_json = model_input["_darts_past_covariates"].iloc[0] - if pd.notna(past_cov_json) and past_cov_json: - predict_kwargs["past_covariates"] = _deserialize_timeseries_from_pyfunc( - past_cov_json - ) - - if "_darts_future_covariates" in model_input.columns: - future_cov_json = model_input["_darts_future_covariates"].iloc[0] - if pd.notna(future_cov_json) and future_cov_json: - predict_kwargs["future_covariates"] = ( - _deserialize_timeseries_from_pyfunc(future_cov_json) - ) - - # Handle model-specific kwargs - if "_darts_kwargs" in model_input.columns: - kwargs_json = model_input["_darts_kwargs"].iloc[0] - if pd.notna(kwargs_json) and kwargs_json: - extra_kwargs = json.loads(kwargs_json) - predict_kwargs.update(extra_kwargs) - - prediction = self.model.predict(**predict_kwargs) - - if isinstance(prediction, TimeSeries): - return prediction.to_dataframe() - else: - dfs = [] - for i, pred in enumerate(prediction): - df = pred.to_dataframe() - df["series_id"] = i - dfs.append(df) - return pd.concat(dfs, axis=0) - - -def _load_pyfunc(path: str): - """Load a darts model as a pyfunc-compatible wrapper. - - This function is called by ``mlflow.pyfunc.load_model()`` when loading a model - saved with the darts flavor. It reconstructs the original Darts model and wraps - it in a ``_DartsModelWrapper`` for MLflow's generic inference API. - - Parameters - ---------- - path : str - Path to the model directory containing the MLmodel file. - - Returns - ------- - _DartsModelWrapper - A wrapper with a ``predict()`` method compatible with MLflow's - pyfunc inference API. - - Raises - ------ - FileNotFoundError - If the MLmodel file cannot be found at the specified path. - """ - mlmodel_path = os.path.join(path, "..", "MLmodel") - if os.path.exists(mlmodel_path): - parent_path = os.path.dirname(os.path.abspath(mlmodel_path)) - else: - parent_path = path - - mlmodel_file = os.path.join(parent_path, "MLmodel") - if not os.path.exists(mlmodel_file): - raise FileNotFoundError( - f"Cannot find MLmodel file. Searched at: {mlmodel_file}" - ) - - with open(mlmodel_file) as f: - mlmodel_dict = yaml.safe_load(f) - - flavor_conf = mlmodel_dict["flavors"][FLAVOR_NAME] - module_path = flavor_conf["model_class_module"] - class_name = flavor_conf["model_class_name"] - model_file = flavor_conf["model_file"] - is_torch = flavor_conf.get("is_torch_model", False) - - model_cls = _import_model_class(module_path, class_name) - - data_dir = os.path.join(parent_path, flavor_conf.get("data", _MODEL_DATA_SUBFOLDER)) - model_path = os.path.join(data_dir, model_file) - - if is_torch: - loaded_model = model_cls.load(model_path) - else: - loaded_model = model_cls.load(model_path) - - return _DartsModelWrapper(loaded_model) - - # stores original (unpatched) `fit` methods so they can be restored. _ORIGINAL_FIT_METHODS: dict[type, Any] = {} @@ -1039,22 +635,6 @@ def autolog( disable If ``True``, restore the original ``fit()`` methods and stop autologging. - - Examples - -------- - .. code-block:: python - - from darts.utils.mlflow import autolog - from darts.models import ExponentialSmoothing - from darts.datasets import AirPassengersDataset - - autolog() # enable - - series = AirPassengersDataset().load() - model = ExponentialSmoothing() - model.fit(series) # automatically logged to MLflow - - autolog(disable=True) # disable """ if disable: _restore_original_fit_methods() From b69de4adc3268a02fc3d6bed12e7092d25e96198 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Mon, 16 Feb 2026 12:23:09 +0100 Subject: [PATCH 009/154] slight refactor by leveraging built-in mflflow validation util methods --- darts/utils/mlflow.py | 266 +++++++++++++++++++++++++++--------------- 1 file changed, 170 insertions(+), 96 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 44d3dde1f0..e0f25e78cd 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -10,7 +10,6 @@ import importlib import json import os -import sys import tempfile from functools import wraps from typing import Any, Optional, Union @@ -18,7 +17,28 @@ import mlflow import yaml from mlflow.models import Model +from mlflow.models.model import MLMODEL_FILE_NAME +from mlflow.models.utils import _save_example from mlflow.tracking.artifact_utils import _download_artifact_from_uri +from mlflow.utils.environment import ( + _CONDA_ENV_FILE_NAME, + _CONSTRAINTS_FILE_NAME, + _PYTHON_ENV_FILE_NAME, + _REQUIREMENTS_FILE_NAME, + _mlflow_conda_env, + _process_conda_env, + _process_pip_requirements, + _PythonEnv, + _validate_env_arguments, +) +from mlflow.utils.file_utils import TempDir, write_to +from mlflow.utils.model_utils import ( + _add_code_from_conf_to_system_path, + _get_flavor_configuration, + _validate_and_copy_code_paths, + _validate_and_prepare_target_save_path, +) +from mlflow.utils.requirements_utils import _get_pinned_requirement import darts from darts.logging import get_logger @@ -114,6 +134,86 @@ def _import_model_class(module_path: str, class_name: str): return getattr(module, class_name) +def _create_mlmodel_file( + path: str, + darts_flavor_conf: dict, + signature, + input_example, + metadata: Optional[dict], +) -> None: + """Create and save MLmodel file with metadata. + + Creates the following files in the model directory: + * ``MLmodel`` - MLmodel file with flavor metadata. + + Parameters + ---------- + path: str + Root directory of the MLflow model where the MLmodel file will be saved. + darts_flavor_conf: dict + Dictionary containing the flavor configuration for the darts model. + signature: mlflow.models.ModelSignature + An ``mlflow.models.ModelSignature`` instance describing model input/output. + Use :func:`infer_signature` to automatically generate from example inputs. + input_example: DataFrame + An example input for the model (used by MLflow UI). Should be a DataFrame + created with :func:`prepare_pyfunc_input`. + metadata: Optional[dict] + Optional dictionary of custom metadata to store in the ``MLmodel`` file. + """ + mlmodel = Model() + + if signature is not None: + mlmodel.signature = signature + + if input_example is not None: + _save_example(mlmodel, input_example, path) + + if metadata is not None: + mlmodel.metadata = metadata + + mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) + mlmodel.save(os.path.join(path, MLMODEL_FILE_NAME)) + + +def _write_environment_files( + path: str, + conda_env: dict, + pip_requirements: list[str], + pip_constraints: Optional[list[str]], +) -> None: + """Write Python environment specification files for model reproducibility. + + Creates the following files in the model directory: + + * ``conda.yaml`` - Conda environment specification including Python version and pip dependencies + * ``requirements.txt`` - Pip requirements list for non-conda environments + * ``python_env.yaml`` - MLflow Python environment specification + * ``constraints.txt`` (optional) - Pip version constraints if specified + + Parameters + ---------- + path: str + Root directory of the MLflow model where environment files will be written. + conda_env: dict + Processed conda environment dictionary containing 'name', 'channels', + 'dependencies' keys. + pip_requirements: list[str] + List of pip requirement strings (e.g., ['numpy>=1.20.0', 'pandas']). + pip_constraints: Optional[list[str]] + Optional list of pip constraint strings for pinning transitive dependencies. + Only written if provided. + """ + with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: + yaml.safe_dump(conda_env, stream=f, default_flow_style=False) + + if pip_constraints: + write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) + + write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) + _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) + + def get_default_pip_requirements(is_torch: bool = False) -> list[str]: """Return the default pip requirements for logging a darts model. @@ -128,9 +228,12 @@ def get_default_pip_requirements(is_torch: bool = False) -> list[str]: list[str] A list of pip requirement strings. """ - reqs = [f"darts=={darts.__version__}"] + reqs = [_get_pinned_requirement("darts")] if is_torch: - reqs.extend(["torch>=2.0.0", "pytorch-lightning>=2.0.0"]) + reqs.extend([ + _get_pinned_requirement("torch"), + _get_pinned_requirement("pytorch-lightning"), + ]) return reqs @@ -147,24 +250,19 @@ def get_default_conda_env(is_torch: bool = False) -> dict: dict A conda environment specification dictionary. """ - return { - "channels": ["defaults", "conda-forge"], - "dependencies": [ - "python", - "pip", - { - "pip": get_default_pip_requirements(is_torch=is_torch), - }, - ], - "name": "darts_env", - } + return _mlflow_conda_env( + additional_pip_deps=get_default_pip_requirements(is_torch), + additional_conda_channels=["conda-forge"], + ) def save_model( model, path: str, conda_env: Optional[Union[dict, str]] = None, + code_paths: Optional[list[str]] = None, pip_requirements: Optional[list[str]] = None, + extra_pip_requirements: Optional[list[str]] = None, signature=None, input_example=None, metadata: Optional[dict] = None, @@ -186,9 +284,16 @@ def save_model( conda_env A conda environment specification (dict or path to a ``conda.yaml``). If ``None``, a default environment is generated. + code_paths + A list of local filesystem paths to Python file dependencies (or directories + containing file dependencies). These files are prepended to the system path + when the model is loaded. pip_requirements A list of pip requirement strings. Overrides ``conda_env`` pip section when provided. + extra_pip_requirements + A list of additional pip requirement strings to add to the model's environment, + in addition to the default requirements. signature An ``mlflow.models.ModelSignature`` instance describing model input/output. Use :func:`infer_signature` to automatically generate from example inputs. @@ -198,11 +303,13 @@ def save_model( metadata Optional dictionary of custom metadata to store in the ``MLmodel`` file. """ - data_dir = os.path.join(path, _MODEL_DATA_SUBFOLDER) + _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements) + _validate_and_prepare_target_save_path(path) + code_dir_subpath = _validate_and_copy_code_paths(code_paths, path) + data_dir = os.path.join(path, _MODEL_DATA_SUBFOLDER) is_torch = _is_torch_model(model) - os.makedirs(path, exist_ok=True) os.makedirs(data_dir, exist_ok=True) if is_torch: @@ -223,50 +330,20 @@ def save_model( "data": _MODEL_DATA_SUBFOLDER, } - if pip_requirements is not None: - pip_reqs = pip_requirements - else: - pip_reqs = get_default_pip_requirements(is_torch=is_torch) - - if conda_env is not None: - if isinstance(conda_env, str): - with open(conda_env) as f: - conda_env_dict = yaml.safe_load(f) - else: - conda_env_dict = conda_env - else: - conda_env_dict = get_default_conda_env(is_torch=is_torch) - - conda_path = os.path.join(path, "conda.yaml") - with open(conda_path, "w") as f: - yaml.dump(conda_env_dict, f, default_flow_style=False) - - reqs_path = os.path.join(path, "requirements.txt") - with open(reqs_path, "w") as f: - f.write("\n".join(pip_reqs) + "\n") - - python_env_path = os.path.join(path, "python_env.yaml") - python_env = { - "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}", - "build_dependencies": ["pip"], - "dependencies": ["requirements.txt"], - } - with open(python_env_path, "w") as f: - yaml.dump(python_env, f, default_flow_style=False) - - mlmodel = Model() - mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) - - if signature is not None: - mlmodel.signature = signature + if code_dir_subpath is not None: + darts_flavor_conf["code"] = code_dir_subpath - if input_example is not None: - mlmodel.input_example = input_example - - if metadata is not None: - mlmodel.metadata = metadata + default_reqs = None if pip_requirements else get_default_pip_requirements(is_torch) + conda_env, pip_requirements, pip_constraints = ( + _process_pip_requirements( + default_reqs, pip_requirements, extra_pip_requirements + ) + if conda_env is None + else _process_conda_env(conda_env) + ) - mlmodel.save(os.path.join(path, "MLmodel")) + _write_environment_files(path, conda_env, pip_requirements, pip_constraints) + _create_mlmodel_file(path, darts_flavor_conf, signature, input_example, metadata) def load_model( @@ -295,32 +372,26 @@ def load_model( local_path = _download_artifact_from_uri( artifact_uri=model_uri, output_path=dst_path ) - mlmodel_path = os.path.join(local_path, "MLmodel") - mlmodel = Model.load(mlmodel_path) - if FLAVOR_NAME not in mlmodel.flavors: - raise ValueError( - f"The MLflow model at '{model_uri}' does not have a '{FLAVOR_NAME}' flavor. " - f"Available flavors: {list(mlmodel.flavors.keys())}" - ) - - flavor_conf = mlmodel.flavors[FLAVOR_NAME] - module_path = flavor_conf["model_class_module"] - class_name = flavor_conf["model_class_name"] - model_file = flavor_conf["model_file"] - is_torch = flavor_conf.get("is_torch_model", False) + flavor_conf = _get_flavor_configuration( + model_path=local_path, flavor_name=FLAVOR_NAME + ) + _add_code_from_conf_to_system_path(local_path, flavor_conf) - model_cls = _import_model_class(module_path, class_name) + model_cls = _import_model_class( + flavor_conf["model_class_module"], flavor_conf["model_class_name"] + ) - data_dir = os.path.join(local_path, flavor_conf.get("data", _MODEL_DATA_SUBFOLDER)) - model_path = os.path.join(data_dir, model_file) + model_path = os.path.join( + local_path, + flavor_conf.get("data", _MODEL_DATA_SUBFOLDER), + flavor_conf["model_file"], + ) - if is_torch: - loaded_model = model_cls.load(model_path, **kwargs) + if flavor_conf.get("is_torch_model", False): + return model_cls.load(model_path, **kwargs) else: - loaded_model = model_cls.load(model_path) - - return loaded_model + return model_cls.load(model_path) def log_model( @@ -329,7 +400,9 @@ def log_model( name: Optional[str] = None, registered_model_name: Optional[str] = None, conda_env: Optional[Union[dict, str]] = None, + code_paths: Optional[list[str]] = None, pip_requirements: Optional[list[str]] = None, + extra_pip_requirements: Optional[list[str]] = None, signature=None, input_example=None, metadata: Optional[dict] = None, @@ -352,8 +425,15 @@ def log_model( under this name. conda_env Conda environment specification (dict or path). + code_paths + A list of local filesystem paths to Python file dependencies (or directories + containing file dependencies). These files are prepended to the system path + when the model is loaded. pip_requirements Pip requirements list. + extra_pip_requirements + A list of additional pip requirement strings to add to the model's environment, + in addition to the default requirements. signature An ``mlflow.models.ModelSignature``. Use :func:`infer_signature` to automatically generate from example inputs. @@ -384,7 +464,9 @@ def log_model( model=model, path=model_dir, conda_env=conda_env, + code_paths=code_paths, pip_requirements=pip_requirements, + extra_pip_requirements=extra_pip_requirements, signature=signature, input_example=input_example, metadata=metadata, @@ -408,8 +490,7 @@ def _log_model_params(model) -> None: """Log model creation parameters to MLflow. Extracts model parameters from ``model.model_params`` and logs them to the active - MLflow run. Logs non-serializable values as "" and truncates long parameter values - to fit MLflow's 500-character limit. + MLflow run. Logs non-serializable values as "". Parameters ---------- @@ -425,13 +506,11 @@ def _log_model_params(model) -> None: safe_params = {} for key, value in params.items(): try: - str_val = str(value) - if len(str_val) > 500: # MLflow param value limit - str_val = str_val[:497] + "..." - safe_params[key] = str_val + safe_params[key] = str(value) except Exception: safe_params[key] = "" + # mlflow validates and truncates the param values internally if safe_params: mlflow.log_params(safe_params) @@ -445,7 +524,7 @@ def _log_covariate_info(model) -> None: Logs three types of information: - Tags: Boolean flags for filtering (e.g., "uses_past_covariates") - - Parameters: Feature counts and names (truncated to 500 chars) + - Parameters: Feature counts and names (truncated to MAX_PARAM_VAL_LENGTH chars) - Artifact: Complete covariate metadata as JSON file Parameters @@ -494,19 +573,14 @@ def _log_covariate_info(model) -> None: if info["names"]: names_str = ",".join(info["names"]) - if len(names_str) > 500: - names_str = names_str[:497] + "..." mlflow.log_param(f"{cov_key.split('_')[0]}_cov_names", names_str) # log complete information as JSON artifact - with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f: - json.dump(covariate_info, f, indent=2) - temp_path = f.name - - try: - mlflow.log_artifact(temp_path, "covariates.json") - finally: - os.remove(temp_path) + with TempDir() as tmp: + covariates_path = tmp.path("covariates.json") + with open(covariates_path, "w") as f: + json.dump(covariate_info, f, indent=2) + mlflow.log_artifact(covariates_path) # stores original (unpatched) `fit` methods so they can be restored. From c488cd7dad51bd880caa2723cecc44056fe4867c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Mon, 16 Feb 2026 13:07:49 +0100 Subject: [PATCH 010/154] restructuring module --- darts/utils/mlflow.py | 456 +++++++++++++++++++++--------------------- 1 file changed, 228 insertions(+), 228 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index e0f25e78cd..a0c6f72183 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -75,187 +75,6 @@ def __init__(self, model_uri: str, run_id: str, artifact_path: str): _MODEL_FILE_TORCH_CKPT = "model.pt.ckpt" -def _is_torch_model(model) -> bool: - """Check if a model is a TorchForecastingModel. - - Parameters - ---------- - model - A Darts forecasting model instance. - - Returns - ------- - bool - True if the model is a TorchForecastingModel, False otherwise. - """ - try: - from darts.models.forecasting.torch_forecasting_model import ( - TorchForecastingModel, - ) - - return isinstance(model, TorchForecastingModel) - except ImportError: - return False - - -def _get_model_class_path(model) -> tuple[str, str]: - """Extract the module path and class name from a model instance. - - Parameters - ---------- - model - A Darts forecasting model instance. - - Returns - ------- - tuple[str, str] - A tuple containing (module_path, class_name). - """ - cls = type(model) - return cls.__module__, cls.__name__ - - -def _import_model_class(module_path: str, class_name: str): - """Dynamically import and return a model class. - - Parameters - ---------- - module_path : str - The fully qualified module path (e.g., "darts.models.exponential_smoothing"). - class_name : str - The name of the class to import (e.g., "ExponentialSmoothing"). - - Returns - ------- - type - The imported model class. - """ - module = importlib.import_module(module_path) - return getattr(module, class_name) - - -def _create_mlmodel_file( - path: str, - darts_flavor_conf: dict, - signature, - input_example, - metadata: Optional[dict], -) -> None: - """Create and save MLmodel file with metadata. - - Creates the following files in the model directory: - * ``MLmodel`` - MLmodel file with flavor metadata. - - Parameters - ---------- - path: str - Root directory of the MLflow model where the MLmodel file will be saved. - darts_flavor_conf: dict - Dictionary containing the flavor configuration for the darts model. - signature: mlflow.models.ModelSignature - An ``mlflow.models.ModelSignature`` instance describing model input/output. - Use :func:`infer_signature` to automatically generate from example inputs. - input_example: DataFrame - An example input for the model (used by MLflow UI). Should be a DataFrame - created with :func:`prepare_pyfunc_input`. - metadata: Optional[dict] - Optional dictionary of custom metadata to store in the ``MLmodel`` file. - """ - mlmodel = Model() - - if signature is not None: - mlmodel.signature = signature - - if input_example is not None: - _save_example(mlmodel, input_example, path) - - if metadata is not None: - mlmodel.metadata = metadata - - mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) - mlmodel.save(os.path.join(path, MLMODEL_FILE_NAME)) - - -def _write_environment_files( - path: str, - conda_env: dict, - pip_requirements: list[str], - pip_constraints: Optional[list[str]], -) -> None: - """Write Python environment specification files for model reproducibility. - - Creates the following files in the model directory: - - * ``conda.yaml`` - Conda environment specification including Python version and pip dependencies - * ``requirements.txt`` - Pip requirements list for non-conda environments - * ``python_env.yaml`` - MLflow Python environment specification - * ``constraints.txt`` (optional) - Pip version constraints if specified - - Parameters - ---------- - path: str - Root directory of the MLflow model where environment files will be written. - conda_env: dict - Processed conda environment dictionary containing 'name', 'channels', - 'dependencies' keys. - pip_requirements: list[str] - List of pip requirement strings (e.g., ['numpy>=1.20.0', 'pandas']). - pip_constraints: Optional[list[str]] - Optional list of pip constraint strings for pinning transitive dependencies. - Only written if provided. - """ - with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: - yaml.safe_dump(conda_env, stream=f, default_flow_style=False) - - if pip_constraints: - write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) - - write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) - _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) - - -def get_default_pip_requirements(is_torch: bool = False) -> list[str]: - """Return the default pip requirements for logging a darts model. - - Parameters - ---------- - is_torch - Whether the model is a PyTorch-based model. If ``True``, adds - ``torch`` and ``pytorch-lightning`` to the requirements. - - Returns - ------- - list[str] - A list of pip requirement strings. - """ - reqs = [_get_pinned_requirement("darts")] - if is_torch: - reqs.extend([ - _get_pinned_requirement("torch"), - _get_pinned_requirement("pytorch-lightning"), - ]) - return reqs - - -def get_default_conda_env(is_torch: bool = False) -> dict: - """Return a default conda environment dict for a darts model. - - Parameters - ---------- - is_torch - Whether the model is a PyTorch-based model. - - Returns - ------- - dict - A conda environment specification dictionary. - """ - return _mlflow_conda_env( - additional_pip_deps=get_default_pip_requirements(is_torch), - additional_conda_channels=["conda-forge"], - ) - - def save_model( model, path: str, @@ -486,6 +305,234 @@ def log_model( ) +def autolog( + log_models: bool = True, + log_params: bool = True, + disable: bool = False, +) -> None: + """Enable (or disable) automatic MLflow logging for darts models. + + When enabled, every call to ``model.fit()`` on any darts forecasting model + will automatically: + + 1. Start an MLflow run (or reuse the currently active one). + 2. Log model creation parameters (``model.model_params``). + 3. For PyTorch-based models: inject a callback that logs per-epoch + ``train_loss`` / ``val_loss`` metrics. + 4. Log the trained model artifact at the end of training. + + Parameters + ---------- + log_models + If ``True`` (default), log the trained model artifact after ``fit()``. + log_params + If ``True`` (default), log model creation parameters. + disable + If ``True``, restore the original ``fit()`` methods and stop + autologging. + """ + if disable: + _restore_original_fit_methods() + return + + _patch_fit(ForecastingModel, log_models=log_models, log_params=log_params) + + try: + from darts.models.forecasting.torch_forecasting_model import ( + TorchForecastingModel, + ) + + _patch_fit( + TorchForecastingModel, + log_models=log_models, + log_params=log_params, + inject_callback=True, + ) + except ImportError: + pass + + +def get_default_pip_requirements(is_torch: bool = False) -> list[str]: + """Return the default pip requirements for logging a darts model. + + Parameters + ---------- + is_torch + Whether the model is a PyTorch-based model. If ``True``, adds + ``torch`` and ``pytorch-lightning`` to the requirements. + + Returns + ------- + list[str] + A list of pip requirement strings. + """ + reqs = [_get_pinned_requirement("darts")] + if is_torch: + reqs.extend([ + _get_pinned_requirement("torch"), + _get_pinned_requirement("pytorch-lightning"), + ]) + return reqs + + +def get_default_conda_env(is_torch: bool = False) -> dict: + """Return a default conda environment dict for a darts model. + + Parameters + ---------- + is_torch + Whether the model is a PyTorch-based model. + + Returns + ------- + dict + A conda environment specification dictionary. + """ + return _mlflow_conda_env( + additional_pip_deps=get_default_pip_requirements(is_torch), + additional_conda_channels=["conda-forge"], + ) + + +def _is_torch_model(model) -> bool: + """Check if a model is a TorchForecastingModel. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + bool + True if the model is a TorchForecastingModel, False otherwise. + """ + try: + from darts.models.forecasting.torch_forecasting_model import ( + TorchForecastingModel, + ) + + return isinstance(model, TorchForecastingModel) + except ImportError: + return False + + +def _get_model_class_path(model) -> tuple[str, str]: + """Extract the module path and class name from a model instance. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + tuple[str, str] + A tuple containing (module_path, class_name). + """ + cls = type(model) + return cls.__module__, cls.__name__ + + +def _import_model_class(module_path: str, class_name: str): + """Dynamically import and return a model class. + + Parameters + ---------- + module_path : str + The fully qualified module path (e.g., "darts.models.exponential_smoothing"). + class_name : str + The name of the class to import (e.g., "ExponentialSmoothing"). + + Returns + ------- + type + The imported model class. + """ + module = importlib.import_module(module_path) + return getattr(module, class_name) + + +def _create_mlmodel_file( + path: str, + darts_flavor_conf: dict, + signature, + input_example, + metadata: Optional[dict], +) -> None: + """Create and save MLmodel file with metadata. + + Creates the following files in the model directory: + * ``MLmodel`` - MLmodel file with flavor metadata. + + Parameters + ---------- + path: str + Root directory of the MLflow model where the MLmodel file will be saved. + darts_flavor_conf: dict + Dictionary containing the flavor configuration for the darts model. + signature: mlflow.models.ModelSignature + An ``mlflow.models.ModelSignature`` instance describing model input/output. + Use :func:`infer_signature` to automatically generate from example inputs. + input_example: DataFrame + An example input for the model (used by MLflow UI). Should be a DataFrame + created with :func:`prepare_pyfunc_input`. + metadata: Optional[dict] + Optional dictionary of custom metadata to store in the ``MLmodel`` file. + """ + mlmodel = Model() + + if signature is not None: + mlmodel.signature = signature + + if input_example is not None: + _save_example(mlmodel, input_example, path) + + if metadata is not None: + mlmodel.metadata = metadata + + mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) + mlmodel.save(os.path.join(path, MLMODEL_FILE_NAME)) + + +def _write_environment_files( + path: str, + conda_env: dict, + pip_requirements: list[str], + pip_constraints: Optional[list[str]], +) -> None: + """Write Python environment specification files for model reproducibility. + + Creates the following files in the model directory: + + * ``conda.yaml`` - Conda environment specification including Python version and pip dependencies + * ``requirements.txt`` - Pip requirements list for non-conda environments + * ``python_env.yaml`` - MLflow Python environment specification + * ``constraints.txt`` (optional) - Pip version constraints if specified + + Parameters + ---------- + path: str + Root directory of the MLflow model where environment files will be written. + conda_env: dict + Processed conda environment dictionary containing 'name', 'channels', + 'dependencies' keys. + pip_requirements: list[str] + List of pip requirement strings (e.g., ['numpy>=1.20.0', 'pandas']). + pip_constraints: Optional[list[str]] + Optional list of pip constraint strings for pinning transitive dependencies. + Only written if provided. + """ + with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: + yaml.safe_dump(conda_env, stream=f, default_flow_style=False) + + if pip_constraints: + write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) + + write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) + _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) + + def _log_model_params(model) -> None: """Log model creation parameters to MLflow. @@ -684,53 +731,6 @@ def _inject_mlflow_callback(model) -> None: model.trainer_params["callbacks"] = existing_callbacks -def autolog( - log_models: bool = True, - log_params: bool = True, - disable: bool = False, -) -> None: - """Enable (or disable) automatic MLflow logging for darts models. - - When enabled, every call to ``model.fit()`` on any darts forecasting model - will automatically: - - 1. Start an MLflow run (or reuse the currently active one). - 2. Log model creation parameters (``model.model_params``). - 3. For PyTorch-based models: inject a callback that logs per-epoch - ``train_loss`` / ``val_loss`` metrics. - 4. Log the trained model artifact at the end of training. - - Parameters - ---------- - log_models - If ``True`` (default), log the trained model artifact after ``fit()``. - log_params - If ``True`` (default), log model creation parameters. - disable - If ``True``, restore the original ``fit()`` methods and stop - autologging. - """ - if disable: - _restore_original_fit_methods() - return - - _patch_fit(ForecastingModel, log_models=log_models, log_params=log_params) - - try: - from darts.models.forecasting.torch_forecasting_model import ( - TorchForecastingModel, - ) - - _patch_fit( - TorchForecastingModel, - log_models=log_models, - log_params=log_params, - inject_callback=True, - ) - except ImportError: - pass - - def _patch_fit( cls, *, From 7fe3cf31e918f75c1683630d1e7a3f4a5dcb15e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Mon, 16 Feb 2026 14:25:44 +0100 Subject: [PATCH 011/154] autologging refactor w/ mlflow decorator --- darts/utils/mlflow.py | 168 +++++++++++++++++++----------------------- 1 file changed, 75 insertions(+), 93 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index a0c6f72183..1b16dea4cb 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -11,8 +11,7 @@ import json import os import tempfile -from functools import wraps -from typing import Any, Optional, Union +from typing import Optional, Union import mlflow import yaml @@ -20,6 +19,11 @@ from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example from mlflow.tracking.artifact_utils import _download_artifact_from_uri +from mlflow.utils.autologging_utils import ( + autologging_integration, + get_autologging_config, + safe_patch, +) from mlflow.utils.environment import ( _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, @@ -305,10 +309,12 @@ def log_model( ) +@autologging_integration(FLAVOR_NAME) def autolog( log_models: bool = True, log_params: bool = True, disable: bool = False, + silent: bool = False, ) -> None: """Enable (or disable) automatic MLflow logging for darts models. @@ -330,23 +336,29 @@ def autolog( disable If ``True``, restore the original ``fit()`` methods and stop autologging. + silent + If ``True`` (default ``False``), suppress all event logging and warnings from + MLflow during autologging. """ - if disable: - _restore_original_fit_methods() - return - - _patch_fit(ForecastingModel, log_models=log_models, log_params=log_params) + safe_patch( + FLAVOR_NAME, + ForecastingModel, + "fit", + _patched_fit, + manage_run=True, + ) try: from darts.models.forecasting.torch_forecasting_model import ( TorchForecastingModel, ) - _patch_fit( + safe_patch( + FLAVOR_NAME, TorchForecastingModel, - log_models=log_models, - log_params=log_params, - inject_callback=True, + "fit", + _patched_fit, + manage_run=True, ) except ImportError: pass @@ -630,8 +642,51 @@ def _log_covariate_info(model) -> None: mlflow.log_artifact(covariates_path) -# stores original (unpatched) `fit` methods so they can be restored. -_ORIGINAL_FIT_METHODS: dict[type, Any] = {} +def _patched_fit(original, self, *args, **kwargs): + """Patch function for ForecastingModel.fit() autologging. + + Handles both statistical and PyTorch-based models. For PyTorch models, + automatically injects MLflow callback for per-epoch metrics logging. + + Parameters + ---------- + original + The original fit method being patched. + self + The model instance (ForecastingModel or TorchForecastingModel). + args + Positional arguments passed to fit. + kwargs + Keyword arguments passed to fit. + + Returns + ------- + The result of calling the original fit method. + """ + log_models = get_autologging_config(FLAVOR_NAME, "log_models", True) + log_params = get_autologging_config(FLAVOR_NAME, "log_params", True) + + mlflow.set_tag("darts.model_class", type(self).__name__) + + if log_params: + _log_model_params(self) + + # Inject callback for torch models (no-op for non-torch models) + _inject_mlflow_callback(self) + + result = original(self, *args, **kwargs) + + if log_params: + _log_covariate_info(self) + + if log_models: + try: + log_model(self, name="model", log_params=False) + except Exception as e: + logger.warning(f"Failed to autolog model artifact: {e}") + + return result + if PL_AVAILABLE: import pytorch_lightning as pl @@ -722,86 +777,13 @@ def _inject_mlflow_callback(model) -> None: existing_callbacks = model.trainer_params.get("callbacks", []) - cb_type = type(callback) - for existing in existing_callbacks: - if type(existing).__name__ == cb_type.__name__: - return - - existing_callbacks.append(callback) - model.trainer_params["callbacks"] = existing_callbacks - - -def _patch_fit( - cls, - *, - log_models: bool, - log_params: bool, - inject_callback: bool = False, -) -> None: - """Replace a model class's ``fit`` method with an MLflow logging wrapper. - - Parameters - ---------- - cls : type - The model class to patch (e.g., ForecastingModel, TorchForecastingModel). - log_models : bool - Whether to log the trained model artifact after fitting. - log_params : bool - Whether to log model creation parameters. - inject_callback : bool, optional - Whether to inject the MLflow callback for PyTorch Lightning models. - Default is False. - """ - if cls in _ORIGINAL_FIT_METHODS: + if any(isinstance(cb, _DartsMlflowCallback) for cb in existing_callbacks): + logger.debug("MLflow callback already present, skipping injection") return - original_fit = cls.fit - _ORIGINAL_FIT_METHODS[cls] = original_fit - - @wraps(original_fit) - def _patched_fit(self, *args, **kwargs): - run_started_here = False - if mlflow.active_run() is None: - mlflow.start_run() - run_started_here = True - - try: - mlflow.set_tag("darts.model_class", type(self).__name__) - - if log_params: - _log_model_params(self) - - if inject_callback: - _inject_mlflow_callback(self) + if not isinstance(existing_callbacks, list): + existing_callbacks = list(existing_callbacks) - result = original_fit(self, *args, **kwargs) - - if log_params: - _log_covariate_info(self) - - if log_models: - try: - log_model(self, name="model", log_params=False) - except Exception as e: - logger.warning(f"Failed to autolog model artifact: {e}") - - return result - - except Exception: - raise - finally: - if run_started_here: - mlflow.end_run() - - cls.fit = _patched_fit - - -def _restore_original_fit_methods() -> None: - """Restore all patched ``fit()`` methods to their original implementations. - - This function is called when ``autolog(disable=True)`` is invoked to remove - all MLflow logging functionality added by autologging. - """ - for cls, original_fit in _ORIGINAL_FIT_METHODS.items(): - cls.fit = original_fit - _ORIGINAL_FIT_METHODS.clear() + existing_callbacks.append(callback) + model.trainer_params["callbacks"] = existing_callbacks + logger.debug(f"Injected MLflow callback into {type(model).__name__}") From ada47b781454f896c9c112dd1844ae7d3d40adbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Mon, 16 Feb 2026 15:02:58 +0100 Subject: [PATCH 012/154] refactoring log_model to leverage Model.log --- darts/utils/mlflow.py | 176 +++++++++++------------------------------- 1 file changed, 45 insertions(+), 131 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 1b16dea4cb..59a33ceafc 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -10,7 +10,6 @@ import importlib import json import os -import tempfile from typing import Optional, Union import mlflow @@ -55,25 +54,6 @@ _MODEL_DATA_SUBFOLDER = "data" -class _ModelLogInfo: - """Lightweight container returned by :func:`log_model` with essential metadata. - - Attributes - ---------- - model_uri : str - The full MLflow model URI (e.g., "runs:/run_id/model"). - run_id : str - The MLflow run ID that logged the model. - artifact_path : str - The artifact path where the model was logged within the run. - """ - - def __init__(self, model_uri: str, run_id: str, artifact_path: str): - self.model_uri = model_uri - self.run_id = run_id - self.artifact_path = artifact_path - - _MODEL_FILE_STAT = "model.pkl" _MODEL_FILE_TORCH = "model.pt" _MODEL_FILE_TORCH_CKPT = "model.pt.ckpt" @@ -89,6 +69,7 @@ def save_model( signature=None, input_example=None, metadata: Optional[dict] = None, + mlflow_model: Optional[Model] = None, ) -> None: """Save a darts forecasting model in MLflow format. @@ -125,6 +106,9 @@ def save_model( created with :func:`prepare_pyfunc_input`. metadata Optional dictionary of custom metadata to store in the ``MLmodel`` file. + mlflow_model + Optional MLflow Model object to use for saving. When provided (typically by + ``Model.log()``), this model instance is used instead of creating a new one. """ _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements) _validate_and_prepare_target_save_path(path) @@ -165,8 +149,29 @@ def save_model( else _process_conda_env(conda_env) ) - _write_environment_files(path, conda_env, pip_requirements, pip_constraints) - _create_mlmodel_file(path, darts_flavor_conf, signature, input_example, metadata) + with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: + yaml.safe_dump(conda_env, stream=f, default_flow_style=False) + + if pip_constraints: + write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) + + write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) + _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) + + if mlflow_model is None: + mlflow_model = Model() + + if signature is not None: + mlflow_model.signature = signature + + if input_example is not None: + _save_example(mlflow_model, input_example, path) + + if metadata is not None: + mlflow_model.metadata = metadata + + mlflow_model.add_flavor(FLAVOR_NAME, **darts_flavor_conf) + mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME)) def load_model( @@ -271,41 +276,30 @@ def log_model( Returns ------- - _ModelLogInfo - A lightweight object with ``model_uri``, ``run_id``, and - ``artifact_path`` attributes. + ModelInfo + MLflow ModelInfo object containing model_uri, run_id, artifact_path, + model_id, timestamps, and other metadata about the logged model. """ - artifact_name = name or artifact_path or "model" + # import required as Model.log will call flavor.save_model() internally + import darts.utils.mlflow as darts_mlflow if log_params: _log_model_params(model) _log_covariate_info(model) - with tempfile.TemporaryDirectory() as tmp_dir: - model_dir = os.path.join(tmp_dir, artifact_name) - save_model( - model=model, - path=model_dir, - conda_env=conda_env, - code_paths=code_paths, - pip_requirements=pip_requirements, - extra_pip_requirements=extra_pip_requirements, - signature=signature, - input_example=input_example, - metadata=metadata, - ) - mlflow.log_artifacts(model_dir, artifact_path=artifact_name) - - run_id = mlflow.active_run().info.run_id - model_uri = f"runs:/{run_id}/{artifact_name}" - - if registered_model_name is not None: - mlflow.register_model(model_uri, registered_model_name) - - return _ModelLogInfo( - model_uri=model_uri, - run_id=run_id, - artifact_path=artifact_name, + return Model.log( + artifact_path=artifact_path, + name=name, + flavor=darts_mlflow, + registered_model_name=registered_model_name, + model=model, + conda_env=conda_env, + code_paths=code_paths, + pip_requirements=pip_requirements, + extra_pip_requirements=extra_pip_requirements, + signature=signature, + input_example=input_example, + metadata=metadata, ) @@ -465,86 +459,6 @@ def _import_model_class(module_path: str, class_name: str): return getattr(module, class_name) -def _create_mlmodel_file( - path: str, - darts_flavor_conf: dict, - signature, - input_example, - metadata: Optional[dict], -) -> None: - """Create and save MLmodel file with metadata. - - Creates the following files in the model directory: - * ``MLmodel`` - MLmodel file with flavor metadata. - - Parameters - ---------- - path: str - Root directory of the MLflow model where the MLmodel file will be saved. - darts_flavor_conf: dict - Dictionary containing the flavor configuration for the darts model. - signature: mlflow.models.ModelSignature - An ``mlflow.models.ModelSignature`` instance describing model input/output. - Use :func:`infer_signature` to automatically generate from example inputs. - input_example: DataFrame - An example input for the model (used by MLflow UI). Should be a DataFrame - created with :func:`prepare_pyfunc_input`. - metadata: Optional[dict] - Optional dictionary of custom metadata to store in the ``MLmodel`` file. - """ - mlmodel = Model() - - if signature is not None: - mlmodel.signature = signature - - if input_example is not None: - _save_example(mlmodel, input_example, path) - - if metadata is not None: - mlmodel.metadata = metadata - - mlmodel.add_flavor(FLAVOR_NAME, **darts_flavor_conf) - mlmodel.save(os.path.join(path, MLMODEL_FILE_NAME)) - - -def _write_environment_files( - path: str, - conda_env: dict, - pip_requirements: list[str], - pip_constraints: Optional[list[str]], -) -> None: - """Write Python environment specification files for model reproducibility. - - Creates the following files in the model directory: - - * ``conda.yaml`` - Conda environment specification including Python version and pip dependencies - * ``requirements.txt`` - Pip requirements list for non-conda environments - * ``python_env.yaml`` - MLflow Python environment specification - * ``constraints.txt`` (optional) - Pip version constraints if specified - - Parameters - ---------- - path: str - Root directory of the MLflow model where environment files will be written. - conda_env: dict - Processed conda environment dictionary containing 'name', 'channels', - 'dependencies' keys. - pip_requirements: list[str] - List of pip requirement strings (e.g., ['numpy>=1.20.0', 'pandas']). - pip_constraints: Optional[list[str]] - Optional list of pip constraint strings for pinning transitive dependencies. - Only written if provided. - """ - with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: - yaml.safe_dump(conda_env, stream=f, default_flow_style=False) - - if pip_constraints: - write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) - - write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) - _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) - - def _log_model_params(model) -> None: """Log model creation parameters to MLflow. From 9fbe42aff4faef503c9f4671c0e612a122bf2135 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 17 Feb 2026 10:56:38 +0100 Subject: [PATCH 013/154] unit test improvenemnts --- darts/tests/optional_deps/test_mlflow.py | 544 +++++++++++++++++++---- 1 file changed, 455 insertions(+), 89 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index ae5bee4432..f9cd64915d 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,3 +1,4 @@ +import json import os import numpy as np @@ -6,6 +7,7 @@ import darts.utils.timeseries_generation as tg from darts.tests.conftest import MLFLOW_AVAILABLE, TORCH_AVAILABLE, tfm_kwargs_dev +from darts.utils.utils import PL_AVAILABLE if not MLFLOW_AVAILABLE: pytest.skip( @@ -27,6 +29,53 @@ from darts.models import NBEATSModel +@pytest.fixture +def mlflow_tracking(tmpdir_fn): + """Set up MLflow tracking with a temporary database.""" + mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") + return mlflow.tracking.MlflowClient() + + +@pytest.fixture +def autolog_context(): + """Context manager to safely enable/disable autolog for a test.""" + from contextlib import contextmanager + + @contextmanager + def _autolog_context(): + autolog(disable=True) # clean state + autolog() # enable for test + try: + yield + finally: + autolog(disable=True) # clean up + + return _autolog_context + + +def assert_mlflow_artifacts_exist(path: str, is_torch: bool = False): + """Assert that all required MLflow artifact files exist.""" + assert os.path.exists(os.path.join(path, "MLmodel")) + assert os.path.exists(os.path.join(path, "conda.yaml")) + assert os.path.exists(os.path.join(path, "requirements.txt")) + assert os.path.exists(os.path.join(path, "python_env.yaml")) + + if is_torch: + assert os.path.exists(os.path.join(path, "data", "model.pt")) + assert os.path.exists(os.path.join(path, "data", "model.pt.ckpt")) + else: + assert os.path.exists(os.path.join(path, "data", "model.pkl")) + + +def assert_predictions_equal(model1, model2, n: int, decimal: int = 4): + """Assert that two models produce equivalent predictions.""" + pred1 = model1.predict(n=n) + pred2 = model2.predict(n=n) + np.testing.assert_array_almost_equal( + pred1.values(), pred2.values(), decimal=decimal + ) + + class TestMLflow: ts_univariate = tg.linear_timeseries( start_value=10, end_value=50, length=50 @@ -45,15 +94,11 @@ def test_save_load_statistical_model(self, tmpdir_fn): model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) - assert os.path.exists(os.path.join(model_path, "MLmodel")) - loaded_model = load_model(f"file://{model_path}") - pred_original = model.predict(n=5) - pred_loaded = loaded_model.predict(n=5) + assert_mlflow_artifacts_exist(model_path, is_torch=False) - np.testing.assert_array_almost_equal( - pred_original.values(), pred_loaded.values(), decimal=4 - ) + loaded_model = load_model(f"file://{model_path}") + assert_predictions_equal(model, loaded_model, n=5) def test_save_load_regression_model(self, tmpdir_fn): """Test save/load round-trip for regression model""" @@ -63,13 +108,10 @@ def test_save_load_regression_model(self, tmpdir_fn): model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) - loaded_model = load_model(f"file://{model_path}") - pred_original = model.predict(n=3) - pred_loaded = loaded_model.predict(n=3) + assert_mlflow_artifacts_exist(model_path, is_torch=False) - np.testing.assert_array_almost_equal( - pred_original.values(), pred_loaded.values(), decimal=4 - ) + loaded_model = load_model(f"file://{model_path}") + assert_predictions_equal(model, loaded_model, n=3) @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_save_load_torch_model(self, tmpdir_fn): @@ -82,19 +124,13 @@ def test_save_load_torch_model(self, tmpdir_fn): model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) - loaded_model = load_model(f"file://{model_path}") - pred_original = model.predict(n=2) - pred_loaded = loaded_model.predict(n=2) + assert_mlflow_artifacts_exist(model_path, is_torch=True) - np.testing.assert_array_almost_equal( - pred_original.values(), pred_loaded.values(), decimal=4 - ) + loaded_model = load_model(f"file://{model_path}") + assert_predictions_equal(model, loaded_model, n=2) - def test_log_model_basic(self, tmpdir_fn): + def test_log_model_basic(self, mlflow_tracking): """Test basic log_model functionality""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - model = ExponentialSmoothing() model.fit(self.ts_univariate) @@ -102,19 +138,10 @@ def test_log_model_basic(self, tmpdir_fn): log_info = log_model(model, name="model") loaded_model = load_model(log_info.model_uri) - pred_loaded = loaded_model.predict(n=5) - pred_original = model.predict(n=5) + assert_predictions_equal(model, loaded_model, n=5) - assert len(pred_loaded) == 5 - np.testing.assert_array_almost_equal( - pred_original.values(), pred_loaded.values(), decimal=4 - ) - - def test_log_model_with_params(self, tmpdir_fn): + def test_log_model_with_params(self, mlflow_tracking): """Test that log_params=True logs model parameters""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - model = LinearRegressionModel(lags=5, lags_past_covariates=3) model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) @@ -129,11 +156,8 @@ def test_log_model_with_params(self, tmpdir_fn): assert run.data.params["n_future_covariates"] == "0" assert run.data.params["n_static_covariates"] == "0" - def test_log_model_with_covariates(self, tmpdir_fn): + def test_log_model_with_covariates(self, mlflow_tracking): """Test that covariate info is logged with correct values""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") - model = LinearRegressionModel(lags=5, lags_past_covariates=3) model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) @@ -141,94 +165,412 @@ def test_log_model_with_covariates(self, tmpdir_fn): log_model(model, name="model", log_params=True) run_id = mlflow.active_run().info.run_id + # get artifact while run is still active + artifact_uri = mlflow.get_artifact_uri("covariates.json") + artifact_path = artifact_uri.replace("file://", "") + assert os.path.exists(artifact_path), ( + "covariates.json artifact should exist" + ) + + with open(artifact_path) as f: + cov_data = json.load(f) + run = mlflow.get_run(run_id) - # Check covariate usage tags have the correct boolean values + # check covariate usage tags have the correct boolean values assert run.data.tags["uses_past_covariates"] == "true" assert run.data.tags["uses_future_covariates"] == "false" assert run.data.tags["uses_static_covariates"] == "false" - # Check covariate count params + # check covariate count params assert run.data.params["n_past_covariates"] == "1" assert run.data.params["n_future_covariates"] == "0" assert run.data.params["n_static_covariates"] == "0" - def test_autolog_enable_disable(self, tmpdir_fn): - """Test autolog can be enabled and disabled""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") + # verify structure and content + assert "past_covariates" in cov_data + assert "future_covariates" in cov_data + assert "static_covariates" in cov_data + + # check past covariates data + assert cov_data["past_covariates"]["used"] is True + assert cov_data["past_covariates"]["count"] == 1 + assert len(cov_data["past_covariates"]["names"]) == 1 + + # check future and static covariates not used + assert cov_data["future_covariates"]["used"] is False + assert cov_data["future_covariates"]["count"] == 0 + assert cov_data["static_covariates"]["used"] is False + assert cov_data["static_covariates"]["count"] == 0 + + def test_log_model_with_all_covariate_types(self, mlflow_tracking): + """Test logging model with past, future, and static covariates""" + # use a model that supports all covariate types + model = LinearRegressionModel( + lags=5, lags_past_covariates=3, lags_future_covariates=[0, 1] + ) + model.fit( + self.ts_with_static[:40], + past_covariates=self.ts_past_cov[:40], + future_covariates=self.ts_future_cov[:50], + ) - autolog() + with mlflow.start_run(): + log_model(model, name="model", log_params=True) + run_id = mlflow.active_run().info.run_id - model = ExponentialSmoothing() - model.fit(self.ts_univariate) + # get artifact while run is still active + artifact_uri = mlflow.get_artifact_uri("covariates.json") + artifact_path = artifact_uri.replace("file://", "") - runs = mlflow.search_runs() - assert len(runs) == 1 + with open(artifact_path) as f: + cov_data = json.load(f) + + run = mlflow.get_run(run_id) + + # verify all covariate types are tracked + assert run.data.tags["uses_past_covariates"] == "true" + assert run.data.tags["uses_future_covariates"] == "true" + assert run.data.tags["uses_static_covariates"] == "true" + + # verify covariate counts + assert run.data.params["n_past_covariates"] == "1" + assert run.data.params["n_future_covariates"] == "1" + assert run.data.params["n_static_covariates"] == "1" + + # all covariate types should be used + assert cov_data["past_covariates"]["used"] is True + assert cov_data["past_covariates"]["count"] == 1 + assert cov_data["future_covariates"]["used"] is True + assert cov_data["future_covariates"]["count"] == 1 + assert cov_data["static_covariates"]["used"] is True + assert cov_data["static_covariates"]["count"] == 1 + + def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): + """Test autolog can be enabled and disabled""" + with autolog_context(): + model = ExponentialSmoothing() + model.fit(self.ts_univariate) - # Verify the run has the expected model class tag - assert runs.iloc[0]["tags.darts.model_class"] == "ExponentialSmoothing" + runs = mlflow.search_runs() + assert len(runs) == 1, "Expected exactly one run after autolog fit" - autolog(disable=True) + # verify the run has expected content + last_run = runs.iloc[0] + assert last_run["tags.darts.model_class"] == "ExponentialSmoothing" + assert last_run["tags.mlflow.runName"] is not None + # after context exits, autolog should be disabled model2 = ExponentialSmoothing() model2.fit(self.ts_univariate) runs_after_disable = mlflow.search_runs() - assert len(runs_after_disable) == 1 + assert len(runs_after_disable) == 1, ( + "No new run should be created after disable" + ) - def test_autolog_parameters(self, tmpdir_fn): + def test_autolog_parameters(self, mlflow_tracking, autolog_context): """Test that autolog logs model parameters""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") + with autolog_context(): + model = ExponentialSmoothing(seasonal_periods=12) + model.fit(self.ts_univariate) - autolog() + runs = mlflow.search_runs() + assert len(runs) == 1 - model = ExponentialSmoothing(seasonal_periods=12) - model.fit(self.ts_univariate) + last_run = runs.iloc[0] + assert last_run["params.seasonal_periods"] == "12" + assert last_run["tags.darts.model_class"] == "ExponentialSmoothing" - runs = mlflow.search_runs() - assert len(runs) == 1 + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): + """Test that autolog logs training metrics for torch models""" + with autolog_context(): + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) + + runs = mlflow.search_runs() + assert len(runs) == 1, "Expected exactly one run" + last_run = runs.iloc[0] + last_run_id = last_run["run_id"] + assert last_run["tags.darts.model_class"] == "NBEATSModel" + + client = mlflow.tracking.MlflowClient() + + # check train_loss metrics + train_metrics = client.get_metric_history(last_run_id, "train_loss") + assert len(train_metrics) > 0, "Expected train_loss metrics to be logged" + assert len(train_metrics) <= 2, "Expected at most 2 epochs of train_loss" + + for m in train_metrics: + assert np.isfinite(m.value), f"train_loss is not finite: {m.value}" + assert m.value >= 0, f"train_loss is negative: {m.value}" + assert m.step >= 0, "Metric step should be non-negative" + + val_metrics = client.get_metric_history(last_run_id, "val_loss") + if val_metrics: + for m in val_metrics: + assert np.isfinite(m.value), f"val_loss is not finite: {m.value}" + assert m.value >= 0, f"val_loss is negative: {m.value}" - last_run = runs.iloc[0] - assert last_run["params.seasonal_periods"] == "12" - assert last_run["tags.darts.model_class"] == "ExponentialSmoothing" + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_injects_callback(self, mlflow_tracking, autolog_context): + """Test that autolog injects MLflow callback into torch models""" + with autolog_context(): + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + **tfm_kwargs_dev, + ) + + # record initial callbacks from trainer_params (before fit) + initial_callbacks = model.trainer_params.get("callbacks", []) + initial_callback_count = len(initial_callbacks) if initial_callbacks else 0 + + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) + + # verify callback was injected after fit + final_callbacks = model.trainer_params.get("callbacks", []) + assert final_callbacks is not None, "Callbacks should not be None" + assert len(final_callbacks) > initial_callback_count, ( + "MLflow callback should be added" + ) + + # check that the _DartsMlflowCallback is present + from darts.utils.mlflow import _DartsMlflowCallback + + has_mlflow_callback = any( + isinstance(cb, _DartsMlflowCallback) for cb in final_callbacks + ) + assert has_mlflow_callback, ( + f"_DartsMlflowCallback not found in {[type(cb).__name__ for cb in final_callbacks]}" + ) + + def test_covariate_artifact_schema(self, mlflow_tracking): + """Test that covariate artifact has correct JSON schema""" + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) - autolog(disable=True) + with mlflow.start_run(): + log_model(model, name="model", log_params=True) - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_torch_metrics(self, tmpdir_fn): - """Test that autolog logs training metrics for torch models""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - mlflow.set_experiment("test_experiment") + artifact_uri = mlflow.get_artifact_uri("covariates.json") + artifact_path = artifact_uri.replace("file://", "") - autolog() + with open(artifact_path) as f: + cov_data = json.load(f) - model = NBEATSModel( - input_chunk_length=4, output_chunk_length=2, n_epochs=2, **tfm_kwargs_dev + # validate schema structure + required_keys = ["past_covariates", "future_covariates", "static_covariates"] + assert all(key in cov_data for key in required_keys), ( + "Missing required covariate keys" ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) + + for cov_type in required_keys: + cov_info = cov_data[cov_type] + assert "used" in cov_info and isinstance(cov_info["used"], bool) + assert "count" in cov_info and isinstance(cov_info["count"], int) + assert "names" in cov_info and isinstance(cov_info["names"], list) + assert cov_info["count"] == len(cov_info["names"]) + + def test_multivariate_with_all_covariate_types(self, mlflow_tracking): + """Test saving/loading multivariate series with all covariate types""" + # create multivariate target with static covariates + target = self.ts_multivariate.with_static_covariates( + pd.DataFrame({"static_feat_1": [1.0], "static_feat_2": [2.0]}) + ) + + model = LinearRegressionModel( + lags=5, lags_past_covariates=3, lags_future_covariates=[0, 1] + ) + model.fit( + target[:40], + past_covariates=self.ts_past_cov[:40], + future_covariates=self.ts_future_cov[:50], + ) + + with mlflow.start_run(): + log_model(model, name="model", log_params=True) + run_id = mlflow.active_run().info.run_id + + run = mlflow.get_run(run_id) + + # verify all covariate types detected + assert run.data.tags["uses_past_covariates"] == "true" + assert run.data.tags["uses_future_covariates"] == "true" + assert run.data.tags["uses_static_covariates"] == "true" + + # verify correct component counts + assert run.data.params["n_past_covariates"] == "1" + assert run.data.params["n_future_covariates"] == "1" + assert run.data.params["n_static_covariates"] == "2" + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_callback_injection_with_existing_callbacks( + self, mlflow_tracking, autolog_context + ): + """Test callback injection when model already has callbacks""" + # create model with existing callback + if PL_AVAILABLE: + import pytorch_lightning as pl + + existing_callback = pl.callbacks.EarlyStopping(monitor="train_loss") + else: + pytest.skip("PyTorch Lightning not available") + + with autolog_context(): + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + pl_trainer_kwargs={"callbacks": [existing_callback]}, + **{k: v for k, v in tfm_kwargs_dev.items() if k != "pl_trainer_kwargs"}, + ) + + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) + + # verify both callbacks present + callbacks = model.trainer_params.get("callbacks", []) + assert len(callbacks) == 2, "Should have both existing and MLflow callbacks" + + from darts.utils.mlflow import _DartsMlflowCallback + + has_mlflow = any(isinstance(cb, _DartsMlflowCallback) for cb in callbacks) + has_existing = any( + isinstance(cb, pl.callbacks.EarlyStopping) for cb in callbacks + ) + assert has_mlflow and has_existing, "Both callbacks should be present" + + def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): + """Test that multiple fits with autolog create separate runs""" + with autolog_context(): + # since managed_run=True, subsequent fits will reuse the existing run, + # so we explicitly start runs for each fit + with mlflow.start_run(): + model2 = LinearRegressionModel(lags=5) + model2.fit(self.ts_univariate) + with mlflow.start_run(): + model1 = ExponentialSmoothing() + model1.fit(self.ts_univariate) runs = mlflow.search_runs() - assert len(runs) == 1 - last_run_id = runs.iloc[0]["run_id"] - assert runs.iloc[0]["tags.darts.model_class"] == "NBEATSModel" + assert len(runs) == 2, "Expected two separate runs for two fits" - client = mlflow.tracking.MlflowClient() - metrics = client.get_metric_history(last_run_id, "train_loss") + # verify different model classes logged + model_classes = set(runs["tags.darts.model_class"]) + assert "ExponentialSmoothing" in model_classes + assert "LinearRegressionModel" in model_classes - assert len(metrics) > 0 - # All logged loss values should be finite and non-negative - for m in metrics: - assert np.isfinite(m.value), f"train_loss is not finite: {m.value}" - assert m.value >= 0, f"train_loss is negative: {m.value}" + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_context): + """Test autolog with multiple fits of a torch model""" + with autolog_context(): + with mlflow.start_run(): + model1 = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=1, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model1.fit(train, val_series=val) + + with mlflow.start_run(): + model2 = LinearRegressionModel(lags=5) + model2.fit(self.ts_univariate) - autolog(disable=True) + runs = mlflow.search_runs() + assert len(runs) == 2, "Expected two separate runs for two fits" + + for _, run in runs.iterrows(): + assert run["tags.darts.model_class"] in [ + "NBEATSModel", + "LinearRegressionModel", + ] + assert run["tags.mlflow.runName"] is not None + + def test_save_load_preserves_series_metadata(self, tmpdir_fn): + """Test that save/load preserves multivariate and static covariate structure""" + target = self.ts_multivariate.with_static_covariates( + pd.DataFrame({"stat1": [1.0], "stat2": [2.0]}) + ) + + model = LinearRegressionModel(lags=5) + model.fit(target) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + + loaded_model = load_model(f"file://{model_path}") + + pred_original = model.predict(n=3) + pred_loaded = loaded_model.predict(n=3) + + # verify multivariate structure preserved + assert pred_original.width == pred_loaded.width == 2, ( + "Should maintain 2 components" + ) + assert pred_original.n_components == pred_loaded.n_components == 2 + + np.testing.assert_array_almost_equal( + pred_original.values(), pred_loaded.values(), decimal=4 + ) def test_load_nonexistent_model(self): """Test that loading nonexistent model raises appropriate error""" with pytest.raises(Exception): load_model("runs:/fake_run_id/model") + def test_load_invalid_uri_fails(self): + """Test that loading with invalid URI raises an error""" + with pytest.raises(Exception): + load_model("invalid://bad/uri") + + with pytest.raises(Exception): + load_model("file:///nonexistent/path/to/model") + + def test_load_corrupted_mlmodel_fails(self, tmpdir_fn): + """Test that loading with corrupted MLmodel file fails""" + # save a valid model + model = LinearRegressionModel(lags=5) + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + + # corrupt the MLmodel file + mlmodel_path = os.path.join(model_path, "MLmodel") + with open(mlmodel_path, "w") as f: + f.write("corrupted content that is not valid YAML {[[") + + # loading should fail + with pytest.raises(Exception): + load_model(f"file://{model_path}") + + def test_load_missing_model_file_fails(self, tmpdir_fn): + """Test that loading with missing model data file fails""" + # save a valid model + model = LinearRegressionModel(lags=5) + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + + # remove the model data file + model_data_path = os.path.join(model_path, "data", "model.pkl") + os.remove(model_data_path) + + # loading should fail + with pytest.raises(Exception): + load_model(f"file://{model_path}") + @pytest.mark.parametrize( "model_cls,fit_kwargs", [ @@ -249,6 +591,30 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): save_model(model, model_path) loaded = load_model(f"file://{model_path}") - pred1 = model.predict(n=5) - pred2 = loaded.predict(n=5) - np.testing.assert_array_almost_equal(pred1.values(), pred2.values(), decimal=4) + assert_predictions_equal(model, loaded, n=5) + + @pytest.mark.parametrize( + "series,series_name", + [ + ("ts_multivariate", "multivariate"), + ("ts_with_static", "static_covariates"), + ], + ) + def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): + """Test save/load with multivariate and static covariate series""" + test_series = getattr(self, series) + + model = LinearRegressionModel(lags=5) + model.fit(test_series) + + model_path = os.path.join(tmpdir_fn, f"test_model_{series_name}") + save_model(model, model_path) + + loaded_model = load_model(f"file://{model_path}") + + assert_predictions_equal(model, loaded_model, n=3) + + # verify the series dimensions are preserved + pred_original = model.predict(n=3) + pred_loaded = loaded_model.predict(n=3) + assert pred_original.width == pred_loaded.width From a0e663fd990a216fe4a0fc0ae279a9ce2c054f27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 17 Feb 2026 10:57:40 +0100 Subject: [PATCH 014/154] ForecastingModel subclasses handling for autolog --- darts/utils/mlflow.py | 242 ++++++++++++++++++++++++------------------ 1 file changed, 137 insertions(+), 105 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 59a33ceafc..2032a08514 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -309,6 +309,7 @@ def autolog( log_params: bool = True, disable: bool = False, silent: bool = False, + manage_run: bool = True, ) -> None: """Enable (or disable) automatic MLflow logging for darts models. @@ -333,29 +334,39 @@ def autolog( silent If ``True`` (default ``False``), suppress all event logging and warnings from MLflow during autologging. + manage_run + If `True`, applies the `with_managed_run` wrapper to the specified + `patch_function`, which automatically creates & terminates an MLflow + active run during patch code execution if necessary. If `False`, + does not apply the `with_managed_run` wrapper to the specified + `patch_function`. """ - safe_patch( - FLAVOR_NAME, - ForecastingModel, - "fit", - _patched_fit, - manage_run=True, - ) - try: - from darts.models.forecasting.torch_forecasting_model import ( - TorchForecastingModel, - ) + # recursively get all subclasses of ForecastingModel that override fit() + def get_all_subclasses(cls): + all_subclasses = [] + for subclass in cls.__subclasses__(): + all_subclasses.append(subclass) + all_subclasses.extend(get_all_subclasses(subclass)) + return all_subclasses - safe_patch( - FLAVOR_NAME, - TorchForecastingModel, - "fit", - _patched_fit, - manage_run=True, - ) - except ImportError: - pass + classes_to_patch = [ForecastingModel] + + for subclass in get_all_subclasses(ForecastingModel): + if "fit" in subclass.__dict__: + classes_to_patch.append(subclass) + + for cls in classes_to_patch: + try: + safe_patch( + FLAVOR_NAME, + cls, + "fit", + _patched_fit, + manage_run=manage_run, + ) + except Exception: + pass def get_default_pip_requirements(is_torch: bool = False) -> list[str]: @@ -400,70 +411,11 @@ def get_default_conda_env(is_torch: bool = False) -> dict: ) -def _is_torch_model(model) -> bool: - """Check if a model is a TorchForecastingModel. - - Parameters - ---------- - model - A Darts forecasting model instance. - - Returns - ------- - bool - True if the model is a TorchForecastingModel, False otherwise. - """ - try: - from darts.models.forecasting.torch_forecasting_model import ( - TorchForecastingModel, - ) - - return isinstance(model, TorchForecastingModel) - except ImportError: - return False - - -def _get_model_class_path(model) -> tuple[str, str]: - """Extract the module path and class name from a model instance. - - Parameters - ---------- - model - A Darts forecasting model instance. - - Returns - ------- - tuple[str, str] - A tuple containing (module_path, class_name). - """ - cls = type(model) - return cls.__module__, cls.__name__ - - -def _import_model_class(module_path: str, class_name: str): - """Dynamically import and return a model class. - - Parameters - ---------- - module_path : str - The fully qualified module path (e.g., "darts.models.exponential_smoothing"). - class_name : str - The name of the class to import (e.g., "ExponentialSmoothing"). - - Returns - ------- - type - The imported model class. - """ - module = importlib.import_module(module_path) - return getattr(module, class_name) - - def _log_model_params(model) -> None: """Log model creation parameters to MLflow. Extracts model parameters from ``model.model_params`` and logs them to the active - MLflow run. Logs non-serializable values as "". + MLflow run. Parameters ---------- @@ -476,16 +428,8 @@ def _log_model_params(model) -> None: logger.debug("Model has no model_params attribute; skipping parameter logging.") return - safe_params = {} - for key, value in params.items(): - try: - safe_params[key] = str(value) - except Exception: - safe_params[key] = "" - - # mlflow validates and truncates the param values internally - if safe_params: - mlflow.log_params(safe_params) + if params: + mlflow.log_params(params) def _log_covariate_info(model) -> None: @@ -497,7 +441,7 @@ def _log_covariate_info(model) -> None: Logs three types of information: - Tags: Boolean flags for filtering (e.g., "uses_past_covariates") - - Parameters: Feature counts and names (truncated to MAX_PARAM_VAL_LENGTH chars) + - Parameters: Feature counts and names (truncated by MLflow) - Artifact: Complete covariate metadata as JSON file Parameters @@ -526,21 +470,14 @@ def _log_covariate_info(model) -> None: ), ] - covariate_info = {} - - for cov_key, uses_attr, series_attr, names_attr in covariate_types: - info = {"used": False, "count": 0, "names": []} - - if getattr(model, uses_attr, False): - info["used"] = True - series = getattr(model, series_attr, None) - if series is not None: - names = getattr(series, names_attr).tolist() - info["names"] = names - info["count"] = len(names) - - covariate_info[cov_key] = info + covariate_info = { + cov_key: _extract_covariate_metadata( + model, cov_key, uses_attr, series_attr, names_attr + ) + for cov_key, uses_attr, series_attr, names_attr in covariate_types + } + for cov_key, info in covariate_info.items(): mlflow.set_tag(f"uses_{cov_key}", str(info["used"]).lower()) mlflow.log_param(f"n_{cov_key}", info["count"]) @@ -556,6 +493,101 @@ def _log_covariate_info(model) -> None: mlflow.log_artifact(covariates_path) +def _is_torch_model(model) -> bool: + """Check if a model is a TorchForecastingModel. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + bool + True if the model is a TorchForecastingModel, False otherwise. + """ + try: + from darts.models.forecasting.torch_forecasting_model import ( + TorchForecastingModel, + ) + + return isinstance(model, TorchForecastingModel) + except ImportError: + return False + + +def _get_model_class_path(model) -> tuple[str, str]: + """Extract the module path and class name from a model instance. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + tuple[str, str] + A tuple containing (module_path, class_name). + """ + cls = type(model) + return cls.__module__, cls.__name__ + + +def _import_model_class(module_path: str, class_name: str): + """Dynamically import and return a model class. + + Parameters + ---------- + module_path : str + The fully qualified module path (e.g., "darts.models.exponential_smoothing"). + class_name : str + The name of the class to import (e.g., "ExponentialSmoothing"). + + Returns + ------- + type + The imported model class. + """ + module = importlib.import_module(module_path) + return getattr(module, class_name) + + +def _extract_covariate_metadata( + model, cov_type: str, uses_attr: str, series_attr: str, names_attr: str +) -> dict: + """Extract metadata for a single covariate type. + + Parameters + ---------- + model + A Darts forecasting model instance. + cov_type : str + Covariate type name (e.g., "past_covariates"). + uses_attr : str + Model attribute name indicating covariate usage. + series_attr : str + Model attribute name for the covariate series. + names_attr : str + Series attribute name for feature names ("components" or "columns"). + + Returns + ------- + dict + Dictionary with keys: "used" (bool), "count" (int), "names" (list). + """ + info = {"used": False, "count": 0, "names": []} + + if getattr(model, uses_attr, False): + info["used"] = True + series = getattr(model, series_attr, None) + if series is not None: + names = getattr(series, names_attr).tolist() + info["names"] = names + info["count"] = len(names) + + return info + + def _patched_fit(original, self, *args, **kwargs): """Patch function for ForecastingModel.fit() autologging. From 93ca22a95e1006234207218aa8137adc2329bc12 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 17 Feb 2026 14:43:56 +0100 Subject: [PATCH 015/154] save models with clean=True --- darts/tests/optional_deps/test_mlflow.py | 25 +++++++++++++++--------- darts/utils/mlflow.py | 5 +++-- 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index f9cd64915d..ed92f2475e 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -67,10 +67,14 @@ def assert_mlflow_artifacts_exist(path: str, is_torch: bool = False): assert os.path.exists(os.path.join(path, "data", "model.pkl")) -def assert_predictions_equal(model1, model2, n: int, decimal: int = 4): - """Assert that two models produce equivalent predictions.""" +def assert_predictions_equal(model1, model2, n: int, decimal: int = 4, series=None): + """Assert that two models produce equivalent predictions. If series is provided, + it will be passed to the second model's predict method (for global models that require it).""" pred1 = model1.predict(n=n) - pred2 = model2.predict(n=n) + if series is not None: + pred2 = model2.predict(n=n, series=series) + else: + pred2 = model2.predict(n=n) np.testing.assert_array_almost_equal( pred1.values(), pred2.values(), decimal=decimal ) @@ -111,7 +115,7 @@ def test_save_load_regression_model(self, tmpdir_fn): assert_mlflow_artifacts_exist(model_path, is_torch=False) loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=3) + assert_predictions_equal(model, loaded_model, n=3, series=self.ts_univariate) @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_save_load_torch_model(self, tmpdir_fn): @@ -127,7 +131,7 @@ def test_save_load_torch_model(self, tmpdir_fn): assert_mlflow_artifacts_exist(model_path, is_torch=True) loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=2) + assert_predictions_equal(model, loaded_model, n=2, series=self.ts_univariate) def test_log_model_basic(self, mlflow_tracking): """Test basic log_model functionality""" @@ -511,7 +515,7 @@ def test_save_load_preserves_series_metadata(self, tmpdir_fn): loaded_model = load_model(f"file://{model_path}") pred_original = model.predict(n=3) - pred_loaded = loaded_model.predict(n=3) + pred_loaded = loaded_model.predict(n=3, series=target) # verify multivariate structure preserved assert pred_original.width == pred_loaded.width == 2, ( @@ -591,7 +595,10 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): save_model(model, model_path) loaded = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded, n=5) + # Only pass series for global models (LinearRegressionModel) + # Local models (ExponentialSmoothing) don't need it + series = self.ts_univariate if fit_kwargs else None + assert_predictions_equal(model, loaded, n=5, series=series) @pytest.mark.parametrize( "series,series_name", @@ -612,9 +619,9 @@ def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=3) + assert_predictions_equal(model, loaded_model, n=3, series=test_series) # verify the series dimensions are preserved pred_original = model.predict(n=3) - pred_loaded = loaded_model.predict(n=3) + pred_loaded = loaded_model.predict(n=3, series=test_series) assert pred_original.width == pred_loaded.width diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 2032a08514..40a8876cf3 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -119,12 +119,13 @@ def save_model( os.makedirs(data_dir, exist_ok=True) + # pass in clean=True to not include any timeseries or callbacks within the model file if is_torch: model_file = _MODEL_FILE_TORCH - model.save(os.path.join(data_dir, model_file)) + model.save(os.path.join(data_dir, model_file), clean=True) else: model_file = _MODEL_FILE_STAT - model.save(os.path.join(data_dir, model_file)) + model.save(os.path.join(data_dir, model_file), clean=True) module_path, class_name = _get_model_class_path(model) From ac4b0c6fe584a56f62f955c22dd15c97cb0616ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 17 Feb 2026 14:59:08 +0100 Subject: [PATCH 016/154] logging update --- darts/utils/mlflow.py | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 40a8876cf3..e25d8ea052 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -44,7 +44,7 @@ from mlflow.utils.requirements_utils import _get_pinned_requirement import darts -from darts.logging import get_logger +from darts.logging import get_logger, raise_if, raise_if_not from darts.models.forecasting.forecasting_model import ForecastingModel from darts.utils.utils import PL_AVAILABLE @@ -110,6 +110,11 @@ def save_model( Optional MLflow Model object to use for saving. When provided (typically by ``Model.log()``), this model instance is used instead of creating a new one. """ + raise_if_not( + isinstance(model, ForecastingModel), + "model must be an instance of darts.models.forecasting.ForecastingModel", + logger, + ) _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements) _validate_and_prepare_target_save_path(path) code_dir_subpath = _validate_and_copy_code_paths(code_paths, path) @@ -366,8 +371,8 @@ def get_all_subclasses(cls): _patched_fit, manage_run=manage_run, ) - except Exception: - pass + except Exception as e: + logger.info(f"Failed to patch {cls.__name__}.fit() for autologging: {e}") def get_default_pip_requirements(is_torch: bool = False) -> list[str]: @@ -426,7 +431,7 @@ def _log_model_params(model) -> None: try: params = model.model_params except AttributeError: - logger.debug("Model has no model_params attribute; skipping parameter logging.") + logger.info("Model has no model_params attribute; skipping parameter logging.") return if params: @@ -514,6 +519,7 @@ def _is_torch_model(model) -> bool: return isinstance(model, TorchForecastingModel) except ImportError: + logger.info("TorchForecastingModel not available; treating model as non-torch") return False @@ -550,7 +556,13 @@ def _import_model_class(module_path: str, class_name: str): The imported model class. """ module = importlib.import_module(module_path) - return getattr(module, class_name) + cls = getattr(module, class_name, None) + raise_if( + cls is None, + f"Class '{class_name}' not found in module '{module_path}'", + logger, + ) + return cls def _extract_covariate_metadata( @@ -630,7 +642,9 @@ def _patched_fit(original, self, *args, **kwargs): try: log_model(self, name="model", log_params=False) except Exception as e: - logger.warning(f"Failed to autolog model artifact: {e}") + logger.warning( + f"Failed to autolog model artifact for {type(self).__name__}: {e}" + ) return result @@ -725,7 +739,7 @@ def _inject_mlflow_callback(model) -> None: existing_callbacks = model.trainer_params.get("callbacks", []) if any(isinstance(cb, _DartsMlflowCallback) for cb in existing_callbacks): - logger.debug("MLflow callback already present, skipping injection") + logger.info("MLflow callback already present, skipping injection") return if not isinstance(existing_callbacks, list): @@ -733,4 +747,4 @@ def _inject_mlflow_callback(model) -> None: existing_callbacks.append(callback) model.trainer_params["callbacks"] = existing_callbacks - logger.debug(f"Injected MLflow callback into {type(model).__name__}") + logger.info(f"Injected MLflow callback into {type(model).__name__}") From a35a834e94ea3e5e03e56844661691bbc3905bf7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 17 Feb 2026 15:01:30 +0100 Subject: [PATCH 017/154] unused var, tfmodel.load handles .ckpt internally --- darts/utils/mlflow.py | 1 - 1 file changed, 1 deletion(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index e25d8ea052..bf9a80576a 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -56,7 +56,6 @@ _MODEL_FILE_STAT = "model.pkl" _MODEL_FILE_TORCH = "model.pt" -_MODEL_FILE_TORCH_CKPT = "model.pt.ckpt" def save_model( From 2695cc9f645c188badd1945b78b1175814b3329a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 09:58:50 +0100 Subject: [PATCH 018/154] documentation --- darts/utils/mlflow.py | 51 +++++++++++++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 16 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index bf9a80576a..bdfa99ea86 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -5,6 +5,13 @@ Custom MLflow model flavor for darts forecasting models. Supports saving, loading, logging and autolog for any darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) to MLflow. + +This module is partly adapted from and inspired by the open-source +implementation of SKtime's MLflow integration, with modifications to support +autologging and handle Darts-specific model and covariate metadata. + +References: +https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py """ import importlib @@ -98,16 +105,23 @@ def save_model( A list of additional pip requirement strings to add to the model's environment, in addition to the default requirements. signature - An ``mlflow.models.ModelSignature`` instance describing model input/output. - Use :func:`infer_signature` to automatically generate from example inputs. + *Unsupported, see notes.* An ``mlflow.models.ModelSignature`` instance describing model input/output. + Use ``mlflow.models.infer_signature()`` to automatically generate from example inputs. input_example - An example input for the model (used by MLflow UI). Should be a DataFrame - created with :func:`prepare_pyfunc_input`. + *Unsupported, see notes.* An example input for the model (used by MLflow UI). metadata Optional dictionary of custom metadata to store in the ``MLmodel`` file. mlflow_model Optional MLflow Model object to use for saving. When provided (typically by ``Model.log()``), this model instance is used instead of creating a new one. + + Notes + ----- + Signature and input_example params are currently not supported, as they + are used to support serving and input validation in the MLflow pyfunc flavor, + which is not implemented for darts models. They are accepted as params for + simplifying potential future extensibility, and to keep in line with MLflow API + conventions. """ raise_if_not( isinstance(model, ForecastingModel), @@ -268,11 +282,10 @@ def log_model( A list of additional pip requirement strings to add to the model's environment, in addition to the default requirements. signature - An ``mlflow.models.ModelSignature``. Use :func:`infer_signature` + *Unsupported, see notes.* An ``mlflow.models.ModelSignature``. Use ``mlflow.models.infer_signature()`` to automatically generate from example inputs. input_example - An example model input. Should be a DataFrame created with - :func:`prepare_pyfunc_input`. + *Unsupported, see notes.* An example model input. metadata Optional dict of custom metadata. log_params @@ -284,6 +297,14 @@ def log_model( ModelInfo MLflow ModelInfo object containing model_uri, run_id, artifact_path, model_id, timestamps, and other metadata about the logged model. + + Notes + ----- + Signature and input_example params are currently not supported, as they + are used to support serving and input validation in the MLflow pyfunc flavor, + which is not implemented for darts models. They are accepted as params for + simplifying potential future extensibility, and to keep in line with MLflow API + conventions. """ # import required as Model.log will call flavor.save_model() internally import darts.utils.mlflow as darts_mlflow @@ -323,9 +344,9 @@ def autolog( 1. Start an MLflow run (or reuse the currently active one). 2. Log model creation parameters (``model.model_params``). - 3. For PyTorch-based models: inject a callback that logs per-epoch - ``train_loss`` / ``val_loss`` metrics. - 4. Log the trained model artifact at the end of training. + 3. Log covariate usage information (past, future, and static covariates). + 4. For PyTorch-based models: inject a callback that logs per-epoch metrics. + 5. Log the trained model artifact at the end of training. Parameters ---------- @@ -476,9 +497,7 @@ def _log_covariate_info(model) -> None: ] covariate_info = { - cov_key: _extract_covariate_metadata( - model, cov_key, uses_attr, series_attr, names_attr - ) + cov_key: _extract_covariate_metadata(model, uses_attr, series_attr, names_attr) for cov_key, uses_attr, series_attr, names_attr in covariate_types } @@ -565,7 +584,7 @@ def _import_model_class(module_path: str, class_name: str): def _extract_covariate_metadata( - model, cov_type: str, uses_attr: str, series_attr: str, names_attr: str + model, uses_attr: str, series_attr: str, names_attr: str ) -> dict: """Extract metadata for a single covariate type. @@ -573,8 +592,6 @@ def _extract_covariate_metadata( ---------- model A Darts forecasting model instance. - cov_type : str - Covariate type name (e.g., "past_covariates"). uses_attr : str Model attribute name indicating covariate usage. series_attr : str @@ -606,6 +623,8 @@ def _patched_fit(original, self, *args, **kwargs): Handles both statistical and PyTorch-based models. For PyTorch models, automatically injects MLflow callback for per-epoch metrics logging. + Logs the trained model artifact if configured. + Parameters ---------- original From 662b8e3c86cd06b7e42f812393133a80987db017 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 13:23:19 +0100 Subject: [PATCH 019/154] added autolog logging default/provided metrics for all models --- darts/utils/mlflow.py | 229 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 226 insertions(+), 3 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index bdfa99ea86..8eaf985fe3 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -17,9 +17,10 @@ import importlib import json import os -from typing import Optional, Union +from typing import Callable, Optional, Union import mlflow +import numpy as np import yaml from mlflow.models import Model from mlflow.models.model import MLMODEL_FILE_NAME @@ -52,7 +53,9 @@ import darts from darts.logging import get_logger, raise_if, raise_if_not +from darts.metrics import mae, mape, mse, rmse from darts.models.forecasting.forecasting_model import ForecastingModel +from darts.timeseries import TimeSeries from darts.utils.utils import PL_AVAILABLE logger = get_logger(__name__) @@ -329,10 +332,17 @@ def log_model( ) +_DEFAULT_METRICS = [mae, mse, rmse, mape] + + @autologging_integration(FLAVOR_NAME) def autolog( log_models: bool = True, log_params: bool = True, + log_training_metrics: bool = True, + log_validation_metrics: bool = True, + inject_per_epoch_callbacks: bool = False, + extra_metrics: Optional[list[Callable]] = None, disable: bool = False, silent: bool = False, manage_run: bool = True, @@ -347,6 +357,8 @@ def autolog( 3. Log covariate usage information (past, future, and static covariates). 4. For PyTorch-based models: inject a callback that logs per-epoch metrics. 5. Log the trained model artifact at the end of training. + 6. Optionally compute and log forecasting metrics on training and/or + validation data. Parameters ---------- @@ -354,6 +366,25 @@ def autolog( If ``True`` (default), log the trained model artifact after ``fit()``. log_params If ``True`` (default), log model creation parameters. + log_training_metrics + If ``True``, compute in-sample forecasting metrics on the training data + after ``fit()`` completes. + Default ``True``. + log_validation_metrics + If ``True``, compute forecasting metrics on the validation series + (``val_series``) passed to ``fit()``. Only effective for models whose + ``fit()`` accepts a ``val_series`` argument (e.g. PyTorch-based models). + Default ``True``. + inject_per_epoch_callbacks + If ``True``, inject a PyTorch Lightning callback to log training and validation metrics at + the end of each epoch. Only effective for PyTorch-based models. To provide additional + callbacks use ``torch_metrics`` parameter while initializing the model. + Default ``False``. + extra_metrics + An optional list of additional Darts metric functions to log on top of + the defaults (``mae``, ``mse``, ``rmse``, ``mape``). Each function + must follow the standard Darts metric signature + ``metric(actual_series, pred_series)``. disable If ``True``, restore the original ``fit()`` methods and stop autologging. @@ -642,20 +673,41 @@ def _patched_fit(original, self, *args, **kwargs): """ log_models = get_autologging_config(FLAVOR_NAME, "log_models", True) log_params = get_autologging_config(FLAVOR_NAME, "log_params", True) + log_training_metrics = get_autologging_config( + FLAVOR_NAME, "log_training_metrics", False + ) + log_validation_metrics = get_autologging_config( + FLAVOR_NAME, "log_validation_metrics", False + ) + inject_per_epoch_callbacks = get_autologging_config( + FLAVOR_NAME, "inject_per_epoch_callbacks", False + ) + extra_metrics = get_autologging_config(FLAVOR_NAME, "extra_metrics", None) mlflow.set_tag("darts.model_class", type(self).__name__) if log_params: _log_model_params(self) - # Inject callback for torch models (no-op for non-torch models) - _inject_mlflow_callback(self) + # Inject per-epoch callbacks for torch models (no-op for non-torch models) + if inject_per_epoch_callbacks: + _inject_mlflow_callback(self) result = original(self, *args, **kwargs) if log_params: _log_covariate_info(self) + if log_training_metrics or log_validation_metrics: + _log_forecasting_metrics( + model=self, + fit_args=args, + fit_kwargs=kwargs, + log_training=log_training_metrics, + log_validation=log_validation_metrics, + extra_metrics=extra_metrics, + ) + if log_models: try: log_model(self, name="model", log_params=False) @@ -667,6 +719,177 @@ def _patched_fit(original, self, *args, **kwargs): return result +def _log_forecasting_metrics( + model, + fit_args: tuple, + fit_kwargs: dict, + log_training: bool, + log_validation: bool, + extra_metrics: Optional[list[Callable]] = None, +) -> None: + """Compute and log training and/or validation forecasting metrics to MLflow. + + After a model has been fitted this function optionally: + + * Runs ``model.backtest()`` on the training series (``retrain=False``) + and logs metrics with a ``train_`` prefix. + * Runs ``model.backtest()`` on the validation series and logs metrics + with a ``val_`` prefix. + + For multiple series the metrics are averaged to produce a single value per metric. + + Parameters + ---------- + model + A fitted Darts forecasting model. + fit_args + Positional arguments originally passed to ``fit()``. + fit_kwargs + Keyword arguments originally passed to ``fit()``. + log_training + Whether to compute and log in-sample training metrics. + log_validation + Whether to compute and log validation metrics. + extra_metrics + Optional extra metric functions in addition to the defaults. + """ + metrics_list = _get_metrics_list(extra_metrics) + + # determine forecast horizon from model attributes + forecast_horizon = getattr(model, "output_chunk_length", None) or 1 + + # extract series and covariates from fit() call + train_series = fit_args[0] if fit_args else fit_kwargs.get("series") + past_covariates = fit_kwargs.get("past_covariates") + future_covariates = fit_kwargs.get("future_covariates") + val_series = fit_kwargs.get("val_series") + val_past_covariates = fit_kwargs.get("val_past_covariates") + val_future_covariates = fit_kwargs.get("val_future_covariates") + + if log_training and train_series is not None: + try: + _backtest_and_log( + model, + series=train_series, + metrics_list=metrics_list, + prefix="train", + past_covariates=past_covariates, + future_covariates=future_covariates, + forecast_horizon=forecast_horizon, + ) + except Exception: + logger.info( + "Could not compute training forecasting metrics for " + f"{type(model).__name__}.", + exc_info=True, + ) + + if log_validation and val_series is not None: + try: + _backtest_and_log( + model, + series=val_series, + metrics_list=metrics_list, + prefix="val", + past_covariates=val_past_covariates or past_covariates, + future_covariates=val_future_covariates or future_covariates, + forecast_horizon=forecast_horizon, + ) + except Exception: + logger.info( + "Could not compute validation forecasting metrics for " + f"{type(model).__name__}.", + exc_info=True, + ) + + +def _backtest_and_log( + model, + series: Union[TimeSeries, list[TimeSeries]], + metrics_list: list[Callable], + prefix: str, + past_covariates=None, + future_covariates=None, + forecast_horizon: int = 1, +) -> None: + """Run ``model.backtest()`` and log the resulting scores to MLflow. + + Parameters + ---------- + model + A fitted Darts forecasting model. + series + One or more target series to evaluate on. + metrics_list + List of Darts metric functions to evaluate. + prefix + Prefix for the logged metric names (e.g. ``"train"`` or ``"val"``). + past_covariates + Optional past covariates matching ``series``. + future_covariates + Optional future covariates matching ``series``. + forecast_horizon + Number of steps to forecast at each backtest step. + """ + backtest_kwargs = dict( + series=series, + forecast_horizon=forecast_horizon, + retrain=False, + overlap_end=False, + last_points_only=True, + reduction=None, + verbose=False, + show_warnings=False, + ) + if past_covariates is not None: + backtest_kwargs["past_covariates"] = past_covariates + if future_covariates is not None: + backtest_kwargs["future_covariates"] = future_covariates + + logged = {} + for metric_fn in metrics_list: + try: + score = model.backtest(**backtest_kwargs, metric=metric_fn) + # backtest returns a float, np.ndarray, or list depending on the + # input. We want a single scalar per metric so we take the mean. + + logged[f"{prefix}_{metric_fn.__name__}"] = float(np.nanmean(score)) + except Exception: + logger.debug( + f"Backtest metric {metric_fn.__name__} failed for " + f"{type(model).__name__}, skipping.", + exc_info=True, + ) + + if logged: + mlflow.log_metrics(logged) + + +def _get_metrics_list( + extra_metrics: Optional[list[Callable]] = None, +) -> list[Callable]: + """Return the combined list of default and extra metric functions. + + Parameters + ---------- + extra_metrics + Optional additional metric functions to append to the defaults. + + Returns + ------- + list[Callable] + A list of metric functions (``mae``, ``mse``, ``rmse``, ``mape``, plus extras). + """ + metrics = list(_DEFAULT_METRICS) + if extra_metrics: + seen_names = {m.__name__ for m in metrics} + for m in extra_metrics: + if m.__name__ not in seen_names: + metrics.append(m) + seen_names.add(m.__name__) + return metrics + + if PL_AVAILABLE: import pytorch_lightning as pl From f19d6bf200976ca2709881f2754e978c99574481 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 13:24:53 +0100 Subject: [PATCH 020/154] autolog metric unit tests --- darts/tests/optional_deps/test_mlflow.py | 272 +++++++++++++++-------- 1 file changed, 177 insertions(+), 95 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index ed92f2475e..b45d6f2e9a 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -38,13 +38,18 @@ def mlflow_tracking(tmpdir_fn): @pytest.fixture def autolog_context(): - """Context manager to safely enable/disable autolog for a test.""" + """Context manager to safely enable/disable autolog for a test. + + Usage: + with autolog_context(): # default autolog + with autolog_context(log_training_metrics=True): # custom kwargs + """ from contextlib import contextmanager @contextmanager - def _autolog_context(): + def _autolog_context(**kwargs): autolog(disable=True) # clean state - autolog() # enable for test + autolog(**kwargs) # enable with custom kwargs try: yield finally: @@ -91,19 +96,6 @@ class TestMLflow: ts_past_cov = tg.sine_timeseries(length=62).astype("float32") ts_future_cov = tg.constant_timeseries(value=1.0, length=62).astype("float32") - def test_save_load_statistical_model(self, tmpdir_fn): - """Test save/load round-trip for statistical model""" - model = ExponentialSmoothing() - model.fit(self.ts_univariate) - - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) - - assert_mlflow_artifacts_exist(model_path, is_torch=False) - - loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=5) - def test_save_load_regression_model(self, tmpdir_fn): """Test save/load round-trip for regression model""" model = LinearRegressionModel(lags=5) @@ -144,22 +136,6 @@ def test_log_model_basic(self, mlflow_tracking): loaded_model = load_model(log_info.model_uri) assert_predictions_equal(model, loaded_model, n=5) - def test_log_model_with_params(self, mlflow_tracking): - """Test that log_params=True logs model parameters""" - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) - - with mlflow.start_run(): - log_model(model, name="model", log_params=True) - run_id = mlflow.active_run().info.run_id - - run = mlflow.get_run(run_id) - assert run.data.params["lags"] == "5" - assert run.data.params["lags_past_covariates"] == "3" - assert run.data.params["n_past_covariates"] == "1" - assert run.data.params["n_future_covariates"] == "0" - assert run.data.params["n_static_covariates"] == "0" - def test_log_model_with_covariates(self, mlflow_tracking): """Test that covariate info is logged with correct values""" model = LinearRegressionModel(lags=5, lags_past_covariates=3) @@ -287,7 +263,7 @@ def test_autolog_parameters(self, mlflow_tracking, autolog_context): @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): """Test that autolog logs training metrics for torch models""" - with autolog_context(): + with autolog_context(inject_per_epoch_callbacks=True): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, @@ -324,7 +300,7 @@ def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_injects_callback(self, mlflow_tracking, autolog_context): """Test that autolog injects MLflow callback into torch models""" - with autolog_context(): + with autolog_context(inject_per_epoch_callbacks=True): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, @@ -356,33 +332,6 @@ def test_autolog_injects_callback(self, mlflow_tracking, autolog_context): f"_DartsMlflowCallback not found in {[type(cb).__name__ for cb in final_callbacks]}" ) - def test_covariate_artifact_schema(self, mlflow_tracking): - """Test that covariate artifact has correct JSON schema""" - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) - - with mlflow.start_run(): - log_model(model, name="model", log_params=True) - - artifact_uri = mlflow.get_artifact_uri("covariates.json") - artifact_path = artifact_uri.replace("file://", "") - - with open(artifact_path) as f: - cov_data = json.load(f) - - # validate schema structure - required_keys = ["past_covariates", "future_covariates", "static_covariates"] - assert all(key in cov_data for key in required_keys), ( - "Missing required covariate keys" - ) - - for cov_type in required_keys: - cov_info = cov_data[cov_type] - assert "used" in cov_info and isinstance(cov_info["used"], bool) - assert "count" in cov_info and isinstance(cov_info["count"], int) - assert "names" in cov_info and isinstance(cov_info["names"], list) - assert cov_info["count"] == len(cov_info["names"]) - def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" # create multivariate target with static covariates @@ -428,7 +377,7 @@ def test_callback_injection_with_existing_callbacks( else: pytest.skip("PyTorch Lightning not available") - with autolog_context(): + with autolog_context(inject_per_epoch_callbacks=True): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, @@ -472,34 +421,6 @@ def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): assert "ExponentialSmoothing" in model_classes assert "LinearRegressionModel" in model_classes - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_context): - """Test autolog with multiple fits of a torch model""" - with autolog_context(): - with mlflow.start_run(): - model1 = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=1, - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model1.fit(train, val_series=val) - - with mlflow.start_run(): - model2 = LinearRegressionModel(lags=5) - model2.fit(self.ts_univariate) - - runs = mlflow.search_runs() - assert len(runs) == 2, "Expected two separate runs for two fits" - - for _, run in runs.iterrows(): - assert run["tags.darts.model_class"] in [ - "NBEATSModel", - "LinearRegressionModel", - ] - assert run["tags.mlflow.runName"] is not None - def test_save_load_preserves_series_metadata(self, tmpdir_fn): """Test that save/load preserves multivariate and static covariate structure""" target = self.ts_multivariate.with_static_covariates( @@ -527,11 +448,6 @@ def test_save_load_preserves_series_metadata(self, tmpdir_fn): pred_original.values(), pred_loaded.values(), decimal=4 ) - def test_load_nonexistent_model(self): - """Test that loading nonexistent model raises appropriate error""" - with pytest.raises(Exception): - load_model("runs:/fake_run_id/model") - def test_load_invalid_uri_fails(self): """Test that loading with invalid URI raises an error""" with pytest.raises(Exception): @@ -625,3 +541,169 @@ def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): pred_original = model.predict(n=3) pred_loaded = loaded_model.predict(n=3, series=test_series) assert pred_original.width == pred_loaded.width + + def test_autolog_training_metrics_regression( + self, mlflow_tracking, autolog_context + ): + """Test that autolog computes and logs in-sample training metrics for regression models.""" + with autolog_context(log_training_metrics=True): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, output_chunk_length=3) + model.fit(self.ts_univariate) + + run_data = mlflow.get_run(run.info.run_id).data + + for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: + assert metric_name in run_data.metrics, f"{metric_name} should be logged" + assert np.isfinite(run_data.metrics[metric_name]) + + def test_autolog_extra_metrics(self, mlflow_tracking, autolog_context): + """Test that extra_metrics are logged alongside defaults.""" + from darts.metrics import r2_score, smape + + with autolog_context( + log_training_metrics=True, extra_metrics=[smape, r2_score] + ): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, output_chunk_length=3) + model.fit(self.ts_univariate) + + run_data = mlflow.get_run(run.info.run_id).data + + # defaults + for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: + assert metric_name in run_data.metrics + # extras + assert "train_smape" in run_data.metrics + assert "train_r2_score" in run_data.metrics + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_training_metrics_torch(self, mlflow_tracking, autolog_context): + """Test that autolog logs training metrics for torch models including epochs_trained.""" + with autolog_context( + log_training_metrics=True, inject_per_epoch_callbacks=True + ): + with mlflow.start_run() as run: + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train) + + run_data = mlflow.get_run(run.info.run_id).data + + assert "train_loss" in run_data.metrics + for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: + assert metric_name in run_data.metrics, ( + f"{metric_name} should be logged for torch model" + ) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_validation_metrics_torch(self, mlflow_tracking, autolog_context): + """Test that validation metrics are computed on val_series for torch models.""" + with autolog_context(log_training_metrics=True, log_validation_metrics=True): + with mlflow.start_run() as run: + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) + + run_data = mlflow.get_run(run.info.run_id).data + + # validation forecasting metrics + for metric_name in ["val_mae", "val_mse", "val_rmse", "val_mape"]: + assert metric_name in run_data.metrics, ( + f"{metric_name} should be logged for torch model with val_series" + ) + assert np.isfinite(run_data.metrics[metric_name]) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_validation_metrics_disabled( + self, mlflow_tracking, autolog_context + ): + """Test that validation metrics are NOT logged when log_validation_metrics=False.""" + with autolog_context(log_training_metrics=True, log_validation_metrics=False): + with mlflow.start_run() as run: + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) + + run_data = mlflow.get_run(run.info.run_id).data + + # training metrics should still be present + assert "train_mae" in run_data.metrics + # validation metrics should NOT be present + for metric_name in ["val_mae", "val_mse", "val_rmse", "val_mape"]: + assert metric_name not in run_data.metrics, ( + f"{metric_name} should NOT be logged when validation disabled" + ) + + def test_autolog_training_metrics_multiple_series( + self, mlflow_tracking, autolog_context + ): + """Test that backtest-based training metrics work with multiple series.""" + ts1 = tg.linear_timeseries(start_value=10, end_value=50, length=50).astype( + "float32" + ) + ts2 = tg.linear_timeseries(start_value=20, end_value=60, length=50).astype( + "float32" + ) + + with autolog_context(log_training_metrics=True): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, output_chunk_length=3) + model.fit([ts1, ts2]) + + run_data = mlflow.get_run(run.info.run_id).data + + for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: + assert metric_name in run_data.metrics, ( + f"{metric_name} should be logged for multiple series" + ) + assert np.isfinite(run_data.metrics[metric_name]) + + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_training_metrics_multiple_series_torch( + self, mlflow_tracking, autolog_context + ): + """Test that backtest-based training metrics work with multiple series on torch models.""" + ts1 = tg.linear_timeseries(start_value=10, end_value=50, length=50).astype( + "float32" + ) + ts2 = tg.linear_timeseries(start_value=20, end_value=60, length=50).astype( + "float32" + ) + + with autolog_context(log_training_metrics=True): + with mlflow.start_run() as run: + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + pl_trainer_kwargs={ + "accelerator": "cpu", + "enable_progress_bar": False, + "enable_model_summary": False, + }, + ) + model.fit([ts1, ts2]) + + run_data = mlflow.get_run(run.info.run_id).data + + for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: + assert metric_name in run_data.metrics, ( + f"{metric_name} should be logged for torch multiple series" + ) + assert np.isfinite(run_data.metrics[metric_name]) From bd932a9034ad626a03837afacddca2aef5d5eff1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 13:25:59 +0100 Subject: [PATCH 021/154] removed redundant tests --- darts/tests/optional_deps/test_mlflow.py | 95 +++++++++++++++++++++++- 1 file changed, 92 insertions(+), 3 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index b45d6f2e9a..b72200f843 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -96,6 +96,19 @@ class TestMLflow: ts_past_cov = tg.sine_timeseries(length=62).astype("float32") ts_future_cov = tg.constant_timeseries(value=1.0, length=62).astype("float32") + def test_save_load_statistical_model(self, tmpdir_fn): + """Test save/load round-trip for statistical model""" + model = ExponentialSmoothing() + model.fit(self.ts_univariate) + + model_path = os.path.join(tmpdir_fn, "test_model") + save_model(model, model_path) + + assert_mlflow_artifacts_exist(model_path, is_torch=False) + + loaded_model = load_model(f"file://{model_path}") + assert_predictions_equal(model, loaded_model, n=5) + def test_save_load_regression_model(self, tmpdir_fn): """Test save/load round-trip for regression model""" model = LinearRegressionModel(lags=5) @@ -136,6 +149,22 @@ def test_log_model_basic(self, mlflow_tracking): loaded_model = load_model(log_info.model_uri) assert_predictions_equal(model, loaded_model, n=5) + def test_log_model_with_params(self, mlflow_tracking): + """Test that log_params=True logs model parameters""" + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) + + with mlflow.start_run(): + log_model(model, name="model", log_params=True) + run_id = mlflow.active_run().info.run_id + + run = mlflow.get_run(run_id) + assert run.data.params["lags"] == "5" + assert run.data.params["lags_past_covariates"] == "3" + assert run.data.params["n_past_covariates"] == "1" + assert run.data.params["n_future_covariates"] == "0" + assert run.data.params["n_static_covariates"] == "0" + def test_log_model_with_covariates(self, mlflow_tracking): """Test that covariate info is logged with correct values""" model = LinearRegressionModel(lags=5, lags_past_covariates=3) @@ -263,7 +292,7 @@ def test_autolog_parameters(self, mlflow_tracking, autolog_context): @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): """Test that autolog logs training metrics for torch models""" - with autolog_context(inject_per_epoch_callbacks=True): + with autolog_context(): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, @@ -300,7 +329,7 @@ def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_injects_callback(self, mlflow_tracking, autolog_context): """Test that autolog injects MLflow callback into torch models""" - with autolog_context(inject_per_epoch_callbacks=True): + with autolog_context(): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, @@ -332,6 +361,33 @@ def test_autolog_injects_callback(self, mlflow_tracking, autolog_context): f"_DartsMlflowCallback not found in {[type(cb).__name__ for cb in final_callbacks]}" ) + def test_covariate_artifact_schema(self, mlflow_tracking): + """Test that covariate artifact has correct JSON schema""" + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) + + with mlflow.start_run(): + log_model(model, name="model", log_params=True) + + artifact_uri = mlflow.get_artifact_uri("covariates.json") + artifact_path = artifact_uri.replace("file://", "") + + with open(artifact_path) as f: + cov_data = json.load(f) + + # validate schema structure + required_keys = ["past_covariates", "future_covariates", "static_covariates"] + assert all(key in cov_data for key in required_keys), ( + "Missing required covariate keys" + ) + + for cov_type in required_keys: + cov_info = cov_data[cov_type] + assert "used" in cov_info and isinstance(cov_info["used"], bool) + assert "count" in cov_info and isinstance(cov_info["count"], int) + assert "names" in cov_info and isinstance(cov_info["names"], list) + assert cov_info["count"] == len(cov_info["names"]) + def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" # create multivariate target with static covariates @@ -377,7 +433,7 @@ def test_callback_injection_with_existing_callbacks( else: pytest.skip("PyTorch Lightning not available") - with autolog_context(inject_per_epoch_callbacks=True): + with autolog_context(): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, @@ -421,6 +477,34 @@ def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): assert "ExponentialSmoothing" in model_classes assert "LinearRegressionModel" in model_classes + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") + def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_context): + """Test autolog with multiple fits of a torch model""" + with autolog_context(): + with mlflow.start_run(): + model1 = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=1, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model1.fit(train, val_series=val) + + with mlflow.start_run(): + model2 = LinearRegressionModel(lags=5) + model2.fit(self.ts_univariate) + + runs = mlflow.search_runs() + assert len(runs) == 2, "Expected two separate runs for two fits" + + for _, run in runs.iterrows(): + assert run["tags.darts.model_class"] in [ + "NBEATSModel", + "LinearRegressionModel", + ] + assert run["tags.mlflow.runName"] is not None + def test_save_load_preserves_series_metadata(self, tmpdir_fn): """Test that save/load preserves multivariate and static covariate structure""" target = self.ts_multivariate.with_static_covariates( @@ -448,6 +532,11 @@ def test_save_load_preserves_series_metadata(self, tmpdir_fn): pred_original.values(), pred_loaded.values(), decimal=4 ) + def test_load_nonexistent_model(self): + """Test that loading nonexistent model raises appropriate error""" + with pytest.raises(Exception): + load_model("runs:/fake_run_id/model") + def test_load_invalid_uri_fails(self): """Test that loading with invalid URI raises an error""" with pytest.raises(Exception): From 3b0ecb2a4195b33ae2624f3a18d710807f80f597 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 14:08:25 +0100 Subject: [PATCH 022/154] changed callback inject to true by default --- darts/utils/mlflow.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 8eaf985fe3..a0c39bf4d7 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -341,7 +341,7 @@ def autolog( log_params: bool = True, log_training_metrics: bool = True, log_validation_metrics: bool = True, - inject_per_epoch_callbacks: bool = False, + inject_per_epoch_callbacks: bool = True, extra_metrics: Optional[list[Callable]] = None, disable: bool = False, silent: bool = False, @@ -376,10 +376,9 @@ def autolog( ``fit()`` accepts a ``val_series`` argument (e.g. PyTorch-based models). Default ``True``. inject_per_epoch_callbacks - If ``True``, inject a PyTorch Lightning callback to log training and validation metrics at - the end of each epoch. Only effective for PyTorch-based models. To provide additional - callbacks use ``torch_metrics`` parameter while initializing the model. - Default ``False``. + If ``True`` (default), inject a PyTorch Lightning callback to log training and validation + metrics at the end of each epoch. Only effective for PyTorch-based models. To provide + additional callbacks use ``torch_metrics`` parameter while initializing the model. extra_metrics An optional list of additional Darts metric functions to log on top of the defaults (``mae``, ``mse``, ``rmse``, ``mape``). Each function @@ -680,7 +679,7 @@ def _patched_fit(original, self, *args, **kwargs): FLAVOR_NAME, "log_validation_metrics", False ) inject_per_epoch_callbacks = get_autologging_config( - FLAVOR_NAME, "inject_per_epoch_callbacks", False + FLAVOR_NAME, "inject_per_epoch_callbacks", True ) extra_metrics = get_autologging_config(FLAVOR_NAME, "extra_metrics", None) From 2d6158d48480aa18dfa3979bd83caf2edcf8ae4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 14:08:31 +0100 Subject: [PATCH 023/154] feat: ensure contiguous tensors in metric updates --- darts/models/forecasting/pl_forecasting_module.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/darts/models/forecasting/pl_forecasting_module.py b/darts/models/forecasting/pl_forecasting_module.py index b45ee0bf0c..b0b832877d 100644 --- a/darts/models/forecasting/pl_forecasting_module.py +++ b/darts/models/forecasting/pl_forecasting_module.py @@ -455,8 +455,11 @@ def _update_metrics(self, output, target, metrics): pred = output.squeeze(dim=-1) # torch metrics require 2D targets of shape (batch size * ocl, num targets) - target = target.reshape(-1, self.n_targets) - pred = pred.reshape(-1, self.n_targets) + # contiguous() is needed because model outputs can be non-contiguous views + # (e.g. NBEATS slices the last dimension), and some torchmetrics implementations + # call .view() internally which requires a contiguous tensor. + target = target.reshape(-1, self.n_targets).contiguous() + pred = pred.reshape(-1, self.n_targets).contiguous() metrics.update(pred, target) From f684041f125700ce3a5871a37eba051f75770e39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 14:52:19 +0100 Subject: [PATCH 024/154] example quickstart for mlflow --- examples/26-MLflow-quickstart.ipynb | 877 ++++++++++++++++++++++++++++ 1 file changed, 877 insertions(+) create mode 100644 examples/26-MLflow-quickstart.ipynb diff --git a/examples/26-MLflow-quickstart.ipynb b/examples/26-MLflow-quickstart.ipynb new file mode 100644 index 0000000000..5a119983c5 --- /dev/null +++ b/examples/26-MLflow-quickstart.ipynb @@ -0,0 +1,877 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "aeddb542", + "metadata": {}, + "source": [ + "# MLflow for Darts\n", + "\n", + "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", + "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", + "\n", + "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", + "\n", + "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." + ] + }, + { + "cell_type": "markdown", + "id": "f72894af", + "metadata": {}, + "source": [ + "## Installing MLflow\n", + "\n", + "MLflow is available as an optional dependency for Darts. Install it with:\n", + "\n", + "```bash\n", + "pip install mlflow\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "42e3dcea", + "metadata": {}, + "source": [ + "## Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "b346ce8f", + "metadata": {}, + "outputs": [], + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13b13fe4", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import mlflow\n", + "import numpy as np\n", + "\n", + "from darts.datasets import AirPassengersDataset\n", + "from darts.metrics import mape, rmse\n", + "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", + "from darts.utils.mlflow import autolog, load_model, log_model, save_model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "4d424e08", + "metadata": {}, + "outputs": [], + "source": [ + "# use darts plotting style\n", + "from darts import set_option\n", + "\n", + "set_option(\"plotting.use_darts_style\", True)" + ] + }, + { + "cell_type": "markdown", + "id": "2f9c40d6", + "metadata": {}, + "source": [ + "## MLflow Setup\n", + "\n", + "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88320df5", + "metadata": {}, + "outputs": [], + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ] + }, + { + "cell_type": "markdown", + "id": "03d5209e", + "metadata": {}, + "source": [ + "## Load Sample Data\n", + "\n", + "We'll use the classic AirPassengers dataset for this example." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "1596e07e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training series: 107 points\n", + "Validation series: 37 points\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "34858645", + "metadata": {}, + "source": [ + "## Basic Model Logging\n", + "\n", + "Let's train a simple model and log it to MLflow manually." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "bc8f520d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = ExponentialSmoothing()\n", + "model.fit(train)\n", + "\n", + "predictions = model.predict(n=len(val))\n", + "\n", + "# calculate metrics you want to log to MLflow\n", + "mape_score = mape(val, predictions)\n", + "rmse_score = rmse(val, predictions)\n", + "\n", + "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", + "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", + "\n", + "train[-50:].plot(label=\"Training\")\n", + "val.plot(label=\"Actual\")\n", + "predictions.plot(label=\"Forecast\")\n", + "plt.legend()\n", + "plt.title(\"Exponential Smoothing Forecast\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "35dc864c", + "metadata": {}, + "source": [ + "Now let's log this model to MLflow:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "61406cd9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run ID: 936e44cf2edb4db0bc6e32aa0d9fdfd9\n", + "Model URI: models:/m-280d9919c51642dabaf49017ad97ca65\n" + ] + } + ], + "source": [ + "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", + " model_info = log_model(\n", + " model=model,\n", + " name=\"model\",\n", + " log_params=True, # True by default, logs all model params\n", + " )\n", + "\n", + " # log calculated metrics you want\n", + " mlflow.log_metric(\"val_mape\", mape_score)\n", + " mlflow.log_metric(\"val_rmse\", rmse_score)\n", + "\n", + " # log any additional tags you want\n", + " mlflow.set_tag(\"model_type\", \"ExponentialSmoothing\")\n", + " mlflow.set_tag(\"dataset\", \"AirPassengers\")\n", + "\n", + " print(f\"Run ID: {run.info.run_id}\")\n", + " print(f\"Model URI: {model_info.model_uri}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0728690e", + "metadata": {}, + "source": [ + "### Load the Model Back\n", + "\n", + "We can load the model from MLflow using its URI:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "cae35ffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model predictions match: True\n" + ] + } + ], + "source": [ + "loaded_model = load_model(model_info.model_uri)\n", + "\n", + "loaded_predictions = loaded_model.predict(n=len(val))\n", + "\n", + "# verify predictions match\n", + "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", + "print(f\"Loaded model predictions match: {predictions_match}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6bd4597c", + "metadata": {}, + "source": [ + "## Automatic Logging with `autolog()`\n", + "\n", + "`autolog()` patches every `model.fit()` call to automatically log parameters, covariate metadata, and the trained model artifact. For PyTorch-based models it also injects a callback that logs `train_loss` / `val_loss` per epoch (see the sections below for details)." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5ef7f73a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Logged metrics: {'train_mae': 8.4783, 'train_mape': 3.9116, 'train_mse': 118.1369, 'train_rmse': 10.8691, 'val_mape': 10.742, 'val_rmse': 51.182}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "autolog()\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", + " auto_model = LinearRegressionModel(lags=12)\n", + " auto_model.fit(train) # no val_series → autolog logs train_* metrics by default\n", + "\n", + " auto_predictions = auto_model.predict(n=len(val))\n", + " auto_mape = mape(val, auto_predictions)\n", + " auto_rmse = rmse(val, auto_predictions)\n", + " mlflow.log_metric(\"val_mape\", auto_mape)\n", + " mlflow.log_metric(\"val_rmse\", auto_rmse)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show logged metrics\n", + "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", + "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", + "\n", + "# plot\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "train[-36:].plot(label=\"Train\", ax=ax)\n", + "val.plot(label=\"Actual\", ax=ax)\n", + "auto_predictions.plot(\n", + " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", + ")\n", + "ax.set_title(\"Linear Regression — autolog run\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f484330f", + "metadata": {}, + "source": [ + "## Open the MLflow UI\n", + "\n", + "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", + "\n", + "The UI lets you:\n", + "- **Compare runs** side-by-side in the Experiments table\n", + "- **Inspect** individual run parameters, metrics, and logged artifacts\n", + "- **Visualize** metrics across runs with built-in charts\n", + "- **Register** models to the Model Registry for versioning" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1a01cd2f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Launch the MLflow UI with this command in your terminal:\n", + "\n", + " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmph5ei82gg/mlflow.db\n", + "\n", + "Then open: http://localhost:5000\n" + ] + } + ], + "source": [ + "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", + "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", + "print(\"Then open: http://localhost:5000\")" + ] + }, + { + "attachments": { + "image-2.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "88b0d285", + "metadata": {}, + "source": [ + "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `val_mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", + ">\n", + "![image-2.png](attachment:image-2.png)" + ] + }, + { + "cell_type": "markdown", + "id": "e2b133bc", + "metadata": {}, + "source": [ + "## Per-epoch Metrics with Torch Models\n", + "\n", + "For neural models, `autolog()` by default injects a PyTorch Lightning callback that logs `train_loss` and `val_loss` at the end of every epoch.\n", + "\n", + "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d01783d1", + "metadata": {}, + "outputs": [], + "source": [ + "from torchmetrics import MeanAbsoluteError, MeanSquaredError, MetricCollection\n", + "\n", + "# inject_per_epoch_callbacks=True is the default\n", + "autolog()\n", + "\n", + "with mlflow.start_run(run_name=\"nbeats-epoch-metrics\"):\n", + " nbeats = NBEATSModel(\n", + " input_chunk_length=24,\n", + " output_chunk_length=12,\n", + " n_epochs=10,\n", + " pl_trainer_kwargs={\"accelerator\": \"cpu\"},\n", + " # these are logged per epoch as train_MAE, val_MAE, train_MSE, val_MSE\n", + " torch_metrics=MetricCollection({\n", + " \"MAE\": MeanAbsoluteError(),\n", + " \"MSE\": MeanSquaredError(),\n", + " }),\n", + " random_state=42,\n", + " )\n", + " nbeats.fit(train, val_series=val)\n", + " nbeats_pred = nbeats.predict(n=len(val))\n", + " mlflow.log_metric(\"val_mape\", mape(val, nbeats_pred))\n", + " mlflow.log_metric(\"val_rmse\", rmse(val, nbeats_pred))\n", + " print(f\"NBEATS MAPE: {mape(val, nbeats_pred):.2f}%\")\n", + "\n", + "autolog(disable=True)" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "6fcc8f13", + "metadata": {}, + "source": [ + "> 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", + ">\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "id": "3f0828c2", + "metadata": {}, + "source": [ + "## Training & Validation Forecast Metrics\n", + "\n", + "Beyond per-epoch loss, `autolog()` can also run a backtest after training and log evaluation metrics (MAE, RMSE, MAPE, …) on both the **training series** and the **validation series**. Enable this with `log_training_metrics=True` and `log_validation_metrics=True`. Pass `extra_metrics` to extend the default set." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "df8e85b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All logged metrics (11):\n", + " manual_mape: 10.7420\n", + " train_mae: 8.4783\n", + " train_mape: 3.9116\n", + " train_mse: 118.1369\n", + " train_rmse: 10.8691\n", + " train_smape: 3.8915\n", + " val_mae: 12.5800\n", + " val_mape: 2.9449\n", + " val_mse: 243.0054\n", + " val_rmse: 15.5886\n", + " val_smape: 2.9130\n" + ] + } + ], + "source": [ + "from darts.metrics import mae, smape\n", + "\n", + "autolog(\n", + " log_training_metrics=True,\n", + " log_validation_metrics=True,\n", + " extra_metrics=[smape, mae], # add smape and mae on top of the defaults\n", + ")\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", + " lr_model = LinearRegressionModel(lags=12)\n", + " # if val_series is provided, autolog will log val_* metrics based on it\n", + " lr_model.fit(train, val_series=val)\n", + " # autolog already computed and logged train_mae, val_rmse, val_smape, ...\n", + " # manually log the final hold-out MAPE as well\n", + " lr_pred = lr_model.predict(n=len(val))\n", + " mlflow.log_metric(\"manual_mape\", mape(val, lr_pred))\n", + " run_id = run.info.run_id\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show what was logged\n", + "client = mlflow.tracking.MlflowClient()\n", + "run_metrics = client.get_run(run_id).data.metrics\n", + "metric_names = sorted(run_metrics.keys())\n", + "print(f\"All logged metrics ({len(metric_names)}):\")\n", + "for name in metric_names:\n", + " print(f\" {name}: {run_metrics[name]:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8511fc08", + "metadata": {}, + "source": [ + "## Saving and Loading Models Locally\n", + "\n", + "You can also save and load models to/from local paths without MLflow runs." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "645ef079", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Files in model directory:\n", + " - python_env.yaml\n", + " - requirements.txt\n", + " - MLmodel\n", + " - conda.yaml\n", + " - data\n" + ] + } + ], + "source": [ + "# Save model to local directory\n", + "local_model_path = os.path.join(tmpdir, \"my_model\")\n", + "save_model(model, path=local_model_path)\n", + "\n", + "print(\"\\nFiles in model directory:\")\n", + "for file in os.listdir(local_model_path):\n", + " print(f\" - {file}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "254ba153", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model successfully!\n", + "Predictions shape: (5, 1)\n" + ] + } + ], + "source": [ + "# Load model from local directory\n", + "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", + "\n", + "# Test it\n", + "local_predictions = local_loaded_model.predict(n=5)\n", + "print(\"Loaded model successfully!\")\n", + "print(f\"Predictions shape: {local_predictions.values().shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "aab0d1e0", + "metadata": {}, + "source": [ + "## Querying Experiments\n", + "\n", + "You can programmatically query and compare runs." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "109a9812", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 4 runs in experiment 'darts-quickstart':\n", + "\n", + "1. linear-regression-full-metrics\n", + " Run ID: 215983d797274f5c896aeac20b509e80\n", + " Validation MAPE: 2.944912539423521\n", + "\n", + "2. exponential-smoothing-baseline\n", + " Run ID: 936e44cf2edb4db0bc6e32aa0d9fdfd9\n", + " Validation MAPE: 7.864181481214469\n", + "\n", + "3. linear-regression-autolog\n", + " Run ID: 1a714494da10495485871221b816f326\n", + " Validation MAPE: 10.742044444678958\n", + "\n", + "4. nbeats-epoch-metrics\n", + " Run ID: d8206b7ef162477ab8eb12b7e950a440\n", + " Validation MAPE: 17.542747705910518\n", + "\n" + ] + } + ], + "source": [ + "from mlflow.tracking import MlflowClient\n", + "\n", + "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", + "\n", + "# get all runs\n", + "client = MlflowClient()\n", + "runs = client.search_runs(\n", + " experiment_ids=[experiment.experiment_id],\n", + " order_by=[\"metrics.val_mape ASC\"], # Sort by best MAPE\n", + ")\n", + "\n", + "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", + "for i, run in enumerate(runs, 1):\n", + " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", + " mape_val = run.data.metrics.get(\"val_mape\", \"N/A\")\n", + " print(f\"{i}. {run_name}\")\n", + " print(f\" Run ID: {run.info.run_id}\")\n", + " print(f\" Validation MAPE: {mape_val}\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "22685423", + "metadata": {}, + "source": [ + "### Load the Best Model" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "7b09db6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading best model from run: linear-regression-full-metrics\n", + "Model URI: runs:/215983d797274f5c896aeac20b509e80/model\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8225dcbe9d6a4297a294bb56eb3fa398", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading artifacts: 0%| | 0/1 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if runs:\n", + " best_run = runs[0]\n", + " best_model_uri = f\"runs:/{best_run.info.run_id}/model\"\n", + "\n", + " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", + " print(f\"Model URI: {best_model_uri}\")\n", + "\n", + " best_model = load_model(best_model_uri)\n", + " # series param required for loaded models, since we save with clean=True\n", + " best_predictions = best_model.predict(n=len(val), series=train)\n", + "\n", + " train[-50:].plot(label=\"Training\")\n", + " val.plot(label=\"Actual\")\n", + " best_predictions.plot(label=\"Best Model Forecast\")\n", + " plt.legend()\n", + " plt.title(\"Best Model Predictions\")\n", + " plt.show()" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "6f1ec89e", + "metadata": {}, + "source": [ + "## Model Registry\n", + "\n", + "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived).\n", + "\n", + "```python\n", + "# Register a model from a run\n", + "result = mlflow.register_model(\n", + " model_uri=f\"runs:/{best_run.info.run_id}/model\",\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")\n", + "```\n", + "\n", + "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", + "\n", + "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", + ">\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "id": "7af49ea9", + "metadata": {}, + "source": [ + "## Important Note: Custom Flavor\n", + "\n", + "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", + "\n", + "**Always use:**\n", + "```python\n", + "from darts.utils.mlflow import load_model\n", + "model = load_model(model_uri)\n", + "```\n", + "\n", + "**Instead of:**\n", + "```python\n", + "import mlflow\n", + "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", + "```\n", + "\n", + "This custom flavor is necessary to properly handle:\n", + "- TimeSeries objects\n", + "- Darts-specific model parameters\n", + "- Covariate handling (past, future, static)\n", + "- PyTorch model state preservation" + ] + }, + { + "cell_type": "markdown", + "id": "40621b13", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51fc7c4a", + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ca40afc1", + "metadata": {}, + "source": [ + "# Final Remarks" + ] + }, + { + "cell_type": "markdown", + "id": "c4c86a23", + "metadata": {}, + "source": [ + "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 894779bc7b62a46de4fe9c4cdc8b067131d3786b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 16:46:21 +0100 Subject: [PATCH 025/154] unit test mps fix for torch --- darts/tests/optional_deps/test_mlflow.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index b72200f843..24caf60494 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -438,7 +438,10 @@ def test_callback_injection_with_existing_callbacks( input_chunk_length=4, output_chunk_length=2, n_epochs=2, - pl_trainer_kwargs={"callbacks": [existing_callback]}, + pl_trainer_kwargs={ + **tfm_kwargs_dev.get("pl_trainer_kwargs", {}), + "callbacks": [existing_callback], + }, **{k: v for k, v in tfm_kwargs_dev.items() if k != "pl_trainer_kwargs"}, ) From c9a13016ea2f2a56393372323f18817f49e82ce6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 16:52:47 +0100 Subject: [PATCH 026/154] typehinting fix --- darts/utils/mlflow.py | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index a0c39bf4d7..98db6bbd3d 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -17,7 +17,7 @@ import importlib import json import os -from typing import Callable, Optional, Union +from collections.abc import Callable import mlflow import numpy as np @@ -71,14 +71,14 @@ def save_model( model, path: str, - conda_env: Optional[Union[dict, str]] = None, - code_paths: Optional[list[str]] = None, - pip_requirements: Optional[list[str]] = None, - extra_pip_requirements: Optional[list[str]] = None, + conda_env: dict | str | None = None, + code_paths: list[str] | None = None, + pip_requirements: list[str] | None = None, + extra_pip_requirements: list[str] | None = None, signature=None, input_example=None, - metadata: Optional[dict] = None, - mlflow_model: Optional[Model] = None, + metadata: dict | None = None, + mlflow_model: Model | None = None, ) -> None: """Save a darts forecasting model in MLflow format. @@ -198,7 +198,7 @@ def save_model( def load_model( model_uri: str, - dst_path: Optional[str] = None, + dst_path: str | None = None, **kwargs, ): """Load a darts model from an MLflow model URI. @@ -246,16 +246,16 @@ def load_model( def log_model( model, - artifact_path: Optional[str] = None, - name: Optional[str] = None, - registered_model_name: Optional[str] = None, - conda_env: Optional[Union[dict, str]] = None, - code_paths: Optional[list[str]] = None, - pip_requirements: Optional[list[str]] = None, - extra_pip_requirements: Optional[list[str]] = None, + artifact_path: str | None = None, + name: str | None = None, + registered_model_name: str | None = None, + conda_env: dict | str | None = None, + code_paths: list[str] | None = None, + pip_requirements: list[str] | None = None, + extra_pip_requirements: list[str] | None = None, signature=None, input_example=None, - metadata: Optional[dict] = None, + metadata: dict | None = None, log_params: bool = True, ): """Log a darts model to the current MLflow run. @@ -342,7 +342,7 @@ def autolog( log_training_metrics: bool = True, log_validation_metrics: bool = True, inject_per_epoch_callbacks: bool = True, - extra_metrics: Optional[list[Callable]] = None, + extra_metrics: list[Callable] | None = None, disable: bool = False, silent: bool = False, manage_run: bool = True, @@ -724,7 +724,7 @@ def _log_forecasting_metrics( fit_kwargs: dict, log_training: bool, log_validation: bool, - extra_metrics: Optional[list[Callable]] = None, + extra_metrics: list[Callable] | None = None, ) -> None: """Compute and log training and/or validation forecasting metrics to MLflow. @@ -804,7 +804,7 @@ def _log_forecasting_metrics( def _backtest_and_log( model, - series: Union[TimeSeries, list[TimeSeries]], + series: TimeSeries | list[TimeSeries], metrics_list: list[Callable], prefix: str, past_covariates=None, @@ -865,7 +865,7 @@ def _backtest_and_log( def _get_metrics_list( - extra_metrics: Optional[list[Callable]] = None, + extra_metrics: list[Callable] | None = None, ) -> list[Callable]: """Return the combined list of default and extra metric functions. From a65612dd57cf8eee58ecb6dd1842ba293f64cb50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 17:15:26 +0100 Subject: [PATCH 027/154] CI hotfix --- darts/tests/optional_deps/test_mlflow.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 24caf60494..ea6d5729aa 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -135,7 +135,12 @@ def test_save_load_torch_model(self, tmpdir_fn): assert_mlflow_artifacts_exist(model_path, is_torch=True) - loaded_model = load_model(f"file://{model_path}") + # save(clean=True) strips pl_trainer_kwargs; explicitly restore accelerator + # so Lightning doesn't default to MPS on Github macOS runner + loaded_model = load_model( + f"file://{model_path}", + pl_trainer_kwargs=tfm_kwargs_dev.get("pl_trainer_kwargs", {}), + ) assert_predictions_equal(model, loaded_model, n=2, series=self.ts_univariate) def test_log_model_basic(self, mlflow_tracking): From 21237420ec8998b79e7838167e41bf139fdf1242 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 18 Feb 2026 17:58:28 +0100 Subject: [PATCH 028/154] temporary fix for catboost, to be removed later --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index f95442a708..a84dce3925 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -64,7 +64,7 @@ torch = [ "safetensors>=0.6.2", ] notorch = [ - "catboost>=1.0.6", + "catboost>=1.0.6,<=1.2.9", "lightgbm>=3.2.0", "prophet>=1.1.1", "statsforecast>=1.4", From 2b41feb63b0d0681eb32a0cb00db340105c0ced6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 24 Feb 2026 13:35:21 +0100 Subject: [PATCH 029/154] scrap backtesting in favor of metric patching --- darts/utils/mlflow.py | 391 ++++++++++++++++++++++-------------------- 1 file changed, 206 insertions(+), 185 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 98db6bbd3d..ba168b2add 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -17,6 +17,7 @@ import importlib import json import os +import re from collections.abc import Callable import mlflow @@ -26,6 +27,7 @@ from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example from mlflow.tracking.artifact_utils import _download_artifact_from_uri +from mlflow.utils import _inspect_original_var_name from mlflow.utils.autologging_utils import ( autologging_integration, get_autologging_config, @@ -53,9 +55,7 @@ import darts from darts.logging import get_logger, raise_if, raise_if_not -from darts.metrics import mae, mape, mse, rmse from darts.models.forecasting.forecasting_model import ForecastingModel -from darts.timeseries import TimeSeries from darts.utils.utils import PL_AVAILABLE logger = get_logger(__name__) @@ -332,17 +332,12 @@ def log_model( ) -_DEFAULT_METRICS = [mae, mse, rmse, mape] - - @autologging_integration(FLAVOR_NAME) def autolog( log_models: bool = True, log_params: bool = True, - log_training_metrics: bool = True, - log_validation_metrics: bool = True, + log_metrics: bool = True, inject_per_epoch_callbacks: bool = True, - extra_metrics: list[Callable] | None = None, disable: bool = False, silent: bool = False, manage_run: bool = True, @@ -355,10 +350,33 @@ def autolog( 1. Start an MLflow run (or reuse the currently active one). 2. Log model creation parameters (``model.model_params``). 3. Log covariate usage information (past, future, and static covariates). - 4. For PyTorch-based models: inject a callback that logs per-epoch metrics. - 5. Log the trained model artifact at the end of training. - 6. Optionally compute and log forecasting metrics on training and/or - validation data. + 4. Patch all darts metric functions so that any call made inside an active + MLflow run automatically logs the result. Repeated calls overwrite + the previous value. + 5. For PyTorch-based models: inject a callback that logs per-epoch metrics. + 6. Log the trained model artifact at the end of training. + + .. important:: + + ``autolog()`` must be called **before** importing metric functions from + ``darts.metrics``. Metric functions imported before ``autolog()`` is + enabled will **not** log to MLflow. + + .. note:: + + Logged metric keys depend on the result shape: + + * **Scalar** → ``{metric_name}`` + * **Per-component** (1-D, single series) → + ``{metric_name}_{component_name}`` + * **Per-series** (1-D, list of series) → + ``{metric_name}_{series_idx}`` + * **Per-series × per-component** (2-D) → + ``{metric_name}_{component_name}_{series_idx}`` + + When a dataset variable name can be captured via frame inspection, + it is inserted after the metric name (e.g. + ``{metric_name}_{dataset_name}_{component_name}``). Parameters ---------- @@ -366,15 +384,9 @@ def autolog( If ``True`` (default), log the trained model artifact after ``fit()``. log_params If ``True`` (default), log model creation parameters. - log_training_metrics - If ``True``, compute in-sample forecasting metrics on the training data - after ``fit()`` completes. - Default ``True``. - log_validation_metrics - If ``True``, compute forecasting metrics on the validation series - (``val_series``) passed to ``fit()``. Only effective for models whose - ``fit()`` accepts a ``val_series`` argument (e.g. PyTorch-based models). - Default ``True``. + log_metrics + If ``True`` (default), patch all darts metric functions so that any + call made inside an active MLflow run is automatically logged. inject_per_epoch_callbacks If ``True`` (default), inject a PyTorch Lightning callback to log training and validation metrics at the end of each epoch. Only effective for PyTorch-based models. To provide @@ -424,6 +436,25 @@ def get_all_subclasses(cls): except Exception as e: logger.info(f"Failed to patch {cls.__name__}.fit() for autologging: {e}") + if log_metrics: + import darts.metrics as _darts_metrics + + for metric_name in _darts_metrics.__all__: + try: + # metrics should not create their own runs; + # they log into the run started by fit(), so manage_run=False here + safe_patch( + FLAVOR_NAME, + _darts_metrics, + metric_name, + _make_metric_patch(metric_name), + manage_run=False, + ) + except Exception as e: + logger.info( + f"Failed to patch metric '{metric_name}' on darts.metrics: {e}" + ) + def get_default_pip_requirements(is_torch: bool = False) -> list[str]: """Return the default pip requirements for logging a darts model. @@ -672,16 +703,9 @@ def _patched_fit(original, self, *args, **kwargs): """ log_models = get_autologging_config(FLAVOR_NAME, "log_models", True) log_params = get_autologging_config(FLAVOR_NAME, "log_params", True) - log_training_metrics = get_autologging_config( - FLAVOR_NAME, "log_training_metrics", False - ) - log_validation_metrics = get_autologging_config( - FLAVOR_NAME, "log_validation_metrics", False - ) inject_per_epoch_callbacks = get_autologging_config( FLAVOR_NAME, "inject_per_epoch_callbacks", True ) - extra_metrics = get_autologging_config(FLAVOR_NAME, "extra_metrics", None) mlflow.set_tag("darts.model_class", type(self).__name__) @@ -697,196 +721,193 @@ def _patched_fit(original, self, *args, **kwargs): if log_params: _log_covariate_info(self) - if log_training_metrics or log_validation_metrics: - _log_forecasting_metrics( - model=self, - fit_args=args, - fit_kwargs=kwargs, - log_training=log_training_metrics, - log_validation=log_validation_metrics, - extra_metrics=extra_metrics, - ) - if log_models: try: log_model(self, name="model", log_params=False) - except Exception as e: - logger.warning( - f"Failed to autolog model artifact for {type(self).__name__}: {e}" + except Exception: + logger.info( + f"Failed to autolog model artifact for {type(self).__name__}.", + exc_info=True, ) return result -def _log_forecasting_metrics( - model, - fit_args: tuple, - fit_kwargs: dict, - log_training: bool, - log_validation: bool, - extra_metrics: list[Callable] | None = None, +def _sanitize_mlflow_key(name: str) -> str: + """Sanitize a string for use as an MLflow metric key. + + Replaces any character that is not alphanumeric, a hyphen, or an + underscore with an underscore, so component names become valid + MLflow keys. + + Parameters + ---------- + name + The raw name to sanitize. + + Returns + ------- + str + A string safe for use as an MLflow metric key. + """ + return re.sub(r"[^\w-]", "_", name) + + +def _log_metric_result( + metric_name: str, + result, + dataset_name: str | None = None, + component_names: list[str] | None = None, + input_is_list: bool = False, ) -> None: - """Compute and log training and/or validation forecasting metrics to MLflow. + """Log a metric result to the active MLflow run. - After a model has been fitted this function optionally: + Handles Python scalars, numpy scalars, 1-D arrays, and 2-D arrays. - * Runs ``model.backtest()`` on the training series (``retrain=False``) - and logs metrics with a ``train_`` prefix. - * Runs ``model.backtest()`` on the validation series and logs metrics - with a ``val_`` prefix. + The logged MLflow key follows the pattern:: - For multiple series the metrics are averaged to produce a single value per metric. + {metric_name}_{dataset_name}_{component}_{series_index} + + Specifically: + + * **Scalar** (0-d) → ``{metric}_{dataset}`` + * **1-D, single TimeSeries input** (per-component) → + ``{metric}_{dataset}_{component_name_or_idx}`` + * **1-D, list input** (per-series, component already reduced) → + ``{metric}_{dataset}_{series_idx}`` + * **2-D, list input** (per-series × per-component) → + ``{metric}_{dataset}_{component_name_or_idx}_{series_idx}`` + + All optional parts are omitted when not available (e.g. no dataset name + when the variable name could not be inspected). Parameters ---------- - model - A fitted Darts forecasting model. - fit_args - Positional arguments originally passed to ``fit()``. - fit_kwargs - Keyword arguments originally passed to ``fit()``. - log_training - Whether to compute and log in-sample training metrics. - log_validation - Whether to compute and log validation metrics. - extra_metrics - Optional extra metric functions in addition to the defaults. + metric_name + Base metric name used as the MLflow key. + result + The metric result to log. + dataset_name + Sanitized variable name of ``actual_series`` in the caller's frame. + Omitted from key when ``None``. + component_names + Component name strings to use as the component part of the key. + For single-series input these come from ``series.components``; for + list input they come from the first series in the list. + Falls back to integer indices when ``None`` or length mismatches. + input_is_list + ``True`` when ``actual_series`` was a ``Sequence[TimeSeries]``. Drives + whether the first result axis is treated as *series* or *components*. """ - metrics_list = _get_metrics_list(extra_metrics) + result_arr = np.asarray(result) - # determine forecast horizon from model attributes - forecast_horizon = getattr(model, "output_chunk_length", None) or 1 + if mlflow.active_run() is None: + return - # extract series and covariates from fit() call - train_series = fit_args[0] if fit_args else fit_kwargs.get("series") - past_covariates = fit_kwargs.get("past_covariates") - future_covariates = fit_kwargs.get("future_covariates") - val_series = fit_kwargs.get("val_series") - val_past_covariates = fit_kwargs.get("val_past_covariates") - val_future_covariates = fit_kwargs.get("val_future_covariates") + base_key = f"{metric_name}_{dataset_name}" if dataset_name else metric_name + + def _comp_suffix(idx: int) -> str: + if component_names is not None and idx < len(component_names): + return _sanitize_mlflow_key(component_names[idx]) + return str(idx) + + if result_arr.ndim == 0: + # scalar result + mlflow.log_metric(base_key, float(result_arr)) + + elif result_arr.ndim == 1: + if not input_is_list: + # single series: log per-component + for c_i, val in enumerate(result_arr): + mlflow.log_metric(f"{base_key}_{_comp_suffix(c_i)}", float(val)) + else: + # list input, components already reduced: log per-series + for s_i, val in enumerate(result_arr): + mlflow.log_metric(f"{base_key}_{s_i}", float(val)) + + elif result_arr.ndim == 2: + # list input: log per-series and per-component + n_series, n_components = result_arr.shape + for s_i in range(n_series): + for c_i in range(n_components): + mlflow.log_metric( + f"{base_key}_{_comp_suffix(c_i)}_{s_i}", + float(result_arr[s_i, c_i]), + ) - if log_training and train_series is not None: - try: - _backtest_and_log( - model, - series=train_series, - metrics_list=metrics_list, - prefix="train", - past_covariates=past_covariates, - future_covariates=future_covariates, - forecast_horizon=forecast_horizon, - ) - except Exception: - logger.info( - "Could not compute training forecasting metrics for " - f"{type(model).__name__}.", - exc_info=True, - ) + else: + # unexpected shape — flatten with integer indices + for i, val in enumerate(result_arr.flatten()): + mlflow.log_metric(f"{base_key}_{i}", float(val)) - if log_validation and val_series is not None: - try: - _backtest_and_log( - model, - series=val_series, - metrics_list=metrics_list, - prefix="val", - past_covariates=val_past_covariates or past_covariates, - future_covariates=val_future_covariates or future_covariates, - forecast_horizon=forecast_horizon, - ) - except Exception: - logger.info( - "Could not compute validation forecasting metrics for " - f"{type(model).__name__}.", - exc_info=True, - ) +def _make_metric_patch(metric_name: str) -> Callable: + """Create a ``safe_patch``-compatible patch function for a darts metric. -def _backtest_and_log( - model, - series: TimeSeries | list[TimeSeries], - metrics_list: list[Callable], - prefix: str, - past_covariates=None, - future_covariates=None, - forecast_horizon: int = 1, -) -> None: - """Run ``model.backtest()`` and log the resulting scores to MLflow. + The returned patch calls the original metric and, when an active MLflow + run exists, logs the result under a key built as:: + + {metric_name}[_{dataset_name}][_{component}][_{series_index}] + + where: + + * ``dataset_name`` – Python variable name of the first argument in the + caller's frame (captured via frame inspection, omitted if not found). + * ``component`` – component label from the ``TimeSeries`` if the result is + per-component, otherwise an integer index. + * ``series_index`` – integer index appended when the input is a + ``Sequence[TimeSeries]`` and the result has a series axis. + + The original return value is always forwarded unchanged. Parameters ---------- - model - A fitted Darts forecasting model. - series - One or more target series to evaluate on. - metrics_list - List of Darts metric functions to evaluate. - prefix - Prefix for the logged metric names (e.g. ``"train"`` or ``"val"``). - past_covariates - Optional past covariates matching ``series``. - future_covariates - Optional future covariates matching ``series``. - forecast_horizon - Number of steps to forecast at each backtest step. + metric_name + The darts metric function name used as the MLflow metric key. """ - backtest_kwargs = dict( - series=series, - forecast_horizon=forecast_horizon, - retrain=False, - overlap_end=False, - last_points_only=True, - reduction=None, - verbose=False, - show_warnings=False, - ) - if past_covariates is not None: - backtest_kwargs["past_covariates"] = past_covariates - if future_covariates is not None: - backtest_kwargs["future_covariates"] = future_covariates - logged = {} - for metric_fn in metrics_list: - try: - score = model.backtest(**backtest_kwargs, metric=metric_fn) - # backtest returns a float, np.ndarray, or list depending on the - # input. We want a single scalar per metric so we take the mean. + def _patched_metric(original, *args, **kwargs): + result = original(*args, **kwargs) - logged[f"{prefix}_{metric_fn.__name__}"] = float(np.nanmean(score)) - except Exception: - logger.debug( - f"Backtest metric {metric_fn.__name__} failed for " - f"{type(model).__name__}, skipping.", - exc_info=True, - ) + if mlflow.active_run() is None: + return result - if logged: - mlflow.log_metrics(logged) + series = args[0] + # capture the variable name of actual_series for metric key + raw = _inspect_original_var_name(series, fallback_name=None) + dataset_name = _sanitize_mlflow_key(raw) if raw else None -def _get_metrics_list( - extra_metrics: list[Callable] | None = None, -) -> list[Callable]: - """Return the combined list of default and extra metric functions. + # handling multi_series input + input_is_list = not hasattr(series, "components") - Parameters - ---------- - extra_metrics - Optional additional metric functions to append to the defaults. + # extract component names from the series (or first element if list) + component_names = None + try: + if input_is_list: + # we assume that subsequent series have same component order + component_names = series[0].components.tolist() + else: + component_names = series.components.tolist() + except Exception: + logger.info("Could not extract component names from series.") - Returns - ------- - list[Callable] - A list of metric functions (``mae``, ``mse``, ``rmse``, ``mape``, plus extras). - """ - metrics = list(_DEFAULT_METRICS) - if extra_metrics: - seen_names = {m.__name__ for m in metrics} - for m in extra_metrics: - if m.__name__ not in seen_names: - metrics.append(m) - seen_names.add(m.__name__) - return metrics + try: + _log_metric_result( + metric_name, + result, + dataset_name=dataset_name, + component_names=component_names, + input_is_list=input_is_list, + ) + except Exception: + logger.info( + f"Failed to log metric '{metric_name}' to MLflow.", exc_info=True + ) + + return result + + return _patched_metric if PL_AVAILABLE: From b119e7b0a46b1840d28bed148380cafe67731656 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 24 Feb 2026 13:35:38 +0100 Subject: [PATCH 030/154] metric patching unit tests --- darts/tests/optional_deps/test_mlflow.py | 223 +++++++++-------------- 1 file changed, 90 insertions(+), 133 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index ea6d5729aa..da9aee12f3 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -639,168 +639,125 @@ def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): pred_loaded = loaded_model.predict(n=3, series=test_series) assert pred_original.width == pred_loaded.width - def test_autolog_training_metrics_regression( - self, mlflow_tracking, autolog_context - ): - """Test that autolog computes and logs in-sample training metrics for regression models.""" - with autolog_context(log_training_metrics=True): + def test_autolog_metric_logging_scalar(self, mlflow_tracking, autolog_context): + """Calling a darts metric inside an active run logs a scalar to MLflow.""" + with autolog_context(log_metrics=True): + from darts.metrics import mae + with mlflow.start_run() as run: - model = LinearRegressionModel(lags=5, output_chunk_length=3) - model.fit(self.ts_univariate) + result = mae(self.ts_univariate, self.ts_univariate * 1.1) run_data = mlflow.get_run(run.info.run_id).data + assert "mae" in run_data.metrics, "mae should be logged to MLflow" + assert np.isfinite(run_data.metrics["mae"]) + assert np.isscalar(result) + assert np.isfinite(float(result)) - for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: - assert metric_name in run_data.metrics, f"{metric_name} should be logged" - assert np.isfinite(run_data.metrics[metric_name]) - - def test_autolog_extra_metrics(self, mlflow_tracking, autolog_context): - """Test that extra_metrics are logged alongside defaults.""" - from darts.metrics import r2_score, smape + def test_autolog_metric_repeated_call(self, mlflow_tracking, autolog_context): + """Calling the same metric twice overwrites the value (last-value-wins).""" + with autolog_context(log_metrics=True): + from darts.metrics import rmse - with autolog_context( - log_training_metrics=True, extra_metrics=[smape, r2_score] - ): with mlflow.start_run() as run: - model = LinearRegressionModel(lags=5, output_chunk_length=3) - model.fit(self.ts_univariate) + rmse(self.ts_univariate, self.ts_univariate * 1.1) + rmse(self.ts_univariate, self.ts_univariate * 1.2) run_data = mlflow.get_run(run.info.run_id).data + assert "rmse" in run_data.metrics, "rmse should be logged to MLflow" - # defaults - for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: - assert metric_name in run_data.metrics - # extras - assert "train_smape" in run_data.metrics - assert "train_r2_score" in run_data.metrics + def test_autolog_metric_per_component(self, mlflow_tracking, autolog_context): + """Non-scalar metric results logged per-component as {name}_{component_name}. + + ts_multivariate = ts_univariate.stack(ts_univariate * 1.5), whose component + names are ['linear', 'linear_1']. With component_reduction=None the result + is a 1-D array (one value per component), so the expected keys are + 'mae_linear' and 'mae_linear_1'. + """ + with autolog_context(log_metrics=True): + from darts.metrics import mae - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_training_metrics_torch(self, mlflow_tracking, autolog_context): - """Test that autolog logs training metrics for torch models including epochs_trained.""" - with autolog_context( - log_training_metrics=True, inject_per_epoch_callbacks=True - ): with mlflow.start_run() as run: - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - **tfm_kwargs_dev, + mae( + self.ts_multivariate, + self.ts_multivariate * 1.1, + component_reduction=None, ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train) run_data = mlflow.get_run(run.info.run_id).data + assert "mae_linear" in run_data.metrics, ( + "Component 'linear' should be logged as mae_linear" + ) + assert "mae_linear_1" in run_data.metrics, ( + "Component 'linear_1' should be logged as mae_linear_1" + ) + assert np.isfinite(run_data.metrics["mae_linear"]) + assert np.isfinite(run_data.metrics["mae_linear_1"]) - assert "train_loss" in run_data.metrics - for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: - assert metric_name in run_data.metrics, ( - f"{metric_name} should be logged for torch model" - ) + def test_autolog_metric_no_active_run(self, mlflow_tracking, autolog_context): + """Calling a metric without an active run does not raise and returns correctly.""" + with autolog_context(log_metrics=True): + from darts.metrics import mse - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_validation_metrics_torch(self, mlflow_tracking, autolog_context): - """Test that validation metrics are computed on val_series for torch models.""" - with autolog_context(log_training_metrics=True, log_validation_metrics=True): - with mlflow.start_run() as run: - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) + # called outside any start_run — must not raise + result = mse(self.ts_univariate, self.ts_univariate * 1.1) - run_data = mlflow.get_run(run.info.run_id).data + assert np.isscalar(result) + assert np.isfinite(float(result)) - # validation forecasting metrics - for metric_name in ["val_mae", "val_mse", "val_rmse", "val_mape"]: - assert metric_name in run_data.metrics, ( - f"{metric_name} should be logged for torch model with val_series" - ) - assert np.isfinite(run_data.metrics[metric_name]) - - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_validation_metrics_disabled( + def test_autolog_metric_returns_correct_value( self, mlflow_tracking, autolog_context ): - """Test that validation metrics are NOT logged when log_validation_metrics=False.""" - with autolog_context(log_training_metrics=True, log_validation_metrics=False): - with mlflow.start_run() as run: - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) + """The patched metric returns the same value whether inside or outside a run.""" + with autolog_context(log_metrics=True): + from darts.metrics import mae - run_data = mlflow.get_run(run.info.run_id).data + pred = self.ts_univariate * 1.05 - # training metrics should still be present - assert "train_mae" in run_data.metrics - # validation metrics should NOT be present - for metric_name in ["val_mae", "val_mse", "val_rmse", "val_mape"]: - assert metric_name not in run_data.metrics, ( - f"{metric_name} should NOT be logged when validation disabled" - ) + with mlflow.start_run(): + result_inside = mae(self.ts_univariate, pred) - def test_autolog_training_metrics_multiple_series( - self, mlflow_tracking, autolog_context - ): - """Test that backtest-based training metrics work with multiple series.""" - ts1 = tg.linear_timeseries(start_value=10, end_value=50, length=50).astype( - "float32" - ) - ts2 = tg.linear_timeseries(start_value=20, end_value=60, length=50).astype( - "float32" - ) + # call outside a run — no logging, same computation + result_outside = mae(self.ts_univariate, pred) + + np.testing.assert_almost_equal(result_inside, result_outside, decimal=6) + assert np.isfinite(result_inside) + + def test_autolog_log_metrics_false(self, mlflow_tracking, autolog_context): + """autolog(log_metrics=False) leaves metrics unpatched — nothing is logged.""" + with autolog_context(log_metrics=False): + from darts.metrics import mape - with autolog_context(log_training_metrics=True): with mlflow.start_run() as run: - model = LinearRegressionModel(lags=5, output_chunk_length=3) - model.fit([ts1, ts2]) + mape(self.ts_univariate, self.ts_univariate * 1.1) run_data = mlflow.get_run(run.info.run_id).data + assert "mape" not in run_data.metrics, ( + "mape should NOT be logged when log_metrics=False" + ) - for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: - assert metric_name in run_data.metrics, ( - f"{metric_name} should be logged for multiple series" - ) - assert np.isfinite(run_data.metrics[metric_name]) + def test_autolog_public_namespace_patched(self, mlflow_tracking, autolog_context): + """Only darts.metrics (public namespace) is patched; darts.metrics.metrics is not. - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_training_metrics_multiple_series_torch( - self, mlflow_tracking, autolog_context - ): - """Test that backtest-based training metrics work with multiple series on torch models.""" - ts1 = tg.linear_timeseries(start_value=10, end_value=50, length=50).astype( - "float32" - ) - ts2 = tg.linear_timeseries(start_value=20, end_value=60, length=50).astype( - "float32" - ) + Patching only the public namespace avoids breaking internal metric-to-metric + calls within the implementation module (e.g. rmse calling mse internally). + """ + with autolog_context(log_metrics=True): + import darts.metrics as dm + import darts.metrics.metrics as dmm - with autolog_context(log_training_metrics=True): - with mlflow.start_run() as run: - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - pl_trainer_kwargs={ - "accelerator": "cpu", - "enable_progress_bar": False, - "enable_model_summary": False, - }, - ) - model.fit([ts1, ts2]) + # public namespace → patched: call inside a run should log + with mlflow.start_run() as run_public: + dm.mae(self.ts_univariate, self.ts_univariate * 1.1) - run_data = mlflow.get_run(run.info.run_id).data + # implementation module → NOT patched: call inside a run should not log + with mlflow.start_run() as run_impl: + dmm.mae(self.ts_univariate, self.ts_univariate * 1.1) - for metric_name in ["train_mae", "train_mse", "train_rmse", "train_mape"]: - assert metric_name in run_data.metrics, ( - f"{metric_name} should be logged for torch multiple series" - ) - assert np.isfinite(run_data.metrics[metric_name]) + run_data_public = mlflow.get_run(run_public.info.run_id).data + run_data_impl = mlflow.get_run(run_impl.info.run_id).data + assert "mae" in run_data_public.metrics, ( + "darts.metrics.mae should log to MLflow (public namespace is patched)" + ) + assert "mae" not in run_data_impl.metrics, ( + "darts.metrics.metrics.mae should NOT log (implementation module is not patched)" + ) From f561438ceb52afb3b59193a19d07d2f8b0032c2f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 25 Feb 2026 22:37:41 +0100 Subject: [PATCH 031/154] pytorch autolog --- darts/utils/mlflow.py | 189 ++++++++++++++---------------------------- 1 file changed, 62 insertions(+), 127 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index ba168b2add..80d1d85576 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -56,7 +56,6 @@ import darts from darts.logging import get_logger, raise_if, raise_if_not from darts.models.forecasting.forecasting_model import ForecastingModel -from darts.utils.utils import PL_AVAILABLE logger = get_logger(__name__) @@ -140,13 +139,9 @@ def save_model( os.makedirs(data_dir, exist_ok=True) - # pass in clean=True to not include any timeseries or callbacks within the model file - if is_torch: - model_file = _MODEL_FILE_TORCH - model.save(os.path.join(data_dir, model_file), clean=True) - else: - model_file = _MODEL_FILE_STAT - model.save(os.path.join(data_dir, model_file), clean=True) + # clean=True excludes any timeseries or callbacks from the model file + model_file = _MODEL_FILE_TORCH if is_torch else _MODEL_FILE_STAT + model.save(os.path.join(data_dir, model_file), clean=True) module_path, class_name = _get_model_class_path(model) @@ -332,7 +327,6 @@ def log_model( ) -@autologging_integration(FLAVOR_NAME) def autolog( log_models: bool = True, log_params: bool = True, @@ -353,7 +347,8 @@ def autolog( 4. Patch all darts metric functions so that any call made inside an active MLflow run automatically logs the result. Repeated calls overwrite the previous value. - 5. For PyTorch-based models: inject a callback that logs per-epoch metrics. + 5. For PyTorch-based models: leverage ``mlflow.pytorch.autolog()`` to + automatically log per-epoch training and validation metrics. 6. Log the trained model artifact at the end of training. .. important:: @@ -388,9 +383,9 @@ def autolog( If ``True`` (default), patch all darts metric functions so that any call made inside an active MLflow run is automatically logged. inject_per_epoch_callbacks - If ``True`` (default), inject a PyTorch Lightning callback to log training and validation - metrics at the end of each epoch. Only effective for PyTorch-based models. To provide - additional callbacks use ``torch_metrics`` parameter while initializing the model. + If ``True`` (default), enable ``mlflow.pytorch.autolog(log_models=False)`` + around PyTorch-based model training to automatically log per-epoch + training and validation metrics. Only effective for PyTorch-based models. extra_metrics An optional list of additional Darts metric functions to log on top of the defaults (``mae``, ``mse``, ``rmse``, ``mape``). Each function @@ -409,6 +404,58 @@ def autolog( does not apply the `with_managed_run` wrapper to the specified `patch_function`. """ + # Enable/disable mlflow.pytorch.autolog for per-epoch metrics on torch models. + # This must happen outside the @autologging_integration-decorated _autolog() + # because the decorator short-circuits on disable=True before the function + # body executes, and MLflow's session manager suppresses nested autolog + # patches if called from within a safe_patch context. + if inject_per_epoch_callbacks and not disable: + try: + import mlflow.pytorch + + mlflow.pytorch.autolog(log_models=False, log_datasets=False, silent=silent) + except ImportError: + logger.info( + "mlflow.pytorch not available; skipping per-epoch metrics logging." + ) + elif disable: + try: + import mlflow.pytorch + + mlflow.pytorch.autolog(disable=True) + except (ImportError, Exception): + logger.info( + "mlflow.pytorch not available; skipping per-epoch metrics logging." + ) + + _autolog( + log_models=log_models, + log_params=log_params, + log_metrics=log_metrics, + inject_per_epoch_callbacks=inject_per_epoch_callbacks, + disable=disable, + silent=silent, + manage_run=manage_run, + ) + + +@autologging_integration(FLAVOR_NAME) +def _autolog( + log_models: bool = True, + log_params: bool = True, + log_metrics: bool = True, + inject_per_epoch_callbacks: bool = True, + disable: bool = False, + silent: bool = False, + manage_run: bool = True, +) -> None: + """Internal autolog implementation decorated with ``@autologging_integration``. + + Handles patching of darts ``ForecastingModel.fit()`` and metric functions. + The ``mlflow.pytorch.autolog`` coordination is handled by the public + ``autolog()`` wrapper because the decorator short-circuits on + ``disable=True``. + """ # recursively get all subclasses of ForecastingModel that override fit() def get_all_subclasses(cls): @@ -681,11 +728,7 @@ def _extract_covariate_metadata( def _patched_fit(original, self, *args, **kwargs): """Patch function for ForecastingModel.fit() autologging. - Handles both statistical and PyTorch-based models. For PyTorch models, - automatically injects MLflow callback for per-epoch metrics logging. - - Logs the trained model artifact if configured. - + Logs model parameters, class, covariates and the model itself. Parameters ---------- original @@ -703,19 +746,12 @@ def _patched_fit(original, self, *args, **kwargs): """ log_models = get_autologging_config(FLAVOR_NAME, "log_models", True) log_params = get_autologging_config(FLAVOR_NAME, "log_params", True) - inject_per_epoch_callbacks = get_autologging_config( - FLAVOR_NAME, "inject_per_epoch_callbacks", True - ) mlflow.set_tag("darts.model_class", type(self).__name__) if log_params: _log_model_params(self) - # Inject per-epoch callbacks for torch models (no-op for non-torch models) - if inject_per_epoch_callbacks: - _inject_mlflow_callback(self) - result = original(self, *args, **kwargs) if log_params: @@ -847,7 +883,7 @@ def _make_metric_patch(metric_name: str) -> Callable: The returned patch calls the original metric and, when an active MLflow run exists, logs the result under a key built as:: - {metric_name}[_{dataset_name}][_{component}][_{series_index}] + {metric_name}_{dataset_name}_{component}_{series_index} where: @@ -908,104 +944,3 @@ def _patched_metric(original, *args, **kwargs): return result return _patched_metric - - -if PL_AVAILABLE: - import pytorch_lightning as pl - - class _DartsMlflowCallback(pl.Callback): - """PyTorch Lightning callback that logs epoch-level metrics to MLflow. - - This callback automatically logs training and validation metrics (such as - loss values) to the active MLflow run at the end of each epoch. - - Notes - ----- - The callback is automatically injected into TorchForecastingModel instances - when ``autolog()`` is enabled with PyTorch-based models. - """ - - def on_train_epoch_end(self, trainer, pl_module): - """Log training metrics at the end of each training epoch.""" - self._log_epoch_metrics(trainer) - - def on_validation_epoch_end(self, trainer, pl_module): - """Log validation metrics at the end of each validation epoch.""" - self._log_epoch_metrics(trainer) - - def _log_epoch_metrics(self, trainer) -> None: - """Extract and log metrics from the trainer to MLflow. - - Parameters - ---------- - trainer - PyTorch Lightning Trainer instance containing metrics. - """ - if mlflow.active_run() is None: - return - - epoch = trainer.current_epoch - metrics: dict[str, float] = {} - - for source in (trainer.callback_metrics, trainer.logged_metrics): - for key, value in source.items(): - try: - metrics[key] = float(value) - except (TypeError, ValueError): - pass - - if metrics: - mlflow.log_metrics(metrics, step=epoch) - -else: - _DartsMlflowCallback = None - - -def _get_mlflow_callback(): - """Create and return a ``_DartsMlflowCallback`` instance. - - Returns - ------- - _DartsMlflowCallback or None - A callback instance if PyTorch Lightning is available, None otherwise. - """ - if not PL_AVAILABLE: - return None - - return _DartsMlflowCallback() - - -def _inject_mlflow_callback(model) -> None: - """Inject the MLflow callback into a ``TorchForecastingModel``'s trainer params. - - Adds a ``_DartsMlflowCallback`` to the model's PyTorch Lightning trainer callbacks - if not already present. This enables automatic logging of training metrics to MLflow. - - Parameters - ---------- - model - A TorchForecastingModel instance with a ``trainer_params`` attribute. - - Notes - ----- - This is a no-op if the callback is already present or PyTorch Lightning is unavailable. - """ - callback = _get_mlflow_callback() - if callback is None: - return - - if not hasattr(model, "trainer_params"): - return - - existing_callbacks = model.trainer_params.get("callbacks", []) - - if any(isinstance(cb, _DartsMlflowCallback) for cb in existing_callbacks): - logger.info("MLflow callback already present, skipping injection") - return - - if not isinstance(existing_callbacks, list): - existing_callbacks = list(existing_callbacks) - - existing_callbacks.append(callback) - model.trainer_params["callbacks"] = existing_callbacks - logger.info(f"Injected MLflow callback into {type(model).__name__}") From df7e097c1b89e6f9c2782eee22923b4316a0d342 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 25 Feb 2026 22:38:06 +0100 Subject: [PATCH 032/154] unit tests for pytorch autolog --- darts/tests/optional_deps/test_mlflow.py | 76 ++++++++++++++---------- 1 file changed, 45 insertions(+), 31 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index da9aee12f3..c6a1790975 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -332,40 +332,49 @@ def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): assert m.value >= 0, f"val_loss is negative: {m.value}" @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_injects_callback(self, mlflow_tracking, autolog_context): - """Test that autolog injects MLflow callback into torch models""" + def test_autolog_pytorch_autolog_enabled(self, mlflow_tracking, autolog_context): + """Test that autolog enables mlflow.pytorch.autolog and logs per-epoch + train_loss, val_loss, and custom torch_metrics with finite non-negative values.""" + import torchmetrics + from mlflow.utils.autologging_utils import autologging_is_disabled + + n_epochs = 2 + + def assert_metric(history, key): + assert len(history) > 0, f"{key} not logged" + assert len(history) <= n_epochs, f"too many {key} entries" + assert all(np.isfinite(m.value) and m.value >= 0 for m in history) + with autolog_context(): + assert not autologging_is_disabled("pytorch") + model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, - n_epochs=2, + n_epochs=n_epochs, + torch_metrics=torchmetrics.MeanAbsoluteError(), **tfm_kwargs_dev, ) - - # record initial callbacks from trainer_params (before fit) - initial_callbacks = model.trainer_params.get("callbacks", []) - initial_callback_count = len(initial_callbacks) if initial_callbacks else 0 - train, val = self.ts_univariate.split_before(0.7) model.fit(train, val_series=val) - # verify callback was injected after fit - final_callbacks = model.trainer_params.get("callbacks", []) - assert final_callbacks is not None, "Callbacks should not be None" - assert len(final_callbacks) > initial_callback_count, ( - "MLflow callback should be added" - ) - - # check that the _DartsMlflowCallback is present - from darts.utils.mlflow import _DartsMlflowCallback + runs = mlflow.search_runs() + assert len(runs) == 1 + run_id = runs.iloc[0]["run_id"] + assert runs.iloc[0]["tags.darts.model_class"] == "NBEATSModel" - has_mlflow_callback = any( - isinstance(cb, _DartsMlflowCallback) for cb in final_callbacks - ) - assert has_mlflow_callback, ( - f"_DartsMlflowCallback not found in {[type(cb).__name__ for cb in final_callbacks]}" + client = mlflow.tracking.MlflowClient() + assert_metric(client.get_metric_history(run_id, "train_loss"), "train_loss") + assert_metric(client.get_metric_history(run_id, "val_loss"), "val_loss") + # custom torch_metrics: in normal use both train_/val_ prefixes are logged, but + # fast_dev_run suppresses the Lightning logger during traininge + assert_metric( + client.get_metric_history(run_id, "val_MeanAbsoluteError"), + "val_MeanAbsoluteError", ) + assert autologging_is_disabled("pytorch") + def test_covariate_artifact_schema(self, mlflow_tracking): """Test that covariate artifact has correct JSON schema""" model = LinearRegressionModel(lags=5, lags_past_covariates=3) @@ -426,10 +435,10 @@ def test_multivariate_with_all_covariate_types(self, mlflow_tracking): assert run.data.params["n_static_covariates"] == "2" @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_callback_injection_with_existing_callbacks( + def test_pytorch_autolog_with_existing_callbacks( self, mlflow_tracking, autolog_context ): - """Test callback injection when model already has callbacks""" + """Test pytorch autolog works when model already has callbacks""" # create model with existing callback if PL_AVAILABLE: import pytorch_lightning as pl @@ -453,17 +462,22 @@ def test_callback_injection_with_existing_callbacks( train, val = self.ts_univariate.split_before(0.7) model.fit(train, val_series=val) - # verify both callbacks present + # verify existing callback is still present (not removed by autolog) callbacks = model.trainer_params.get("callbacks", []) - assert len(callbacks) == 2, "Should have both existing and MLflow callbacks" - - from darts.utils.mlflow import _DartsMlflowCallback - - has_mlflow = any(isinstance(cb, _DartsMlflowCallback) for cb in callbacks) has_existing = any( isinstance(cb, pl.callbacks.EarlyStopping) for cb in callbacks ) - assert has_mlflow and has_existing, "Both callbacks should be present" + assert has_existing, "Existing EarlyStopping callback should be preserved" + + # verify metrics were still logged via mlflow.pytorch.autolog + runs = mlflow.search_runs() + assert len(runs) >= 1, "Expected at least one run" + last_run_id = runs.iloc[0]["run_id"] + client = mlflow.tracking.MlflowClient() + train_metrics = client.get_metric_history(last_run_id, "train_loss") + assert len(train_metrics) > 0, ( + "Expected train_loss metrics to be logged via pytorch autolog" + ) def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): """Test that multiple fits with autolog create separate runs""" From 99f161cab0182a3f7fd195b153dd649cbd944e77 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 09:37:26 +0000 Subject: [PATCH 033/154] Revert catboost cap Co-authored-by: Zhihao Dai --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 2d49f78df4..76099c41b3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -64,7 +64,7 @@ torch = [ "safetensors>=0.6.2", ] notorch = [ - "catboost>=1.0.6,<=1.2.9", + "catboost>=1.0.6", "lightgbm>=3.2.0", "prophet>=1.1.1", "statsforecast>=1.4", From 1c7b073bac55e3eaf6065a7ec693ba2b6827c292 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 09:41:30 +0000 Subject: [PATCH 034/154] Replace raise_if and raise_if_not Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 80d1d85576..37ea4e5ff5 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -31,8 +31,8 @@ from mlflow.utils.autologging_utils import ( autologging_integration, get_autologging_config, - safe_patch, ) +from mlflow.utils.autologging_utils.safety import safe_patch from mlflow.utils.environment import ( _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, @@ -54,7 +54,7 @@ from mlflow.utils.requirements_utils import _get_pinned_requirement import darts -from darts.logging import get_logger, raise_if, raise_if_not +from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import ForecastingModel logger = get_logger(__name__) @@ -125,11 +125,14 @@ def save_model( simplifying potential future extensibility, and to keep in line with MLflow API conventions. """ - raise_if_not( - isinstance(model, ForecastingModel), - "model must be an instance of darts.models.forecasting.ForecastingModel", - logger, - ) + if not isinstance(model, ForecastingModel): + raise_log( + ValueError( + "Model must be an instance of darts.models.forecasting.ForecastingModel." + ), + logger, + ) + _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements) _validate_and_prepare_target_save_path(path) code_dir_subpath = _validate_and_copy_code_paths(code_paths, path) @@ -683,11 +686,11 @@ def _import_model_class(module_path: str, class_name: str): """ module = importlib.import_module(module_path) cls = getattr(module, class_name, None) - raise_if( - cls is None, - f"Class '{class_name}' not found in module '{module_path}'", - logger, - ) + if cls is None: + raise_log( + ImportError(f"Class `{class_name}` not found in module `{module_path}`"), + logger, + ) return cls From e885b64332e6ff10c4224bc7fbb6dcabd5624cd5 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 09:47:55 +0000 Subject: [PATCH 035/154] Use abs path Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 37ea4e5ff5..11c85695b5 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -134,6 +134,8 @@ def save_model( ) _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements) + + path = os.path.abspath(path) _validate_and_prepare_target_save_path(path) code_dir_subpath = _validate_and_copy_code_paths(code_paths, path) From b46cf952929de952919c9256bd7cb96f614a779c Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 09:52:48 +0000 Subject: [PATCH 036/154] Use direct path for saving model Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 26 +++++++++----------------- 1 file changed, 9 insertions(+), 17 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 11c85695b5..50cda6181f 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -139,29 +139,14 @@ def save_model( _validate_and_prepare_target_save_path(path) code_dir_subpath = _validate_and_copy_code_paths(code_paths, path) - data_dir = os.path.join(path, _MODEL_DATA_SUBFOLDER) is_torch = _is_torch_model(model) - os.makedirs(data_dir, exist_ok=True) - # clean=True excludes any timeseries or callbacks from the model file model_file = _MODEL_FILE_TORCH if is_torch else _MODEL_FILE_STAT - model.save(os.path.join(data_dir, model_file), clean=True) + model.save(os.path.join(path, model_file), clean=True) module_path, class_name = _get_model_class_path(model) - darts_flavor_conf = { - "darts_version": darts.__version__, - "model_class_module": module_path, - "model_class_name": class_name, - "model_file": model_file, - "is_torch_model": is_torch, - "data": _MODEL_DATA_SUBFOLDER, - } - - if code_dir_subpath is not None: - darts_flavor_conf["code"] = code_dir_subpath - default_reqs = None if pip_requirements else get_default_pip_requirements(is_torch) conda_env, pip_requirements, pip_constraints = ( _process_pip_requirements( @@ -192,7 +177,14 @@ def save_model( if metadata is not None: mlflow_model.metadata = metadata - mlflow_model.add_flavor(FLAVOR_NAME, **darts_flavor_conf) + mlflow_model.add_flavor( + FLAVOR_NAME, + darts_version=darts.__version__, + data=model_file, + model_class=f"{module_path}.{class_name}", + code=code_dir_subpath, + is_torch_model=is_torch, + ) mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME)) From 51a47f20f32f9b1bf194483b07121b8c27cd05bc Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 09:55:54 +0000 Subject: [PATCH 037/154] Update #2 Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 50cda6181f..35704238d8 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -224,11 +224,7 @@ def load_model( flavor_conf["model_class_module"], flavor_conf["model_class_name"] ) - model_path = os.path.join( - local_path, - flavor_conf.get("data", _MODEL_DATA_SUBFOLDER), - flavor_conf["model_file"], - ) + model_path = os.path.join(local_path, flavor_conf["data"]) if flavor_conf.get("is_torch_model", False): return model_cls.load(model_path, **kwargs) From 28c11ed360bbf34f8f561a86d521242cb9305f8e Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 10:21:53 +0000 Subject: [PATCH 038/154] Use mlflow class utils to replace insepctlib Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 119 ++++++++++++++---------------------------- 1 file changed, 39 insertions(+), 80 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 35704238d8..4ccee575cc 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -14,7 +14,6 @@ https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py """ -import importlib import json import os import re @@ -27,12 +26,13 @@ from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example from mlflow.tracking.artifact_utils import _download_artifact_from_uri -from mlflow.utils import _inspect_original_var_name +from mlflow.utils import _get_fully_qualified_class_name, _inspect_original_var_name from mlflow.utils.autologging_utils import ( autologging_integration, get_autologging_config, ) from mlflow.utils.autologging_utils.safety import safe_patch +from mlflow.utils.class_utils import _get_class_from_string from mlflow.utils.environment import ( _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, @@ -60,7 +60,6 @@ logger = get_logger(__name__) FLAVOR_NAME = "darts" -_MODEL_DATA_SUBFOLDER = "data" _MODEL_FILE_STAT = "model.pkl" @@ -145,25 +144,7 @@ def save_model( model_file = _MODEL_FILE_TORCH if is_torch else _MODEL_FILE_STAT model.save(os.path.join(path, model_file), clean=True) - module_path, class_name = _get_model_class_path(model) - - default_reqs = None if pip_requirements else get_default_pip_requirements(is_torch) - conda_env, pip_requirements, pip_constraints = ( - _process_pip_requirements( - default_reqs, pip_requirements, extra_pip_requirements - ) - if conda_env is None - else _process_conda_env(conda_env) - ) - - with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: - yaml.safe_dump(conda_env, stream=f, default_flow_style=False) - - if pip_constraints: - write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) - - write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) - _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) + model_class = _get_fully_qualified_class_name(model) if mlflow_model is None: mlflow_model = Model() @@ -181,12 +162,36 @@ def save_model( FLAVOR_NAME, darts_version=darts.__version__, data=model_file, - model_class=f"{module_path}.{class_name}", + model_class=model_class, code=code_dir_subpath, is_torch_model=is_torch, ) mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME)) + if pip_requirements is None: + default_reqs = get_default_pip_requirements() + # TODO: `infer_pip_requirements` requires `pyfunc` flavor to be implemented. + # inferred_reqs = infer_pip_requirements(path, FLAVOR_NAME, fallback=default_reqs) + # default_reqs = sorted(set(inferred_reqs).union(default_reqs)) + else: + default_reqs = None + conda_env, pip_requirements, pip_constraints = ( + _process_pip_requirements( + default_reqs, pip_requirements, extra_pip_requirements + ) + if conda_env is None + else _process_conda_env(conda_env) + ) + + with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: + yaml.safe_dump(conda_env, stream=f, default_flow_style=False) + + if pip_constraints: + write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) + + write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) + _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) + def load_model( model_uri: str, @@ -220,9 +225,16 @@ def load_model( ) _add_code_from_conf_to_system_path(local_path, flavor_conf) - model_cls = _import_model_class( - flavor_conf["model_class_module"], flavor_conf["model_class_name"] - ) + model_cls_str = flavor_conf.get("model_class", None) + model_cls = _get_class_from_string(model_cls_str) + + if not issubclass(model_cls, ForecastingModel): + raise_log( + ValueError( + f"Cannot load model: class `{model_cls_str}` is not a subclass of `ForecastingModel`." + ), + logger, + ) model_path = os.path.join(local_path, flavor_conf["data"]) @@ -499,23 +511,12 @@ def get_all_subclasses(cls): def get_default_pip_requirements(is_torch: bool = False) -> list[str]: """Return the default pip requirements for logging a darts model. - Parameters - ---------- - is_torch - Whether the model is a PyTorch-based model. If ``True``, adds - ``torch`` and ``pytorch-lightning`` to the requirements. - Returns ------- list[str] A list of pip requirement strings. """ - reqs = [_get_pinned_requirement("darts")] - if is_torch: - reqs.extend([ - _get_pinned_requirement("torch"), - _get_pinned_requirement("pytorch-lightning"), - ]) + reqs = [_get_pinned_requirement("darts[all]")] return reqs @@ -642,48 +643,6 @@ def _is_torch_model(model) -> bool: return False -def _get_model_class_path(model) -> tuple[str, str]: - """Extract the module path and class name from a model instance. - - Parameters - ---------- - model - A Darts forecasting model instance. - - Returns - ------- - tuple[str, str] - A tuple containing (module_path, class_name). - """ - cls = type(model) - return cls.__module__, cls.__name__ - - -def _import_model_class(module_path: str, class_name: str): - """Dynamically import and return a model class. - - Parameters - ---------- - module_path : str - The fully qualified module path (e.g., "darts.models.exponential_smoothing"). - class_name : str - The name of the class to import (e.g., "ExponentialSmoothing"). - - Returns - ------- - type - The imported model class. - """ - module = importlib.import_module(module_path) - cls = getattr(module, class_name, None) - if cls is None: - raise_log( - ImportError(f"Class `{class_name}` not found in module `{module_path}`"), - logger, - ) - return cls - - def _extract_covariate_metadata( model, uses_attr: str, series_attr: str, names_attr: str ) -> dict: From ddae08adb75300949df559179c8651a6d0303e00 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 10:25:55 +0000 Subject: [PATCH 039/154] Fix tests Co-authored-by: Zhihao Dai --- darts/tests/optional_deps/test_mlflow.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index c6a1790975..9ee402f9b4 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -66,10 +66,10 @@ def assert_mlflow_artifacts_exist(path: str, is_torch: bool = False): assert os.path.exists(os.path.join(path, "python_env.yaml")) if is_torch: - assert os.path.exists(os.path.join(path, "data", "model.pt")) - assert os.path.exists(os.path.join(path, "data", "model.pt.ckpt")) + assert os.path.exists(os.path.join(path, "model.pt")) + assert os.path.exists(os.path.join(path, "model.pt.ckpt")) else: - assert os.path.exists(os.path.join(path, "data", "model.pkl")) + assert os.path.exists(os.path.join(path, "model.pkl")) def assert_predictions_equal(model1, model2, n: int, decimal: int = 4, series=None): @@ -595,7 +595,7 @@ def test_load_missing_model_file_fails(self, tmpdir_fn): save_model(model, model_path) # remove the model data file - model_data_path = os.path.join(model_path, "data", "model.pkl") + model_data_path = os.path.join(model_path, "model.pkl") os.remove(model_data_path) # loading should fail From 91f66607bb3a367b2b2402fb86f8da2fa693c94c Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 14:34:45 +0000 Subject: [PATCH 040/154] Get all forecasting models ith inspect Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 48 ++++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 26 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 4ccee575cc..fe2d4918b9 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -14,10 +14,12 @@ https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py """ +import inspect import json import os import re from collections.abc import Callable +from operator import itemgetter import mlflow import numpy as np @@ -437,19 +439,33 @@ def autolog( log_models=log_models, log_params=log_params, log_metrics=log_metrics, - inject_per_epoch_callbacks=inject_per_epoch_callbacks, disable=disable, silent=silent, manage_run=manage_run, ) +def _get_forecasting_models(): + """ + Returns: + A list of (name, class) tuples for all forecasting models in the Darts library. + """ + import darts.models + + classes = inspect.getmembers(darts.models, inspect.isclass) + + classes = [ + (name, cls) for name, cls in classes if issubclass(cls, ForecastingModel) + ] + + return sorted(set(classes), key=itemgetter(0)) + + @autologging_integration(FLAVOR_NAME) def _autolog( log_models: bool = True, log_params: bool = True, log_metrics: bool = True, - inject_per_epoch_callbacks: bool = True, disable: bool = False, silent: bool = False, manage_run: bool = True, @@ -462,21 +478,7 @@ def _autolog( ``disable=True``. """ - # recursively get all subclasses of ForecastingModel that override fit() - def get_all_subclasses(cls): - all_subclasses = [] - for subclass in cls.__subclasses__(): - all_subclasses.append(subclass) - all_subclasses.extend(get_all_subclasses(subclass)) - return all_subclasses - - classes_to_patch = [ForecastingModel] - - for subclass in get_all_subclasses(ForecastingModel): - if "fit" in subclass.__dict__: - classes_to_patch.append(subclass) - - for cls in classes_to_patch: + for _, cls in _get_forecasting_models(): try: safe_patch( FLAVOR_NAME, @@ -508,7 +510,7 @@ def get_all_subclasses(cls): ) -def get_default_pip_requirements(is_torch: bool = False) -> list[str]: +def get_default_pip_requirements(): """Return the default pip requirements for logging a darts model. Returns @@ -520,22 +522,16 @@ def get_default_pip_requirements(is_torch: bool = False) -> list[str]: return reqs -def get_default_conda_env(is_torch: bool = False) -> dict: +def get_default_conda_env(): """Return a default conda environment dict for a darts model. - Parameters - ---------- - is_torch - Whether the model is a PyTorch-based model. - Returns ------- dict A conda environment specification dictionary. """ return _mlflow_conda_env( - additional_pip_deps=get_default_pip_requirements(is_torch), - additional_conda_channels=["conda-forge"], + additional_pip_deps=get_default_pip_requirements(), ) From ce56906075b5bf40f267f9b12f8eda67969633d3 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 14:39:53 +0000 Subject: [PATCH 041/154] Rename `log_torch_metrics` Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index fe2d4918b9..484acb8163 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -338,7 +338,7 @@ def autolog( log_models: bool = True, log_params: bool = True, log_metrics: bool = True, - inject_per_epoch_callbacks: bool = True, + log_torch_metrics: bool = True, disable: bool = False, silent: bool = False, manage_run: bool = True, @@ -389,15 +389,10 @@ def autolog( log_metrics If ``True`` (default), patch all darts metric functions so that any call made inside an active MLflow run is automatically logged. - inject_per_epoch_callbacks + log_torch_metrics If ``True`` (default), enable ``mlflow.pytorch.autolog(log_models=False)`` around PyTorch-based model training to automatically log per-epoch training and validation metrics. Only effective for PyTorch-based models. - extra_metrics - An optional list of additional Darts metric functions to log on top of - the defaults (``mae``, ``mse``, ``rmse``, ``mape``). Each function - must follow the standard Darts metric signature - ``metric(actual_series, pred_series)``. disable If ``True``, restore the original ``fit()`` methods and stop autologging. @@ -416,7 +411,7 @@ def autolog( # because the decorator short-circuits on disable=True before the function # body executes, and MLflow's session manager suppresses nested autolog # patches if called from within a safe_patch context. - if inject_per_epoch_callbacks and not disable: + if log_torch_metrics and not disable: try: import mlflow.pytorch @@ -478,6 +473,7 @@ def _autolog( ``disable=True``. """ + # patch `fit()` for all forecasting models for _, cls in _get_forecasting_models(): try: safe_patch( @@ -493,6 +489,7 @@ def _autolog( if log_metrics: import darts.metrics as _darts_metrics + # patch all metric functions to log results for metric_name in _darts_metrics.__all__: try: # metrics should not create their own runs; From 3dcceacb60f8ae5697934215f186e027643230b4 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 14:52:46 +0000 Subject: [PATCH 042/154] Change `save_model` param order Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 484acb8163..b45e406692 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -20,11 +20,12 @@ import re from collections.abc import Callable from operator import itemgetter +from typing import Any import mlflow import numpy as np import yaml -from mlflow.models import Model +from mlflow.models import Model, ModelInputExample, ModelSignature from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example from mlflow.tracking.artifact_utils import _download_artifact_from_uri @@ -73,12 +74,12 @@ def save_model( path: str, conda_env: dict | str | None = None, code_paths: list[str] | None = None, + mlflow_model: Model | None = None, + signature: ModelSignature | None = None, + input_example: ModelInputExample | None = None, pip_requirements: list[str] | None = None, extra_pip_requirements: list[str] | None = None, - signature=None, - input_example=None, - metadata: dict | None = None, - mlflow_model: Model | None = None, + metadata: dict[str, Any] | None = None, ) -> None: """Save a darts forecasting model in MLflow format. @@ -101,22 +102,22 @@ def save_model( A list of local filesystem paths to Python file dependencies (or directories containing file dependencies). These files are prepended to the system path when the model is loaded. + mlflow_model + Optional MLflow Model object to use for saving. When provided (typically by + ``Model.log()``), this model instance is used instead of creating a new one. + signature + *Unsupported, see notes.* An ``mlflow.models.ModelSignature`` instance describing model input/output. + Use ``mlflow.models.infer_signature()`` to automatically generate from example inputs. + input_example + *Unsupported, see notes.* An example input for the model (used by MLflow UI). pip_requirements A list of pip requirement strings. Overrides ``conda_env`` pip section when provided. extra_pip_requirements A list of additional pip requirement strings to add to the model's environment, in addition to the default requirements. - signature - *Unsupported, see notes.* An ``mlflow.models.ModelSignature`` instance describing model input/output. - Use ``mlflow.models.infer_signature()`` to automatically generate from example inputs. - input_example - *Unsupported, see notes.* An example input for the model (used by MLflow UI). metadata Optional dictionary of custom metadata to store in the ``MLmodel`` file. - mlflow_model - Optional MLflow Model object to use for saving. When provided (typically by - ``Model.log()``), this model instance is used instead of creating a new one. Notes ----- From 1b7fa8910d0fda297bc8bd22093b04540cce7c9a Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 15:04:23 +0000 Subject: [PATCH 043/154] Update `log_model` params Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 67 +++++++++++++++++++++++++++++-------------- 1 file changed, 46 insertions(+), 21 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index b45e406692..75f1b8d83e 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -18,6 +18,7 @@ import json import os import re +import sys from collections.abc import Callable from operator import itemgetter from typing import Any @@ -28,6 +29,7 @@ from mlflow.models import Model, ModelInputExample, ModelSignature from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example +from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS from mlflow.tracking.artifact_utils import _download_artifact_from_uri from mlflow.utils import _get_fully_qualified_class_name, _inspect_original_var_name from mlflow.utils.autologging_utils import ( @@ -250,16 +252,23 @@ def load_model( def log_model( model, artifact_path: str | None = None, - name: str | None = None, - registered_model_name: str | None = None, conda_env: dict | str | None = None, code_paths: list[str] | None = None, + registered_model_name: str | None = None, + signature: ModelSignature | None = None, + input_example: ModelInputExample | None = None, + await_registration_for: int = DEFAULT_AWAIT_MAX_SLEEP_SECONDS, pip_requirements: list[str] | None = None, extra_pip_requirements: list[str] | None = None, - signature=None, - input_example=None, - metadata: dict | None = None, + metadata: dict[str, Any] | None = None, + name: str | None = None, + params: dict[str, Any] | None = None, + tags: dict[str, Any] | None = None, + model_type: str | None = None, + step: int = 0, + model_id: str | None = None, log_params: bool = True, + **kwargs, ): """Log a darts model to the current MLflow run. @@ -270,30 +279,43 @@ def log_model( artifact_path The run-relative artifact path under which to log the model. Defaults to ``"model"``. Deprecated in favour of ``name``. - name - The name for the model artifact. If provided, takes precedence over - ``artifact_path``. - registered_model_name - If provided, the model is registered in the MLflow Model Registry - under this name. conda_env Conda environment specification (dict or path). code_paths A list of local filesystem paths to Python file dependencies (or directories containing file dependencies). These files are prepended to the system path when the model is loaded. - pip_requirements - Pip requirements list. - extra_pip_requirements - A list of additional pip requirement strings to add to the model's environment, - in addition to the default requirements. + registered_model_name + If provided, the model is registered in the MLflow Model Registry + under this name. signature *Unsupported, see notes.* An ``mlflow.models.ModelSignature``. Use ``mlflow.models.infer_signature()`` to automatically generate from example inputs. input_example *Unsupported, see notes.* An example model input. + await_registration_for + Number of seconds to wait for the model version to finish being created and is in ``READY`` status. + By default, the function waits for five minutes. Specify 0 to skip waiting. + pip_requirements + Pip requirements list. + extra_pip_requirements + A list of additional pip requirement strings to add to the model's environment, + in addition to the default requirements. metadata Optional dict of custom metadata. + name + The name for the model artifact. If provided, takes precedence over + ``artifact_path``. + params + Optional dictionary of parameters to log alongside the model. + tags + Optional dictionary of tags to log alongside the model. + model_type + Optional string for the model type. + step + Optional step value to log with the model's metrics. Defaults to 0. + model_id + Optional string for the model ID. log_params If ``True`` (default), log the model's creation parameters via ``mlflow.log_params()``. @@ -312,17 +334,13 @@ def log_model( simplifying potential future extensibility, and to keep in line with MLflow API conventions. """ - # import required as Model.log will call flavor.save_model() internally - import darts.utils.mlflow as darts_mlflow - if log_params: _log_model_params(model) _log_covariate_info(model) return Model.log( artifact_path=artifact_path, - name=name, - flavor=darts_mlflow, + flavor=sys.modules[__name__], registered_model_name=registered_model_name, model=model, conda_env=conda_env, @@ -331,7 +349,14 @@ def log_model( extra_pip_requirements=extra_pip_requirements, signature=signature, input_example=input_example, + await_registration_for=await_registration_for, metadata=metadata, + name=name, + params=params, + tags=tags, + model_type=model_type, + step=step, + model_id=model_id, ) From b8a4f8d2c1bdb6f506ef2b475ada1c392cc12d75 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 15:08:37 +0000 Subject: [PATCH 044/154] Remove `log_params` from `log_model()` Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 75f1b8d83e..37ab546f6a 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -267,7 +267,6 @@ def log_model( model_type: str | None = None, step: int = 0, model_id: str | None = None, - log_params: bool = True, **kwargs, ): """Log a darts model to the current MLflow run. @@ -316,9 +315,6 @@ def log_model( Optional step value to log with the model's metrics. Defaults to 0. model_id Optional string for the model ID. - log_params - If ``True`` (default), log the model's creation parameters via - ``mlflow.log_params()``. Returns ------- @@ -334,9 +330,6 @@ def log_model( simplifying potential future extensibility, and to keep in line with MLflow API conventions. """ - if log_params: - _log_model_params(model) - _log_covariate_info(model) return Model.log( artifact_path=artifact_path, @@ -357,6 +350,7 @@ def log_model( model_type=model_type, step=step, model_id=model_id, + **kwargs, ) From 331c4c35164243e10c76d27a28bac7cc00c7adcd Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 16:10:37 +0000 Subject: [PATCH 045/154] Update unit tests Co-authored-by: Zhihao Dai --- darts/tests/optional_deps/test_mlflow.py | 189 ++++++++--------------- 1 file changed, 68 insertions(+), 121 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 9ee402f9b4..bd46384723 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,4 +1,3 @@ -import json import os import numpy as np @@ -6,6 +5,11 @@ import pytest import darts.utils.timeseries_generation as tg +from darts import TimeSeries +from darts.models.forecasting.forecasting_model import ( + ForecastingModel, + GlobalForecastingModel, +) from darts.tests.conftest import MLFLOW_AVAILABLE, TORCH_AVAILABLE, tfm_kwargs_dev from darts.utils.utils import PL_AVAILABLE @@ -72,14 +76,37 @@ def assert_mlflow_artifacts_exist(path: str, is_torch: bool = False): assert os.path.exists(os.path.join(path, "model.pkl")) -def assert_predictions_equal(model1, model2, n: int, decimal: int = 4, series=None): +def assert_predictions_equal( + model1: ForecastingModel, + model2: ForecastingModel, + n: int, + decimal: int = 4, + is_global: bool = True, + series: TimeSeries | None = None, + past_covariates: TimeSeries | None = None, + future_covariates: TimeSeries | None = None, +): """Assert that two models produce equivalent predictions. If series is provided, it will be passed to the second model's predict method (for global models that require it).""" - pred1 = model1.predict(n=n) - if series is not None: - pred2 = model2.predict(n=n, series=series) + if is_global: + assert isinstance(model1, GlobalForecastingModel) + assert isinstance(model2, GlobalForecastingModel) + pred1 = model1.predict( + n=n, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + ) + pred2 = model2.predict( + n=n, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + ) else: + pred1 = model1.predict(n=n) pred2 = model2.predict(n=n) + np.testing.assert_array_almost_equal( pred1.values(), pred2.values(), decimal=decimal ) @@ -107,7 +134,7 @@ def test_save_load_statistical_model(self, tmpdir_fn): assert_mlflow_artifacts_exist(model_path, is_torch=False) loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=5) + assert_predictions_equal(model, loaded_model, n=5, is_global=False) def test_save_load_regression_model(self, tmpdir_fn): """Test save/load round-trip for regression model""" @@ -152,23 +179,7 @@ def test_log_model_basic(self, mlflow_tracking): log_info = log_model(model, name="model") loaded_model = load_model(log_info.model_uri) - assert_predictions_equal(model, loaded_model, n=5) - - def test_log_model_with_params(self, mlflow_tracking): - """Test that log_params=True logs model parameters""" - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) - - with mlflow.start_run(): - log_model(model, name="model", log_params=True) - run_id = mlflow.active_run().info.run_id - - run = mlflow.get_run(run_id) - assert run.data.params["lags"] == "5" - assert run.data.params["lags_past_covariates"] == "3" - assert run.data.params["n_past_covariates"] == "1" - assert run.data.params["n_future_covariates"] == "0" - assert run.data.params["n_static_covariates"] == "0" + assert_predictions_equal(model, loaded_model, n=5, is_global=False) def test_log_model_with_covariates(self, mlflow_tracking): """Test that covariate info is logged with correct values""" @@ -176,44 +187,17 @@ def test_log_model_with_covariates(self, mlflow_tracking): model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) with mlflow.start_run(): - log_model(model, name="model", log_params=True) + log_model(model, name="model") run_id = mlflow.active_run().info.run_id - # get artifact while run is still active - artifact_uri = mlflow.get_artifact_uri("covariates.json") - artifact_path = artifact_uri.replace("file://", "") - assert os.path.exists(artifact_path), ( - "covariates.json artifact should exist" - ) - - with open(artifact_path) as f: - cov_data = json.load(f) - - run = mlflow.get_run(run_id) - # check covariate usage tags have the correct boolean values - assert run.data.tags["uses_past_covariates"] == "true" - assert run.data.tags["uses_future_covariates"] == "false" - assert run.data.tags["uses_static_covariates"] == "false" - # check covariate count params - assert run.data.params["n_past_covariates"] == "1" - assert run.data.params["n_future_covariates"] == "0" - assert run.data.params["n_static_covariates"] == "0" - - # verify structure and content - assert "past_covariates" in cov_data - assert "future_covariates" in cov_data - assert "static_covariates" in cov_data - - # check past covariates data - assert cov_data["past_covariates"]["used"] is True - assert cov_data["past_covariates"]["count"] == 1 - assert len(cov_data["past_covariates"]["names"]) == 1 - - # check future and static covariates not used - assert cov_data["future_covariates"]["used"] is False - assert cov_data["future_covariates"]["count"] == 0 - assert cov_data["static_covariates"]["used"] is False - assert cov_data["static_covariates"]["count"] == 0 + loaded_model = load_model(f"runs:/{run_id}/model") + assert_predictions_equal( + model, + loaded_model, + n=5, + series=self.ts_univariate[:40], + past_covariates=self.ts_past_cov, + ) def test_log_model_with_all_covariate_types(self, mlflow_tracking): """Test logging model with past, future, and static covariates""" @@ -228,35 +212,18 @@ def test_log_model_with_all_covariate_types(self, mlflow_tracking): ) with mlflow.start_run(): - log_model(model, name="model", log_params=True) + log_model(model, name="model") run_id = mlflow.active_run().info.run_id - # get artifact while run is still active - artifact_uri = mlflow.get_artifact_uri("covariates.json") - artifact_path = artifact_uri.replace("file://", "") - - with open(artifact_path) as f: - cov_data = json.load(f) - - run = mlflow.get_run(run_id) - - # verify all covariate types are tracked - assert run.data.tags["uses_past_covariates"] == "true" - assert run.data.tags["uses_future_covariates"] == "true" - assert run.data.tags["uses_static_covariates"] == "true" - - # verify covariate counts - assert run.data.params["n_past_covariates"] == "1" - assert run.data.params["n_future_covariates"] == "1" - assert run.data.params["n_static_covariates"] == "1" - - # all covariate types should be used - assert cov_data["past_covariates"]["used"] is True - assert cov_data["past_covariates"]["count"] == 1 - assert cov_data["future_covariates"]["used"] is True - assert cov_data["future_covariates"]["count"] == 1 - assert cov_data["static_covariates"]["used"] is True - assert cov_data["static_covariates"]["count"] == 1 + loaded_model = load_model(f"runs:/{run_id}/model") + assert_predictions_equal( + model, + loaded_model, + n=5, + series=self.ts_with_static[:40], + past_covariates=self.ts_past_cov, + future_covariates=self.ts_future_cov, + ) def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): """Test autolog can be enabled and disabled""" @@ -380,27 +347,7 @@ def test_covariate_artifact_schema(self, mlflow_tracking): model = LinearRegressionModel(lags=5, lags_past_covariates=3) model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) - with mlflow.start_run(): - log_model(model, name="model", log_params=True) - - artifact_uri = mlflow.get_artifact_uri("covariates.json") - artifact_path = artifact_uri.replace("file://", "") - - with open(artifact_path) as f: - cov_data = json.load(f) - - # validate schema structure - required_keys = ["past_covariates", "future_covariates", "static_covariates"] - assert all(key in cov_data for key in required_keys), ( - "Missing required covariate keys" - ) - - for cov_type in required_keys: - cov_info = cov_data[cov_type] - assert "used" in cov_info and isinstance(cov_info["used"], bool) - assert "count" in cov_info and isinstance(cov_info["count"], int) - assert "names" in cov_info and isinstance(cov_info["names"], list) - assert cov_info["count"] == len(cov_info["names"]) + # TODO: use autolog def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" @@ -419,20 +366,18 @@ def test_multivariate_with_all_covariate_types(self, mlflow_tracking): ) with mlflow.start_run(): - log_model(model, name="model", log_params=True) + log_model(model, name="model") run_id = mlflow.active_run().info.run_id - run = mlflow.get_run(run_id) - - # verify all covariate types detected - assert run.data.tags["uses_past_covariates"] == "true" - assert run.data.tags["uses_future_covariates"] == "true" - assert run.data.tags["uses_static_covariates"] == "true" - - # verify correct component counts - assert run.data.params["n_past_covariates"] == "1" - assert run.data.params["n_future_covariates"] == "1" - assert run.data.params["n_static_covariates"] == "2" + loaded_model = load_model(f"runs:/{run_id}/model") + assert_predictions_equal( + loaded_model, + model, + n=5, + series=target[:40], + past_covariates=self.ts_past_cov, + future_covariates=self.ts_future_cov, + ) @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_pytorch_autolog_with_existing_callbacks( @@ -624,8 +569,10 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): # Only pass series for global models (LinearRegressionModel) # Local models (ExponentialSmoothing) don't need it - series = self.ts_univariate if fit_kwargs else None - assert_predictions_equal(model, loaded, n=5, series=series) + if isinstance(model, GlobalForecastingModel): + assert_predictions_equal(model, loaded, n=5, series=self.ts_univariate) + else: + assert_predictions_equal(model, loaded, n=5, is_global=False) @pytest.mark.parametrize( "series,series_name", From 2396f16a46de0064fcea974ae67fc8a4ce603b12 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 19:30:59 +0000 Subject: [PATCH 046/154] Simplify `_is_torch_model` Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 37ab546f6a..2b22fa469b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -169,7 +169,6 @@ def save_model( data=model_file, model_class=model_class, code=code_dir_subpath, - is_torch_model=is_torch, ) mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME)) @@ -243,10 +242,7 @@ def load_model( model_path = os.path.join(local_path, flavor_conf["data"]) - if flavor_conf.get("is_torch_model", False): - return model_cls.load(model_path, **kwargs) - else: - return model_cls.load(model_path) + return model_cls.load(model_path, **kwargs) def log_model( @@ -645,15 +641,8 @@ def _is_torch_model(model) -> bool: bool True if the model is a TorchForecastingModel, False otherwise. """ - try: - from darts.models.forecasting.torch_forecasting_model import ( - TorchForecastingModel, - ) - - return isinstance(model, TorchForecastingModel) - except ImportError: - logger.info("TorchForecastingModel not available; treating model as non-torch") - return False + method = getattr(model, "predict_from_dataset", None) + return callable(method) def _extract_covariate_metadata( From 7646dde8f47d962c0ecb1eab5a1ac75d01a21417 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 19:34:51 +0000 Subject: [PATCH 047/154] Move `_patched_fit` inside `_autolog()` Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 94 ++++++++++++++++++++----------------------- 1 file changed, 44 insertions(+), 50 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 2b22fa469b..6415565df6 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -32,10 +32,7 @@ from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS from mlflow.tracking.artifact_utils import _download_artifact_from_uri from mlflow.utils import _get_fully_qualified_class_name, _inspect_original_var_name -from mlflow.utils.autologging_utils import ( - autologging_integration, - get_autologging_config, -) +from mlflow.utils.autologging_utils import autologging_integration from mlflow.utils.autologging_utils.safety import safe_patch from mlflow.utils.class_utils import _get_class_from_string from mlflow.utils.environment import ( @@ -489,6 +486,47 @@ def _autolog( ``disable=True``. """ + def _patched_fit(original, self, *args, **kwargs): + """Patch function for ForecastingModel.fit() autologging. + + Logs model parameters, class, covariates and the model itself. + Parameters + ---------- + original + The original fit method being patched. + self + The model instance (ForecastingModel or TorchForecastingModel). + args + Positional arguments passed to fit. + kwargs + Keyword arguments passed to fit. + + Returns + ------- + The result of calling the original fit method. + """ + + mlflow.set_tag("darts.model_class", type(self).__name__) + + if log_params: + _log_model_params(self) + + result = original(self, *args, **kwargs) + + if log_params: + _log_covariate_info(self) + + if log_models: + try: + log_model(self, name="model", log_params=False) + except Exception: + logger.info( + f"Failed to autolog model artifact for {type(self).__name__}.", + exc_info=True, + ) + + return result + # patch `fit()` for all forecasting models for _, cls in _get_forecasting_models(): try: @@ -629,7 +667,7 @@ def _log_covariate_info(model) -> None: def _is_torch_model(model) -> bool: - """Check if a model is a TorchForecastingModel. + """Check if a model is a `TorchForecastingModel`. Parameters ---------- @@ -639,7 +677,7 @@ def _is_torch_model(model) -> bool: Returns ------- bool - True if the model is a TorchForecastingModel, False otherwise. + True if the model is a `TorchForecastingModel`, False otherwise. """ method = getattr(model, "predict_from_dataset", None) return callable(method) @@ -679,50 +717,6 @@ def _extract_covariate_metadata( return info -def _patched_fit(original, self, *args, **kwargs): - """Patch function for ForecastingModel.fit() autologging. - - Logs model parameters, class, covariates and the model itself. - Parameters - ---------- - original - The original fit method being patched. - self - The model instance (ForecastingModel or TorchForecastingModel). - args - Positional arguments passed to fit. - kwargs - Keyword arguments passed to fit. - - Returns - ------- - The result of calling the original fit method. - """ - log_models = get_autologging_config(FLAVOR_NAME, "log_models", True) - log_params = get_autologging_config(FLAVOR_NAME, "log_params", True) - - mlflow.set_tag("darts.model_class", type(self).__name__) - - if log_params: - _log_model_params(self) - - result = original(self, *args, **kwargs) - - if log_params: - _log_covariate_info(self) - - if log_models: - try: - log_model(self, name="model", log_params=False) - except Exception: - logger.info( - f"Failed to autolog model artifact for {type(self).__name__}.", - exc_info=True, - ) - - return result - - def _sanitize_mlflow_key(name: str) -> str: """Sanitize a string for use as an MLflow metric key. From 948ab56c5b2d3905a8881e47b1733ea0d5e618fc Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 19:42:26 +0000 Subject: [PATCH 048/154] Handle single series in metric patching Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 6415565df6..ad35e40eaf 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -58,6 +58,7 @@ import darts from darts.logging import get_logger, raise_log from darts.models.forecasting.forecasting_model import ForecastingModel +from darts.utils.ts_utils import get_single_series logger = get_logger(__name__) @@ -866,15 +867,10 @@ def _patched_metric(original, *args, **kwargs): input_is_list = not hasattr(series, "components") # extract component names from the series (or first element if list) - component_names = None - try: - if input_is_list: - # we assume that subsequent series have same component order - component_names = series[0].components.tolist() - else: - component_names = series.components.tolist() - except Exception: - logger.info("Could not extract component names from series.") + single_series = get_single_series(series) + component_names = ( + single_series.components.tolist() if single_series is not None else None + ) try: _log_metric_result( From 6ad82f7a459e10899bdd451d17df6de861698383 Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 20:04:51 +0000 Subject: [PATCH 049/154] Update covariate logging logic Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 120 +++++++++++++++++++++++------------------- 1 file changed, 67 insertions(+), 53 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index ad35e40eaf..fbe5712a7f 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -31,8 +31,13 @@ from mlflow.models.utils import _save_example from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS from mlflow.tracking.artifact_utils import _download_artifact_from_uri +from mlflow.tracking.fluent import _initialize_logged_model from mlflow.utils import _get_fully_qualified_class_name, _inspect_original_var_name -from mlflow.utils.autologging_utils import autologging_integration +from mlflow.utils.autologging_utils import ( + autologging_integration, + get_autologging_config, +) +from mlflow.utils.autologging_utils.client import MlflowAutologgingQueueingClient from mlflow.utils.autologging_utils.safety import safe_patch from mlflow.utils.class_utils import _get_class_from_string from mlflow.utils.environment import ( @@ -68,6 +73,27 @@ _MODEL_FILE_STAT = "model.pkl" _MODEL_FILE_TORCH = "model.pt" +_covariate_types = [ + ( + "past_covariates", + "uses_past_covariates", + "past_covariate_series", + "components", + ), + ( + "future_covariates", + "uses_future_covariates", + "future_covariate_series", + "components", + ), + ( + "static_covariates", + "uses_static_covariates", + "static_covariates", + "columns", + ), +] + def save_model( model, @@ -507,19 +533,32 @@ def _patched_fit(original, self, *args, **kwargs): The result of calling the original fit method. """ - mlflow.set_tag("darts.model_class", type(self).__name__) + # Create a training session to track the training process and log information + autologging_client = MlflowAutologgingQueueingClient() - if log_params: - _log_model_params(self) + run_id = mlflow.active_run().info.run_id + + # Set tags to identify the model class and relevant information + autologging_client.set_tags(run_id=run_id, tags=_get_model_info_tags(self)) result = original(self, *args, **kwargs) if log_params: + # Log the parameters for model creation + autologging_client.log_params(run_id=run_id, params=self.model_params) _log_covariate_info(self) if log_models: + model_id = _initialize_logged_model("model", flavor=FLAVOR_NAME).model_id try: - log_model(self, name="model", log_params=False) + registered_model_name = get_autologging_config( + FLAVOR_NAME, "registered_model_name", None + ) + log_model( + result, + registered_model_name=registered_model_name, + model_id=model_id, + ) except Exception: logger.info( f"Failed to autolog model artifact for {type(self).__name__}.", @@ -587,28 +626,26 @@ def get_default_conda_env(): ) -def _log_model_params(model) -> None: - """Log model creation parameters to MLflow. - - Extracts model parameters from ``model.model_params`` and logs them to the active - MLflow run. - - Parameters - ---------- - model - A Darts forecasting model instance with a ``model_params`` attribute. +def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: """ - try: - params = model.model_params - except AttributeError: - logger.info("Model has no model_params attribute; skipping parameter logging.") - return - - if params: - mlflow.log_params(params) + Returns: + A dictionary of MLflow run tag keys and values describing the specified model. + """ + return { + "model_name": model.__class__.__name__, + "model_class": (model.__class__.__module__ + "." + model.__class__.__name__), + "model_likelihood": ( + model.likelihood.__class__.__name__ + if model.likelihood is not None + else None + ), + "model_uses_past_covariates": model.uses_past_covariates, + "model_uses_future_covariates": model.uses_future_covariates, + "model_uses_static_covariates": model.uses_static_covariates, + } -def _log_covariate_info(model) -> None: +def _log_covariate_info(model: ForecastingModel) -> None: """Log covariate usage information to MLflow. Extracts information about past, future, and static covariates used during @@ -625,39 +662,16 @@ def _log_covariate_info(model) -> None: model A fitted Darts forecasting model instance. """ - covariate_types = [ - ( - "past_covariates", - "_uses_past_covariates", - "past_covariate_series", - "components", - ), - ( - "future_covariates", - "_uses_future_covariates", - "future_covariate_series", - "components", - ), - ( - "static_covariates", - "_uses_static_covariates", - "static_covariates", - "columns", - ), - ] covariate_info = { cov_key: _extract_covariate_metadata(model, uses_attr, series_attr, names_attr) - for cov_key, uses_attr, series_attr, names_attr in covariate_types + for cov_key, uses_attr, series_attr, names_attr in _covariate_types } - for cov_key, info in covariate_info.items(): - mlflow.set_tag(f"uses_{cov_key}", str(info["used"]).lower()) - mlflow.log_param(f"n_{cov_key}", info["count"]) - - if info["names"]: - names_str = ",".join(info["names"]) - mlflow.log_param(f"{cov_key.split('_')[0]}_cov_names", names_str) + if model.uses_static_covariates and model.static_covariates is not None: + covariate_info["static_covariates"]["is_global"] = len( + model.static_covariates + ) != len(model.static_covariates.columns) # log complete information as JSON artifact with TempDir() as tmp: @@ -685,7 +699,7 @@ def _is_torch_model(model) -> bool: def _extract_covariate_metadata( - model, uses_attr: str, series_attr: str, names_attr: str + model: ForecastingModel, uses_attr: str, series_attr: str, names_attr: str ) -> dict: """Extract metadata for a single covariate type. From abf24f561980fabf33b9f93649e0a54d05e7496e Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 20:22:09 +0000 Subject: [PATCH 050/154] Update tests and wait for completion Co-authored-by: Zhihao Dai --- darts/tests/optional_deps/test_mlflow.py | 12 ++++++------ darts/utils/mlflow.py | 8 ++++++-- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index bd46384723..5341d4e704 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -236,7 +236,7 @@ def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): # verify the run has expected content last_run = runs.iloc[0] - assert last_run["tags.darts.model_class"] == "ExponentialSmoothing" + assert last_run["tags.model_name"] == "ExponentialSmoothing" assert last_run["tags.mlflow.runName"] is not None # after context exits, autolog should be disabled @@ -259,7 +259,7 @@ def test_autolog_parameters(self, mlflow_tracking, autolog_context): last_run = runs.iloc[0] assert last_run["params.seasonal_periods"] == "12" - assert last_run["tags.darts.model_class"] == "ExponentialSmoothing" + assert last_run["tags.model_name"] == "ExponentialSmoothing" @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): @@ -278,7 +278,7 @@ def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): assert len(runs) == 1, "Expected exactly one run" last_run = runs.iloc[0] last_run_id = last_run["run_id"] - assert last_run["tags.darts.model_class"] == "NBEATSModel" + assert last_run["tags.model_name"] == "NBEATSModel" client = mlflow.tracking.MlflowClient() @@ -328,7 +328,7 @@ def assert_metric(history, key): runs = mlflow.search_runs() assert len(runs) == 1 run_id = runs.iloc[0]["run_id"] - assert runs.iloc[0]["tags.darts.model_class"] == "NBEATSModel" + assert runs.iloc[0]["tags.model_name"] == "NBEATSModel" client = mlflow.tracking.MlflowClient() assert_metric(client.get_metric_history(run_id, "train_loss"), "train_loss") @@ -440,7 +440,7 @@ def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): assert len(runs) == 2, "Expected two separate runs for two fits" # verify different model classes logged - model_classes = set(runs["tags.darts.model_class"]) + model_classes = set(runs["tags.model_name"]) assert "ExponentialSmoothing" in model_classes assert "LinearRegressionModel" in model_classes @@ -466,7 +466,7 @@ def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_contex assert len(runs) == 2, "Expected two separate runs for two fits" for _, run in runs.iterrows(): - assert run["tags.darts.model_class"] in [ + assert run["tags.model_name"] in [ "NBEATSModel", "LinearRegressionModel", ] diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index fbe5712a7f..100dc3c732 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -538,16 +538,18 @@ def _patched_fit(original, self, *args, **kwargs): run_id = mlflow.active_run().info.run_id + result = original(self, *args, **kwargs) + # Set tags to identify the model class and relevant information autologging_client.set_tags(run_id=run_id, tags=_get_model_info_tags(self)) - result = original(self, *args, **kwargs) - if log_params: # Log the parameters for model creation autologging_client.log_params(run_id=run_id, params=self.model_params) _log_covariate_info(self) + param_logging_ops = autologging_client.flush(synchronous=False) + if log_models: model_id = _initialize_logged_model("model", flavor=FLAVOR_NAME).model_id try: @@ -565,6 +567,8 @@ def _patched_fit(original, self, *args, **kwargs): exc_info=True, ) + param_logging_ops.await_completion() + return result # patch `fit()` for all forecasting models From 774a222f69cc803a8588296b4a9920b79c7b3efa Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 20:28:27 +0000 Subject: [PATCH 051/154] Remove `PL_AVAILABLE` flag Co-authored-by: Zhihao Dai --- darts/tests/optional_deps/test_mlflow.py | 3 +-- darts/utils/utils.py | 7 ------- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 5341d4e704..4b2599e452 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -11,7 +11,6 @@ GlobalForecastingModel, ) from darts.tests.conftest import MLFLOW_AVAILABLE, TORCH_AVAILABLE, tfm_kwargs_dev -from darts.utils.utils import PL_AVAILABLE if not MLFLOW_AVAILABLE: pytest.skip( @@ -385,7 +384,7 @@ def test_pytorch_autolog_with_existing_callbacks( ): """Test pytorch autolog works when model already has callbacks""" # create model with existing callback - if PL_AVAILABLE: + if TORCH_AVAILABLE: import pytorch_lightning as pl existing_callback = pl.callbacks.EarlyStopping(monitor="train_loss") diff --git a/darts/utils/utils.py b/darts/utils/utils.py index 77ce154732..d04c70fa67 100644 --- a/darts/utils/utils.py +++ b/darts/utils/utils.py @@ -38,13 +38,6 @@ except ImportError: TORCH_AVAILABLE = False -try: - import pytorch_lightning as pl # noqa: F401 - - PL_AVAILABLE = True -except ImportError: - PL_AVAILABLE = False - logger = get_logger(__name__) MAX_TORCH_SEED_VALUE = (1 << 31) - 1 # to accommodate 32-bit architectures From 3c9296f928a04d9f6cf221653413d0c097f446eb Mon Sep 17 00:00:00 2001 From: Zhihao Dai Date: Thu, 5 Mar 2026 22:00:15 +0000 Subject: [PATCH 052/154] Add post-fitting metric TODO note Co-authored-by: Zhihao Dai --- darts/utils/mlflow.py | 112 +++++++++++++++++++++++------------------- 1 file changed, 62 insertions(+), 50 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 100dc3c732..2e71dfd180 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -573,36 +573,40 @@ def _patched_fit(original, self, *args, **kwargs): # patch `fit()` for all forecasting models for _, cls in _get_forecasting_models(): - try: - safe_patch( - FLAVOR_NAME, - cls, - "fit", - _patched_fit, - manage_run=manage_run, - ) - except Exception as e: - logger.info(f"Failed to patch {cls.__name__}.fit() for autologging: {e}") + safe_patch( + FLAVOR_NAME, + cls, + "fit", + _patched_fit, + manage_run=manage_run, + ) if log_metrics: - import darts.metrics as _darts_metrics + import darts.metrics + + # TODO: To log metrics post-fitting, only patching the metric methods may not be enough. + # This is becuase `model.fit()` method would terminate the active MLflow run at the end of training, + # so any metric calls made after that would not be logged. + # To address this, we need to implement three things: + # 1. Implement a singleton `_AutologgingMetricsManager` (`mlflow.sklearn`) to maintain a mapping between fitted + # models and their prediction outputs. + # 2. Patch the `model.predict()` method to create a mapping between the model (run_id) and prediction output. + # 3. Patch the metric functions to find the model (run_id) from the input series, then log the metrics to + # the corresponding run. + # This way, even if the metric calls are made after `fit()` has terminated the active run, we can still log + # the metrics to the correct run. # patch all metric functions to log results - for metric_name in _darts_metrics.__all__: - try: - # metrics should not create their own runs; - # they log into the run started by fit(), so manage_run=False here - safe_patch( - FLAVOR_NAME, - _darts_metrics, - metric_name, - _make_metric_patch(metric_name), - manage_run=False, - ) - except Exception as e: - logger.info( - f"Failed to patch metric '{metric_name}' on darts.metrics: {e}" - ) + for metric_name in darts.metrics.__all__: + # metrics should not create their own runs; + # they log into the run started by fit(), so manage_run=False here + safe_patch( + FLAVOR_NAME, + darts.metrics, + metric_name, + _make_metric_patch(metric_name), + manage_run=False, + ) def get_default_pip_requirements(): @@ -757,6 +761,8 @@ def _sanitize_mlflow_key(name: str) -> str: def _log_metric_result( + autologging_client: MlflowAutologgingQueueingClient, + run_id: str, metric_name: str, result, dataset_name: str | None = None, @@ -804,9 +810,6 @@ def _log_metric_result( """ result_arr = np.asarray(result) - if mlflow.active_run() is None: - return - base_key = f"{metric_name}_{dataset_name}" if dataset_name else metric_name def _comp_suffix(idx: int) -> str: @@ -814,34 +817,39 @@ def _comp_suffix(idx: int) -> str: return _sanitize_mlflow_key(component_names[idx]) return str(idx) + metrics = {} + if result_arr.ndim == 0: # scalar result - mlflow.log_metric(base_key, float(result_arr)) + metrics[base_key] = float(result_arr) elif result_arr.ndim == 1: if not input_is_list: # single series: log per-component for c_i, val in enumerate(result_arr): - mlflow.log_metric(f"{base_key}_{_comp_suffix(c_i)}", float(val)) + metrics[f"{base_key}_{_comp_suffix(c_i)}"] = float(val) else: # list input, components already reduced: log per-series for s_i, val in enumerate(result_arr): - mlflow.log_metric(f"{base_key}_{s_i}", float(val)) + metrics[f"{base_key}_{s_i}"] = float(val) elif result_arr.ndim == 2: # list input: log per-series and per-component n_series, n_components = result_arr.shape for s_i in range(n_series): for c_i in range(n_components): - mlflow.log_metric( - f"{base_key}_{_comp_suffix(c_i)}_{s_i}", - float(result_arr[s_i, c_i]), + metrics[f"{base_key}_{_comp_suffix(c_i)}_{s_i}"] = float( + result_arr[s_i, c_i] ) else: # unexpected shape — flatten with integer indices for i, val in enumerate(result_arr.flatten()): - mlflow.log_metric(f"{base_key}_{i}", float(val)) + metrics[f"{base_key}_{i}"] = float(val) + + autologging_client.log_metrics(run_id=run_id, metrics=metrics) + operation = autologging_client.flush(synchronous=False) + operation.await_completion() def _make_metric_patch(metric_name: str) -> Callable: @@ -872,10 +880,17 @@ def _make_metric_patch(metric_name: str) -> Callable: def _patched_metric(original, *args, **kwargs): result = original(*args, **kwargs) - if mlflow.active_run() is None: + active_run = mlflow.active_run() + if active_run is None: return result - series = args[0] + autologging_client = MlflowAutologgingQueueingClient() + run_id = active_run.info.run_id + + if len(args) > 0: + series = args[0] + else: + series = kwargs.get("actual_series", None) # capture the variable name of actual_series for metric key raw = _inspect_original_var_name(series, fallback_name=None) @@ -890,18 +905,15 @@ def _patched_metric(original, *args, **kwargs): single_series.components.tolist() if single_series is not None else None ) - try: - _log_metric_result( - metric_name, - result, - dataset_name=dataset_name, - component_names=component_names, - input_is_list=input_is_list, - ) - except Exception: - logger.info( - f"Failed to log metric '{metric_name}' to MLflow.", exc_info=True - ) + _log_metric_result( + autologging_client, + run_id, + metric_name, + result, + dataset_name=dataset_name, + component_names=component_names, + input_is_list=input_is_list, + ) return result From a7bca2eb94d4c9ac9d97fa592be82236e1124b0a Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Fri, 6 Mar 2026 16:30:12 +0100 Subject: [PATCH 053/154] chore: rename mlflow jupyter from 26 to 27 --- .../{26-MLflow-quickstart.ipynb => 27-MLflow-quickstart.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename examples/{26-MLflow-quickstart.ipynb => 27-MLflow-quickstart.ipynb} (100%) diff --git a/examples/26-MLflow-quickstart.ipynb b/examples/27-MLflow-quickstart.ipynb similarity index 100% rename from examples/26-MLflow-quickstart.ipynb rename to examples/27-MLflow-quickstart.ipynb From eb8f8cdbdbb986bbcdfccb19abb0b55e1be7ad57 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Fri, 6 Mar 2026 17:17:47 +0100 Subject: [PATCH 054/154] chore: fix jupyter for mlflow; work in progress --- .gitignore | 2 ++ darts/utils/mlflow.py | 12 ++++--- examples/27-MLflow-quickstart.ipynb | 50 +++++++++++++---------------- 3 files changed, 33 insertions(+), 31 deletions(-) diff --git a/.gitignore b/.gitignore index 6d5390ef1c..6e5eb81a78 100644 --- a/.gitignore +++ b/.gitignore @@ -25,3 +25,5 @@ docs_env .venv uv.lock +repl/ +examples/mlruns/* \ No newline at end of file diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 2e71dfd180..922348c198 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -400,9 +400,13 @@ def autolog( .. important:: - ``autolog()`` must be called **before** importing metric functions from - ``darts.metrics``. Metric functions imported before ``autolog()`` is - enabled will **not** log to MLflow. + Metric functions imported with ``from darts.metrics import `` + before ``autolog()`` is enabled will **not** log to MLflow (function + reference is copied out of the module before the patch is applied). + + To avoid this restriction, use ``import darts.metrics as dm`` and call + ``dm.()`` instead (module attribute lookups are resolved at call + time and will always see the patched version). .. note:: @@ -810,7 +814,7 @@ def _log_metric_result( """ result_arr = np.asarray(result) - base_key = f"{metric_name}_{dataset_name}" if dataset_name else metric_name + base_key = f"{dataset_name}_{metric_name}" if dataset_name else metric_name def _comp_suffix(idx: int) -> str: if component_names is not None and idx < len(component_names): diff --git a/examples/27-MLflow-quickstart.ipynb b/examples/27-MLflow-quickstart.ipynb index 5a119983c5..0b793f75b3 100644 --- a/examples/27-MLflow-quickstart.ipynb +++ b/examples/27-MLflow-quickstart.ipynb @@ -70,15 +70,16 @@ "import mlflow\n", "import numpy as np\n", "\n", + "import darts.metrics\n", + "\n", "from darts.datasets import AirPassengersDataset\n", - "from darts.metrics import mape, rmse\n", "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", "from darts.utils.mlflow import autolog, load_model, log_model, save_model" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 3, "id": "4d424e08", "metadata": {}, "outputs": [], @@ -178,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 6, "id": "bc8f520d", "metadata": {}, "outputs": [ @@ -208,8 +209,8 @@ "predictions = model.predict(n=len(val))\n", "\n", "# calculate metrics you want to log to MLflow\n", - "mape_score = mape(val, predictions)\n", - "rmse_score = rmse(val, predictions)\n", + "mape_score = darts.metrics.mape(val, predictions)\n", + "rmse_score = darts.metrics.rmse(val, predictions)\n", "\n", "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", @@ -232,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "id": "61406cd9", "metadata": {}, "outputs": [ @@ -249,18 +250,18 @@ "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", " model_info = log_model(\n", " model=model,\n", - " name=\"model\",\n", - " log_params=True, # True by default, logs all model params\n", + " name=\"exponential-smoothing-model\",\n", + " # alternatively, use mlflow.set_tag(key, value) in the run\n", + " tags={\n", + " \"model_type\": \"ExponentialSmoothing\",\n", + " \"dataset\": \"AirPassengers\"\n", + " }\n", " )\n", "\n", " # log calculated metrics you want\n", " mlflow.log_metric(\"val_mape\", mape_score)\n", " mlflow.log_metric(\"val_rmse\", rmse_score)\n", "\n", - " # log any additional tags you want\n", - " mlflow.set_tag(\"model_type\", \"ExponentialSmoothing\")\n", - " mlflow.set_tag(\"dataset\", \"AirPassengers\")\n", - "\n", " print(f\"Run ID: {run.info.run_id}\")\n", " print(f\"Model URI: {model_info.model_uri}\")" ] @@ -341,10 +342,8 @@ " auto_model.fit(train) # no val_series → autolog logs train_* metrics by default\n", "\n", " auto_predictions = auto_model.predict(n=len(val))\n", - " auto_mape = mape(val, auto_predictions)\n", - " auto_rmse = rmse(val, auto_predictions)\n", - " mlflow.log_metric(\"val_mape\", auto_mape)\n", - " mlflow.log_metric(\"val_rmse\", auto_rmse)\n", + " auto_mape = darts.metrics.mape(val, auto_predictions)\n", + " auto_rmse = darts.metrics.rmse(val, auto_predictions)\n", "\n", "autolog(disable=True)\n", "\n", @@ -383,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 10, "id": "1a01cd2f", "metadata": {}, "outputs": [ @@ -393,7 +392,7 @@ "text": [ "Launch the MLflow UI with this command in your terminal:\n", "\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmph5ei82gg/mlflow.db\n", + " mlflow ui --backend-store-uri sqlite:////var/folders/4x/8t1xtpd11cb5xxdp87gm92jw0000gn/T/tmp3vfszfy0/mlflow.db\n", "\n", "Then open: http://localhost:5000\n" ] @@ -459,8 +458,8 @@ " )\n", " nbeats.fit(train, val_series=val)\n", " nbeats_pred = nbeats.predict(n=len(val))\n", - " mlflow.log_metric(\"val_mape\", mape(val, nbeats_pred))\n", - " mlflow.log_metric(\"val_rmse\", rmse(val, nbeats_pred))\n", + " darts.metrics.mape(val, nbeats_pred))\n", + " darts.metrics.rmse(val, nbeats_pred))\n", " print(f\"NBEATS MAPE: {mape(val, nbeats_pred):.2f}%\")\n", "\n", "autolog(disable=True)" @@ -493,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "id": "df8e85b6", "metadata": {}, "outputs": [ @@ -517,12 +516,9 @@ } ], "source": [ - "from darts.metrics import mae, smape\n", - "\n", "autolog(\n", - " log_training_metrics=True,\n", - " log_validation_metrics=True,\n", - " extra_metrics=[smape, mae], # add smape and mae on top of the defaults\n", + " log_metrics=True,\n", + " extra_metrics=[darts.metrics.smape, darts.metrics.mae], # add smape and mae on top of the defaults\n", ")\n", "\n", "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", @@ -869,7 +865,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.13.12" } }, "nbformat": 4, From ab591968f980256a0babd4d1ea4a5b81352f3cf5 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Fri, 17 Apr 2026 15:47:23 +0200 Subject: [PATCH 055/154] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 6e5eb81a78..06bba7cef4 100644 --- a/.gitignore +++ b/.gitignore @@ -26,4 +26,5 @@ docs_env uv.lock repl/ +mlruns/* examples/mlruns/* \ No newline at end of file From 01947445a48c40b125f3c300da4d0cc7d33923ab Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Fri, 17 Apr 2026 15:47:35 +0200 Subject: [PATCH 056/154] chore: local test files; remove later --- debug_hf_mlflow.py | 197 +++++++++++++++++++++++++++++++++++++++++++++ mlflow_test_v2.py | 118 +++++++++++++++++++++++++++ 2 files changed, 315 insertions(+) create mode 100644 debug_hf_mlflow.py create mode 100644 mlflow_test_v2.py diff --git a/debug_hf_mlflow.py b/debug_hf_mlflow.py new file mode 100644 index 0000000000..b9464b10ea --- /dev/null +++ b/debug_hf_mlflow.py @@ -0,0 +1,197 @@ +""" +Debug script: historical_forecasts / backtest with MLflow autologging. + +Issue (from PR #3022): historical_forecasts(retrain=True) and backtest() call +fit() internally on each iteration. Because _patched_fit runs with +manage_run=True, every internal fit() spawns its own MLflow run when no +active run exists - i.e. the typical autolog-only usage (no explicit +mlflow.start_run() wrapper). + +Expected: 1 run per historical_forecasts / backtest call. +Actual: 1 run per stride iteration. + +Run with: + python examples/repl/debug_hf_mlflow.py + +Then inspect in the UI: + mlflow ui --backend-store-uri sqlite:////tmp/mlflow_debug.db +""" + +# %% +import os + +import mlflow + +import darts.utils.mlflow as mlflow_darts +from darts.datasets import AirPassengersDataset +from darts.models import LinearRegressionModel + +# ---- setup ------------------------------------------------------------------- +series = AirPassengersDataset().load() + +STRIDE = 4 # keep iteration count low for fast runs + +DB_PATH = "/tmp/mlflow_debug.db" + +mlflow.set_tracking_uri(f"sqlite:///{DB_PATH}") +mlflow.set_experiment("debug-hf-mlflow") +client = mlflow.tracking.MlflowClient() +exp_id = mlflow.get_experiment_by_name("debug-hf-mlflow").experiment_id + + +def run_count(name=None): + runs = client.search_runs(experiment_ids=[exp_id]) + if name: + return sum(1 for r in runs if r.info.run_name == name) + return len(runs) + + +# ---- 1. normal fit WITH explicit start_run (baseline) ----------------------- +print("=" * 60) +print("1. Normal fit() inside mlflow.start_run()") +mlflow_darts.autolog(disable=True) +mlflow_darts.autolog() + +before = run_count() +with mlflow.start_run(run_name="fit-with-run"): + LinearRegressionModel(lags=12).fit(series[:100]) +mlflow_darts.autolog(disable=True) + +print(f" Runs created: {run_count() - before} (expected: 1)") + +# ---- 2. historical_forecasts WITH explicit start_run ------------------------ +print() +print("=" * 60) +print("2. historical_forecasts(retrain=True) inside mlflow.start_run()") +mlflow_darts.autolog(disable=True) +mlflow_darts.autolog() + +before = run_count() +with mlflow.start_run(run_name="hf-with-run"): + LinearRegressionModel(lags=12).historical_forecasts( + series, + start=0.75, + forecast_horizon=1, + stride=STRIDE, + retrain=True, + last_points_only=True, + ) +mlflow_darts.autolog(disable=True) + +print(f" Runs created: {run_count() - before} (expected: 1)") + +# ---- 3. historical_forecasts WITHOUT start_run (autolog-only usage) --------- +print() +print("=" * 60) +print("3. historical_forecasts(retrain=True) with autolog only (no start_run)") +mlflow_darts.autolog(disable=True) +mlflow_darts.autolog() + +before = run_count() +LinearRegressionModel(lags=12).historical_forecasts( + series, + start=0.75, + forecast_horizon=1, + stride=STRIDE, + retrain=True, + last_points_only=True, +) +mlflow_darts.autolog(disable=True) + +created = run_count() - before +print(f" Runs created: {created} (expected: 1)") +print(f" -> Each stride iteration spawned its own run: {created > 1}") + +# ---- 4. backtest WITHOUT start_run ------------------------------------------ +print() +print("=" * 60) +print("4. backtest() with autolog only (no start_run)") +mlflow_darts.autolog(disable=True) +mlflow_darts.autolog() + +before = run_count() +LinearRegressionModel(lags=12).backtest( + series, + start=0.75, + forecast_horizon=1, + stride=STRIDE, + retrain=True, +) +mlflow_darts.autolog(disable=True) + +created = run_count() - before +print(f" Runs created: {created} (expected: 1)") +print(f" -> Each stride iteration spawned its own run: {created > 1}") + +# Assert backtest_mape was logged +all_runs = client.search_runs(experiment_ids=[exp_id]) +bt_run = sorted(all_runs, key=lambda x: x.info.start_time)[-1] +metrics = bt_run.data.metrics +assert "backtest_mape" in metrics, f"Expected backtest_mape in metrics, got: {metrics}" +print(f" -> backtest_mape = {metrics['backtest_mape']:.4f} (PASS)") + +# ---- 5. backtest with reduction=None → per-window metrics ------------------- +print() +print("=" * 60) +print("5. backtest(reduction=None) — per-window MAPE logged as separate metrics") +mlflow_darts.autolog(disable=True) +mlflow_darts.autolog() + +before = run_count() +per_window = LinearRegressionModel(lags=12).backtest( + series, + start=0.75, + forecast_horizon=1, + stride=STRIDE, + retrain=True, + reduction=None, +) +mlflow_darts.autolog(disable=True) + +created = run_count() - before +print(f" Runs created: {created} (expected: 1)") + +all_runs = client.search_runs(experiment_ids=[exp_id]) +pw_run = sorted(all_runs, key=lambda x: x.info.start_time)[-1] +history = client.get_metric_history(pw_run.info.run_id, "backtest_mape") +assert history, f"Expected backtest_mape steps in metric history, got nothing" +print(f" -> backtest_mape logged across {len(history)} steps (windows)") + +# Plot per-window MAPE +import matplotlib.pyplot as plt +import numpy as np + +window_nums = [p.step for p in sorted(history, key=lambda p: p.step)] +values = [p.value for p in sorted(history, key=lambda p: p.step)] + +fig, ax = plt.subplots(figsize=(8, 4)) +ax.plot(window_nums, values, marker="o", linewidth=1.5, label="MAPE per window") +ax.axhline(np.mean(values), color="red", linestyle="--", linewidth=1, label=f"mean = {np.mean(values):.2f}%") +ax.set_xlabel("Backtest window index") +ax.set_ylabel("MAPE (%)") +ax.set_title("Per-window MAPE (backtest, reduction=None)") +ax.legend() +fig.tight_layout() +plt.savefig("/tmp/backtest_per_window_mape.png", dpi=150) +print(" -> Plot saved to /tmp/backtest_per_window_mape.png") +plt.show() + +# ---- summary ----------------------------------------------------------------- +print() +print("=" * 60) +print("Summary of ALL runs in experiment:") +all_runs = client.search_runs(experiment_ids=[exp_id]) +for r in sorted(all_runs, key=lambda x: x.info.start_time): + m = r.data.metrics + if "backtest_mape" in m: + h = client.get_metric_history(r.info.run_id, "backtest_mape") + if len(h) > 1: + metric_str = f" backtest_mape ({len(h)} steps, mean={sum(p.value for p in h)/len(h):.4f})" + else: + metric_str = f" backtest_mape={m['backtest_mape']:.4f}" + else: + metric_str = "" + print(f" [{r.info.status}] {r.info.run_name!r:30s} id={r.info.run_id[:8]}{metric_str}") +print(f" Total: {len(all_runs)} runs") +print() +print(f"Inspect in UI: mlflow ui --backend-store-uri sqlite:///{DB_PATH}") diff --git a/mlflow_test_v2.py b/mlflow_test_v2.py new file mode 100644 index 0000000000..ade751c54d --- /dev/null +++ b/mlflow_test_v2.py @@ -0,0 +1,118 @@ +""" +MLflow (auto)-logging: Multi-model comparison with backtest + +Demonstrates: + * Single MLflow run containing all models — no nested runs needed. + Metric keys are automatically prefixed with the model class name + (e.g. ``LinearRegressionModel_val_mape``, ``ExponentialSmoothing_val_mape``), + so all results live in one run without key collisions. + * Automatic parameter and tag logging via darts autolog + * Inline metric logging: ``mape`` and ``rmse`` called inside an active run + are automatically captured by the patched metric functions + * Backtest with pre-computed historical forecasts, multiple metric functions, + and ``reduction=None`` so each window is logged as a step of + ``{Model}_backtest_mape`` / ``{Model}_backtest_rmse`` in the MLflow UI + +Notes: + * ``mlflow_darts.autolog()`` is required — it patches ``fit()``, the darts + metric functions, and ``backtest()`` to make logging automatic. + ``mlflow.start_run()`` only manages the run context; without ``autolog()`` + nothing would be logged. + * ``last_points_only=False`` is used for historical forecasts so that + ``backtest()`` receives a list of per-window forecasts and can compute one + metric value per window (enabling the per-step chart in the UI). + ``last_points_only=True`` would collapse all windows into a single + TimeSeries, making the metric treat them as one window. + +Run with: + python mlflow_test_v2.py + +Inspect in the UI: + mlflow ui --backend-store-uri sqlite:////tmp/mlflow_v2.db +""" + +import logging + +import mlflow +import coolname +from loguru import logger + +logging.getLogger("mlflow.utils.environment").setLevel(logging.ERROR) + +import darts.metrics as darts_metrics +import darts.utils.mlflow as mlflow_darts +from darts.datasets import AirPassengersDataset +from darts.models import ExponentialSmoothing, LinearRegressionModel + +# ── data ────────────────────────────────────────────────────────────────────── +series = AirPassengersDataset().load() +train, val = series.split_after(0.75) + +FORECAST_HORIZON = 1 +STRIDE = 2 +BT_START = 0.5 # more windows: backtest from 50 % of the full series + +# ── MLflow setup ────────────────────────────────────────────────────────────── +# autolog() is required becausse it patches fit() / metric functions / backtest() +# start_run() separate only controls the run context +DB_PATH = "/tmp/mlflow_v2.db" +mlflow.set_tracking_uri(f"sqlite:///{DB_PATH}") + + +exp_name: str = coolname.generate_slug(2) +run_name: str = coolname.generate_slug(2) +logger.info(f"Starting experiment: {exp_name}") +mlflow.set_experiment(exp_name) +mlflow_darts.autolog() + +models = [ + LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON), + ExponentialSmoothing(), +] + +# NOTE: would this make more sense actually? +# for model in models: +# with mlflow.start_run(run_name=run_name): +# ... + +with mlflow.start_run(run_name=run_name): + for model in models: + # ── fit ─────────────────────────────────────────────────────────── + # NOTE: add val_series=val here for TorchForecastingModels to enable + # validation-based early stopping during training. + model.fit(train) + + # ── predict + inline metric logging ─────────────────────────────── + pred = model.predict(n=len(val)) + + # Calls inside an active MLflow run are intercepted by the patched + # metric functions and logged automatically. + # Keys are prefixed with the model class name, e.g.: + # LinearRegressionModel_val_mape, ExponentialSmoothing_val_mape + darts_metrics.mape(val, pred) + darts_metrics.rmse(val, pred) + + # ── backtest ────────────────────────────────────────────────────── + # Pre-compute historical forecasts once so they can be reused + # without paying the refitting cost again. + # last_points_only=False → list[TimeSeries], one per window, so + # backtest() computes the metric separately for each window. + hfc = model.historical_forecasts( + series, + start=BT_START, + forecast_horizon=FORECAST_HORIZON, + stride=STRIDE, + retrain=True, + last_points_only=False, + ) + + # reduction=None → one value per window per metric, logged as + # consecutive steps of {Model}_backtest_mape / {Model}_backtest_rmse + # so the MLflow UI renders a chart over backtest windows. + model.backtest( + series=series, + historical_forecasts=hfc, + last_points_only=False, + metric=[darts_metrics.mape, darts_metrics.rmse], + reduction=None, + ) \ No newline at end of file From 1c1b3d007462aa61f6d41e15e3f2e3408376dd40 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Fri, 17 Apr 2026 15:47:54 +0200 Subject: [PATCH 057/154] fix: use MLFlow>=3.0 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 76099c41b3..4b956e9c8b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -70,7 +70,7 @@ notorch = [ "statsforecast>=1.4", "xgboost>=2.1.4", ] -mlflow = ["mlflow>=2.0"] +mlflow = ["mlflow>=3.0"] all = ["darts[torch,notorch]"] [tool.uv.sources] From e4b6823f86562ffb9a340c9161539f0570b5e0f1 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Mon, 20 Apr 2026 12:39:46 +0200 Subject: [PATCH 058/154] Update mlflow_test_v2.py --- mlflow_test_v2.py | 167 ++++++++++++++++++++++++++-------------------- 1 file changed, 93 insertions(+), 74 deletions(-) diff --git a/mlflow_test_v2.py b/mlflow_test_v2.py index ade751c54d..12031f7827 100644 --- a/mlflow_test_v2.py +++ b/mlflow_test_v2.py @@ -2,22 +2,24 @@ MLflow (auto)-logging: Multi-model comparison with backtest Demonstrates: - * Single MLflow run containing all models — no nested runs needed. - Metric keys are automatically prefixed with the model class name - (e.g. ``LinearRegressionModel_val_mape``, ``ExponentialSmoothing_val_mape``), - so all results live in one run without key collisions. - * Automatic parameter and tag logging via darts autolog + * One MLflow run per model — each ``model.fit()`` auto-creates its own run + (via ``manage_run=True`` in autolog). The run is named after the model + class (e.g. ``LinearRegressionModel``, ``ExponentialSmoothing``). + * Metric keys are unprefixed (``val_mape``, ``backtest_mape``, etc.) so + the experiment-level comparison view can overlay them directly. + * Automatic parameter and tag logging via darts autolog. * Inline metric logging: ``mape`` and ``rmse`` called inside an active run - are automatically captured by the patched metric functions + are automatically captured by the patched metric functions. * Backtest with pre-computed historical forecasts, multiple metric functions, and ``reduction=None`` so each window is logged as a step of - ``{Model}_backtest_mape`` / ``{Model}_backtest_rmse`` in the MLflow UI + ``backtest_mape`` / ``backtest_rmse`` in the MLflow UI. Notes: * ``mlflow_darts.autolog()`` is required — it patches ``fit()``, the darts metric functions, and ``backtest()`` to make logging automatic. - ``mlflow.start_run()`` only manages the run context; without ``autolog()`` - nothing would be logged. + * ``manage_run=False`` is passed to ``autolog()`` so that we control the run + lifecycle ourselves with ``mlflow.start_run()``. This lets us keep the + run open for predict + metrics + backtest after ``fit()`` returns. * ``last_points_only=False`` is used for historical forecasts so that ``backtest()`` receives a list of per-window forecasts and can compute one metric value per window (enabling the per-step chart in the UI). @@ -33,86 +35,103 @@ import logging -import mlflow import coolname +import mlflow from loguru import logger logging.getLogger("mlflow.utils.environment").setLevel(logging.ERROR) +import numpy as np + import darts.metrics as darts_metrics import darts.utils.mlflow as mlflow_darts from darts.datasets import AirPassengersDataset -from darts.models import ExponentialSmoothing, LinearRegressionModel - -# ── data ────────────────────────────────────────────────────────────────────── -series = AirPassengersDataset().load() +from darts.models import ( + ExponentialSmoothing, + LinearRegressionModel, + NBEATSModel, + NHiTSModel, + TCNModel, +) + + +def _magic(model, train, val, series, log) -> None: + log(f"[{model_name}] Run created: run_id={run.info.run_id}") + # ── fit ─────────────────────────────────────────────────────────── + log(f"[{model_name}] Fitting model on {len(train)} training samples") + model.fit(train) + # ── predict + inline metric logging ─────────────────────────────── + log(f"[{model_name}] Predicting {len(val)} steps") + pred = model.predict(n=len(val)) + # Calls inside active MLflow run are intercepted by patched metric + # functions and auto-logged -> val_mape, val_rmse + val_mape = darts_metrics.mape(val, pred) + val_rmse = darts_metrics.rmse(val, pred) + log(f"[{model_name}] val_mape={val_mape:.4f} val_rmse={val_rmse:.4f}") + + # ── backtest ────────────────────────────────────────────────────── + log( + f"[{model_name}] Computing historical forecasts " + f"(start={BT_START}, horizon={FORECAST_HORIZON}, stride={STRIDE})" + ) + hfc = model.historical_forecasts( + series, + start=BT_START, + forecast_horizon=FORECAST_HORIZON, + stride=STRIDE, + retrain=True, + last_points_only=False, + ) + log(f"[{model_name}] {len(hfc)} backtest windows computed") + + # reduction=None → one value per window per metric, logged as + # consecutive steps of backtest_mape / backtest_rmse + log(f"[{model_name}] Running backtest (logging per-window metrics as steps)") + model.backtest( + series=series, + historical_forecasts=hfc, + last_points_only=False, + metric=[darts_metrics.mape, darts_metrics.rmse, darts_metrics.ape], + reduction=None, + ) + log(f"[{model_name}] Run complete: {run.info.run_id}") + +# ── Data setup ---------------------------------------------------------------- +# Cast to float32: MPS doesn't support float64 tensors +series = AirPassengersDataset().load().astype(np.float32) train, val = series.split_after(0.75) +FORECAST_HORIZON, STRIDE, BT_START = 1, 2, 0.75 -FORECAST_HORIZON = 1 -STRIDE = 2 -BT_START = 0.5 # more windows: backtest from 50 % of the full series - +# ── Logging setup ───────────────────────────────────────────────────────────── +VERBOSE = False +log = logger.info if VERBOSE else lambda *a, **kw: None # ── MLflow setup ────────────────────────────────────────────────────────────── -# autolog() is required becausse it patches fit() / metric functions / backtest() -# start_run() separate only controls the run context DB_PATH = "/tmp/mlflow_v2.db" mlflow.set_tracking_uri(f"sqlite:///{DB_PATH}") - - -exp_name: str = coolname.generate_slug(2) -run_name: str = coolname.generate_slug(2) -logger.info(f"Starting experiment: {exp_name}") -mlflow.set_experiment(exp_name) -mlflow_darts.autolog() - +# ── Model setup --------------------------------------------------------------- +_torch_kwargs = dict( + input_chunk_length=12, + output_chunk_length=FORECAST_HORIZON, + n_epochs=10, + pl_trainer_kwargs={"accelerator": "mps", "precision": "32-true", "enable_progress_bar": False}, +) models = [ LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON), + # LinearRegressionModel(lags=24, output_chunk_length=FORECAST_HORIZON), # same model, more lags ExponentialSmoothing(), + # NBEATSModel(**_torch_kwargs), + # NBEATSModel(**_torch_kwargs, num_stacks=4, num_blocks=2), # same model, deeper architecture + # NHiTSModel(**_torch_kwargs), + # TCNModel(**_torch_kwargs), ] -# NOTE: would this make more sense actually? -# for model in models: -# with mlflow.start_run(run_name=run_name): -# ... - -with mlflow.start_run(run_name=run_name): - for model in models: - # ── fit ─────────────────────────────────────────────────────────── - # NOTE: add val_series=val here for TorchForecastingModels to enable - # validation-based early stopping during training. - model.fit(train) - - # ── predict + inline metric logging ─────────────────────────────── - pred = model.predict(n=len(val)) - - # Calls inside an active MLflow run are intercepted by the patched - # metric functions and logged automatically. - # Keys are prefixed with the model class name, e.g.: - # LinearRegressionModel_val_mape, ExponentialSmoothing_val_mape - darts_metrics.mape(val, pred) - darts_metrics.rmse(val, pred) - - # ── backtest ────────────────────────────────────────────────────── - # Pre-compute historical forecasts once so they can be reused - # without paying the refitting cost again. - # last_points_only=False → list[TimeSeries], one per window, so - # backtest() computes the metric separately for each window. - hfc = model.historical_forecasts( - series, - start=BT_START, - forecast_horizon=FORECAST_HORIZON, - stride=STRIDE, - retrain=True, - last_points_only=False, - ) - - # reduction=None → one value per window per metric, logged as - # consecutive steps of {Model}_backtest_mape / {Model}_backtest_rmse - # so the MLflow UI renders a chart over backtest windows. - model.backtest( - series=series, - historical_forecasts=hfc, - last_points_only=False, - metric=[darts_metrics.mape, darts_metrics.rmse], - reduction=None, - ) \ No newline at end of file +#--- MLflow experiment with manage_run=False ------------------------- +exp_name: str = coolname.generate_slug(2) +mlflow.set_experiment(exp_name) +mlflow_darts.autolog(manage_run=False) # NOTE: manage_run = False +logger.info(f"Starting experiment: {exp_name}") +for model in models: + model_name = type(model).__name__ + log(f"[{model_name}] Starting run") + with mlflow.start_run() as run: + _magic(model, train, val, series, log) From 4c239a80095ccc0d0ab38996e94ba394a98e75eb Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Mon, 20 Apr 2026 12:39:51 +0200 Subject: [PATCH 059/154] Update pyproject.toml --- pyproject.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 4b956e9c8b..7b4a930c61 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,8 +30,10 @@ classifiers = [ "Programming Language :: Python :: Implementation :: PyPy", ] dependencies = [ + "coolname>=4.2.0", "holidays>=0.11.1", "joblib>=0.16.0", + "loguru>=0.7.3", "matplotlib>=3.3.0", "narwhals>=1.25.1", "nfoursid>=1.0.0", From 3ce5475c0162ba5676ba8c497bc95a26239f33b3 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Tue, 21 Apr 2026 09:04:29 +0200 Subject: [PATCH 060/154] Update mlflow_test_v2.py --- mlflow_test_v2.py | 164 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 155 insertions(+), 9 deletions(-) diff --git a/mlflow_test_v2.py b/mlflow_test_v2.py index 12031f7827..dea8f0aae9 100644 --- a/mlflow_test_v2.py +++ b/mlflow_test_v2.py @@ -32,7 +32,6 @@ class (e.g. ``LinearRegressionModel``, ``ExponentialSmoothing``). Inspect in the UI: mlflow ui --backend-store-uri sqlite:////tmp/mlflow_v2.db """ - import logging import coolname @@ -55,8 +54,77 @@ class (e.g. ``LinearRegressionModel``, ``ExponentialSmoothing``). ) +def _managed_run_scenarios(model, train, val, log) -> None: + """Explores manage_run=True behaviour across four scenarios. + + Metrics always use manage_run=False internally — they only log into an + already-active run and never create one themselves. + + Scenario A — bare fit(): + fit() uses with_managed_run which creates a run when none is active, + then closes it on return. + Result: one run per model, params logged, no metrics. + + Scenario B — metric with no active run: + Metric patches have manage_run=False so they never open a run. + With nothing active there is nowhere to log. + Result: nothing logged (silent no-op). + + Scenario C — metric inside an explicit start_run(): + Caller opens a run; metric patch sees an active run and logs into it. + No fit() → no params. + Result: one run with only the metric logged. + + Scenario D — fit() + metric inside an explicit start_run(): + with_managed_run creates a run "if necessary". Because the caller's + run is already active, fit() reuses it rather than nesting a child. + Params and metric all land in the same single run. + Result: one run per model with both params and metric logged. + """ + model_name = type(model).__name__ + + # ── Scenario A: bare fit ────────────────────────────────────────── + # Expected: one run with params logged; no metrics. + log(f"[{model_name}] Scenario A — bare fit") + model.fit(train) + pred = model.predict(n=len(val)) + + # ── Scenario B: metric outside any run ─────────────────────────── + # Expected: nothing logged (metrics have manage_run=False). + log(f"[{model_name}] Scenario B — metric with no active run (expect: not logged)") + darts_metrics.mape(val, pred) + + # ── Scenario C: metric inside explicit start_run ────────────────── + # Expected: one run with rmse logged, no params. + log(f"[{model_name}] Scenario C — metric inside explicit start_run") + with mlflow.start_run(): + darts_metrics.rmse(val, pred) + + # ── Scenario D: fit + metric inside explicit start_run ─────────── + # Expected: one run with both params (from fit) and mape logged. + # fit() reuses the caller's run — no nesting. + log(f"[{model_name}] Scenario D — fit + metric inside explicit start_run") + with mlflow.start_run(): + model.fit(train) + pred = model.predict(n=len(val)) + darts_metrics.mape(val, pred) + + def _magic(model, train, val, series, log) -> None: - log(f"[{model_name}] Run created: run_id={run.info.run_id}") + """Advanced use case: caller-managed run with predict, val metrics, and backtest. + + Requires autolog(manage_run=False) and an active mlflow.start_run() in the + caller. Because manage_run=False, fit() never opens or closes a run on its + own — the caller's run stays open for the entire workflow. + + What gets logged into the single run: + - Model params (from fit via the autolog patch). + - val_mape, val_rmse (from patched darts_metrics calls while run is active). + - backtest_mape, backtest_rmse, backtest_ape as consecutive steps + (one value per window, because reduction=None). + """ + model_name = type(model).__name__ + log(f"[{model_name}] Run created: run_id={mlflow.active_run().info.run_id}") # ── fit ─────────────────────────────────────────────────────────── log(f"[{model_name}] Fitting model on {len(train)} training samples") model.fit(train) @@ -94,7 +162,59 @@ def _magic(model, train, val, series, log) -> None: metric=[darts_metrics.mape, darts_metrics.rmse, darts_metrics.ape], reduction=None, ) - log(f"[{model_name}] Run complete: {run.info.run_id}") + log(f"[{model_name}] Run complete: {mlflow.active_run().info.run_id}") + + +def _backtest_reduction_scenarios(model, train, series, log) -> None: + """Explores how different ``reduction`` values affect MLflow logging. + + Fits once and computes historical forecasts once, then calls backtest with + four different reductions. Each variant runs inside its own nested + child run so the MLflow UI shows them separately without key collisions. + + Reduction variants and their logged shape: + None → 1-D array per metric → logged as consecutive steps (chart). + np.mean → scalar per metric → single value (mean over windows). + np.median → scalar per metric → single value (median over windows). + custom → scalar per metric → single value (90th-percentile). + + All variants use the same metric list (mape, rmse) and the same + pre-computed historical forecasts so results are directly comparable. + """ + model_name = type(model).__name__ + metrics = [darts_metrics.mape, darts_metrics.rmse] + + log(f"[{model_name}] Fitting") + model.fit(train) + log(f"[{model_name}] Computing historical forecasts") + hfc = model.historical_forecasts( + series, + start=BT_START, + forecast_horizon=FORECAST_HORIZON, + stride=STRIDE, + retrain=True, + last_points_only=False, + ) + log(f"[{model_name}] {len(hfc)} windows") + + reductions = [ + (None, "reduction=None (per-window steps)"), + (np.mean, "reduction=np.mean"), + (np.median, "reduction=np.median"), + (lambda x, axis=None: np.percentile(x, 90, axis=axis), "reduction=p90"), + ] + + for reduction_fn, label in reductions: + log(f"[{model_name}] Backtest — {label}") + with mlflow.start_run(nested=True, run_name=label): + model.backtest( + series=series, + historical_forecasts=hfc, + last_points_only=False, + metric=metrics, + reduction=reduction_fn, + ) + # ── Data setup ---------------------------------------------------------------- # Cast to float32: MPS doesn't support float64 tensors @@ -103,7 +223,7 @@ def _magic(model, train, val, series, log) -> None: FORECAST_HORIZON, STRIDE, BT_START = 1, 2, 0.75 # ── Logging setup ───────────────────────────────────────────────────────────── -VERBOSE = False +VERBOSE = True log = logger.info if VERBOSE else lambda *a, **kw: None # ── MLflow setup ────────────────────────────────────────────────────────────── DB_PATH = "/tmp/mlflow_v2.db" @@ -119,19 +239,45 @@ def _magic(model, train, val, series, log) -> None: LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON), # LinearRegressionModel(lags=24, output_chunk_length=FORECAST_HORIZON), # same model, more lags ExponentialSmoothing(), - # NBEATSModel(**_torch_kwargs), + NBEATSModel(**_torch_kwargs), # NBEATSModel(**_torch_kwargs, num_stacks=4, num_blocks=2), # same model, deeper architecture # NHiTSModel(**_torch_kwargs), # TCNModel(**_torch_kwargs), ] -#--- MLflow experiment with manage_run=False ------------------------- +# ── Use case 1: manage_run=True (default) ───────────────────────────────────── +# fit() auto-creates and closes a run per model — no start_run() needed. exp_name: str = coolname.generate_slug(2) mlflow.set_experiment(exp_name) -mlflow_darts.autolog(manage_run=False) # NOTE: manage_run = False -logger.info(f"Starting experiment: {exp_name}") +mlflow_darts.autolog(manage_run=True) +logger.info(f"[Use case 1] Experiment: {exp_name}") for model in models: + _managed_run_scenarios(model, train, val, log) + +# ── Use case 2: manage_run=False + backtest ─────────────────────────────────── +# Caller opens the run so predict, val metrics, and backtest all land in it. +# NOTE: this is the recommended way to use MLFlow in Darts. It avoids +# nesting runs and ensures all metrics land in the same run. +exp_name = coolname.generate_slug(2) +mlflow.set_experiment(exp_name) +mlflow_darts.autolog(manage_run=False) +logger.info(f"[Use case 2] Experiment: {exp_name}") +for i, model in enumerate(models): model_name = type(model).__name__ log(f"[{model_name}] Starting run") - with mlflow.start_run() as run: + with mlflow.start_run( + run_name=model_name, + description = f"Small exp. run for {model_name}", + ) as run: _magic(model, train, val, series, log) + +# ── Use case 3: backtest reduction variants ─────────────────────────────────── +# One parent run per model; one nested child run per reduction variant. +exp_name = coolname.generate_slug(2) +mlflow.set_experiment(exp_name) +mlflow_darts.autolog(manage_run=False) +logger.info(f"[Use case 3] Experiment: {exp_name}") +for model in models: + model_name = type(model).__name__ + with mlflow.start_run(run_name=model_name): + _backtest_reduction_scenarios(model, train, series, log) From 2d1cd6548524657a0465adf0e0e45a3be108a911 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Tue, 21 Apr 2026 09:15:07 +0200 Subject: [PATCH 061/154] feat: support backtest/historical forecasts --- darts/utils/mlflow.py | 154 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 151 insertions(+), 3 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 922348c198..92d4cc7b6e 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -19,6 +19,7 @@ import os import re import sys +import threading from collections.abc import Callable from operator import itemgetter from typing import Any @@ -26,6 +27,7 @@ import mlflow import numpy as np import yaml +from mlflow.entities import LoggedModel from mlflow.models import Model, ModelInputExample, ModelSignature from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example @@ -94,6 +96,10 @@ ), ] +# Thread-local flag set during historical_forecasts to suppress per-iteration +# autologging in _patched_fit (which would otherwise spawn one run per iteration). +_autolog_state = threading.local() + def save_model( model, @@ -536,10 +542,15 @@ def _patched_fit(original, self, *args, **kwargs): ------- The result of calling the original fit method. """ - # Create a training session to track the training process and log information autologging_client = MlflowAutologgingQueueingClient() + if getattr(_autolog_state, "in_historical_forecasts", False): + return original(self, *args, **kwargs) + + # Track which model is active so metric patches can prefix their keys + _autolog_state.current_model_name = type(self).__name__ + run_id = mlflow.active_run().info.run_id result = original(self, *args, **kwargs) @@ -555,15 +566,19 @@ def _patched_fit(original, self, *args, **kwargs): param_logging_ops = autologging_client.flush(synchronous=False) if log_models: - model_id = _initialize_logged_model("model", flavor=FLAVOR_NAME).model_id + model_name = type(self).__name__ + model: LoggedModel = _initialize_logged_model( + name=model_name, flavor=FLAVOR_NAME + ) try: registered_model_name = get_autologging_config( FLAVOR_NAME, "registered_model_name", None ) log_model( result, + name=model_name, registered_model_name=registered_model_name, - model_id=model_id, + model_id=model.model_id, ) except Exception: logger.info( @@ -575,6 +590,112 @@ def _patched_fit(original, self, *args, **kwargs): return result + def _patched_historical_forecasts(original, self, *args, **kwargs): + """Suppress per-iteration fit() autologging during historical_forecasts. + + Sets a thread-local flag so _patched_fit skips autologging for the + internal fit() calls. The outer safe_patch(manage_run=manage_run) on + historical_forecasts itself provides a single managed run. + """ + _autolog_state.in_historical_forecasts = True + try: + return original(self, *args, **kwargs) + finally: + _autolog_state.in_historical_forecasts = False + + def _patched_backtest(original, self, *args, **kwargs): + """Log backtest metric result(s) to the active MLflow run. + + Scalar results (default reduction) are logged as a single metric value. + Per-window arrays (reduction=None) are logged as consecutive steps of + the same metric key so the MLflow UI renders them as a chart. + """ + _autolog_state.in_backtest = True + try: + result = original(self, *args, **kwargs) + finally: + _autolog_state.in_backtest = False + + if not log_metrics: + return result + + active_run = mlflow.active_run() + if active_run is None: + return result + + # Resolve `metric` arg (keyword is the common case; fall back to sig-bind) + metric = kwargs.get("metric") + if metric is None: + try: + sig = inspect.signature(original) + bound = sig.bind(self, *args, **kwargs) + bound.apply_defaults() + metric = bound.arguments.get("metric") + except Exception: + pass + + # Derive metric name(s) + if callable(metric): + names = [getattr(metric, "__name__", "metric")] + elif isinstance(metric, list | tuple): + names = [ + getattr(m, "__name__", f"metric_{i}") for i, m in enumerate(metric) + ] + else: + names = ["mape"] # darts default + + run_id = active_run.info.run_id + autologging_client = MlflowAutologgingQueueingClient() + + def _log(key, val_or_arr): + arr = np.asarray(val_or_arr) + if arr.ndim == 0: + autologging_client.log_metrics(run_id=run_id, metrics={key: float(arr)}) + elif arr.ndim == 1: + # per-window: log as steps so the MLflow UI shows a chart + for step, val in enumerate(arr): + autologging_client.log_metrics( + run_id=run_id, metrics={key: float(val)}, step=step + ) + # 2-D and higher: skip to keep MVP simple + + result_arr = np.asarray(result) if not isinstance(result, list) else None + + if isinstance(metric, (list, tuple)) and isinstance(result, list): + # multiple metrics → result is list[scalar_or_array], one per metric + for name, r in zip(names, result): + _log(f"backtest_{name}", r) + elif ( + isinstance(metric, list| tuple) + and result_arr is not None + and result_arr.ndim == 1 + and len(result_arr) == len(names) + ): + # multiple metrics with scalar reduction returned as a 1-D ndarray + # (e.g. np.mean/median/percentile) — log each as a separate scalar + for name, r in zip(names, result_arr): + autologging_client.log_metrics( + run_id=run_id, metrics={f"backtest_{name}": float(r)} + ) + elif result_arr is not None and result_arr.ndim == 2: + # (N_windows, N_metrics) ndarray — multi-metric + reduction=None + for col_i, name in enumerate(names[: result_arr.shape[1]]): + for step, val in enumerate(result_arr[:, col_i]): + autologging_client.log_metrics( + run_id=run_id, + metrics={f"backtest_{name}": float(val)}, + step=step, + ) + elif isinstance(result, list): + # single metric, multiple series → result is list[scalar_or_array] + for s_i, r in enumerate(result): + _log(f"backtest_{names[0]}_{s_i}", r) + else: + _log(f"backtest_{names[0]}", result) + + autologging_client.flush(synchronous=False).await_completion() + return result + # patch `fit()` for all forecasting models for _, cls in _get_forecasting_models(): safe_patch( @@ -585,6 +706,27 @@ def _patched_fit(original, self, *args, **kwargs): manage_run=manage_run, ) + # patch `historical_forecasts()` for all forecasting models so that the + # N internal fit() calls don't each spawn their own MLflow run + for _, cls in _get_forecasting_models(): + safe_patch( + FLAVOR_NAME, + cls, + "historical_forecasts", + _patched_historical_forecasts, + manage_run=manage_run, + ) + + # patch `backtest()` for all forecasting models to log metric results + for _, cls in _get_forecasting_models(): + safe_patch( + FLAVOR_NAME, + cls, + "backtest", + _patched_backtest, + manage_run=manage_run, + ) + if log_metrics: import darts.metrics @@ -888,6 +1030,12 @@ def _patched_metric(original, *args, **kwargs): if active_run is None: return result + # backtest() calls metric functions internally; _patched_backtest + # handles logging the aggregated result, so skip here to avoid + # generating one flat key per window (series_gen_mape_0, _1, …). + if getattr(_autolog_state, "in_backtest", False): + return result + autologging_client = MlflowAutologgingQueueingClient() run_id = active_run.info.run_id From 5acd8de2198981d77caed00b84238f78fb3a555f Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Tue, 21 Apr 2026 09:15:44 +0200 Subject: [PATCH 062/154] fix: mlflow test script --- mlflow_test_v2.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/mlflow_test_v2.py b/mlflow_test_v2.py index dea8f0aae9..25cc488f37 100644 --- a/mlflow_test_v2.py +++ b/mlflow_test_v2.py @@ -32,6 +32,7 @@ class (e.g. ``LinearRegressionModel``, ``ExponentialSmoothing``). Inspect in the UI: mlflow ui --backend-store-uri sqlite:////tmp/mlflow_v2.db """ + import logging import coolname @@ -198,9 +199,9 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: log(f"[{model_name}] {len(hfc)} windows") reductions = [ - (None, "reduction=None (per-window steps)"), - (np.mean, "reduction=np.mean"), - (np.median, "reduction=np.median"), + (None, "reduction=None (per-window steps)"), + (np.mean, "reduction=np.mean"), + (np.median, "reduction=np.median"), (lambda x, axis=None: np.percentile(x, 90, axis=axis), "reduction=p90"), ] @@ -233,7 +234,11 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: input_chunk_length=12, output_chunk_length=FORECAST_HORIZON, n_epochs=10, - pl_trainer_kwargs={"accelerator": "mps", "precision": "32-true", "enable_progress_bar": False}, + pl_trainer_kwargs={ + "accelerator": "mps", + "precision": "32-true", + "enable_progress_bar": False, + }, ) models = [ LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON), @@ -267,7 +272,7 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: log(f"[{model_name}] Starting run") with mlflow.start_run( run_name=model_name, - description = f"Small exp. run for {model_name}", + description=f"Small exp. run for {model_name}", ) as run: _magic(model, train, val, series, log) From c0b1c6e8107fab6713dfbd627b8a6106075a8b55 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Tue, 21 Apr 2026 09:16:11 +0200 Subject: [PATCH 063/154] fix: remove obsolte file --- debug_hf_mlflow.py | 197 --------------------------------------------- 1 file changed, 197 deletions(-) delete mode 100644 debug_hf_mlflow.py diff --git a/debug_hf_mlflow.py b/debug_hf_mlflow.py deleted file mode 100644 index b9464b10ea..0000000000 --- a/debug_hf_mlflow.py +++ /dev/null @@ -1,197 +0,0 @@ -""" -Debug script: historical_forecasts / backtest with MLflow autologging. - -Issue (from PR #3022): historical_forecasts(retrain=True) and backtest() call -fit() internally on each iteration. Because _patched_fit runs with -manage_run=True, every internal fit() spawns its own MLflow run when no -active run exists - i.e. the typical autolog-only usage (no explicit -mlflow.start_run() wrapper). - -Expected: 1 run per historical_forecasts / backtest call. -Actual: 1 run per stride iteration. - -Run with: - python examples/repl/debug_hf_mlflow.py - -Then inspect in the UI: - mlflow ui --backend-store-uri sqlite:////tmp/mlflow_debug.db -""" - -# %% -import os - -import mlflow - -import darts.utils.mlflow as mlflow_darts -from darts.datasets import AirPassengersDataset -from darts.models import LinearRegressionModel - -# ---- setup ------------------------------------------------------------------- -series = AirPassengersDataset().load() - -STRIDE = 4 # keep iteration count low for fast runs - -DB_PATH = "/tmp/mlflow_debug.db" - -mlflow.set_tracking_uri(f"sqlite:///{DB_PATH}") -mlflow.set_experiment("debug-hf-mlflow") -client = mlflow.tracking.MlflowClient() -exp_id = mlflow.get_experiment_by_name("debug-hf-mlflow").experiment_id - - -def run_count(name=None): - runs = client.search_runs(experiment_ids=[exp_id]) - if name: - return sum(1 for r in runs if r.info.run_name == name) - return len(runs) - - -# ---- 1. normal fit WITH explicit start_run (baseline) ----------------------- -print("=" * 60) -print("1. Normal fit() inside mlflow.start_run()") -mlflow_darts.autolog(disable=True) -mlflow_darts.autolog() - -before = run_count() -with mlflow.start_run(run_name="fit-with-run"): - LinearRegressionModel(lags=12).fit(series[:100]) -mlflow_darts.autolog(disable=True) - -print(f" Runs created: {run_count() - before} (expected: 1)") - -# ---- 2. historical_forecasts WITH explicit start_run ------------------------ -print() -print("=" * 60) -print("2. historical_forecasts(retrain=True) inside mlflow.start_run()") -mlflow_darts.autolog(disable=True) -mlflow_darts.autolog() - -before = run_count() -with mlflow.start_run(run_name="hf-with-run"): - LinearRegressionModel(lags=12).historical_forecasts( - series, - start=0.75, - forecast_horizon=1, - stride=STRIDE, - retrain=True, - last_points_only=True, - ) -mlflow_darts.autolog(disable=True) - -print(f" Runs created: {run_count() - before} (expected: 1)") - -# ---- 3. historical_forecasts WITHOUT start_run (autolog-only usage) --------- -print() -print("=" * 60) -print("3. historical_forecasts(retrain=True) with autolog only (no start_run)") -mlflow_darts.autolog(disable=True) -mlflow_darts.autolog() - -before = run_count() -LinearRegressionModel(lags=12).historical_forecasts( - series, - start=0.75, - forecast_horizon=1, - stride=STRIDE, - retrain=True, - last_points_only=True, -) -mlflow_darts.autolog(disable=True) - -created = run_count() - before -print(f" Runs created: {created} (expected: 1)") -print(f" -> Each stride iteration spawned its own run: {created > 1}") - -# ---- 4. backtest WITHOUT start_run ------------------------------------------ -print() -print("=" * 60) -print("4. backtest() with autolog only (no start_run)") -mlflow_darts.autolog(disable=True) -mlflow_darts.autolog() - -before = run_count() -LinearRegressionModel(lags=12).backtest( - series, - start=0.75, - forecast_horizon=1, - stride=STRIDE, - retrain=True, -) -mlflow_darts.autolog(disable=True) - -created = run_count() - before -print(f" Runs created: {created} (expected: 1)") -print(f" -> Each stride iteration spawned its own run: {created > 1}") - -# Assert backtest_mape was logged -all_runs = client.search_runs(experiment_ids=[exp_id]) -bt_run = sorted(all_runs, key=lambda x: x.info.start_time)[-1] -metrics = bt_run.data.metrics -assert "backtest_mape" in metrics, f"Expected backtest_mape in metrics, got: {metrics}" -print(f" -> backtest_mape = {metrics['backtest_mape']:.4f} (PASS)") - -# ---- 5. backtest with reduction=None → per-window metrics ------------------- -print() -print("=" * 60) -print("5. backtest(reduction=None) — per-window MAPE logged as separate metrics") -mlflow_darts.autolog(disable=True) -mlflow_darts.autolog() - -before = run_count() -per_window = LinearRegressionModel(lags=12).backtest( - series, - start=0.75, - forecast_horizon=1, - stride=STRIDE, - retrain=True, - reduction=None, -) -mlflow_darts.autolog(disable=True) - -created = run_count() - before -print(f" Runs created: {created} (expected: 1)") - -all_runs = client.search_runs(experiment_ids=[exp_id]) -pw_run = sorted(all_runs, key=lambda x: x.info.start_time)[-1] -history = client.get_metric_history(pw_run.info.run_id, "backtest_mape") -assert history, f"Expected backtest_mape steps in metric history, got nothing" -print(f" -> backtest_mape logged across {len(history)} steps (windows)") - -# Plot per-window MAPE -import matplotlib.pyplot as plt -import numpy as np - -window_nums = [p.step for p in sorted(history, key=lambda p: p.step)] -values = [p.value for p in sorted(history, key=lambda p: p.step)] - -fig, ax = plt.subplots(figsize=(8, 4)) -ax.plot(window_nums, values, marker="o", linewidth=1.5, label="MAPE per window") -ax.axhline(np.mean(values), color="red", linestyle="--", linewidth=1, label=f"mean = {np.mean(values):.2f}%") -ax.set_xlabel("Backtest window index") -ax.set_ylabel("MAPE (%)") -ax.set_title("Per-window MAPE (backtest, reduction=None)") -ax.legend() -fig.tight_layout() -plt.savefig("/tmp/backtest_per_window_mape.png", dpi=150) -print(" -> Plot saved to /tmp/backtest_per_window_mape.png") -plt.show() - -# ---- summary ----------------------------------------------------------------- -print() -print("=" * 60) -print("Summary of ALL runs in experiment:") -all_runs = client.search_runs(experiment_ids=[exp_id]) -for r in sorted(all_runs, key=lambda x: x.info.start_time): - m = r.data.metrics - if "backtest_mape" in m: - h = client.get_metric_history(r.info.run_id, "backtest_mape") - if len(h) > 1: - metric_str = f" backtest_mape ({len(h)} steps, mean={sum(p.value for p in h)/len(h):.4f})" - else: - metric_str = f" backtest_mape={m['backtest_mape']:.4f}" - else: - metric_str = "" - print(f" [{r.info.status}] {r.info.run_name!r:30s} id={r.info.run_id[:8]}{metric_str}") -print(f" Total: {len(all_runs)} runs") -print() -print(f"Inspect in UI: mlflow ui --backend-store-uri sqlite:///{DB_PATH}") From d5977c8dc81efeafed5dcde149fba6106e6288df Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Tue, 21 Apr 2026 09:16:21 +0200 Subject: [PATCH 064/154] fix: formatting --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 06bba7cef4..84ef809f4b 100644 --- a/.gitignore +++ b/.gitignore @@ -27,4 +27,4 @@ docs_env uv.lock repl/ mlruns/* -examples/mlruns/* \ No newline at end of file +examples/mlruns/* From bbe0bf945ec56c2f1f6a9d68ff6fb4a3ab4e743f Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Tue, 21 Apr 2026 22:41:58 +0200 Subject: [PATCH 065/154] fix: deprecate manage_run --- darts/utils/mlflow.py | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 92d4cc7b6e..7e6ae0f2db 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -387,7 +387,6 @@ def autolog( log_torch_metrics: bool = True, disable: bool = False, silent: bool = False, - manage_run: bool = True, ) -> None: """Enable (or disable) automatic MLflow logging for darts models. @@ -449,12 +448,6 @@ def autolog( silent If ``True`` (default ``False``), suppress all event logging and warnings from MLflow during autologging. - manage_run - If `True`, applies the `with_managed_run` wrapper to the specified - `patch_function`, which automatically creates & terminates an MLflow - active run during patch code execution if necessary. If `False`, - does not apply the `with_managed_run` wrapper to the specified - `patch_function`. """ # Enable/disable mlflow.pytorch.autolog for per-epoch metrics on torch models. # This must happen outside the @autologging_integration-decorated _autolog() @@ -486,7 +479,6 @@ def autolog( log_metrics=log_metrics, disable=disable, silent=silent, - manage_run=manage_run, ) @@ -513,7 +505,6 @@ def _autolog( log_metrics: bool = True, disable: bool = False, silent: bool = False, - manage_run: bool = True, ) -> None: """Internal autolog implementation decorated with ``@autologging_integration``. @@ -594,7 +585,7 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): """Suppress per-iteration fit() autologging during historical_forecasts. Sets a thread-local flag so _patched_fit skips autologging for the - internal fit() calls. The outer safe_patch(manage_run=manage_run) on + internal fit() calls. The outer safe_patch() on historical_forecasts itself provides a single managed run. """ _autolog_state.in_historical_forecasts = True @@ -703,7 +694,6 @@ def _log(key, val_or_arr): cls, "fit", _patched_fit, - manage_run=manage_run, ) # patch `historical_forecasts()` for all forecasting models so that the @@ -714,7 +704,6 @@ def _log(key, val_or_arr): cls, "historical_forecasts", _patched_historical_forecasts, - manage_run=manage_run, ) # patch `backtest()` for all forecasting models to log metric results @@ -724,7 +713,6 @@ def _log(key, val_or_arr): cls, "backtest", _patched_backtest, - manage_run=manage_run, ) if log_metrics: @@ -744,14 +732,11 @@ def _log(key, val_or_arr): # patch all metric functions to log results for metric_name in darts.metrics.__all__: - # metrics should not create their own runs; - # they log into the run started by fit(), so manage_run=False here safe_patch( FLAVOR_NAME, darts.metrics, metric_name, _make_metric_patch(metric_name), - manage_run=False, ) From 09ad11732b27fb959b57557d792b4991b6c16151 Mon Sep 17 00:00:00 2001 From: Michel Zeller Date: Wed, 13 May 2026 13:38:26 +0200 Subject: [PATCH 066/154] Update mlflow_test_v2.py --- mlflow_test_v2.py | 52 ++++++++++++++++------------------------------- 1 file changed, 17 insertions(+), 35 deletions(-) diff --git a/mlflow_test_v2.py b/mlflow_test_v2.py index 25cc488f37..655065ac76 100644 --- a/mlflow_test_v2.py +++ b/mlflow_test_v2.py @@ -82,33 +82,6 @@ def _managed_run_scenarios(model, train, val, log) -> None: Params and metric all land in the same single run. Result: one run per model with both params and metric logged. """ - model_name = type(model).__name__ - - # ── Scenario A: bare fit ────────────────────────────────────────── - # Expected: one run with params logged; no metrics. - log(f"[{model_name}] Scenario A — bare fit") - model.fit(train) - pred = model.predict(n=len(val)) - - # ── Scenario B: metric outside any run ─────────────────────────── - # Expected: nothing logged (metrics have manage_run=False). - log(f"[{model_name}] Scenario B — metric with no active run (expect: not logged)") - darts_metrics.mape(val, pred) - - # ── Scenario C: metric inside explicit start_run ────────────────── - # Expected: one run with rmse logged, no params. - log(f"[{model_name}] Scenario C — metric inside explicit start_run") - with mlflow.start_run(): - darts_metrics.rmse(val, pred) - - # ── Scenario D: fit + metric inside explicit start_run ─────────── - # Expected: one run with both params (from fit) and mape logged. - # fit() reuses the caller's run — no nesting. - log(f"[{model_name}] Scenario D — fit + metric inside explicit start_run") - with mlflow.start_run(): - model.fit(train) - pred = model.predict(n=len(val)) - darts_metrics.mape(val, pred) def _magic(model, train, val, series, log) -> None: @@ -160,7 +133,8 @@ def _magic(model, train, val, series, log) -> None: series=series, historical_forecasts=hfc, last_points_only=False, - metric=[darts_metrics.mape, darts_metrics.rmse, darts_metrics.ape], + metric=[darts_metrics.mape, darts_metrics.rmse, darts_metrics.ape, darts_metrics.mase, darts_metrics.mase], + metric_kwargs=[{}, {}, {}, {"m": 1}, {"m": 2}], reduction=None, ) log(f"[{model_name}] Run complete: {mlflow.active_run().info.run_id}") @@ -200,9 +174,9 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: reductions = [ (None, "reduction=None (per-window steps)"), - (np.mean, "reduction=np.mean"), - (np.median, "reduction=np.median"), - (lambda x, axis=None: np.percentile(x, 90, axis=axis), "reduction=p90"), + # (np.mean, "reduction=np.mean"), + # (np.median, "reduction=np.median"), + # (lambda x, axis=None: np.percentile(x, 90, axis=axis), "reduction=p90"), ] for reduction_fn, label in reductions: @@ -220,6 +194,11 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: # ── Data setup ---------------------------------------------------------------- # Cast to float32: MPS doesn't support float64 tensors series = AirPassengersDataset().load().astype(np.float32) +# TODO: implement/test the follwoing cases! +series_multiple = [series, series / 3.] +series_multivariate = series.stack(series / 3.) +series_multiple_multivariate = [series.stack(series / 3.), series.stack(series / 10.)] + train, val = series.split_after(0.75) FORECAST_HORIZON, STRIDE, BT_START = 1, 2, 0.75 @@ -244,7 +223,7 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON), # LinearRegressionModel(lags=24, output_chunk_length=FORECAST_HORIZON), # same model, more lags ExponentialSmoothing(), - NBEATSModel(**_torch_kwargs), + # NBEATSModel(**_torch_kwargs), # NBEATSModel(**_torch_kwargs, num_stacks=4, num_blocks=2), # same model, deeper architecture # NHiTSModel(**_torch_kwargs), # TCNModel(**_torch_kwargs), @@ -254,10 +233,13 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: # fit() auto-creates and closes a run per model — no start_run() needed. exp_name: str = coolname.generate_slug(2) mlflow.set_experiment(exp_name) -mlflow_darts.autolog(manage_run=True) +mlflow_darts.autolog() logger.info(f"[Use case 1] Experiment: {exp_name}") for model in models: - _managed_run_scenarios(model, train, val, log) + with mlflow.start_run(): + model.fit(train) + pred = model.predict(n=len(val)) + darts_metrics.mape(val, pred) # ── Use case 2: manage_run=False + backtest ─────────────────────────────────── # Caller opens the run so predict, val metrics, and backtest all land in it. @@ -265,7 +247,7 @@ def _backtest_reduction_scenarios(model, train, series, log) -> None: # nesting runs and ensures all metrics land in the same run. exp_name = coolname.generate_slug(2) mlflow.set_experiment(exp_name) -mlflow_darts.autolog(manage_run=False) +mlflow_darts.autolog() logger.info(f"[Use case 2] Experiment: {exp_name}") for i, model in enumerate(models): model_name = type(model).__name__ From 5a9f4931fa7f3b43b5711877b7b00968f8d3d90a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 26 May 2026 15:14:35 +0200 Subject: [PATCH 067/154] feat: metric kwarg support for autolog --- darts/utils/mlflow.py | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 7e6ae0f2db..b7ad90c965 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -616,6 +616,7 @@ def _patched_backtest(original, self, *args, **kwargs): # Resolve `metric` arg (keyword is the common case; fall back to sig-bind) metric = kwargs.get("metric") + metric_kwargs = kwargs.get("metric_kwargs") or {} if metric is None: try: sig = inspect.signature(original) @@ -627,10 +628,20 @@ def _patched_backtest(original, self, *args, **kwargs): # Derive metric name(s) if callable(metric): - names = [getattr(metric, "__name__", "metric")] - elif isinstance(metric, list | tuple): names = [ - getattr(m, "__name__", f"metric_{i}") for i, m in enumerate(metric) + getattr(metric, "__name__", "metric") + _kwargs_suffix(metric_kwargs) + ] + elif isinstance(metric, (list | tuple)): + kw_list = ( + list(metric_kwargs) + if isinstance(metric_kwargs, (list | tuple)) + else [metric_kwargs] + ) + if len(kw_list) < len(metric): + kw_list = kw_list + [{}] * (len(metric) - len(kw_list)) + names = [ + getattr(m, "__name__", f"metric_{i}") + _kwargs_suffix(kw) + for i, (m, kw) in enumerate(zip(metric, kw_list)) ] else: names = ["mape"] # darts default @@ -652,12 +663,12 @@ def _log(key, val_or_arr): result_arr = np.asarray(result) if not isinstance(result, list) else None - if isinstance(metric, (list, tuple)) and isinstance(result, list): + if isinstance(metric, (list | tuple)) and isinstance(result, list): # multiple metrics → result is list[scalar_or_array], one per metric for name, r in zip(names, result): _log(f"backtest_{name}", r) elif ( - isinstance(metric, list| tuple) + isinstance(metric, list | tuple) and result_arr is not None and result_arr.ndim == 1 and len(result_arr) == len(names) @@ -871,6 +882,12 @@ def _extract_covariate_metadata( return info +def _kwargs_suffix(kw: dict | None) -> str: + if not kw: + return "" + return "".join(f"_{k}{v}" for k, v in sorted(kw.items())) + + def _sanitize_mlflow_key(name: str) -> str: """Sanitize a string for use as an MLflow metric key. From 9113c41b6c0fa482b9cbad3ee8dd9bc2b34158ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 23 Jun 2026 12:54:45 +0200 Subject: [PATCH 068/154] chore: remove redundant metric check --- darts/utils/mlflow.py | 9 --------- 1 file changed, 9 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index b7ad90c965..7a19e50450 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -614,17 +614,8 @@ def _patched_backtest(original, self, *args, **kwargs): if active_run is None: return result - # Resolve `metric` arg (keyword is the common case; fall back to sig-bind) metric = kwargs.get("metric") metric_kwargs = kwargs.get("metric_kwargs") or {} - if metric is None: - try: - sig = inspect.signature(original) - bound = sig.bind(self, *args, **kwargs) - bound.apply_defaults() - metric = bound.arguments.get("metric") - except Exception: - pass # Derive metric name(s) if callable(metric): From 845dcd6faf7123d5bcb3d821203d924c17d65d06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 15:38:10 +0200 Subject: [PATCH 069/154] fix: check for active run in fit patch --- darts/utils/mlflow.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 7a19e50450..574b1c986e 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -542,10 +542,13 @@ def _patched_fit(original, self, *args, **kwargs): # Track which model is active so metric patches can prefix their keys _autolog_state.current_model_name = type(self).__name__ - run_id = mlflow.active_run().info.run_id - result = original(self, *args, **kwargs) + active_run = mlflow.active_run() + if active_run is None: + return result + run_id = active_run.info.run_id + # Set tags to identify the model class and relevant information autologging_client.set_tags(run_id=run_id, tags=_get_model_info_tags(self)) From b9a7b62dbd0cc0bd73d2ade7a5b834cc9999b3f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 15:40:01 +0200 Subject: [PATCH 070/154] feat: infer backtest output dim based on metric/backtests kwargs --- darts/utils/mlflow.py | 373 ++++++++++++++++++++++++++++++++---------- 1 file changed, 288 insertions(+), 85 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 574b1c986e..6a844513ba 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -64,8 +64,15 @@ import darts from darts.logging import get_logger, raise_log +from darts.metrics import CLASSIFICATION_METRICS +from darts.metrics.utils import _LabelReduction from darts.models.forecasting.forecasting_model import ForecastingModel -from darts.utils.ts_utils import get_single_series +from darts.utils.ts_utils import ( + SeriesType, + get_series_seq_type, + get_single_series, + series2seq, +) logger = get_logger(__name__) @@ -598,11 +605,10 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): _autolog_state.in_historical_forecasts = False def _patched_backtest(original, self, *args, **kwargs): - """Log backtest metric result(s) to the active MLflow run. + """Wrap ``backtest`` to log metric result(s) to the active MLflow run. - Scalar results (default reduction) are logged as a single metric value. - Per-window arrays (reduction=None) are logged as consecutive steps of - the same metric key so the MLflow UI renders them as a chart. + Delegates to ``_log_backtest_metrics``, which infers result shape from + the metric signature and logs every cell under a descriptive key. """ _autolog_state.in_backtest = True try: @@ -610,85 +616,18 @@ def _patched_backtest(original, self, *args, **kwargs): finally: _autolog_state.in_backtest = False - if not log_metrics: - return result - active_run = mlflow.active_run() - if active_run is None: + if not log_metrics or active_run is None: return result - metric = kwargs.get("metric") - metric_kwargs = kwargs.get("metric_kwargs") or {} - - # Derive metric name(s) - if callable(metric): - names = [ - getattr(metric, "__name__", "metric") + _kwargs_suffix(metric_kwargs) - ] - elif isinstance(metric, (list | tuple)): - kw_list = ( - list(metric_kwargs) - if isinstance(metric_kwargs, (list | tuple)) - else [metric_kwargs] - ) - if len(kw_list) < len(metric): - kw_list = kw_list + [{}] * (len(metric) - len(kw_list)) - names = [ - getattr(m, "__name__", f"metric_{i}") + _kwargs_suffix(kw) - for i, (m, kw) in enumerate(zip(metric, kw_list)) - ] - else: - names = ["mape"] # darts default + bound = inspect.signature(ForecastingModel.backtest).bind(self, *args, **kwargs) + bound.apply_defaults() + backtest_args = bound.arguments - run_id = active_run.info.run_id autologging_client = MlflowAutologgingQueueingClient() - - def _log(key, val_or_arr): - arr = np.asarray(val_or_arr) - if arr.ndim == 0: - autologging_client.log_metrics(run_id=run_id, metrics={key: float(arr)}) - elif arr.ndim == 1: - # per-window: log as steps so the MLflow UI shows a chart - for step, val in enumerate(arr): - autologging_client.log_metrics( - run_id=run_id, metrics={key: float(val)}, step=step - ) - # 2-D and higher: skip to keep MVP simple - - result_arr = np.asarray(result) if not isinstance(result, list) else None - - if isinstance(metric, (list | tuple)) and isinstance(result, list): - # multiple metrics → result is list[scalar_or_array], one per metric - for name, r in zip(names, result): - _log(f"backtest_{name}", r) - elif ( - isinstance(metric, list | tuple) - and result_arr is not None - and result_arr.ndim == 1 - and len(result_arr) == len(names) - ): - # multiple metrics with scalar reduction returned as a 1-D ndarray - # (e.g. np.mean/median/percentile) — log each as a separate scalar - for name, r in zip(names, result_arr): - autologging_client.log_metrics( - run_id=run_id, metrics={f"backtest_{name}": float(r)} - ) - elif result_arr is not None and result_arr.ndim == 2: - # (N_windows, N_metrics) ndarray — multi-metric + reduction=None - for col_i, name in enumerate(names[: result_arr.shape[1]]): - for step, val in enumerate(result_arr[:, col_i]): - autologging_client.log_metrics( - run_id=run_id, - metrics={f"backtest_{name}": float(val)}, - step=step, - ) - elif isinstance(result, list): - # single metric, multiple series → result is list[scalar_or_array] - for s_i, r in enumerate(result): - _log(f"backtest_{names[0]}_{s_i}", r) - else: - _log(f"backtest_{names[0]}", result) - + _log_backtest_metrics( + autologging_client, active_run.info.run_id, result, backtest_args + ) autologging_client.flush(synchronous=False).await_completion() return result @@ -876,12 +815,6 @@ def _extract_covariate_metadata( return info -def _kwargs_suffix(kw: dict | None) -> str: - if not kw: - return "" - return "".join(f"_{k}{v}" for k, v in sorted(kw.items())) - - def _sanitize_mlflow_key(name: str) -> str: """Sanitize a string for use as an MLflow metric key. @@ -902,6 +835,276 @@ def _sanitize_mlflow_key(name: str) -> str: return re.sub(r"[^\w-]", "_", name) +def _log_backtest_metrics( + autologging_client: MlflowAutologgingQueueingClient, + run_id: str, + result, + backtest_args: dict, +) -> None: + """Log backtest metric result(s) to MLflow. + + Reshapes each per-series result to a canonical ``(W, T, C, M)`` layout + (windows, timesteps, components × quantiles, metrics) inferred from the + metric signatures and ``backtest_args``, logging every cell under a + descriptive key with the time axis (or window axis when time is reduced) + mapped to the MLflow ``step``. + + Shape inference respects all kwargs that affect output dimensions: + + * ``time_reduction`` – collapses the time axis (``T=1``). + * ``component_reduction`` – collapses the component axis (``C=1``). + * ``series_reduction`` – if non-``None``, windows are already aggregated + inside the metric, so ``W=1`` regardless of ``backtest.reduction``. + * ``q`` / ``q_interval`` – expand the component axis with one entry per + quantile / interval. + * ``label_reduction`` / ``labels`` – expand the component axis for + classification metrics. + * ``reduction=None`` – no aggregation across windows → one value per window. + * ``last_points_only`` – collapses all windows into one TimeSeries before scoring, + so there is effectively only one window regardless of reduction. + + When ``label_reduction=None`` is used without explicit ``labels``, the + unique class values are inferred from ``series`` at runtime so structured + per-label keys are still produced. When two metrics have incompatible axis + layouts (different ``time_reduction`` / ``component_reduction`` / quantile + count), each series result is flattened to integer-indexed keys instead. + + Parameters + ---------- + autologging_client + MLflow autologging client used to queue metric writes. + run_id + ID of the active MLflow run. + result + Return value of ``backtest()``. + backtest_args + Bound arguments of the ``backtest()`` call (from + ``inspect.BoundArguments.arguments`` after ``apply_defaults``). + """ + metric = backtest_args.get("metric") + metric = metric if isinstance(metric, list) else [metric] + metric_kwargs = backtest_args.get("metric_kwargs") or {} + metric_kwargs = ( + metric_kwargs if isinstance(metric_kwargs, list) else [metric_kwargs] + ) + # backtest accepts a single dict that applies to all metrics; broadcast it + if len(metric_kwargs) != len(metric): + metric_kwargs = [metric_kwargs[0]] * len(metric) + metric_names = [ + _sanitize_mlflow_key(getattr(m, "__name__", f"metric_{i}")) + for i, m in enumerate(metric) + ] + n_metrics = len(metric) + + # reduction=None means no aggregation across windows → one value per window. + # last_points_only collapses all windows into one TimeSeries before scoring, + # so there is effectively only one window regardless of reduction. + has_windows = backtest_args.get("reduction") is None and not backtest_args.get( + "last_points_only", False + ) + + # series_reduction inside the metric itself already aggregates across windows, + # so the result has no window axis even when backtest.reduction is None. + metric_0_params = inspect.signature(metric[0]).parameters + if "series_reduction" in metric_0_params: + effective_sr = metric_kwargs[0].get( + "series_reduction", metric_0_params["series_reduction"].default + ) + if effective_sr is not None: + has_windows = False + + # check the dim axes from the metric kwargs for each + metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metric, metric_kwargs)] + has_time_axis, has_comp_axis, quantiles_num, _ = metric_axes[0] + + # Inconsistent axes across metrics (different has_time_axis, has_comp_axis, or + # quantiles_num) means the result can't be reshaped into a single canonical array. + # Fall back to flat integer-indexed keys for this case. + axes_inconsistent = any(ax[:3] != metric_axes[0][:3] for ax in metric_axes[1:]) + + # quantiles_num=None means label_reduction=None was requested with labels=None, + labels_unknown = quantiles_num is None + + series = backtest_args.get("series") + forecast_horizon = backtest_args.get("forecast_horizon") + + series_seq = series2seq(series) + results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result + + metrics_by_step: dict[int, dict[str, float]] = {} + for series_index, (s, r) in enumerate(zip(series_seq, results)): + series_suffix = f"_s{series_index}" if len(series_seq) > 1 else "" + + if axes_inconsistent: + name_prefix = metric_names[0] if len(metric_names) == 1 else "metrics" + flat = np.asarray(r, dtype=float).flatten() + for i, val in enumerate(flat): + key = _sanitize_mlflow_key(f"backtest_{name_prefix}{series_suffix}_{i}") + metrics_by_step.setdefault(0, {})[key] = float(val) + continue + + # resolve label names from series data when not provided explicitly. + # mirrors np.unique(np.concatenate([y_true, y_pred])) inside _confusion_matrix. + # NOTE: importantly this checks the series for labels, not just the windows, if + # this is an issue, then I'd suggest falling back to flat integer-indexed keys + # and enforcing explicit labels. + if labels_unknown: + inferred_labels = np.unique(s.values()) + quantiles_num = len(inferred_labels) + metric_axes = [ + ( + has_time_axis, + has_comp_axis, + quantiles_num, + [f"_label{x:g}" for x in inferred_labels], + ) + ] + list(metric_axes[1:]) + + comps = s.components.tolist() + # c_size = components × quantiles/intervals/labels per component + c_size = (s.n_components if has_comp_axis else 1) * quantiles_num + arr = np.asarray(r, dtype=float) + # after stripping C and M axes, rest = W*T (or W or T alone) + rest, extra = divmod(arr.size, c_size * n_metrics) + if extra: + logger.warning( + "Backtest metric logging skipped: result size (%d) is not " + "divisible by c_size * n_metrics (%d * %d = %d). " + "The metric output shape does not match the inferred axes.", + arr.size, + c_size, + n_metrics, + c_size * n_metrics, + ) + return + + # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can + # recover W and T only if forecast_horizon is known (T = forecast_horizon) + if has_time_axis and has_windows: + if not forecast_horizon or rest % forecast_horizon: + logger.warning( + "Backtest metric logging skipped: cannot split window/time " + "axes — %d elements remain after stripping component and " + "metric axes, but forecast_horizon=%r does not divide " + "evenly. Pass an explicit forecast_horizon to backtest().", + rest, + forecast_horizon, + ) + return + t_size, w_size = forecast_horizon, rest // forecast_horizon + elif has_time_axis: + t_size, w_size = rest, 1 + elif has_windows: + t_size, w_size = 1, rest + else: + if rest != 1: + logger.warning( + "Backtest metric logging skipped: expected a single scalar " + "per component/metric after reduction, but got %d elements. " + "Check time_reduction and component_reduction defaults.", + rest, + ) + return + t_size, w_size = 1, 1 + + canonical = arr.reshape(w_size, t_size, c_size, n_metrics) + for m, metric_name in enumerate(metric_names): + quantiles_labels = metric_axes[m][3] + for w in range(w_size): + for c in range(c_size): + # c is a flat index into the (n_components × quantiles_num) C axis: + # c = comp_i * quantiles_num + q_i + component_index, quantile_index = divmod(c, quantiles_num) + comp_part = ( + "_" + _sanitize_mlflow_key(comps[component_index]) + if has_comp_axis + else "" + ) + key = f"backtest_{metric_name}{comp_part}{quantiles_labels[quantile_index]}" + if has_time_axis and has_windows: + key += f"_w{w}" + key = _sanitize_mlflow_key(key + series_suffix) + for t in range(t_size): + # MLflow step maps to the axis the UI should chart: + # time when present, otherwise window index + step = t if has_time_axis else w + metrics_by_step.setdefault(step, {})[key] = float( + canonical[w, t, c, m] + ) + + for step, metrics in metrics_by_step.items(): + autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + + +def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: + """Infer a metric's output axes from its signature and ``metric_kwargs``. + + Covers ``time_reduction``, ``component_reduction``, ``q``, ``q_interval``, + and ``label_reduction`` / ``labels`` for classification metrics. + ``series_reduction`` is handled at the ``_log_backtest_metrics`` level. + + Parameters + ---------- + metric + A darts metric callable. + metric_kwargs + Keyword arguments that will be forwarded to ``metric``. + + Returns + ------- + tuple + ``(has_time_axis, has_comp_axis, quantiles_num, quantiles_labels)`` where + + - ``has_time_axis`` – ``True`` when ``time_reduction`` is ``None`` (i.e. a + per-timestep axis is present in the output). + - ``has_comp_axis`` – ``True`` when components are expanded (not collapsed to a scalar). + - ``quantiles_num`` – number of quantile/interval/label entries; ``None`` when it + cannot be determined (e.g. ``label_reduction=None`` without explicit + ``labels``), signalling the caller to fall back to flat logging. + - ``quantiles_labels`` – one key suffix per ``quantiles_num`` entry (empty list when + ``quantiles_num`` is ``None``). + """ + params = inspect.signature(metric).parameters + + def effective(param_name: str) -> Any: + """Return metric_kwargs value if present, else the signature default.""" + if param_name in metric_kwargs: + return metric_kwargs[param_name] + return params[param_name].default if param_name in params else None + + has_time_axis = "time_reduction" in params and effective("time_reduction") is None + has_comp_axis = ( + "component_reduction" in params and effective("component_reduction") is None + ) + + q_interval, q = metric_kwargs.get("q_interval"), metric_kwargs.get("q") + if "q_interval" in params and q_interval is not None: + intervals = np.atleast_2d(np.array(q_interval, dtype=float)) + quantiles_labels = [f"_qi{lo:g}_{hi:g}" for lo, hi in intervals] + elif "q" in params and q is not None: + quantiles_labels = [f"_q{v:g}" for v in np.atleast_1d(np.array(q, dtype=float))] + elif "label_reduction" in params and getattr(metric, "__name__", "") in { + m.__name__ for m in CLASSIFICATION_METRICS + }: + label_reduction = effective("label_reduction") + if isinstance(label_reduction, _LabelReduction): + label_reduction = label_reduction.value + labels = metric_kwargs.get("labels") + # label_reduction=None means one output per label, but without explicit + # labels we can't know how many — signal the caller to fall back + if label_reduction is None and labels is None: + return (has_time_axis, has_comp_axis, None, []) + quantiles_labels = ( + [f"_label{x}" for x in np.atleast_1d(labels)] + if label_reduction is None + else [""] + ) + else: + quantiles_labels = [""] + + return (has_time_axis, has_comp_axis, len(quantiles_labels), quantiles_labels) + + def _log_metric_result( autologging_client: MlflowAutologgingQueueingClient, run_id: str, From bf497e67c608446cdd6690ce9791b3e906e7f6e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 16:49:47 +0200 Subject: [PATCH 071/154] feat: backtest metric testing suite --- darts/tests/optional_deps/test_mlflow.py | 378 +++++++++++++++++++++-- 1 file changed, 355 insertions(+), 23 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 4b2599e452..c2b4a06eb8 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,9 +1,12 @@ +import logging import os import numpy as np import pandas as pd import pytest +import darts.metrics as dm +import darts.metrics.metrics as dmm import darts.utils.timeseries_generation as tg from darts import TimeSeries from darts.models.forecasting.forecasting_model import ( @@ -19,9 +22,12 @@ ) import mlflow +from mlflow.utils.autologging_utils.client import MlflowAutologgingQueueingClient from darts.models import ExponentialSmoothing, LinearRegressionModel from darts.utils.mlflow import ( + _infer_metric_axes, + _log_backtest_metrics, autolog, load_model, log_model, @@ -121,6 +127,13 @@ class TestMLflow: ) ts_past_cov = tg.sine_timeseries(length=62).astype("float32") ts_future_cov = tg.constant_timeseries(value=1.0, length=62).astype("float32") + # binary classification series with values {0.0, 1.0} + ts_binary = tg.constant_timeseries(value=0.0, length=50).with_values( + np.random.default_rng(42) + .choice([0.0, 1.0], size=50) + .astype(np.float32) + .reshape(-1, 1) + ) def test_save_load_statistical_model(self, tmpdir_fn): """Test save/load round-trip for statistical model""" @@ -602,10 +615,8 @@ def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): def test_autolog_metric_logging_scalar(self, mlflow_tracking, autolog_context): """Calling a darts metric inside an active run logs a scalar to MLflow.""" with autolog_context(log_metrics=True): - from darts.metrics import mae - with mlflow.start_run() as run: - result = mae(self.ts_univariate, self.ts_univariate * 1.1) + result = dm.mae(self.ts_univariate, self.ts_univariate * 1.1) run_data = mlflow.get_run(run.info.run_id).data assert "mae" in run_data.metrics, "mae should be logged to MLflow" @@ -616,11 +627,9 @@ def test_autolog_metric_logging_scalar(self, mlflow_tracking, autolog_context): def test_autolog_metric_repeated_call(self, mlflow_tracking, autolog_context): """Calling the same metric twice overwrites the value (last-value-wins).""" with autolog_context(log_metrics=True): - from darts.metrics import rmse - with mlflow.start_run() as run: - rmse(self.ts_univariate, self.ts_univariate * 1.1) - rmse(self.ts_univariate, self.ts_univariate * 1.2) + dm.rmse(self.ts_univariate, self.ts_univariate * 1.1) + dm.rmse(self.ts_univariate, self.ts_univariate * 1.2) run_data = mlflow.get_run(run.info.run_id).data assert "rmse" in run_data.metrics, "rmse should be logged to MLflow" @@ -634,10 +643,8 @@ def test_autolog_metric_per_component(self, mlflow_tracking, autolog_context): 'mae_linear' and 'mae_linear_1'. """ with autolog_context(log_metrics=True): - from darts.metrics import mae - with mlflow.start_run() as run: - mae( + dm.mae( self.ts_multivariate, self.ts_multivariate * 1.1, component_reduction=None, @@ -656,10 +663,8 @@ def test_autolog_metric_per_component(self, mlflow_tracking, autolog_context): def test_autolog_metric_no_active_run(self, mlflow_tracking, autolog_context): """Calling a metric without an active run does not raise and returns correctly.""" with autolog_context(log_metrics=True): - from darts.metrics import mse - # called outside any start_run — must not raise - result = mse(self.ts_univariate, self.ts_univariate * 1.1) + result = dm.mse(self.ts_univariate, self.ts_univariate * 1.1) assert np.isscalar(result) assert np.isfinite(float(result)) @@ -669,15 +674,13 @@ def test_autolog_metric_returns_correct_value( ): """The patched metric returns the same value whether inside or outside a run.""" with autolog_context(log_metrics=True): - from darts.metrics import mae - pred = self.ts_univariate * 1.05 with mlflow.start_run(): - result_inside = mae(self.ts_univariate, pred) + result_inside = dm.mae(self.ts_univariate, pred) # call outside a run — no logging, same computation - result_outside = mae(self.ts_univariate, pred) + result_outside = dm.mae(self.ts_univariate, pred) np.testing.assert_almost_equal(result_inside, result_outside, decimal=6) assert np.isfinite(result_inside) @@ -685,10 +688,8 @@ def test_autolog_metric_returns_correct_value( def test_autolog_log_metrics_false(self, mlflow_tracking, autolog_context): """autolog(log_metrics=False) leaves metrics unpatched — nothing is logged.""" with autolog_context(log_metrics=False): - from darts.metrics import mape - with mlflow.start_run() as run: - mape(self.ts_univariate, self.ts_univariate * 1.1) + dm.mape(self.ts_univariate, self.ts_univariate * 1.1) run_data = mlflow.get_run(run.info.run_id).data assert "mape" not in run_data.metrics, ( @@ -702,9 +703,6 @@ def test_autolog_public_namespace_patched(self, mlflow_tracking, autolog_context calls within the implementation module (e.g. rmse calling mse internally). """ with autolog_context(log_metrics=True): - import darts.metrics as dm - import darts.metrics.metrics as dmm - # public namespace → patched: call inside a run should log with mlflow.start_run() as run_public: dm.mae(self.ts_univariate, self.ts_univariate * 1.1) @@ -721,3 +719,337 @@ def test_autolog_public_namespace_patched(self, mlflow_tracking, autolog_context assert "mae" not in run_data_impl.metrics, ( "darts.metrics.metrics.mae should NOT log (implementation module is not patched)" ) + + def test_autolog_backtest_scalar(self, mlflow_tracking, autolog_context): + """Default (reduced) backtest of a single univariate series logs one scalar.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr().backtest( + self.ts_univariate, metric=dm.mae, retrain=False, stride=10 + ) + + run_data = mlflow.get_run(run.info.run_id).data + assert "backtest_mae" in run_data.metrics + assert run_data.metrics["backtest_mae"] == pytest.approx(float(ref), abs=1e-5) + + def test_autolog_backtest_per_window_steps(self, mlflow_tracking, autolog_context): + """reduction=None logs per-window values as consecutive steps of one key.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr().backtest( + self.ts_univariate, + metric=dm.mae, + retrain=False, + stride=10, + reduction=None, + ) + + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") + assert len(history) > 1, "Expected multiple per-window steps" + steps = sorted(m.step for m in history) + assert steps == list(range(len(history))) + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose(logged, np.asarray(ref, dtype=float), atol=1e-5) + + def test_autolog_backtest_per_component(self, mlflow_tracking, autolog_context): + """component_reduction=None logs one key per component name.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr(self.ts_multivariate).backtest( + self.ts_multivariate, + metric=dm.mae, + retrain=False, + stride=10, + metric_kwargs={"component_reduction": None}, + ) + + run_data = mlflow.get_run(run.info.run_id).data + assert "backtest_mae_linear" in run_data.metrics + assert "backtest_mae_linear_1" in run_data.metrics + ref = np.asarray(ref, dtype=float) + assert run_data.metrics["backtest_mae_linear"] == pytest.approx( + ref[0], abs=1e-5 + ) + assert run_data.metrics["backtest_mae_linear_1"] == pytest.approx( + ref[1], abs=1e-5 + ) + + def test_autolog_backtest_multi_metric(self, mlflow_tracking, autolog_context): + """Multiple metrics are logged under one key each.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr().backtest( + self.ts_univariate, + metric=[dm.mae, dm.rmse], + retrain=False, + stride=10, + ) + + run_data = mlflow.get_run(run.info.run_id).data + assert "backtest_mae" in run_data.metrics + assert "backtest_rmse" in run_data.metrics + assert run_data.metrics["backtest_mae"] == pytest.approx( + float(ref[0]), abs=1e-5 + ) + assert run_data.metrics["backtest_rmse"] == pytest.approx( + float(ref[1]), abs=1e-5 + ) + + def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): + """A list of series logs one key per series index.""" + series = [self.ts_univariate, self.ts_univariate * 1.2] + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr(series).backtest( + series, metric=dm.mae, retrain=False, stride=10 + ) + + run_data = mlflow.get_run(run.info.run_id).data + assert "backtest_mae_s0" in run_data.metrics + assert "backtest_mae_s1" in run_data.metrics + assert run_data.metrics["backtest_mae_s0"] == pytest.approx( + float(ref[0]), abs=1e-5 + ) + assert run_data.metrics["backtest_mae_s1"] == pytest.approx( + float(ref[1]), abs=1e-5 + ) + + def test_autolog_backtest_per_timestep_scalar( + self, mlflow_tracking, autolog_context + ): + """A per-timestep metric (ae) under default reduction collapses to one scalar.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr().backtest( + self.ts_univariate, metric=dm.ae, retrain=False, stride=10 + ) + + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") + assert len(history) == 1, "Default reduction should yield a single value" + assert history[0].value == pytest.approx(float(ref), abs=1e-5) + + def test_autolog_backtest_per_timestep_per_window( + self, mlflow_tracking, autolog_context + ): + """ae + reduction=None + forecast_horizon>1 logs one key per window, with + one step per forecast horizon timestep.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = self._fit_lr().backtest( + self.ts_univariate, + metric=dm.ae, + retrain=False, + stride=10, + forecast_horizon=4, + reduction=None, + ) + + ref = np.asarray(ref, dtype=float) # shape (n_windows, forecast_horizon) + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae_w0") + assert len(history) == 4, "Expected one step per forecast horizon timestep" + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose(logged, ref[0], atol=1e-5) + + def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): + """A quantile metric (mql) logs one key per quantile.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + self._fit_qlr().backtest( + self.ts_univariate, + metric=dm.mql, + metric_kwargs={"q": [0.1, 0.5, 0.9]}, + retrain=False, + stride=10, + num_samples=200, + ) + + m = mlflow.get_run(run.info.run_id).data.metrics + for key in ("backtest_mql_q0_1", "backtest_mql_q0_5", "backtest_mql_q0_9"): + assert key in m, f"Expected quantile key {key}" + assert np.isfinite(m[key]) + + def test_autolog_backtest_inconsistent_axes_flat_fallback( + self, mlflow_tracking, autolog_context + ): + """Metrics with mismatched axes (mae has no time axis, ae does) cannot be + merged into a structured layout, so values are logged flat by index.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + self._fit_lr().backtest( + self.ts_univariate, + metric=[dm.mae, dm.ae], + retrain=False, + stride=10, + ) + + m = mlflow.get_run(run.info.run_id).data.metrics + flat_keys = [k for k in m if k.startswith("backtest_metrics_")] + assert flat_keys, "Expected flat fallback keys for inconsistent axes" + assert "backtest_mae" not in m, "No structured key on flat fallback" + + def test_autolog_backtest_classification_labels_in_data( + self, mlflow_tracking, autolog_context + ): + """f1 with explicit labels present in the series logs finite per-label keys.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + self._fit_lr(self.ts_binary).backtest( + self.ts_binary, + metric=dm.f1, + metric_kwargs={"label_reduction": None, "labels": [0, 1]}, + retrain=False, + stride=10, + ) + + m = mlflow.get_run(run.info.run_id).data.metrics + assert "backtest_f1_label0" in m + assert "backtest_f1_label1" in m + assert np.isfinite(m["backtest_f1_label0"]) + assert np.isfinite(m["backtest_f1_label1"]) + + def test_autolog_backtest_classification_labels_not_in_data( + self, mlflow_tracking, autolog_context + ): + """f1 with explicit labels absent from the series still creates the keys, but + the scores are NaN (the labels never appear in any window).""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + self._fit_lr(self.ts_binary).backtest( + self.ts_binary, + metric=dm.f1, + metric_kwargs={"label_reduction": None, "labels": [5, 10]}, + retrain=False, + stride=10, + ) + + m = mlflow.get_run(run.info.run_id).data.metrics + assert "backtest_f1_label5" in m + assert "backtest_f1_label10" in m + assert np.isnan(m["backtest_f1_label5"]) + assert np.isnan(m["backtest_f1_label10"]) + + def test_autolog_backtest_classification_labels_inferred( + self, mlflow_tracking, autolog_context + ): + """f1 with label_reduction=None and no explicit labels infers class names + from series values and logs structured per-label keys instead of flat + integer-indexed ones.""" + # binary classification series: values are 0.0 and 1.0 + rng = np.random.default_rng(42) + vals = rng.choice([0.0, 1.0], size=50).astype(np.float32).reshape(-1, 1) + ts_bin = tg.constant_timeseries(value=0.0, length=50).with_values(vals) + + model = LinearRegressionModel(lags=4) + model.fit(ts_bin) + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + model.backtest( + series=ts_bin, + metric=dm.f1, + metric_kwargs={"label_reduction": None}, + retrain=False, + stride=10, + ) + + m = mlflow.get_run(run.info.run_id).data.metrics + # unique values are 0.0 and 1.0 → keys should use actual class values + assert "backtest_f1_label0" in m, "Expected 'backtest_f1_label0' for class 0.0" + assert "backtest_f1_label1" in m, "Expected 'backtest_f1_label1' for class 1.0" + # no flat integer-indexed keys + flat_keys = [ + k + for k in m + if k.startswith("backtest_f1_") and k[-1].isdigit() and "_label" not in k + ] + assert not flat_keys, f"Did not expect flat fallback keys: {flat_keys}" + + def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking, caplog): + """When the inferred label count does not divide the metric output size, + logging is skipped with a warning rather than raising — keeping autologging + non-fatal for the surrounding backtest call. + + This is tested by calling _log_backtest_metrics directly so the warning is + not swallowed by MLflow's safe_patch wrapper. + """ + # Series has 3 unique classes so np.unique(series.values()) → [0, 1, 2]. + vals = np.array([0.0, 1.0, 2.0] * 17, dtype=np.float32)[:50].reshape(-1, 1) + ts_3class = tg.constant_timeseries(value=0.0, length=50).with_values(vals) + + # Simulate a backtest result with only 2 entries — as if the metric was + # evaluated on windows that only contained classes 0 and 1. + # quantiles_num will be inferred as 3 (from series) but result has 2 → mismatch. + fake_result = np.array([0.8, 0.6], dtype=float) + + backtest_args = { + "metric": dm.f1, + "metric_kwargs": {"label_reduction": None}, + "series": ts_3class, + "forecast_horizon": 1, + "reduction": np.mean, # not None → has_windows=False → single window + "last_points_only": True, + } + + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + with caplog.at_level(logging.WARNING): + # must not raise — logging is skipped on shape mismatch + _log_backtest_metrics( + client, run.info.run_id, fake_result, backtest_args + ) + assert "not divisible" in caplog.text + client.flush(synchronous=True) + + assert not mlflow.get_run(run.info.run_id).data.metrics + + def _fit_lr(self, series=None): + """Fit and return a fresh LinearRegressionModel (no active run).""" + model = LinearRegressionModel(lags=4) + model.fit(series if series is not None else self.ts_univariate) + return model + + def _fit_qlr(self, series=None): + """Fit and return a fresh quantile LinearRegressionModel (no active run).""" + model = LinearRegressionModel( + lags=4, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] + ) + model.fit(series if series is not None else self.ts_univariate) + return model + + +@pytest.mark.parametrize( + "metric_name, metric_kwargs, expected", + [ + ("mae", {}, dict(has_time_axis=False, has_comp_axis=False, quantiles_num=1)), + ("ae", {}, dict(has_time_axis=True, has_comp_axis=False, quantiles_num=1)), + ("mae", {"component_reduction": None}, dict(has_comp_axis=True)), + ], +) +def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): + _attr_idx = {"has_time_axis": 0, "has_comp_axis": 1, "quantiles_num": 2} + axes = _infer_metric_axes(getattr(dm, metric_name), metric_kwargs) + for attr, value in expected.items(): + assert axes[_attr_idx[attr]] == value + + +def test_infer_metric_axes_quantiles(): + _, _, quantiles_num, quantiles_labels = _infer_metric_axes( + dm.mql, {"q": [0.1, 0.5, 0.9]} + ) + assert quantiles_num == 3 + assert quantiles_labels == ["_q0.1", "_q0.5", "_q0.9"] + + +def test_infer_metric_axes_quantile_interval(): + has_time, _, quantiles_num, quantiles_labels = _infer_metric_axes( + dm.iw, {"q_interval": (0.1, 0.9)} + ) + assert quantiles_num == 1 + assert quantiles_labels == ["_qi0.1_0.9"] + assert has_time is True + + +def test_infer_metric_axes_unknown_labels(): + """label_reduction=None with no explicit labels cannot determine QL.""" + _, _, quantiles_num, _ = _infer_metric_axes(dm.f1, {"label_reduction": None}) + assert quantiles_num is None From 9e4934d4b1fa73c40d60e875ef4b45579c5f1ab7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 16:53:33 +0200 Subject: [PATCH 072/154] fix: update failing tests due to manage_run deprecation --- darts/tests/optional_deps/test_mlflow.py | 46 +++++++++++++----------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index c2b4a06eb8..d3d559e939 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -240,8 +240,9 @@ def test_log_model_with_all_covariate_types(self, mlflow_tracking): def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): """Test autolog can be enabled and disabled""" with autolog_context(): - model = ExponentialSmoothing() - model.fit(self.ts_univariate) + with mlflow.start_run(): + model = ExponentialSmoothing() + model.fit(self.ts_univariate) runs = mlflow.search_runs() assert len(runs) == 1, "Expected exactly one run after autolog fit" @@ -263,8 +264,9 @@ def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): def test_autolog_parameters(self, mlflow_tracking, autolog_context): """Test that autolog logs model parameters""" with autolog_context(): - model = ExponentialSmoothing(seasonal_periods=12) - model.fit(self.ts_univariate) + with mlflow.start_run(): + model = ExponentialSmoothing(seasonal_periods=12) + model.fit(self.ts_univariate) runs = mlflow.search_runs() assert len(runs) == 1 @@ -277,14 +279,15 @@ def test_autolog_parameters(self, mlflow_tracking, autolog_context): def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): """Test that autolog logs training metrics for torch models""" with autolog_context(): - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) + with mlflow.start_run(): + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) runs = mlflow.search_runs() assert len(runs) == 1, "Expected exactly one run" @@ -327,15 +330,16 @@ def assert_metric(history, key): with autolog_context(): assert not autologging_is_disabled("pytorch") - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=n_epochs, - torch_metrics=torchmetrics.MeanAbsoluteError(), - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) + with mlflow.start_run(): + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=n_epochs, + torch_metrics=torchmetrics.MeanAbsoluteError(), + **tfm_kwargs_dev, + ) + train, val = self.ts_univariate.split_before(0.7) + model.fit(train, val_series=val) runs = mlflow.search_runs() assert len(runs) == 1 From 7b8dbcd72b6da87b212b6f2a8c7282218d206130 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 17:02:51 +0200 Subject: [PATCH 073/154] chore: remove temporary test file --- mlflow_test_v2.py | 270 ---------------------------------------------- 1 file changed, 270 deletions(-) delete mode 100644 mlflow_test_v2.py diff --git a/mlflow_test_v2.py b/mlflow_test_v2.py deleted file mode 100644 index 655065ac76..0000000000 --- a/mlflow_test_v2.py +++ /dev/null @@ -1,270 +0,0 @@ -""" -MLflow (auto)-logging: Multi-model comparison with backtest - -Demonstrates: - * One MLflow run per model — each ``model.fit()`` auto-creates its own run - (via ``manage_run=True`` in autolog). The run is named after the model - class (e.g. ``LinearRegressionModel``, ``ExponentialSmoothing``). - * Metric keys are unprefixed (``val_mape``, ``backtest_mape``, etc.) so - the experiment-level comparison view can overlay them directly. - * Automatic parameter and tag logging via darts autolog. - * Inline metric logging: ``mape`` and ``rmse`` called inside an active run - are automatically captured by the patched metric functions. - * Backtest with pre-computed historical forecasts, multiple metric functions, - and ``reduction=None`` so each window is logged as a step of - ``backtest_mape`` / ``backtest_rmse`` in the MLflow UI. - -Notes: - * ``mlflow_darts.autolog()`` is required — it patches ``fit()``, the darts - metric functions, and ``backtest()`` to make logging automatic. - * ``manage_run=False`` is passed to ``autolog()`` so that we control the run - lifecycle ourselves with ``mlflow.start_run()``. This lets us keep the - run open for predict + metrics + backtest after ``fit()`` returns. - * ``last_points_only=False`` is used for historical forecasts so that - ``backtest()`` receives a list of per-window forecasts and can compute one - metric value per window (enabling the per-step chart in the UI). - ``last_points_only=True`` would collapse all windows into a single - TimeSeries, making the metric treat them as one window. - -Run with: - python mlflow_test_v2.py - -Inspect in the UI: - mlflow ui --backend-store-uri sqlite:////tmp/mlflow_v2.db -""" - -import logging - -import coolname -import mlflow -from loguru import logger - -logging.getLogger("mlflow.utils.environment").setLevel(logging.ERROR) - -import numpy as np - -import darts.metrics as darts_metrics -import darts.utils.mlflow as mlflow_darts -from darts.datasets import AirPassengersDataset -from darts.models import ( - ExponentialSmoothing, - LinearRegressionModel, - NBEATSModel, - NHiTSModel, - TCNModel, -) - - -def _managed_run_scenarios(model, train, val, log) -> None: - """Explores manage_run=True behaviour across four scenarios. - - Metrics always use manage_run=False internally — they only log into an - already-active run and never create one themselves. - - Scenario A — bare fit(): - fit() uses with_managed_run which creates a run when none is active, - then closes it on return. - Result: one run per model, params logged, no metrics. - - Scenario B — metric with no active run: - Metric patches have manage_run=False so they never open a run. - With nothing active there is nowhere to log. - Result: nothing logged (silent no-op). - - Scenario C — metric inside an explicit start_run(): - Caller opens a run; metric patch sees an active run and logs into it. - No fit() → no params. - Result: one run with only the metric logged. - - Scenario D — fit() + metric inside an explicit start_run(): - with_managed_run creates a run "if necessary". Because the caller's - run is already active, fit() reuses it rather than nesting a child. - Params and metric all land in the same single run. - Result: one run per model with both params and metric logged. - """ - - -def _magic(model, train, val, series, log) -> None: - """Advanced use case: caller-managed run with predict, val metrics, and backtest. - - Requires autolog(manage_run=False) and an active mlflow.start_run() in the - caller. Because manage_run=False, fit() never opens or closes a run on its - own — the caller's run stays open for the entire workflow. - - What gets logged into the single run: - - Model params (from fit via the autolog patch). - - val_mape, val_rmse (from patched darts_metrics calls while run is active). - - backtest_mape, backtest_rmse, backtest_ape as consecutive steps - (one value per window, because reduction=None). - """ - model_name = type(model).__name__ - log(f"[{model_name}] Run created: run_id={mlflow.active_run().info.run_id}") - # ── fit ─────────────────────────────────────────────────────────── - log(f"[{model_name}] Fitting model on {len(train)} training samples") - model.fit(train) - # ── predict + inline metric logging ─────────────────────────────── - log(f"[{model_name}] Predicting {len(val)} steps") - pred = model.predict(n=len(val)) - # Calls inside active MLflow run are intercepted by patched metric - # functions and auto-logged -> val_mape, val_rmse - val_mape = darts_metrics.mape(val, pred) - val_rmse = darts_metrics.rmse(val, pred) - log(f"[{model_name}] val_mape={val_mape:.4f} val_rmse={val_rmse:.4f}") - - # ── backtest ────────────────────────────────────────────────────── - log( - f"[{model_name}] Computing historical forecasts " - f"(start={BT_START}, horizon={FORECAST_HORIZON}, stride={STRIDE})" - ) - hfc = model.historical_forecasts( - series, - start=BT_START, - forecast_horizon=FORECAST_HORIZON, - stride=STRIDE, - retrain=True, - last_points_only=False, - ) - log(f"[{model_name}] {len(hfc)} backtest windows computed") - - # reduction=None → one value per window per metric, logged as - # consecutive steps of backtest_mape / backtest_rmse - log(f"[{model_name}] Running backtest (logging per-window metrics as steps)") - model.backtest( - series=series, - historical_forecasts=hfc, - last_points_only=False, - metric=[darts_metrics.mape, darts_metrics.rmse, darts_metrics.ape, darts_metrics.mase, darts_metrics.mase], - metric_kwargs=[{}, {}, {}, {"m": 1}, {"m": 2}], - reduction=None, - ) - log(f"[{model_name}] Run complete: {mlflow.active_run().info.run_id}") - - -def _backtest_reduction_scenarios(model, train, series, log) -> None: - """Explores how different ``reduction`` values affect MLflow logging. - - Fits once and computes historical forecasts once, then calls backtest with - four different reductions. Each variant runs inside its own nested - child run so the MLflow UI shows them separately without key collisions. - - Reduction variants and their logged shape: - None → 1-D array per metric → logged as consecutive steps (chart). - np.mean → scalar per metric → single value (mean over windows). - np.median → scalar per metric → single value (median over windows). - custom → scalar per metric → single value (90th-percentile). - - All variants use the same metric list (mape, rmse) and the same - pre-computed historical forecasts so results are directly comparable. - """ - model_name = type(model).__name__ - metrics = [darts_metrics.mape, darts_metrics.rmse] - - log(f"[{model_name}] Fitting") - model.fit(train) - log(f"[{model_name}] Computing historical forecasts") - hfc = model.historical_forecasts( - series, - start=BT_START, - forecast_horizon=FORECAST_HORIZON, - stride=STRIDE, - retrain=True, - last_points_only=False, - ) - log(f"[{model_name}] {len(hfc)} windows") - - reductions = [ - (None, "reduction=None (per-window steps)"), - # (np.mean, "reduction=np.mean"), - # (np.median, "reduction=np.median"), - # (lambda x, axis=None: np.percentile(x, 90, axis=axis), "reduction=p90"), - ] - - for reduction_fn, label in reductions: - log(f"[{model_name}] Backtest — {label}") - with mlflow.start_run(nested=True, run_name=label): - model.backtest( - series=series, - historical_forecasts=hfc, - last_points_only=False, - metric=metrics, - reduction=reduction_fn, - ) - - -# ── Data setup ---------------------------------------------------------------- -# Cast to float32: MPS doesn't support float64 tensors -series = AirPassengersDataset().load().astype(np.float32) -# TODO: implement/test the follwoing cases! -series_multiple = [series, series / 3.] -series_multivariate = series.stack(series / 3.) -series_multiple_multivariate = [series.stack(series / 3.), series.stack(series / 10.)] - -train, val = series.split_after(0.75) -FORECAST_HORIZON, STRIDE, BT_START = 1, 2, 0.75 - -# ── Logging setup ───────────────────────────────────────────────────────────── -VERBOSE = True -log = logger.info if VERBOSE else lambda *a, **kw: None -# ── MLflow setup ────────────────────────────────────────────────────────────── -DB_PATH = "/tmp/mlflow_v2.db" -mlflow.set_tracking_uri(f"sqlite:///{DB_PATH}") -# ── Model setup --------------------------------------------------------------- -_torch_kwargs = dict( - input_chunk_length=12, - output_chunk_length=FORECAST_HORIZON, - n_epochs=10, - pl_trainer_kwargs={ - "accelerator": "mps", - "precision": "32-true", - "enable_progress_bar": False, - }, -) -models = [ - LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON), - # LinearRegressionModel(lags=24, output_chunk_length=FORECAST_HORIZON), # same model, more lags - ExponentialSmoothing(), - # NBEATSModel(**_torch_kwargs), - # NBEATSModel(**_torch_kwargs, num_stacks=4, num_blocks=2), # same model, deeper architecture - # NHiTSModel(**_torch_kwargs), - # TCNModel(**_torch_kwargs), -] - -# ── Use case 1: manage_run=True (default) ───────────────────────────────────── -# fit() auto-creates and closes a run per model — no start_run() needed. -exp_name: str = coolname.generate_slug(2) -mlflow.set_experiment(exp_name) -mlflow_darts.autolog() -logger.info(f"[Use case 1] Experiment: {exp_name}") -for model in models: - with mlflow.start_run(): - model.fit(train) - pred = model.predict(n=len(val)) - darts_metrics.mape(val, pred) - -# ── Use case 2: manage_run=False + backtest ─────────────────────────────────── -# Caller opens the run so predict, val metrics, and backtest all land in it. -# NOTE: this is the recommended way to use MLFlow in Darts. It avoids -# nesting runs and ensures all metrics land in the same run. -exp_name = coolname.generate_slug(2) -mlflow.set_experiment(exp_name) -mlflow_darts.autolog() -logger.info(f"[Use case 2] Experiment: {exp_name}") -for i, model in enumerate(models): - model_name = type(model).__name__ - log(f"[{model_name}] Starting run") - with mlflow.start_run( - run_name=model_name, - description=f"Small exp. run for {model_name}", - ) as run: - _magic(model, train, val, series, log) - -# ── Use case 3: backtest reduction variants ─────────────────────────────────── -# One parent run per model; one nested child run per reduction variant. -exp_name = coolname.generate_slug(2) -mlflow.set_experiment(exp_name) -mlflow_darts.autolog(manage_run=False) -logger.info(f"[Use case 3] Experiment: {exp_name}") -for model in models: - model_name = type(model).__name__ - with mlflow.start_run(run_name=model_name): - _backtest_reduction_scenarios(model, train, series, log) From 502db7103c59eee0af5b97eebd043b2103698452 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 17:48:57 +0200 Subject: [PATCH 074/154] feat: update mlflow notebook --- examples/27-MLflow-quickstart.ipynb | 873 --- examples/29-MLflow-quickstart.ipynb | 5959 ++++++++++++++++++++ examples/static/images/mlflow_charts.png | Bin 0 -> 357183 bytes examples/static/images/mlflow_models.png | Bin 0 -> 361032 bytes examples/static/images/mlflow_overview.png | Bin 0 -> 332549 bytes 5 files changed, 5959 insertions(+), 873 deletions(-) delete mode 100644 examples/27-MLflow-quickstart.ipynb create mode 100644 examples/29-MLflow-quickstart.ipynb create mode 100644 examples/static/images/mlflow_charts.png create mode 100644 examples/static/images/mlflow_models.png create mode 100644 examples/static/images/mlflow_overview.png diff --git a/examples/27-MLflow-quickstart.ipynb b/examples/27-MLflow-quickstart.ipynb deleted file mode 100644 index 0b793f75b3..0000000000 --- a/examples/27-MLflow-quickstart.ipynb +++ /dev/null @@ -1,873 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "aeddb542", - "metadata": {}, - "source": [ - "# MLflow for Darts\n", - "\n", - "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", - "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", - "\n", - "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", - "\n", - "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ] - }, - { - "cell_type": "markdown", - "id": "f72894af", - "metadata": {}, - "source": [ - "## Installing MLflow\n", - "\n", - "MLflow is available as an optional dependency for Darts. Install it with:\n", - "\n", - "```bash\n", - "pip install mlflow\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "42e3dcea", - "metadata": {}, - "source": [ - "## Setup and Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "b346ce8f", - "metadata": {}, - "outputs": [], - "source": [ - "# fix python path if working locally\n", - "from utils import fix_pythonpath_if_working_locally\n", - "\n", - "fix_pythonpath_if_working_locally()\n", - "\n", - "import warnings\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "13b13fe4", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import os\n", - "import tempfile\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import mlflow\n", - "import numpy as np\n", - "\n", - "import darts.metrics\n", - "\n", - "from darts.datasets import AirPassengersDataset\n", - "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", - "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "4d424e08", - "metadata": {}, - "outputs": [], - "source": [ - "# use darts plotting style\n", - "from darts import set_option\n", - "\n", - "set_option(\"plotting.use_darts_style\", True)" - ] - }, - { - "cell_type": "markdown", - "id": "2f9c40d6", - "metadata": {}, - "source": [ - "## MLflow Setup\n", - "\n", - "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "88320df5", - "metadata": {}, - "outputs": [], - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ] - }, - { - "cell_type": "markdown", - "id": "03d5209e", - "metadata": {}, - "source": [ - "## Load Sample Data\n", - "\n", - "We'll use the classic AirPassengers dataset for this example." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "1596e07e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training series: 107 points\n", - "Validation series: 37 points\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "34858645", - "metadata": {}, - "source": [ - "## Basic Model Logging\n", - "\n", - "Let's train a simple model and log it to MLflow manually." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bc8f520d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = ExponentialSmoothing()\n", - "model.fit(train)\n", - "\n", - "predictions = model.predict(n=len(val))\n", - "\n", - "# calculate metrics you want to log to MLflow\n", - "mape_score = darts.metrics.mape(val, predictions)\n", - "rmse_score = darts.metrics.rmse(val, predictions)\n", - "\n", - "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", - "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", - "\n", - "train[-50:].plot(label=\"Training\")\n", - "val.plot(label=\"Actual\")\n", - "predictions.plot(label=\"Forecast\")\n", - "plt.legend()\n", - "plt.title(\"Exponential Smoothing Forecast\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "35dc864c", - "metadata": {}, - "source": [ - "Now let's log this model to MLflow:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "61406cd9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run ID: 936e44cf2edb4db0bc6e32aa0d9fdfd9\n", - "Model URI: models:/m-280d9919c51642dabaf49017ad97ca65\n" - ] - } - ], - "source": [ - "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", - " model_info = log_model(\n", - " model=model,\n", - " name=\"exponential-smoothing-model\",\n", - " # alternatively, use mlflow.set_tag(key, value) in the run\n", - " tags={\n", - " \"model_type\": \"ExponentialSmoothing\",\n", - " \"dataset\": \"AirPassengers\"\n", - " }\n", - " )\n", - "\n", - " # log calculated metrics you want\n", - " mlflow.log_metric(\"val_mape\", mape_score)\n", - " mlflow.log_metric(\"val_rmse\", rmse_score)\n", - "\n", - " print(f\"Run ID: {run.info.run_id}\")\n", - " print(f\"Model URI: {model_info.model_uri}\")" - ] - }, - { - "cell_type": "markdown", - "id": "0728690e", - "metadata": {}, - "source": [ - "### Load the Model Back\n", - "\n", - "We can load the model from MLflow using its URI:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "cae35ffa", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model predictions match: True\n" - ] - } - ], - "source": [ - "loaded_model = load_model(model_info.model_uri)\n", - "\n", - "loaded_predictions = loaded_model.predict(n=len(val))\n", - "\n", - "# verify predictions match\n", - "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", - "print(f\"Loaded model predictions match: {predictions_match}\")" - ] - }, - { - "cell_type": "markdown", - "id": "6bd4597c", - "metadata": {}, - "source": [ - "## Automatic Logging with `autolog()`\n", - "\n", - "`autolog()` patches every `model.fit()` call to automatically log parameters, covariate metadata, and the trained model artifact. For PyTorch-based models it also injects a callback that logs `train_loss` / `val_loss` per epoch (see the sections below for details)." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "5ef7f73a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Logged metrics: {'train_mae': 8.4783, 'train_mape': 3.9116, 'train_mse': 118.1369, 'train_rmse': 10.8691, 'val_mape': 10.742, 'val_rmse': 51.182}\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", - " auto_model = LinearRegressionModel(lags=12)\n", - " auto_model.fit(train) # no val_series → autolog logs train_* metrics by default\n", - "\n", - " auto_predictions = auto_model.predict(n=len(val))\n", - " auto_mape = darts.metrics.mape(val, auto_predictions)\n", - " auto_rmse = darts.metrics.rmse(val, auto_predictions)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show logged metrics\n", - "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", - "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", - "\n", - "# plot\n", - "fig, ax = plt.subplots(figsize=(10, 4))\n", - "train[-36:].plot(label=\"Train\", ax=ax)\n", - "val.plot(label=\"Actual\", ax=ax)\n", - "auto_predictions.plot(\n", - " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", - ")\n", - "ax.set_title(\"Linear Regression — autolog run\")\n", - "ax.legend()\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f484330f", - "metadata": {}, - "source": [ - "## Open the MLflow UI\n", - "\n", - "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", - "\n", - "The UI lets you:\n", - "- **Compare runs** side-by-side in the Experiments table\n", - "- **Inspect** individual run parameters, metrics, and logged artifacts\n", - "- **Visualize** metrics across runs with built-in charts\n", - "- **Register** models to the Model Registry for versioning" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "1a01cd2f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Launch the MLflow UI with this command in your terminal:\n", - "\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/4x/8t1xtpd11cb5xxdp87gm92jw0000gn/T/tmp3vfszfy0/mlflow.db\n", - "\n", - "Then open: http://localhost:5000\n" - ] - } - ], - "source": [ - "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", - "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", - "print(\"Then open: http://localhost:5000\")" - ] - }, - { - "attachments": { - "image-2.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "88b0d285", - "metadata": {}, - "source": [ - "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `val_mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", - ">\n", - "![image-2.png](attachment:image-2.png)" - ] - }, - { - "cell_type": "markdown", - "id": "e2b133bc", - "metadata": {}, - "source": [ - "## Per-epoch Metrics with Torch Models\n", - "\n", - "For neural models, `autolog()` by default injects a PyTorch Lightning callback that logs `train_loss` and `val_loss` at the end of every epoch.\n", - "\n", - "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d01783d1", - "metadata": {}, - "outputs": [], - "source": [ - "from torchmetrics import MeanAbsoluteError, MeanSquaredError, MetricCollection\n", - "\n", - "# inject_per_epoch_callbacks=True is the default\n", - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"nbeats-epoch-metrics\"):\n", - " nbeats = NBEATSModel(\n", - " input_chunk_length=24,\n", - " output_chunk_length=12,\n", - " n_epochs=10,\n", - " pl_trainer_kwargs={\"accelerator\": \"cpu\"},\n", - " # these are logged per epoch as train_MAE, val_MAE, train_MSE, val_MSE\n", - " torch_metrics=MetricCollection({\n", - " \"MAE\": MeanAbsoluteError(),\n", - " \"MSE\": MeanSquaredError(),\n", - " }),\n", - " random_state=42,\n", - " )\n", - " nbeats.fit(train, val_series=val)\n", - " nbeats_pred = nbeats.predict(n=len(val))\n", - " darts.metrics.mape(val, nbeats_pred))\n", - " darts.metrics.rmse(val, nbeats_pred))\n", - " print(f\"NBEATS MAPE: {mape(val, nbeats_pred):.2f}%\")\n", - "\n", - "autolog(disable=True)" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "6fcc8f13", - "metadata": {}, - "source": [ - "> 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", - ">\n", - "![image.png](attachment:image.png)" - ] - }, - { - "cell_type": "markdown", - "id": "3f0828c2", - "metadata": {}, - "source": [ - "## Training & Validation Forecast Metrics\n", - "\n", - "Beyond per-epoch loss, `autolog()` can also run a backtest after training and log evaluation metrics (MAE, RMSE, MAPE, …) on both the **training series** and the **validation series**. Enable this with `log_training_metrics=True` and `log_validation_metrics=True`. Pass `extra_metrics` to extend the default set." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "df8e85b6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All logged metrics (11):\n", - " manual_mape: 10.7420\n", - " train_mae: 8.4783\n", - " train_mape: 3.9116\n", - " train_mse: 118.1369\n", - " train_rmse: 10.8691\n", - " train_smape: 3.8915\n", - " val_mae: 12.5800\n", - " val_mape: 2.9449\n", - " val_mse: 243.0054\n", - " val_rmse: 15.5886\n", - " val_smape: 2.9130\n" - ] - } - ], - "source": [ - "autolog(\n", - " log_metrics=True,\n", - " extra_metrics=[darts.metrics.smape, darts.metrics.mae], # add smape and mae on top of the defaults\n", - ")\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", - " lr_model = LinearRegressionModel(lags=12)\n", - " # if val_series is provided, autolog will log val_* metrics based on it\n", - " lr_model.fit(train, val_series=val)\n", - " # autolog already computed and logged train_mae, val_rmse, val_smape, ...\n", - " # manually log the final hold-out MAPE as well\n", - " lr_pred = lr_model.predict(n=len(val))\n", - " mlflow.log_metric(\"manual_mape\", mape(val, lr_pred))\n", - " run_id = run.info.run_id\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show what was logged\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_metrics = client.get_run(run_id).data.metrics\n", - "metric_names = sorted(run_metrics.keys())\n", - "print(f\"All logged metrics ({len(metric_names)}):\")\n", - "for name in metric_names:\n", - " print(f\" {name}: {run_metrics[name]:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "8511fc08", - "metadata": {}, - "source": [ - "## Saving and Loading Models Locally\n", - "\n", - "You can also save and load models to/from local paths without MLflow runs." - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "645ef079", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Files in model directory:\n", - " - python_env.yaml\n", - " - requirements.txt\n", - " - MLmodel\n", - " - conda.yaml\n", - " - data\n" - ] - } - ], - "source": [ - "# Save model to local directory\n", - "local_model_path = os.path.join(tmpdir, \"my_model\")\n", - "save_model(model, path=local_model_path)\n", - "\n", - "print(\"\\nFiles in model directory:\")\n", - "for file in os.listdir(local_model_path):\n", - " print(f\" - {file}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "254ba153", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model successfully!\n", - "Predictions shape: (5, 1)\n" - ] - } - ], - "source": [ - "# Load model from local directory\n", - "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", - "\n", - "# Test it\n", - "local_predictions = local_loaded_model.predict(n=5)\n", - "print(\"Loaded model successfully!\")\n", - "print(f\"Predictions shape: {local_predictions.values().shape}\")" - ] - }, - { - "cell_type": "markdown", - "id": "aab0d1e0", - "metadata": {}, - "source": [ - "## Querying Experiments\n", - "\n", - "You can programmatically query and compare runs." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "109a9812", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 4 runs in experiment 'darts-quickstart':\n", - "\n", - "1. linear-regression-full-metrics\n", - " Run ID: 215983d797274f5c896aeac20b509e80\n", - " Validation MAPE: 2.944912539423521\n", - "\n", - "2. exponential-smoothing-baseline\n", - " Run ID: 936e44cf2edb4db0bc6e32aa0d9fdfd9\n", - " Validation MAPE: 7.864181481214469\n", - "\n", - "3. linear-regression-autolog\n", - " Run ID: 1a714494da10495485871221b816f326\n", - " Validation MAPE: 10.742044444678958\n", - "\n", - "4. nbeats-epoch-metrics\n", - " Run ID: d8206b7ef162477ab8eb12b7e950a440\n", - " Validation MAPE: 17.542747705910518\n", - "\n" - ] - } - ], - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.val_mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"val_mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" - ] - }, - { - "cell_type": "markdown", - "id": "22685423", - "metadata": {}, - "source": [ - "### Load the Best Model" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "7b09db6a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading best model from run: linear-regression-full-metrics\n", - "Model URI: runs:/215983d797274f5c896aeac20b509e80/model\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8225dcbe9d6a4297a294bb56eb3fa398", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Downloading artifacts: 0%| | 0/1 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "if runs:\n", - " best_run = runs[0]\n", - " best_model_uri = f\"runs:/{best_run.info.run_id}/model\"\n", - "\n", - " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", - " print(f\"Model URI: {best_model_uri}\")\n", - "\n", - " best_model = load_model(best_model_uri)\n", - " # series param required for loaded models, since we save with clean=True\n", - " best_predictions = best_model.predict(n=len(val), series=train)\n", - "\n", - " train[-50:].plot(label=\"Training\")\n", - " val.plot(label=\"Actual\")\n", - " best_predictions.plot(label=\"Best Model Forecast\")\n", - " plt.legend()\n", - " plt.title(\"Best Model Predictions\")\n", - " plt.show()" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "6f1ec89e", - "metadata": {}, - "source": [ - "## Model Registry\n", - "\n", - "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived).\n", - "\n", - "```python\n", - "# Register a model from a run\n", - "result = mlflow.register_model(\n", - " model_uri=f\"runs:/{best_run.info.run_id}/model\",\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")\n", - "```\n", - "\n", - "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", - "\n", - "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", - ">\n", - "![image.png](attachment:image.png)" - ] - }, - { - "cell_type": "markdown", - "id": "7af49ea9", - "metadata": {}, - "source": [ - "## Important Note: Custom Flavor\n", - "\n", - "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", - "\n", - "**Always use:**\n", - "```python\n", - "from darts.utils.mlflow import load_model\n", - "model = load_model(model_uri)\n", - "```\n", - "\n", - "**Instead of:**\n", - "```python\n", - "import mlflow\n", - "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", - "```\n", - "\n", - "This custom flavor is necessary to properly handle:\n", - "- TimeSeries objects\n", - "- Darts-specific model parameters\n", - "- Covariate handling (past, future, static)\n", - "- PyTorch model state preservation" - ] - }, - { - "cell_type": "markdown", - "id": "40621b13", - "metadata": {}, - "source": [ - "## Cleanup" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "51fc7c4a", - "metadata": {}, - "outputs": [], - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ] - }, - { - "cell_type": "markdown", - "id": "ca40afc1", - "metadata": {}, - "source": [ - "# Final Remarks" - ] - }, - { - "cell_type": "markdown", - "id": "c4c86a23", - "metadata": {}, - "source": [ - "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb new file mode 100644 index 0000000000..fff71cb24a --- /dev/null +++ b/examples/29-MLflow-quickstart.ipynb @@ -0,0 +1,5959 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "aeddb542", + "metadata": {}, + "source": [ + "# MLflow for Darts\n", + "\n", + "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", + "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", + "\n", + "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", + "\n", + "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." + ] + }, + { + "cell_type": "markdown", + "id": "f72894af", + "metadata": {}, + "source": [ + "## Installing MLflow\n", + "\n", + "MLflow is available as an optional dependency for Darts. Install it with:\n", + "\n", + "```bash\n", + "pip install mlflow\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "42e3dcea", + "metadata": {}, + "source": [ + "## Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b346ce8f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.049165Z", + "iopub.status.busy": "2026-06-24T15:18:43.049088Z", + "iopub.status.idle": "2026-06-24T15:18:43.053693Z", + "shell.execute_reply": "2026-06-24T15:18:43.053435Z" + } + }, + "outputs": [], + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "13b13fe4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.054776Z", + "iopub.status.busy": "2026-06-24T15:18:43.054722Z", + "iopub.status.idle": "2026-06-24T15:18:46.599643Z", + "shell.execute_reply": "2026-06-24T15:18:46.599208Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import mlflow\n", + "import numpy as np\n", + "\n", + "import darts.metrics\n", + "from darts.datasets import AirPassengersDataset\n", + "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", + "from darts.utils.mlflow import autolog, load_model, log_model, save_model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4d424e08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.600906Z", + "iopub.status.busy": "2026-06-24T15:18:46.600748Z", + "iopub.status.idle": "2026-06-24T15:18:46.634540Z", + "shell.execute_reply": "2026-06-24T15:18:46.634100Z" + } + }, + "outputs": [], + "source": [ + "# use darts plotting style\n", + "from darts import set_option\n", + "\n", + "set_option(\"plotting.use_darts_style\", True)" + ] + }, + { + "cell_type": "markdown", + "id": "2f9c40d6", + "metadata": {}, + "source": [ + "## MLflow Setup\n", + "\n", + "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "88320df5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.636640Z", + "iopub.status.busy": "2026-06-24T15:18:46.636565Z", + "iopub.status.idle": "2026-06-24T15:18:47.268439Z", + "shell.execute_reply": "2026-06-24T15:18:47.268081Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/06/24 17:34:20 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", + "2026/06/24 17:34:20 INFO mlflow.store.db.utils: Updating database tables\n", + "2026/06/24 17:34:20 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpyqkqfzoe/mlflow.db\n", + "Experiment: darts-quickstart\n" + ] + } + ], + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ] + }, + { + "cell_type": "markdown", + "id": "03d5209e", + "metadata": {}, + "source": [ + "## Load Sample Data\n", + "\n", + "We'll use the classic AirPassengers dataset for this example." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1596e07e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.269628Z", + "iopub.status.busy": "2026-06-24T15:18:47.269548Z", + "iopub.status.idle": "2026-06-24T15:18:47.356588Z", + "shell.execute_reply": "2026-06-24T15:18:47.356201Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Failed to find font weight 600, now using 700.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training series: 107 points\n", + "Validation series: 37 points\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "34858645", + "metadata": {}, + "source": [ + "## Basic Model Logging\n", + "\n", + "Let's train a simple model and log it to MLflow manually." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bc8f520d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.357581Z", + "iopub.status.busy": "2026-06-24T15:18:47.357516Z", + "iopub.status.idle": "2026-06-24T15:18:47.450374Z", + "shell.execute_reply": "2026-06-24T15:18:47.449925Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = ExponentialSmoothing()\n", + "model.fit(train)\n", + "\n", + "predictions = model.predict(n=len(val))\n", + "\n", + "# calculate metrics you want to log to MLflow\n", + "mape_score = darts.metrics.mape(val, predictions)\n", + "rmse_score = darts.metrics.rmse(val, predictions)\n", + "\n", + "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", + "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", + "\n", + "train[-50:].plot(label=\"Training\")\n", + "val.plot(label=\"Actual\")\n", + "predictions.plot(label=\"Forecast\")\n", + "plt.legend()\n", + "plt.title(\"Exponential Smoothing Forecast\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "35dc864c", + "metadata": {}, + "source": [ + "Now let's log this model to MLflow:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "61406cd9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.451366Z", + "iopub.status.busy": "2026-06-24T15:18:47.451297Z", + "iopub.status.idle": "2026-06-24T15:18:47.906785Z", + "shell.execute_reply": "2026-06-24T15:18:47.906380Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/06/24 17:34:21 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run ID: 3d1f7f864f7240599e3b080109e246bf\n", + "Model URI: models:/m-f42705a59eb34300b377f0219577bfa4\n" + ] + } + ], + "source": [ + "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", + " model_info = log_model(\n", + " model=model,\n", + " name=\"exponential-smoothing-model\",\n", + " # alternatively, use mlflow.set_tag(key, value) in the run\n", + " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", + " )\n", + "\n", + " # log calculated metrics you want\n", + " mlflow.log_metric(\"val_mape\", mape_score)\n", + " mlflow.log_metric(\"val_rmse\", rmse_score)\n", + "\n", + " print(f\"Run ID: {run.info.run_id}\")\n", + " print(f\"Model URI: {model_info.model_uri}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0728690e", + "metadata": {}, + "source": [ + "### Load the Model Back\n", + "\n", + "We can load the model from MLflow using its URI:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cae35ffa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.907880Z", + "iopub.status.busy": "2026-06-24T15:18:47.907802Z", + "iopub.status.idle": "2026-06-24T15:18:47.914695Z", + "shell.execute_reply": "2026-06-24T15:18:47.914326Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model predictions match: True\n" + ] + } + ], + "source": [ + "loaded_model = load_model(model_info.model_uri)\n", + "\n", + "loaded_predictions = loaded_model.predict(n=len(val))\n", + "\n", + "# verify predictions match\n", + "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", + "print(f\"Loaded model predictions match: {predictions_match}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6bd4597c", + "metadata": {}, + "source": [ + "## Automatic Logging with `autolog()`\n", + "\n", + "`autolog()` patches every `model.fit()` call to automatically log parameters, covariate metadata, and the trained model artifact. It also patches the darts metric functions so any metric called inside an active run is logged. For PyTorch-based models it enables MLflow's PyTorch autologging to record `train_loss` / `val_loss` per epoch (see the sections below for details)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5ef7f73a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.915629Z", + "iopub.status.busy": "2026-06-24T15:18:47.915566Z", + "iopub.status.idle": "2026-06-24T15:18:50.020337Z", + "shell.execute_reply": "2026-06-24T15:18:50.019951Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/06/24 17:34:24 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n", + "2026/06/24 17:34:24 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Logged metrics: {'val_mape': 10.742, 'val_rmse': 51.182}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "autolog()\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", + " auto_model = LinearRegressionModel(lags=12)\n", + " auto_model.fit(train) # autolog logs params, covariate metadata, and the model\n", + "\n", + " auto_predictions = auto_model.predict(n=len(val))\n", + " # these metric calls happen inside the run, so they are logged automatically\n", + " auto_mape = darts.metrics.mape(val, auto_predictions)\n", + " auto_rmse = darts.metrics.rmse(val, auto_predictions)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show logged metrics\n", + "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", + "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", + "\n", + "# plot\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "train[-36:].plot(label=\"Train\", ax=ax)\n", + "val.plot(label=\"Actual\", ax=ax)\n", + "auto_predictions.plot(\n", + " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", + ")\n", + "ax.set_title(\"Linear Regression — autolog run\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f484330f", + "metadata": {}, + "source": [ + "## Open the MLflow UI\n", + "\n", + "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", + "\n", + "The UI lets you:\n", + "- **Compare runs** side-by-side in the Experiments table\n", + "- **Inspect** individual run parameters, metrics, and logged artifacts\n", + "- **Visualize** metrics across runs with built-in charts\n", + "- **Register** models to the Model Registry for versioning" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1a01cd2f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:50.021527Z", + "iopub.status.busy": "2026-06-24T15:18:50.021439Z", + "iopub.status.idle": "2026-06-24T15:18:50.023116Z", + "shell.execute_reply": "2026-06-24T15:18:50.022824Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Launch the MLflow UI with this command in your terminal:\n", + "\n", + " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpyqkqfzoe/mlflow.db\n", + "\n", + "Then open: http://localhost:5000\n" + ] + } + ], + "source": [ + "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", + "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", + "print(\"Then open: http://localhost:5000\")" + ] + }, + { + "cell_type": "markdown", + "id": "88b0d285", + "metadata": {}, + "source": [ + "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `val_mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", + ">\n", + "![Mlflow Overview](./static/images/mlflow_overview.png)" + ] + }, + { + "cell_type": "markdown", + "id": "e2b133bc", + "metadata": {}, + "source": [ + "## Per-epoch Metrics with Torch Models\n", + "\n", + "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", + "\n", + "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d01783d1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:50.024161Z", + "iopub.status.busy": "2026-06-24T15:18:50.024087Z", + "iopub.status.idle": "2026-06-24T15:18:53.370946Z", + "shell.execute_reply": "2026-06-24T15:18:53.370531Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: GPU available: True (mps), used: False\n", + "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", + "INFO: TPU available: False, using: 0 TPU cores\n", + "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", + "INFO: HPU available: False, using: 0 HPUs\n", + "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params | Mode \n", + "-------------------------------------------------------------\n", + "0 | criterion | MSELoss | 0 | train\n", + "1 | train_criterion | MSELoss | 0 | train\n", + "2 | val_criterion | MSELoss | 0 | train\n", + "3 | train_metrics | MetricCollection | 0 | train\n", + "4 | val_metrics | MetricCollection | 0 | train\n", + "5 | stacks | ModuleList | 6.2 M | train\n", + "-------------------------------------------------------------\n", + "6.2 M Trainable params\n", + "1.4 K Non-trainable params\n", + "6.2 M Total params\n", + "24.787 Total estimated model params size (MB)\n", + "400 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b08a95d734ed47b892fbee0631114072", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_charts.png)" + ] + }, + { + "cell_type": "markdown", + "id": "3f0828c2", + "metadata": {}, + "source": [ + "## Forecast Metrics\n", + "\n", + "With `log_metrics=True` (the default), `autolog()` patches every darts metric function. Any metric you call **inside an active run** is logged automatically with no extra arguments needed.\n", + "\n", + "The metric key is derived from the result: a scalar is logged under `{metric}`, and when the variable name of the actual series can be detected it is prefixed (e.g. calling `darts.metrics.mae(val, pred)` logs `val_mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "df8e85b6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.372445Z", + "iopub.status.busy": "2026-06-24T15:18:53.372367Z", + "iopub.status.idle": "2026-06-24T15:18:53.470125Z", + "shell.execute_reply": "2026-06-24T15:18:53.469722Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/06/24 17:34:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n", + "2026/06/24 17:34:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All logged metrics (5):\n", + " manual_mape: 10.7420\n", + " val_mae: 46.0220\n", + " val_mape: 10.7420\n", + " val_rmse: 51.1820\n", + " val_smape: 10.1015\n" + ] + } + ], + "source": [ + "# log_metrics=True (the default) patches every darts metric so that calls made\n", + "# inside an active run are logged automatically\n", + "autolog(log_metrics=True)\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", + " lr_model = LinearRegressionModel(lags=12)\n", + " lr_model.fit(train)\n", + " lr_pred = lr_model.predict(n=len(val))\n", + "\n", + " # each metric called here is auto-logged; the key is prefixed with the\n", + " # variable name of the first argument (here \"val\"): val_mae, val_rmse, val_smape\n", + " darts.metrics.mae(val, lr_pred)\n", + " darts.metrics.rmse(val, lr_pred)\n", + " darts.metrics.smape(val, lr_pred)\n", + " # you can still log a custom-named metric explicitly\n", + " mlflow.log_metric(\"manual_mape\", darts.metrics.mape(val, lr_pred))\n", + " run_id = run.info.run_id\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show what was logged\n", + "client = mlflow.tracking.MlflowClient()\n", + "run_metrics = client.get_run(run_id).data.metrics\n", + "metric_names = sorted(run_metrics.keys())\n", + "print(f\"All logged metrics ({len(metric_names)}):\")\n", + "for name in metric_names:\n", + " print(f\" {name}: {run_metrics[name]:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8511fc08", + "metadata": {}, + "source": [ + "## Saving and Loading Models Locally\n", + "\n", + "You can also save and load models to/from local paths without MLflow runs." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "645ef079", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.471252Z", + "iopub.status.busy": "2026-06-24T15:18:53.471178Z", + "iopub.status.idle": "2026-06-24T15:18:53.478682Z", + "shell.execute_reply": "2026-06-24T15:18:53.478330Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/06/24 17:34:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Files in model directory:\n", + " - python_env.yaml\n", + " - requirements.txt\n", + " - MLmodel\n", + " - model.pkl\n", + " - conda.yaml\n" + ] + } + ], + "source": [ + "# Save model to local directory\n", + "local_model_path = os.path.join(tmpdir, \"my_model\")\n", + "save_model(model, path=local_model_path)\n", + "\n", + "print(\"\\nFiles in model directory:\")\n", + "for file in os.listdir(local_model_path):\n", + " print(f\" - {file}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "254ba153", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.479679Z", + "iopub.status.busy": "2026-06-24T15:18:53.479604Z", + "iopub.status.idle": "2026-06-24T15:18:53.484973Z", + "shell.execute_reply": "2026-06-24T15:18:53.484638Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model successfully!\n", + "Predictions shape: (5, 1)\n" + ] + } + ], + "source": [ + "# Load model from local directory\n", + "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", + "\n", + "# Test it\n", + "local_predictions = local_loaded_model.predict(n=5)\n", + "print(\"Loaded model successfully!\")\n", + "print(f\"Predictions shape: {local_predictions.values().shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "aab0d1e0", + "metadata": {}, + "source": [ + "## Querying Experiments\n", + "\n", + "You can programmatically query and compare runs." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "109a9812", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.485914Z", + "iopub.status.busy": "2026-06-24T15:18:53.485859Z", + "iopub.status.idle": "2026-06-24T15:18:53.496380Z", + "shell.execute_reply": "2026-06-24T15:18:53.496048Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 4 runs in experiment 'darts-quickstart':\n", + "\n", + "1. exponential-smoothing-baseline\n", + " Run ID: 3d1f7f864f7240599e3b080109e246bf\n", + " Validation MAPE: 7.864181481214469\n", + "\n", + "2. linear-regression-full-metrics\n", + " Run ID: c655521973ca47b69ad3d423e5302759\n", + " Validation MAPE: 10.742044444678953\n", + "\n", + "3. linear-regression-autolog\n", + " Run ID: e4e4ae8b46004a5b8309337d5d58cbd2\n", + " Validation MAPE: 10.742044444678953\n", + "\n", + "4. nbeats-epoch-metrics\n", + " Run ID: d5a971cffab244e192839ae3ba1652e5\n", + " Validation MAPE: 13.639569217869525\n", + "\n" + ] + } + ], + "source": [ + "from mlflow.tracking import MlflowClient\n", + "\n", + "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", + "\n", + "# get all runs\n", + "client = MlflowClient()\n", + "runs = client.search_runs(\n", + " experiment_ids=[experiment.experiment_id],\n", + " order_by=[\"metrics.val_mape ASC\"], # Sort by best MAPE\n", + ")\n", + "\n", + "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", + "for i, run in enumerate(runs, 1):\n", + " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", + " mape_val = run.data.metrics.get(\"val_mape\", \"N/A\")\n", + " print(f\"{i}. {run_name}\")\n", + " print(f\" Run ID: {run.info.run_id}\")\n", + " print(f\" Validation MAPE: {mape_val}\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "22685423", + "metadata": {}, + "source": [ + "### Load the Best Model" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7b09db6a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.497560Z", + "iopub.status.busy": "2026-06-24T15:18:53.497496Z", + "iopub.status.idle": "2026-06-24T15:18:53.572540Z", + "shell.execute_reply": "2026-06-24T15:18:53.572133Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading best model from run: exponential-smoothing-baseline\n", + "Model URI: models:/m-f42705a59eb34300b377f0219577bfa4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", + "\n", + "if runs:\n", + " best_run = runs[0]\n", + " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", + " # from the run outputs and load it with a models:/ URI\n", + " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", + " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", + "\n", + " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", + " print(f\"Model URI: {best_model_uri}\")\n", + "\n", + " best_model = load_model(best_model_uri)\n", + " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", + " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", + " if isinstance(best_model, GlobalForecastingModel):\n", + " best_predictions = best_model.predict(n=len(val), series=train)\n", + " else:\n", + " best_predictions = best_model.predict(n=len(val))\n", + "\n", + " train[-50:].plot(label=\"Training\")\n", + " val.plot(label=\"Actual\")\n", + " best_predictions.plot(label=\"Best Model Forecast\")\n", + " plt.legend()\n", + " plt.title(\"Best Model Predictions\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6f1ec89e", + "metadata": {}, + "source": [ + "## Model Registry\n", + "\n", + "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived).\n", + "\n", + "```python\n", + "# Register a model from a run\n", + "result = mlflow.register_model(\n", + " model_uri=f\"runs:/{best_run.info.run_id}/model\",\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")\n", + "```\n", + "\n", + "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", + "\n", + "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_models.png)" + ] + }, + { + "cell_type": "markdown", + "id": "7af49ea9", + "metadata": {}, + "source": [ + "## Important Note: Custom Flavor\n", + "\n", + "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", + "\n", + "**Always use:**\n", + "```python\n", + "from darts.utils.mlflow import load_model\n", + "model = load_model(model_uri)\n", + "```\n", + "\n", + "**Instead of:**\n", + "```python\n", + "import mlflow\n", + "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", + "```\n", + "\n", + "This custom flavor is necessary to properly handle:\n", + "- TimeSeries objects\n", + "- Darts-specific model parameters\n", + "- Covariate handling (past, future, static)\n", + "- PyTorch model state preservation" + ] + }, + { + "cell_type": "markdown", + "id": "40621b13", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "51fc7c4a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.573724Z", + "iopub.status.busy": "2026-06-24T15:18:53.573637Z", + "iopub.status.idle": "2026-06-24T15:18:53.575115Z", + "shell.execute_reply": "2026-06-24T15:18:53.574817Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpyqkqfzoe\n" + ] + } + ], + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ca40afc1", + "metadata": {}, + "source": [ + "# Final Remarks" + ] + }, + { + "cell_type": "markdown", + "id": "c4c86a23", + "metadata": {}, + "source": [ + "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.11.9)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01ac1053789e45fab75e2cde894b417a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02cefe41f8814ddf9de26418b26783c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "03569ea4478d4d74b0ae4c5416c40d6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "055bae1119db45caa5b6cd91921c76d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", + "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", + "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" + ], + "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", + "tabbable": null, + "tooltip": null + } + }, + "05d25d3b3bd9497f86849702e5a19515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "071709416bab4673a582978e2e3592a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e8c0b16c2d430ea8bb6798e9b4f103": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", + "placeholder": "​", + "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "0deaf695a8544725ac4904ff7388f489": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "11dbeaae3ae640c3995e784abfda15c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", + "placeholder": "​", + "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "12524abe09304f9bb20bd9978ac2a44d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", + "placeholder": "​", + "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 189.90it/s]" + } + }, + "13af542c17d64851a3ef54ce9610bb99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "153af823c040405dbc075bf50a28ff17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "16656416b10a43c8b81c6c4b2a02ec0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "16ce59abc5bb4ffe978736017f60e21a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", + "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", + "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" + ], + "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", + "tabbable": null, + "tooltip": null + } + }, + "19382158e51343918122512753ca25c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "20cca542fe2a4e19846e2e1cb07dd165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "252a64f9c6d440e2a3d3c3f62f44d764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", + "placeholder": "​", + "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", + "tabbable": null, + "tooltip": null, + "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" + } + }, + "27e25633e2a549dcbfafe1129839043d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b154733d72e4e468c339683e83c30a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b197d3911154085bb86f0dbba2c8b98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c4ee939558d44a4a3bc9040a940693f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", + "placeholder": "​", + "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 199.01it/s]" + } + }, + "2e727ab68ed64ee98bfb9d81f1e39c1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", + "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", + "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" + ], + "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", + "tabbable": null, + "tooltip": null + } + }, + "2ec00b06939145ec95930e3c1490efcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", + "placeholder": "​", + "style": "IPY_MODEL_19382158e51343918122512753ca25c7", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "30a18f8c59754940a9785cd152a67daa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "32e9a01e1a2b4914989eda6f6832f989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "331f7f90d7d049a6adc72c260c06570e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "33a28231831d473aa27d32e1c15a8989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35778f5ef201497d8d453772f80a7978": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "366e2af2827540728d29bfa6d931dbdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", + "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", + "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" + ], + "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", + "tabbable": null, + "tooltip": null + } + }, + "3799be676aea4d12b87992115e4b90ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a36a442c4a94ab585d8522e57f45c34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3b44dec6a3354f7ebc4117e7d7f50b1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", + "placeholder": "​", + "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "3c3d34b732664135a79031e8bc9e2984": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3cde338fcaf548de8e8216a98e66f9bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", + "placeholder": "​", + "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 195.74it/s]" + } + }, + "3dddd89019c849f0872e9a9700e14ad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", + "placeholder": "​", + "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", + "tabbable": null, + "tooltip": null, + "value": "Predicting DataLoader 0: 100%" + } + }, + "40b8f5c6c7844bd0bb071f043f97a639": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "40df96a9f08440a893ffe9d57d176e1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41e23a2458044b888fb76fd882428b39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "42360fe280a14e44831c8e62f6ad249e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "425a21a3b7604c8cb49871c1b2850f68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4297b4158e4f43da9226bfc00272f9c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "43eab5ba00014d7ba62f97acd9e93eba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44c3cc7783594142a19ffad035eea9d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "4787d389023845a8ae398eb5d1155ab1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "480afa5d41c145d0ac88e2adaca7b1e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", + "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", + "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" + ], + "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", + "tabbable": null, + "tooltip": null + } + }, + "4b3f0ca06bf54eb9bab4e081dabcf139": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f10caf0abca4aa59053c4cb374ea3d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "50e4f1e4cd994abeae53d0f84b6afd44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "522af0834c254f0eb2fe7c9efa74c5f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "54aad655289741b59d3c83b8508e68b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", + "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", + "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" + ], + "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", + "tabbable": null, + "tooltip": null + } + }, + "55e102413ba54377b2fd1995b98c7858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "579cbbe7cfb34e429bffd11ec774ba50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "57cd2f911c6840da87c1d6c8a78521e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "57db1d3f28d347878d9f48d0ceef5589": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", + "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", + "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" + ], + "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", + "tabbable": null, + "tooltip": null + } + }, + "580c0814097844e186ef642094968d3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "590ebae9a3664214be16b105941c7ee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59413112366944be8e0d6600880dc1a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dcf47d8b9c0420898fe491a81bab8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", + "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", + "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" + ], + "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", + "tabbable": null, + "tooltip": null + } + }, + "61734f2b95c34e13971fd65cd7da2e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "641b5ae5b9e7475db63a31e67b13b601": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "642a06d187834b96af41b74a25d13e1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6da83aee80314ceb9ace5fa0c4c76529": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9e33a121da334db899669d702f9d54ce", + "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", + "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" + ], + "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", + "tabbable": null, + "tooltip": null + } + }, + "6dad7db23e9e4397bfb93655cd8b08b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e794979a2793408791ee570d3af6f371", + "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", + "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" + ], + "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", + "tabbable": null, + "tooltip": null + } + }, + "6eb691aae3a44a25b1e7471929151f47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71c1aa3663804753bf3a75a227412072": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72125343cca3416fbd3f012232e63ae5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "761dbbe1bf4e4804a3649858898b78e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7adbf399ea5e4a7c990cdff60674b593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", + "max": 3, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", + "tabbable": null, + "tooltip": null, + "value": 3 + } + }, + "7d599e5710f4485a8f7580c7efca3bc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e0ad83f116b4933a35870525656df5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "81e281800a094e34b2e43021bea6fd11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", + "placeholder": "​", + "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 174.77it/s]" + } + }, + "859b368a8a6d4500960a6e2285f4c016": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86bfcc40b08440af98f64a732df1ea5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8766872fa61844458d70112fcf44bdb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8825c219393f4040890a639a17210bc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "89dc0773756b4b7b93cce8e6cfe47202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", + "placeholder": "​", + "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 100.83it/s]" + } + }, + "8d829381b5034ed9807b86d514b1fdbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "8e6984bd5a00425bb9071deba84f4cea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8f2ac8fd36964f11bd556782c96b0f72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "924315df026a41fb97d7cc8488bb8503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95daeef1bd3e4f77b883d3d71fcd1fac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", + "placeholder": "​", + "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", + "tabbable": null, + "tooltip": null, + "value": "Sanity Checking DataLoader 0: 100%" + } + }, + "97b2d3e5a7e847739b237fc9c5cdc3a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9914744ed44845fd9d00727c7da93d32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "9a20b5d724584e289863cf63a4c13259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b1dd53c1fdd45dabf3660e9e0be1310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", + "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", + "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" + ], + "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", + "tabbable": null, + "tooltip": null + } + }, + "9b8b6898ef244336989227f5469a2d11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b933a5d5aa14741904151b4ea7e3f50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", + "placeholder": "​", + "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 88.28it/s]" + } + }, + "9e33a121da334db899669d702f9d54ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", + "placeholder": "​", + "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", + "tabbable": null, + "tooltip": null, + "value": "Epoch 9: 100%" + } + }, + "9fd5c0e984d04e4aa0e106ec89434720": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "a30948d8cfd6491484d6b63591b65a84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a5f3118f4f9040ebbdb1a7acae012087": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1dc954934944e92914a1c129d8c7dcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b23efdc3bb5747af96dd5e539a14b5c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", + "placeholder": "​", + "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "b35ce184b43b48daaa39ccef748eeac6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "b4d7ddbd507e4e1681cc0888680abb5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b4e804d6e4b44314a8847c2f5be857d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b6625b52007b4434a7804cfd824452cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", + "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", + "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" + ], + "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", + "tabbable": null, + "tooltip": null + } + }, + "b676b1571a00427587827caac8158c14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "be1dd700617141cf9517ee7ef1153746": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c198ffce01de4b7294649c1619b5b7e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c255e442c01446699af3179f14eb8fc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", + "placeholder": "​", + "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "c2906f9d5f47471ca6bf44d8754f8d30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c325a187e8a54e639300ff5a29640f03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c60add7b277344feaad65a884c7fbf37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c7c373a0b1c14b809041651ffcdd4559": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c99d9a52749b40628b8d148c64e75e88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb3cebaf14cc445a8055d1aac2f0d05c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", + "placeholder": "​", + "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 180.77it/s]" + } + }, + "cc7d97d8845d46ff9d946020b1b8e4cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "cd4d74958b704246a2cb2462a784d502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce45f3190357423a9563bfae253f2f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce49dfd502074696aefcfa2cff18e4f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce97bb2d961e4dc9bf44a646cb3d3aff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d04931a3bb0c47329cdd67701a7be0ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", + "placeholder": "​", + "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 192.16it/s]" + } + }, + "d473da3081af4d4a810014019cd40b29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", + "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", + "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" + ], + "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", + "tabbable": null, + "tooltip": null + } + }, + "d4b49fabdd4543959d64e4e1c60dc360": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "d9fc58b33d2645488a8c53af72f21e7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "da4c6178632b4cfe96d2a9504cc3173b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc6cccb142db43b7ac9849983a154a20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dcb0a4350297443aa61691406923fb81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcced12e0ae04e32a811f60680db24f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", + "placeholder": "​", + "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "e09f041d857346029cbba27fb36f009e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e12d00f1e1b94e749f22904d3cec2445": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", + "placeholder": "​", + "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 186.36it/s]" + } + }, + "e19ea3de3e554c50a7300a7214c773f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e53d8d156b1c4db6aff2ba8395bf5415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e6dfb5d14dfe4a1193e551f414ea393e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7198635809b4f56bd1a30b6cbe661cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e742e68a86474f0db17ccb64db4264c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e794979a2793408791ee570d3af6f371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", + "placeholder": "​", + "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "ed4968eb8435434db1604e34ee657413": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eeb45b37592a4a599da1857d3444382e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", + "placeholder": "​", + "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f03f6404137144b8b600f8131c78ac63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f286ebc675c549678f70419f668a7baa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f299c926a6a64a769d3db2e71725f8af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f60411b259344a9e9a892d9552ecdabf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f609670bc6b840ed9f8698af8c7615a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f69737793cc648bd9aadfc0dd4b16569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", + "placeholder": "​", + "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f6f12cd135674388b0fc72167a0308eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fb53a4348865461783df6d1e5b16386b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", + "placeholder": "​", + "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.28it/s]" + } + }, + "fb7ccdb37f844e989de3f7a0b12b8924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fe3a78bc7ec842b08aac1b4e0fe1ed29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", + "placeholder": "​", + "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.93it/s]" + } + }, + "fe40606eebe6464db0b7f86e5abe1997": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", + "placeholder": "​", + "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 177.56it/s]" + } + }, + "fffac86b0934453d88f52df4b9ac6dd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/static/images/mlflow_charts.png b/examples/static/images/mlflow_charts.png new file mode 100644 index 0000000000000000000000000000000000000000..cdf6da63563dae8fa55cbdf11538a36117557f86 GIT binary patch literal 357183 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 z

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 z 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�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≶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%0A`rh5fZ%X) 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 B*b)E$ literal 0 HcmV?d00001 diff --git a/examples/static/images/mlflow_overview.png b/examples/static/images/mlflow_overview.png new file mode 100644 index 0000000000000000000000000000000000000000..2d923379e249c34de6eeadab80264c789609d338 GIT binary patch literal 332549 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

@Z_W6B?Q>to=c{V6>yc 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

U2q)qg?;wnx8kJ~4wx&zOWiDuxz^Gb#3x}-Xi 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 EAGvpN^8f$< literal 0 HcmV?d00001 From 6dda789b16eb77c40c1e07ce657625fc9c33f253 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 24 Jun 2026 18:06:49 +0200 Subject: [PATCH 075/154] fix: add MLFLOW_AVAILABLE flag --- darts/tests/conftest.py | 1 + 1 file changed, 1 insertion(+) diff --git a/darts/tests/conftest.py b/darts/tests/conftest.py index 85e0b9c855..9ee525501c 100644 --- a/darts/tests/conftest.py +++ b/darts/tests/conftest.py @@ -36,6 +36,7 @@ def _package_available(*names: str) -> bool: PLOTLY_AVAILABLE = _package_available("plotly") IPYTHON_AVAILABLE = _package_available("IPython") TIREX_AVAILABLE = _package_available("tirex") +MLFLOW_AVAILABLE = _package_available("mlflow") tfm_kwargs: dict[str, Any] = { "pl_trainer_kwargs": { From c3f1df63bf43752f341532d813c61c4a89889ddc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 10:20:52 +0200 Subject: [PATCH 076/154] feat: align direct metric logging shape to backtesting (based on metric kwargs) --- darts/utils/mlflow.py | 214 ++++++++++++++++++++++++++++-------------- 1 file changed, 141 insertions(+), 73 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 6a844513ba..98fce464fa 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1110,30 +1110,37 @@ def _log_metric_result( run_id: str, metric_name: str, result, + series, + has_time_axis: bool, + has_comp_axis: bool, + quantiles_num: int | None, + quantiles_labels: list[str], dataset_name: str | None = None, - component_names: list[str] | None = None, - input_is_list: bool = False, + series_reduced: bool = False, ) -> None: """Log a metric result to the active MLflow run. - Handles Python scalars, numpy scalars, 1-D arrays, and 2-D arrays. + Reshapes each per-series result into a canonical ``(T, C)`` layout + (timesteps, components × quantiles/intervals/labels) inferred from the + metric signature and call kwargs by ``_infer_metric_axes``, logging every + cell under a descriptive key with the time axis mapped to the MLflow + ``step``. This mirrors ``_log_backtest_metrics`` (without the + window/``forecast_horizon`` split, since ``multi_ts_support`` returns a + clean per-series list). The logged MLflow key follows the pattern:: - {metric_name}_{dataset_name}_{component}_{series_index} + {dataset_name}_{metric_name}{component}{quantile_or_label}{series_suffix} - Specifically: + where each optional part is included only when the corresponding axis is + present: - * **Scalar** (0-d) → ``{metric}_{dataset}`` - * **1-D, single TimeSeries input** (per-component) → - ``{metric}_{dataset}_{component_name_or_idx}`` - * **1-D, list input** (per-series, component already reduced) → - ``{metric}_{dataset}_{series_idx}`` - * **2-D, list input** (per-series × per-component) → - ``{metric}_{dataset}_{component_name_or_idx}_{series_idx}`` + * ``component`` – ``_{component_name}`` when ``has_comp_axis``. + * ``quantile_or_label`` – e.g. ``_q0.5`` / ``_qi0.1_0.9`` / ``_label1``. + * ``series_suffix`` – ``_s{series_index}`` when more than one series. - All optional parts are omitted when not available (e.g. no dataset name - when the variable name could not be inspected). + On a shape/size mismatch it warns and returns (does not raise), keeping + autologging non-fatal. Parameters ---------- @@ -1141,80 +1148,129 @@ def _log_metric_result( Base metric name used as the MLflow key. result The metric result to log. + series + The ``actual_series`` argument passed to the metric (single series or + ``Sequence[TimeSeries]``); used for component names, series count, and + runtime label inference. + has_time_axis + ``True`` when the result carries a per-timestep axis (``time_reduction=None``). + has_comp_axis + ``True`` when components are expanded (``component_reduction=None``). + quantiles_num + Number of quantile/interval/label entries; ``None`` when it cannot be + determined ahead of time (``label_reduction=None`` without explicit + ``labels``), in which case labels are inferred from ``series`` at runtime. + quantiles_labels + One key suffix per ``quantiles_num`` entry (empty list when ``quantiles_num`` + is ``None``). dataset_name Sanitized variable name of ``actual_series`` in the caller's frame. Omitted from key when ``None``. - component_names - Component name strings to use as the component part of the key. - For single-series input these come from ``series.components``; for - list input they come from the first series in the list. - Falls back to integer indices when ``None`` or length mismatches. - input_is_list - ``True`` when ``actual_series`` was a ``Sequence[TimeSeries]``. Drives - whether the first result axis is treated as *series* or *components*. + series_reduced + ``True`` when ``series_reduction`` collapsed the series axis inside the + metric, so the result has no leading series axis even for list input. """ - result_arr = np.asarray(result) - base_key = f"{dataset_name}_{metric_name}" if dataset_name else metric_name - def _comp_suffix(idx: int) -> str: - if component_names is not None and idx < len(component_names): - return _sanitize_mlflow_key(component_names[idx]) - return str(idx) + if series_reduced: + # series_reduction aggregated across series → single result, no series axis + series_seq = [get_single_series(series)] + results = [result] + else: + series_seq = series2seq(series) + results = ( + [result] if get_series_seq_type(series) == SeriesType.SINGLE else result + ) - metrics = {} + labels_unknown = quantiles_num is None - if result_arr.ndim == 0: - # scalar result - metrics[base_key] = float(result_arr) + metrics_by_step: dict[int, dict[str, float]] = {} + for series_index, (s, r) in enumerate(zip(series_seq, results)): + series_suffix = f"_s{series_index}" if len(series_seq) > 1 else "" - elif result_arr.ndim == 1: - if not input_is_list: - # single series: log per-component - for c_i, val in enumerate(result_arr): - metrics[f"{base_key}_{_comp_suffix(c_i)}"] = float(val) - else: - # list input, components already reduced: log per-series - for s_i, val in enumerate(result_arr): - metrics[f"{base_key}_{s_i}"] = float(val) - - elif result_arr.ndim == 2: - # list input: log per-series and per-component - n_series, n_components = result_arr.shape - for s_i in range(n_series): - for c_i in range(n_components): - metrics[f"{base_key}_{_comp_suffix(c_i)}_{s_i}"] = float( - result_arr[s_i, c_i] - ) + # quantiles_num=None means label_reduction=None was requested without explicit labels + # so class labels are inferred per-series inside the loop. + if labels_unknown: + inferred_labels = np.unique(s.values()) + quantiles_num = len(inferred_labels) + quantiles_labels = [f"_label{x:g}" for x in inferred_labels] - else: - # unexpected shape — flatten with integer indices - for i, val in enumerate(result_arr.flatten()): - metrics[f"{base_key}_{i}"] = float(val) + comps = s.components.tolist() + # c_size = components × quantiles/intervals/labels per component + c_size = (s.n_components if has_comp_axis else 1) * quantiles_num + arr = np.asarray(r, dtype=float) + # after stripping the C axis, the remainder is the time axis (or scalar) + rest, extra = divmod(arr.size, c_size) + if extra: + logger.warning( + "Metric logging skipped for `%s`: result size (%d) is not " + "divisible by the inferred component/quantile size (%d). " + "The metric output shape does not match the inferred axes.", + metric_name, + arr.size, + c_size, + ) + return - autologging_client.log_metrics(run_id=run_id, metrics=metrics) - operation = autologging_client.flush(synchronous=False) - operation.await_completion() + if has_time_axis: + t_size = rest + elif rest != 1: + logger.warning( + "Metric logging skipped for `%s`: expected a single value per " + "component/quantile after reduction, but got %d elements. " + "Check time_reduction and component_reduction.", + metric_name, + rest, + ) + return + else: + t_size = 1 + + canonical = arr.reshape(t_size, c_size) + for c in range(c_size): + # c is a flat index into the (n_components × quantiles_num) C axis: + # c = comp_i * quantiles_num + q_i + component_index, quantile_index = divmod(c, quantiles_num) + comp_part = ( + "_" + _sanitize_mlflow_key(comps[component_index]) + if has_comp_axis + else "" + ) + key = _sanitize_mlflow_key( + base_key + comp_part + quantiles_labels[quantile_index] + series_suffix + ) + for t in range(t_size): + # MLflow step maps to the time axis when present + step = t if has_time_axis else 0 + metrics_by_step.setdefault(step, {})[key] = float(canonical[t, c]) + + for step, metrics in metrics_by_step.items(): + autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + autologging_client.flush(synchronous=False).await_completion() def _make_metric_patch(metric_name: str) -> Callable: """Create a ``safe_patch``-compatible patch function for a darts metric. The returned patch calls the original metric and, when an active MLflow - run exists, logs the result under a key built as:: + run exists, infers the output axes from the metric signature and call + kwargs (via ``_infer_metric_axes``) and delegates to ``_log_metric_result``, + which logs each cell under a key built as:: - {metric_name}_{dataset_name}_{component}_{series_index} + {dataset_name}_{metric_name}{component}{quantile_or_label}{series_suffix} where: * ``dataset_name`` – Python variable name of the first argument in the caller's frame (captured via frame inspection, omitted if not found). - * ``component`` – component label from the ``TimeSeries`` if the result is - per-component, otherwise an integer index. - * ``series_index`` – integer index appended when the input is a - ``Sequence[TimeSeries]`` and the result has a series axis. + * ``component`` – ``_{component_name}`` when ``component_reduction=None``. + * ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.5``, + ``_qi0.1_0.9``, ``_label1``) when applicable. + * ``series_suffix`` – ``_s{series_index}`` when the input is a + ``Sequence[TimeSeries]`` with more than one series. - The original return value is always forwarded unchanged. + The per-timestep axis (``time_reduction=None``) is mapped to the MLflow + ``step``. The original return value is always forwarded unchanged. Parameters ---------- @@ -1242,28 +1298,40 @@ def _patched_metric(original, *args, **kwargs): series = args[0] else: series = kwargs.get("actual_series", None) + if series is None: + return result # capture the variable name of actual_series for metric key raw = _inspect_original_var_name(series, fallback_name=None) dataset_name = _sanitize_mlflow_key(raw) if raw else None - # handling multi_series input - input_is_list = not hasattr(series, "components") - - # extract component names from the series (or first element if list) - single_series = get_single_series(series) - component_names = ( - single_series.components.tolist() if single_series is not None else None + # infer output axes from the metric signature + call kwargs + has_time_axis, has_comp_axis, quantiles_num, quantiles_labels = ( + _infer_metric_axes(original, kwargs) ) + # series_reduction collapses the series axis inside the metric, so the + # result has no leading series axis even for list input. + params = inspect.signature(original).parameters + series_reduced = False + if "series_reduction" in params: + effective_sr = kwargs.get( + "series_reduction", params["series_reduction"].default + ) + series_reduced = effective_sr is not None + _log_metric_result( autologging_client, run_id, metric_name, result, + series, + has_time_axis, + has_comp_axis, + quantiles_num, + quantiles_labels, dataset_name=dataset_name, - component_names=component_names, - input_is_list=input_is_list, + series_reduced=series_reduced, ) return result From 8b8157bebca646a68caa5297caa04e018e38d354 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 10:21:58 +0200 Subject: [PATCH 077/154] feat: add missing autolog shape unit test --- darts/tests/optional_deps/test_mlflow.py | 174 +++++++++++++++++++++++ 1 file changed, 174 insertions(+) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index d3d559e939..80f376d07d 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -724,6 +724,180 @@ def test_autolog_public_namespace_patched(self, mlflow_tracking, autolog_context "darts.metrics.metrics.mae should NOT log (implementation module is not patched)" ) + def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): + """A per-timestep metric (ae) logs one value per timestep across MLflow steps. + + time_reduction=None (ae's default) means the result keeps a per-timestep + axis, which is mapped to the MLflow step (mirroring the backtest path) + rather than being mislabeled as per-component. + """ + train = self.ts_univariate[:40] + model = LinearRegressionModel(lags=4) + model.fit(train) + pred = model.predict(n=10) + actual = self.ts_univariate[40:] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.ae(actual, pred) + + # the first-arg variable name ("actual") is captured as the key prefix + ref = np.asarray(ref, dtype=float) # shape (n_timesteps,) + history = mlflow_tracking.get_metric_history(run.info.run_id, "actual_ae") + assert len(history) == len(ref), "Expected one step per timestep" + steps = sorted(m.step for m in history) + assert steps == list(range(len(ref))) + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose(logged, ref, atol=1e-5) + + def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): + """A quantile metric (mql) logs one key per quantile with matching values.""" + train = self.ts_univariate[:40] + model = LinearRegressionModel( + lags=4, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] + ) + model.fit(train) + pred = model.predict(n=10, num_samples=200) + actual = self.ts_univariate[40:] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.mql(actual, pred, q=[0.1, 0.5, 0.9]) + + # the first-arg variable name ("actual") is captured as the key prefix + ref = np.asarray(ref, dtype=float) # shape (n_quantiles,) + m = mlflow.get_run(run.info.run_id).data.metrics + for i, key in enumerate(( + "actual_mql_q0_1", + "actual_mql_q0_5", + "actual_mql_q0_9", + )): + assert key in m, f"Expected quantile key {key}" + assert m[key] == pytest.approx(ref[i], abs=1e-5) + + def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context): + """A quantile interval metric (miw) logs one key per interval.""" + train = self.ts_univariate[:40] + model = LinearRegressionModel( + lags=4, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] + ) + model.fit(train) + pred = model.predict(n=10, num_samples=200) + actual = self.ts_univariate[40:] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.miw(actual, pred, q_interval=(0.1, 0.9)) + + # the first-arg variable name ("actual") is captured as the key prefix + m = mlflow.get_run(run.info.run_id).data.metrics + assert "actual_miw_qi0_1_0_9" in m + assert m["actual_miw_qi0_1_0_9"] == pytest.approx(float(ref), abs=1e-5) + + def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): + """A list of series logs one key per series index using the _s{i} suffix.""" + series = [self.ts_univariate, self.ts_univariate * 1.2] + pred = [s * 1.1 for s in series] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.mae(series, pred) + + # the first-arg variable name ("series") is captured as the key prefix + ref = np.asarray(ref, dtype=float) # shape (n_series,) + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["series_mae_s0"] == pytest.approx(ref[0], abs=1e-5) + assert m["series_mae_s1"] == pytest.approx(ref[1], abs=1e-5) + + def test_autolog_metric_multi_series_per_component( + self, mlflow_tracking, autolog_context + ): + """A list of multivariate series with component_reduction=None logs one key + per (component, series) — exercising the 2-D (series × component) layout.""" + series = [self.ts_multivariate, self.ts_multivariate * 1.2] + pred = [s * 1.1 for s in series] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.mae(series, pred, component_reduction=None) + + # the first-arg variable name ("series") is captured as the key prefix + ref = np.asarray(ref, dtype=float) # shape (n_series, n_components) + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["series_mae_linear_s0"] == pytest.approx(ref[0, 0], abs=1e-5) + assert m["series_mae_linear_1_s0"] == pytest.approx(ref[0, 1], abs=1e-5) + assert m["series_mae_linear_s1"] == pytest.approx(ref[1, 0], abs=1e-5) + assert m["series_mae_linear_1_s1"] == pytest.approx(ref[1, 1], abs=1e-5) + + def test_autolog_metric_multi_series_classification_labels_inferred( + self, mlflow_tracking, autolog_context + ): + """f1 with label_reduction=None on a list of binary series infers class labels + per-series and logs structured per-label keys with the _s{i} suffix. + + This exercises the labels_unknown branch inside the per-series loop so that + each series' own class set is inferred rather than reusing the first series'. + """ + # two independent binary series (same classes, deterministic) + binary1 = tg.constant_timeseries(value=0.0, length=50).with_values( + np.array([0.0, 1.0] * 25, dtype=np.float32).reshape(-1, 1) + ) + binary2 = tg.constant_timeseries(value=0.0, length=50).with_values( + np.array([1.0, 0.0] * 25, dtype=np.float32).reshape(-1, 1) + ) + series = [binary1, binary2] + pred = series # perfect predictions → f1 == 1.0 per label per series + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.f1(series, pred, label_reduction=None) + + ref = [np.asarray(r, dtype=float).flatten() for r in ref] + m = mlflow.get_run(run.info.run_id).data.metrics + for i in range(2): + assert f"series_f1_label0_s{i}" in m, f"Missing key for series {i}, label 0" + assert f"series_f1_label1_s{i}" in m, f"Missing key for series {i}, label 1" + assert m[f"series_f1_label0_s{i}"] == pytest.approx(ref[i][0], abs=1e-5) + assert m[f"series_f1_label1_s{i}"] == pytest.approx(ref[i][1], abs=1e-5) + + def test_autolog_metric_size_mismatch_warns_and_skips( + self, mlflow_tracking, autolog_context, caplog + ): + """When the inferred C-axis size doesn't divide the result, a warning is logged + and no metrics are written (non-fatal — autologging must not raise).""" + actual = self.ts_univariate[40:] + # mae with component_reduction=None on a univariate series produces shape (T,), + # which is size T — divisible by c_size=1 (1 component × 1 quantile), so we + # need to force a mismatch. We do that by monkey-patching _infer_metric_axes + # to report has_comp_axis=True with a fake 3-component count, making c_size=3 + # while the actual result is shape (T,). + train = self.ts_univariate[:40] + model = LinearRegressionModel(lags=4) + model.fit(train) + pred = model.predict(n=10) + + import unittest.mock as mock + + from darts.utils import mlflow as mlflow_utils + + fake_axes = (False, True, 3, ["_c0", "_c1", "_c2"]) + with mock.patch.object( + mlflow_utils, "_infer_metric_axes", return_value=fake_axes + ): + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + with caplog.at_level(logging.WARNING, logger="darts"): + dm.mae(actual, pred) + + assert any("not divisible" in record.message for record in caplog.records), ( + "Expected a 'not divisible' warning when axes don't match the result" + ) + # no metrics should have been written for the (faked) mismatched call + run_data = mlflow.get_run(run.info.run_id).data.metrics + assert not any("mae" in k for k in run_data), ( + "No mae metrics should be logged when the size check fails" + ) + def test_autolog_backtest_scalar(self, mlflow_tracking, autolog_context): """Default (reduced) backtest of a single univariate series logs one scalar.""" with autolog_context(log_metrics=True): From 3deccb1414dc25076b8260af0e6306bfad07e295 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 13:15:09 +0200 Subject: [PATCH 078/154] feat: save per-series metrics to csv and the aggregate to mlflow --- darts/utils/mlflow.py | 122 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 101 insertions(+), 21 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 98fce464fa..bd5ec7c439 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -14,6 +14,7 @@ https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py """ +import csv import inspect import json import os @@ -835,6 +836,37 @@ def _sanitize_mlflow_key(name: str) -> str: return re.sub(r"[^\w-]", "_", name) +def _write_per_series_csv(rows: list[dict], filename: str) -> None: + """Write the granular per-series metric breakdown to a CSV artifact. + + Each row is a single metric cell for one series, with columns ``key`` (the + aggregate MLflow key, without any series suffix), ``series_index``, ``step`` + (the time or window index charted by MLflow), and ``value``. The file is + logged under the ``per_series_metrics`` artifact subdirectory of the active + run. Used when more than one series is scored, since the logged metric keys + only carry the mean over series. + + Parameters + ---------- + rows + One dict per metric cell with keys ``key``, ``series_index``, ``step``, + and ``value``. + filename + Basename of the CSV file (e.g. ``series_mae_per_series.csv``). + """ + if not rows: + return + sorted_rows = sorted(rows, key=itemgetter("key", "series_index", "step")) + fieldnames = ["key", "series_index", "step", "value"] + with TempDir() as tmp: + path = tmp.path(filename) + with open(path, "w", newline="") as f: + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + writer.writerows(sorted_rows) + mlflow.log_artifact(path, artifact_path="per_series_metrics") + + def _log_backtest_metrics( autologging_client: MlflowAutologgingQueueingClient, run_id: str, @@ -869,6 +901,11 @@ def _log_backtest_metrics( layouts (different ``time_reduction`` / ``component_reduction`` / quantile count), each series result is flattened to integer-indexed keys instead. + When more than one series is scored, the logged value is the mean over + series for each cell, and the granular per-series breakdown is written to a + ``per_series_metrics/backtest_per_series.csv`` artifact. For a single series + the mean is just the value itself and no artifact is written. + Parameters ---------- autologging_client @@ -931,16 +968,23 @@ def _log_backtest_metrics( series_seq = series2seq(series) results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result - metrics_by_step: dict[int, dict[str, float]] = {} + # agg maps (key, step) -> per-series values, averaged into the logged metric. + agg: dict[tuple[str, int], list[float]] = {} + rows: list[dict] = [] for series_index, (s, r) in enumerate(zip(series_seq, results)): - series_suffix = f"_s{series_index}" if len(series_seq) > 1 else "" - if axes_inconsistent: name_prefix = metric_names[0] if len(metric_names) == 1 else "metrics" flat = np.asarray(r, dtype=float).flatten() for i, val in enumerate(flat): - key = _sanitize_mlflow_key(f"backtest_{name_prefix}{series_suffix}_{i}") - metrics_by_step.setdefault(0, {})[key] = float(val) + key = _sanitize_mlflow_key(f"backtest_{name_prefix}_{i}") + value = float(val) + agg.setdefault((key, 0), []).append(value) + rows.append({ + "key": key, + "series_index": series_index, + "step": 0, + "value": value, + }) continue # resolve label names from series data when not provided explicitly. @@ -1023,18 +1067,32 @@ def _log_backtest_metrics( key = f"backtest_{metric_name}{comp_part}{quantiles_labels[quantile_index]}" if has_time_axis and has_windows: key += f"_w{w}" - key = _sanitize_mlflow_key(key + series_suffix) + key = _sanitize_mlflow_key(key) for t in range(t_size): # MLflow step maps to the axis the UI should chart: # time when present, otherwise window index step = t if has_time_axis else w - metrics_by_step.setdefault(step, {})[key] = float( - canonical[w, t, c, m] - ) - + value = float(canonical[w, t, c, m]) + agg.setdefault((key, step), []).append(value) + rows.append({ + "key": key, + "series_index": series_index, + "step": step, + "value": value, + }) + + # log the mean over series for each (key, step); for a single series this is + # just the value itself. + metrics_by_step: dict[int, dict[str, float]] = {} + for (key, step), values in agg.items(): + metrics_by_step.setdefault(step, {})[key] = float(np.mean(values)) for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + # write the granular per-series breakdown to a CSV artifact (multi-series only) + if len(series_seq) > 1: + _write_per_series_csv(rows, "backtest_per_series.csv") + def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: """Infer a metric's output axes from its signature and ``metric_kwargs``. @@ -1130,14 +1188,18 @@ def _log_metric_result( The logged MLflow key follows the pattern:: - {dataset_name}_{metric_name}{component}{quantile_or_label}{series_suffix} + {dataset_name}_{metric_name}{component}{quantile_or_label} where each optional part is included only when the corresponding axis is present: * ``component`` – ``_{component_name}`` when ``has_comp_axis``. * ``quantile_or_label`` – e.g. ``_q0.5`` / ``_qi0.1_0.9`` / ``_label1``. - * ``series_suffix`` – ``_s{series_index}`` when more than one series. + + When more than one series is scored, the logged value is the mean over + series for each cell, and the granular per-series breakdown is written to a + ``per_series_metrics/{base_key}_per_series.csv`` artifact. For a single + series the mean is just the value itself and no artifact is written. On a shape/size mismatch it warns and returns (does not raise), keeping autologging non-fatal. @@ -1184,10 +1246,10 @@ def _log_metric_result( labels_unknown = quantiles_num is None - metrics_by_step: dict[int, dict[str, float]] = {} + # agg maps (key, step) -> per-series values, averaged into the logged metric. + agg: dict[tuple[str, int], list[float]] = {} + rows: list[dict] = [] for series_index, (s, r) in enumerate(zip(series_seq, results)): - series_suffix = f"_s{series_index}" if len(series_seq) > 1 else "" - # quantiles_num=None means label_reduction=None was requested without explicit labels # so class labels are inferred per-series inside the loop. if labels_unknown: @@ -1237,17 +1299,33 @@ def _log_metric_result( else "" ) key = _sanitize_mlflow_key( - base_key + comp_part + quantiles_labels[quantile_index] + series_suffix + base_key + comp_part + quantiles_labels[quantile_index] ) for t in range(t_size): # MLflow step maps to the time axis when present step = t if has_time_axis else 0 - metrics_by_step.setdefault(step, {})[key] = float(canonical[t, c]) - + value = float(canonical[t, c]) + agg.setdefault((key, step), []).append(value) + rows.append({ + "key": key, + "series_index": series_index, + "step": step, + "value": value, + }) + + # log the mean over series for each (key, step); for a single series this is + # just the value itself. + metrics_by_step: dict[int, dict[str, float]] = {} + for (key, step), values in agg.items(): + metrics_by_step.setdefault(step, {})[key] = float(np.mean(values)) for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) autologging_client.flush(synchronous=False).await_completion() + # write the granular per-series breakdown to a CSV artifact (multi-series only) + if len(series_seq) > 1: + _write_per_series_csv(rows, f"{base_key}_per_series.csv") + def _make_metric_patch(metric_name: str) -> Callable: """Create a ``safe_patch``-compatible patch function for a darts metric. @@ -1257,7 +1335,7 @@ def _make_metric_patch(metric_name: str) -> Callable: kwargs (via ``_infer_metric_axes``) and delegates to ``_log_metric_result``, which logs each cell under a key built as:: - {dataset_name}_{metric_name}{component}{quantile_or_label}{series_suffix} + {dataset_name}_{metric_name}{component}{quantile_or_label} where: @@ -1266,8 +1344,10 @@ def _make_metric_patch(metric_name: str) -> Callable: * ``component`` – ``_{component_name}`` when ``component_reduction=None``. * ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.5``, ``_qi0.1_0.9``, ``_label1``) when applicable. - * ``series_suffix`` – ``_s{series_index}`` when the input is a - ``Sequence[TimeSeries]`` with more than one series. + + When the input is a ``Sequence[TimeSeries]`` with more than one series, the + logged value is the mean over series and the per-series breakdown is written + to a ``per_series_metrics/`` CSV artifact instead of per-series keys. The per-timestep axis (``time_reduction=None``) is mapped to the MLflow ``step``. The original return value is always forwarded unchanged. From 277153f6a42c0a2410eb7a0251e765b6b2105c30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 13:16:00 +0200 Subject: [PATCH 079/154] feat: autolog per-series csv saving tests --- darts/tests/optional_deps/test_mlflow.py | 122 +++++++++++++++++++---- 1 file changed, 101 insertions(+), 21 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 80f376d07d..228f665750 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,3 +1,4 @@ +import csv import logging import os @@ -795,7 +796,7 @@ def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context assert m["actual_miw_qi0_1_0_9"] == pytest.approx(float(ref), abs=1e-5) def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): - """A list of series logs one key per series index using the _s{i} suffix.""" + """A list of series logs the mean over series; per-series values go to a CSV.""" series = [self.ts_univariate, self.ts_univariate * 1.2] pred = [s * 1.1 for s in series] @@ -806,14 +807,21 @@ def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): # the first-arg variable name ("series") is captured as the key prefix ref = np.asarray(ref, dtype=float) # shape (n_series,) m = mlflow.get_run(run.info.run_id).data.metrics - assert m["series_mae_s0"] == pytest.approx(ref[0], abs=1e-5) - assert m["series_mae_s1"] == pytest.approx(ref[1], abs=1e-5) + # aggregate = mean over series, no per-series _s{i} keys + assert m["series_mae"] == pytest.approx(float(np.mean(ref)), abs=1e-5) + assert not any(k.startswith("series_mae_s") for k in m) + # granular per-series breakdown written to a CSV artifact + csv_rows = self._read_per_series_csv( + run.info.run_id, "series_mae_per_series.csv" + ) + by_series = {int(row["series_index"]): float(row["value"]) for row in csv_rows} + assert by_series == pytest.approx({0: ref[0], 1: ref[1]}, abs=1e-5) def test_autolog_metric_multi_series_per_component( self, mlflow_tracking, autolog_context ): - """A list of multivariate series with component_reduction=None logs one key - per (component, series) — exercising the 2-D (series × component) layout.""" + """A list of multivariate series with component_reduction=None logs the + per-component mean over series; the CSV carries one row per (component, series).""" series = [self.ts_multivariate, self.ts_multivariate * 1.2] pred = [s * 1.1 for s in series] @@ -824,16 +832,32 @@ def test_autolog_metric_multi_series_per_component( # the first-arg variable name ("series") is captured as the key prefix ref = np.asarray(ref, dtype=float) # shape (n_series, n_components) m = mlflow.get_run(run.info.run_id).data.metrics - assert m["series_mae_linear_s0"] == pytest.approx(ref[0, 0], abs=1e-5) - assert m["series_mae_linear_1_s0"] == pytest.approx(ref[0, 1], abs=1e-5) - assert m["series_mae_linear_s1"] == pytest.approx(ref[1, 0], abs=1e-5) - assert m["series_mae_linear_1_s1"] == pytest.approx(ref[1, 1], abs=1e-5) + # aggregate per component = mean over series, no per-series _s{i} keys + assert m["series_mae_linear"] == pytest.approx( + float(ref[:, 0].mean()), abs=1e-5 + ) + assert m["series_mae_linear_1"] == pytest.approx( + float(ref[:, 1].mean()), abs=1e-5 + ) + assert not any(k.endswith(("_s0", "_s1")) for k in m) + # granular CSV: one row per (component, series) + csv_rows = self._read_per_series_csv( + run.info.run_id, "series_mae_per_series.csv" + ) + got = { + (row["key"], int(row["series_index"])): float(row["value"]) + for row in csv_rows + } + assert got[("series_mae_linear", 0)] == pytest.approx(ref[0, 0], abs=1e-5) + assert got[("series_mae_linear", 1)] == pytest.approx(ref[1, 0], abs=1e-5) + assert got[("series_mae_linear_1", 0)] == pytest.approx(ref[0, 1], abs=1e-5) + assert got[("series_mae_linear_1", 1)] == pytest.approx(ref[1, 1], abs=1e-5) def test_autolog_metric_multi_series_classification_labels_inferred( self, mlflow_tracking, autolog_context ): """f1 with label_reduction=None on a list of binary series infers class labels - per-series and logs structured per-label keys with the _s{i} suffix. + per-series, logs the per-label mean over series, and writes the per-series CSV. This exercises the labels_unknown branch inside the per-series loop so that each series' own class set is inferred rather than reusing the first series'. @@ -854,11 +878,25 @@ def test_autolog_metric_multi_series_classification_labels_inferred( ref = [np.asarray(r, dtype=float).flatten() for r in ref] m = mlflow.get_run(run.info.run_id).data.metrics + # aggregate per label = mean over series, no per-series _s{i} keys + assert m["series_f1_label0"] == pytest.approx( + float(np.mean([ref[0][0], ref[1][0]])), abs=1e-5 + ) + assert m["series_f1_label1"] == pytest.approx( + float(np.mean([ref[0][1], ref[1][1]])), abs=1e-5 + ) + assert not any(k.endswith(("_s0", "_s1")) for k in m) + # granular CSV: one row per (label, series) + csv_rows = self._read_per_series_csv( + run.info.run_id, "series_f1_per_series.csv" + ) + got = { + (row["key"], int(row["series_index"])): float(row["value"]) + for row in csv_rows + } for i in range(2): - assert f"series_f1_label0_s{i}" in m, f"Missing key for series {i}, label 0" - assert f"series_f1_label1_s{i}" in m, f"Missing key for series {i}, label 1" - assert m[f"series_f1_label0_s{i}"] == pytest.approx(ref[i][0], abs=1e-5) - assert m[f"series_f1_label1_s{i}"] == pytest.approx(ref[i][1], abs=1e-5) + assert got[("series_f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) + assert got[("series_f1_label1", i)] == pytest.approx(ref[i][1], abs=1e-5) def test_autolog_metric_size_mismatch_warns_and_skips( self, mlflow_tracking, autolog_context, caplog @@ -898,6 +936,36 @@ def test_autolog_metric_size_mismatch_warns_and_skips( "No mae metrics should be logged when the size check fails" ) + def test_autolog_metric_per_series_csv_schema_and_single_series_skip( + self, mlflow_tracking, autolog_context + ): + """The per-series CSV has the expected schema for multi-series input, and no + artifact is written for single-series input (mean == the value itself).""" + # multi-series: artifact exists with the documented columns + multi = [self.ts_univariate, self.ts_univariate * 1.2] + pred_multi = [s * 1.1 for s in multi] + with autolog_context(log_metrics=True): + with mlflow.start_run() as run_multi: + dm.mae(multi, pred_multi) + + csv_rows = self._read_per_series_csv( + run_multi.info.run_id, "multi_mae_per_series.csv" + ) + assert list(csv_rows[0].keys()) == ["key", "series_index", "step", "value"] + assert {int(r["series_index"]) for r in csv_rows} == {0, 1} + + # single-series: no per_series_metrics artifact directory should be created + single = self.ts_univariate + pred_single = single * 1.1 + with autolog_context(log_metrics=True): + with mlflow.start_run() as run_single: + dm.mae(single, pred_single) + + artifacts = mlflow_tracking.list_artifacts(run_single.info.run_id) + assert not any(a.path == "per_series_metrics" for a in artifacts), ( + "Single-series input should not write a per-series CSV artifact" + ) + def test_autolog_backtest_scalar(self, mlflow_tracking, autolog_context): """Default (reduced) backtest of a single univariate series logs one scalar.""" with autolog_context(log_metrics=True): @@ -974,7 +1042,7 @@ def test_autolog_backtest_multi_metric(self, mlflow_tracking, autolog_context): ) def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): - """A list of series logs one key per series index.""" + """A list of series logs the mean over series; per-series values go to a CSV.""" series = [self.ts_univariate, self.ts_univariate * 1.2] with autolog_context(log_metrics=True): with mlflow.start_run() as run: @@ -983,13 +1051,16 @@ def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): ) run_data = mlflow.get_run(run.info.run_id).data - assert "backtest_mae_s0" in run_data.metrics - assert "backtest_mae_s1" in run_data.metrics - assert run_data.metrics["backtest_mae_s0"] == pytest.approx( - float(ref[0]), abs=1e-5 + # aggregate = mean over series, no per-series _s{i} keys + assert run_data.metrics["backtest_mae"] == pytest.approx( + float(np.mean(ref)), abs=1e-5 ) - assert run_data.metrics["backtest_mae_s1"] == pytest.approx( - float(ref[1]), abs=1e-5 + assert not any(k.startswith("backtest_mae_s") for k in run_data.metrics) + # granular per-series breakdown written to a CSV artifact + csv_rows = self._read_per_series_csv(run.info.run_id, "backtest_per_series.csv") + by_series = {int(row["series_index"]): float(row["value"]) for row in csv_rows} + assert by_series == pytest.approx( + {0: float(ref[0]), 1: float(ref[1])}, abs=1e-5 ) def test_autolog_backtest_per_timestep_scalar( @@ -1180,6 +1251,15 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking, caplog assert not mlflow.get_run(run.info.run_id).data.metrics + @staticmethod + def _read_per_series_csv(run_id, filename): + """Download and parse a per_series_metrics CSV artifact into row dicts.""" + local = mlflow.artifacts.download_artifacts( + run_id=run_id, artifact_path=f"per_series_metrics/{filename}" + ) + with open(local, newline="") as f: + return list(csv.DictReader(f)) + def _fit_lr(self, series=None): """Fit and return a fresh LinearRegressionModel (no active run).""" model = LinearRegressionModel(lags=4) From f746d7bd79b1954af97cdfb19d34a716d79170f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 14:03:45 +0200 Subject: [PATCH 080/154] feat: add metric shape and per-series csv saving explanation section to example notebook --- examples/29-MLflow-quickstart.ipynb | 11832 +++++++++++++------------- 1 file changed, 5969 insertions(+), 5863 deletions(-) diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index fff71cb24a..c64140f653 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -1,5959 +1,6065 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "aeddb542", - "metadata": {}, - "source": [ - "# MLflow for Darts\n", - "\n", - "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", - "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", - "\n", - "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", - "\n", - "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ] - }, - { - "cell_type": "markdown", - "id": "f72894af", - "metadata": {}, - "source": [ - "## Installing MLflow\n", - "\n", - "MLflow is available as an optional dependency for Darts. Install it with:\n", - "\n", - "```bash\n", - "pip install mlflow\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "42e3dcea", - "metadata": {}, - "source": [ - "## Setup and Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "b346ce8f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.049165Z", - "iopub.status.busy": "2026-06-24T15:18:43.049088Z", - "iopub.status.idle": "2026-06-24T15:18:43.053693Z", - "shell.execute_reply": "2026-06-24T15:18:43.053435Z" - } - }, - "outputs": [], - "source": [ - "# fix python path if working locally\n", - "from utils import fix_pythonpath_if_working_locally\n", - "\n", - "fix_pythonpath_if_working_locally()\n", - "\n", - "import warnings\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "13b13fe4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.054776Z", - "iopub.status.busy": "2026-06-24T15:18:43.054722Z", - "iopub.status.idle": "2026-06-24T15:18:46.599643Z", - "shell.execute_reply": "2026-06-24T15:18:46.599208Z" - } - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import os\n", - "import tempfile\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import mlflow\n", - "import numpy as np\n", - "\n", - "import darts.metrics\n", - "from darts.datasets import AirPassengersDataset\n", - "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", - "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "4d424e08", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.600906Z", - "iopub.status.busy": "2026-06-24T15:18:46.600748Z", - "iopub.status.idle": "2026-06-24T15:18:46.634540Z", - "shell.execute_reply": "2026-06-24T15:18:46.634100Z" - } - }, - "outputs": [], - "source": [ - "# use darts plotting style\n", - "from darts import set_option\n", - "\n", - "set_option(\"plotting.use_darts_style\", True)" - ] - }, - { - "cell_type": "markdown", - "id": "2f9c40d6", - "metadata": {}, - "source": [ - "## MLflow Setup\n", - "\n", - "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "88320df5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.636640Z", - "iopub.status.busy": "2026-06-24T15:18:46.636565Z", - "iopub.status.idle": "2026-06-24T15:18:47.268439Z", - "shell.execute_reply": "2026-06-24T15:18:47.268081Z" - } - }, - "outputs": [ + "cells": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/06/24 17:34:20 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", - "2026/06/24 17:34:20 INFO mlflow.store.db.utils: Updating database tables\n", - "2026/06/24 17:34:20 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" - ] + "cell_type": "markdown", + "id": "aeddb542", + "metadata": {}, + "source": [ + "# MLflow for Darts\n", + "\n", + "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", + "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", + "\n", + "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", + "\n", + "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpyqkqfzoe/mlflow.db\n", - "Experiment: darts-quickstart\n" - ] - } - ], - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ] - }, - { - "cell_type": "markdown", - "id": "03d5209e", - "metadata": {}, - "source": [ - "## Load Sample Data\n", - "\n", - "We'll use the classic AirPassengers dataset for this example." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1596e07e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.269628Z", - "iopub.status.busy": "2026-06-24T15:18:47.269548Z", - "iopub.status.idle": "2026-06-24T15:18:47.356588Z", - "shell.execute_reply": "2026-06-24T15:18:47.356201Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "f72894af", + "metadata": {}, + "source": [ + "## Installing MLflow\n", + "\n", + "MLflow is available as an optional dependency for Darts. Install it with:\n", + "\n", + "```bash\n", + "pip install mlflow\n", + "```" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "findfont: Failed to find font weight 600, now using 700.\n" - ] + "cell_type": "markdown", + "id": "42e3dcea", + "metadata": {}, + "source": [ + "## Setup and Imports" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training series: 107 points\n", - "Validation series: 37 points\n" - ] + "cell_type": "code", + "execution_count": 2, + "id": "b346ce8f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.049165Z", + "iopub.status.busy": "2026-06-24T15:18:43.049088Z", + "iopub.status.idle": "2026-06-24T15:18:43.053693Z", + "shell.execute_reply": "2026-06-24T15:18:43.053435Z" + } + }, + "outputs": [], + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "

" + "cell_type": "code", + "execution_count": 3, + "id": "13b13fe4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.054776Z", + "iopub.status.busy": "2026-06-24T15:18:43.054722Z", + "iopub.status.idle": "2026-06-24T15:18:46.599643Z", + "shell.execute_reply": "2026-06-24T15:18:46.599208Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import mlflow\n", + "import numpy as np\n", + "\n", + "import darts.metrics\n", + "from darts.datasets import AirPassengersDataset\n", + "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", + "from darts.utils.mlflow import autolog, load_model, log_model, save_model" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "34858645", - "metadata": {}, - "source": [ - "## Basic Model Logging\n", - "\n", - "Let's train a simple model and log it to MLflow manually." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bc8f520d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.357581Z", - "iopub.status.busy": "2026-06-24T15:18:47.357516Z", - "iopub.status.idle": "2026-06-24T15:18:47.450374Z", - "shell.execute_reply": "2026-06-24T15:18:47.449925Z" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] + "cell_type": "code", + "execution_count": 4, + "id": "4d424e08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.600906Z", + "iopub.status.busy": "2026-06-24T15:18:46.600748Z", + "iopub.status.idle": "2026-06-24T15:18:46.634540Z", + "shell.execute_reply": "2026-06-24T15:18:46.634100Z" + } + }, + "outputs": [], + "source": [ + "# use darts plotting style\n", + "from darts import set_option\n", + "\n", + "set_option(\"plotting.use_darts_style\", True)" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "2f9c40d6", + "metadata": {}, + "source": [ + "## MLflow Setup\n", + "\n", + "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = ExponentialSmoothing()\n", - "model.fit(train)\n", - "\n", - "predictions = model.predict(n=len(val))\n", - "\n", - "# calculate metrics you want to log to MLflow\n", - "mape_score = darts.metrics.mape(val, predictions)\n", - "rmse_score = darts.metrics.rmse(val, predictions)\n", - "\n", - "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", - "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", - "\n", - "train[-50:].plot(label=\"Training\")\n", - "val.plot(label=\"Actual\")\n", - "predictions.plot(label=\"Forecast\")\n", - "plt.legend()\n", - "plt.title(\"Exponential Smoothing Forecast\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "35dc864c", - "metadata": {}, - "source": [ - "Now let's log this model to MLflow:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "61406cd9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.451366Z", - "iopub.status.busy": "2026-06-24T15:18:47.451297Z", - "iopub.status.idle": "2026-06-24T15:18:47.906785Z", - "shell.execute_reply": "2026-06-24T15:18:47.906380Z" - } - }, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/06/24 17:34:21 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] + "cell_type": "code", + "execution_count": 5, + "id": "88320df5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.636640Z", + "iopub.status.busy": "2026-06-24T15:18:46.636565Z", + "iopub.status.idle": "2026-06-24T15:18:47.268439Z", + "shell.execute_reply": "2026-06-24T15:18:47.268081Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026/06/25 13:57:21 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", + "2026/06/25 13:57:21 INFO mlflow.store.db.utils: Updating database tables\n", + "2026/06/25 13:57:22 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpvwnlx3yj/mlflow.db\n", + "Experiment: darts-quickstart\n" + ] + } + ], + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run ID: 3d1f7f864f7240599e3b080109e246bf\n", - "Model URI: models:/m-f42705a59eb34300b377f0219577bfa4\n" - ] - } - ], - "source": [ - "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", - " model_info = log_model(\n", - " model=model,\n", - " name=\"exponential-smoothing-model\",\n", - " # alternatively, use mlflow.set_tag(key, value) in the run\n", - " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", - " )\n", - "\n", - " # log calculated metrics you want\n", - " mlflow.log_metric(\"val_mape\", mape_score)\n", - " mlflow.log_metric(\"val_rmse\", rmse_score)\n", - "\n", - " print(f\"Run ID: {run.info.run_id}\")\n", - " print(f\"Model URI: {model_info.model_uri}\")" - ] - }, - { - "cell_type": "markdown", - "id": "0728690e", - "metadata": {}, - "source": [ - "### Load the Model Back\n", - "\n", - "We can load the model from MLflow using its URI:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "cae35ffa", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.907880Z", - "iopub.status.busy": "2026-06-24T15:18:47.907802Z", - "iopub.status.idle": "2026-06-24T15:18:47.914695Z", - "shell.execute_reply": "2026-06-24T15:18:47.914326Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "03d5209e", + "metadata": {}, + "source": [ + "## Load Sample Data\n", + "\n", + "We'll use the classic AirPassengers dataset for this example." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model predictions match: True\n" - ] - } - ], - "source": [ - "loaded_model = load_model(model_info.model_uri)\n", - "\n", - "loaded_predictions = loaded_model.predict(n=len(val))\n", - "\n", - "# verify predictions match\n", - "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", - "print(f\"Loaded model predictions match: {predictions_match}\")" - ] - }, - { - "cell_type": "markdown", - "id": "6bd4597c", - "metadata": {}, - "source": [ - "## Automatic Logging with `autolog()`\n", - "\n", - "`autolog()` patches every `model.fit()` call to automatically log parameters, covariate metadata, and the trained model artifact. It also patches the darts metric functions so any metric called inside an active run is logged. For PyTorch-based models it enables MLflow's PyTorch autologging to record `train_loss` / `val_loss` per epoch (see the sections below for details)." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "5ef7f73a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.915629Z", - "iopub.status.busy": "2026-06-24T15:18:47.915566Z", - "iopub.status.idle": "2026-06-24T15:18:50.020337Z", - "shell.execute_reply": "2026-06-24T15:18:50.019951Z" - } - }, - "outputs": [ + "cell_type": "code", + "execution_count": 6, + "id": "1596e07e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.269628Z", + "iopub.status.busy": "2026-06-24T15:18:47.269548Z", + "iopub.status.idle": "2026-06-24T15:18:47.356588Z", + "shell.execute_reply": "2026-06-24T15:18:47.356201Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "findfont: Failed to find font weight 600, now using 700.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training series: 107 points\n", + "Validation series: 37 points\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/06/24 17:34:24 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n", - "2026/06/24 17:34:24 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] + "cell_type": "markdown", + "id": "34858645", + "metadata": {}, + "source": [ + "## Basic Model Logging\n", + "\n", + "Let's train a simple model and log it to MLflow manually." + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Logged metrics: {'val_mape': 10.742, 'val_rmse': 51.182}\n" - ] + "cell_type": "code", + "execution_count": 7, + "id": "bc8f520d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.357581Z", + "iopub.status.busy": "2026-06-24T15:18:47.357516Z", + "iopub.status.idle": "2026-06-24T15:18:47.450374Z", + "shell.execute_reply": "2026-06-24T15:18:47.449925Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = ExponentialSmoothing()\n", + "model.fit(train)\n", + "\n", + "predictions = model.predict(n=len(val))\n", + "\n", + "# calculate metrics you want to log to MLflow\n", + "mape_score = darts.metrics.mape(val, predictions)\n", + "rmse_score = darts.metrics.rmse(val, predictions)\n", + "\n", + "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", + "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", + "\n", + "train[-50:].plot(label=\"Training\")\n", + "val.plot(label=\"Actual\")\n", + "predictions.plot(label=\"Forecast\")\n", + "plt.legend()\n", + "plt.title(\"Exponential Smoothing Forecast\")\n", + "plt.show()" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "35dc864c", + "metadata": {}, + "source": [ + "Now let's log this model to MLflow:" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", - " auto_model = LinearRegressionModel(lags=12)\n", - " auto_model.fit(train) # autolog logs params, covariate metadata, and the model\n", - "\n", - " auto_predictions = auto_model.predict(n=len(val))\n", - " # these metric calls happen inside the run, so they are logged automatically\n", - " auto_mape = darts.metrics.mape(val, auto_predictions)\n", - " auto_rmse = darts.metrics.rmse(val, auto_predictions)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show logged metrics\n", - "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", - "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", - "\n", - "# plot\n", - "fig, ax = plt.subplots(figsize=(10, 4))\n", - "train[-36:].plot(label=\"Train\", ax=ax)\n", - "val.plot(label=\"Actual\", ax=ax)\n", - "auto_predictions.plot(\n", - " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", - ")\n", - "ax.set_title(\"Linear Regression — autolog run\")\n", - "ax.legend()\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f484330f", - "metadata": {}, - "source": [ - "## Open the MLflow UI\n", - "\n", - "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", - "\n", - "The UI lets you:\n", - "- **Compare runs** side-by-side in the Experiments table\n", - "- **Inspect** individual run parameters, metrics, and logged artifacts\n", - "- **Visualize** metrics across runs with built-in charts\n", - "- **Register** models to the Model Registry for versioning" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "1a01cd2f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:50.021527Z", - "iopub.status.busy": "2026-06-24T15:18:50.021439Z", - "iopub.status.idle": "2026-06-24T15:18:50.023116Z", - "shell.execute_reply": "2026-06-24T15:18:50.022824Z" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Launch the MLflow UI with this command in your terminal:\n", - "\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpyqkqfzoe/mlflow.db\n", - "\n", - "Then open: http://localhost:5000\n" - ] - } - ], - "source": [ - "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", - "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", - "print(\"Then open: http://localhost:5000\")" - ] - }, - { - "cell_type": "markdown", - "id": "88b0d285", - "metadata": {}, - "source": [ - "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `val_mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", - ">\n", - "![Mlflow Overview](./static/images/mlflow_overview.png)" - ] - }, - { - "cell_type": "markdown", - "id": "e2b133bc", - "metadata": {}, - "source": [ - "## Per-epoch Metrics with Torch Models\n", - "\n", - "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", - "\n", - "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d01783d1", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:50.024161Z", - "iopub.status.busy": "2026-06-24T15:18:50.024087Z", - "iopub.status.idle": "2026-06-24T15:18:53.370946Z", - "shell.execute_reply": "2026-06-24T15:18:53.370531Z" - } - }, - "outputs": [ + "cell_type": "code", + "execution_count": 8, + "id": "61406cd9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.451366Z", + "iopub.status.busy": "2026-06-24T15:18:47.451297Z", + "iopub.status.idle": "2026-06-24T15:18:47.906785Z", + "shell.execute_reply": "2026-06-24T15:18:47.906380Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026/06/25 13:57:23 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run ID: 22b3b299ce8d4d72b1646564a35b04ee\n", + "Model URI: models:/m-e61e8518e2a04143ace1d627ed4a775b\n" + ] + } + ], + "source": [ + "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", + " model_info = log_model(\n", + " model=model,\n", + " name=\"exponential-smoothing-model\",\n", + " # alternatively, use mlflow.set_tag(key, value) in the run\n", + " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", + " )\n", + "\n", + " # log calculated metrics you want\n", + " mlflow.log_metric(\"val_mape\", mape_score)\n", + " mlflow.log_metric(\"val_rmse\", rmse_score)\n", + "\n", + " print(f\"Run ID: {run.info.run_id}\")\n", + " print(f\"Model URI: {model_info.model_uri}\")" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: GPU available: True (mps), used: False\n", - "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", - "INFO: TPU available: False, using: 0 TPU cores\n", - "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO: HPU available: False, using: 0 HPUs\n", - "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "\n", - " | Name | Type | Params | Mode \n", - "-------------------------------------------------------------\n", - "0 | criterion | MSELoss | 0 | train\n", - "1 | train_criterion | MSELoss | 0 | train\n", - "2 | val_criterion | MSELoss | 0 | train\n", - "3 | train_metrics | MetricCollection | 0 | train\n", - "4 | val_metrics | MetricCollection | 0 | train\n", - "5 | stacks | ModuleList | 6.2 M | train\n", - "-------------------------------------------------------------\n", - "6.2 M Trainable params\n", - "1.4 K Non-trainable params\n", - "6.2 M Total params\n", - "24.787 Total estimated model params size (MB)\n", - "400 Modules in train mode\n", - "0 Modules in eval mode\n" - ] + "cell_type": "markdown", + "id": "0728690e", + "metadata": {}, + "source": [ + "### Load the Model Back\n", + "\n", + "We can load the model from MLflow using its URI:" + ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b08a95d734ed47b892fbee0631114072", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "execution_count": 9, + "id": "cae35ffa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.907880Z", + "iopub.status.busy": "2026-06-24T15:18:47.907802Z", + "iopub.status.idle": "2026-06-24T15:18:47.914695Z", + "shell.execute_reply": "2026-06-24T15:18:47.914326Z" + } }, - "text/plain": [ - "Sanity Checking: | | 0/? [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "autolog()\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", + " auto_model = LinearRegressionModel(lags=12)\n", + " auto_model.fit(train) # autolog logs params, covariate metadata, and the model\n", + "\n", + " auto_predictions = auto_model.predict(n=len(val))\n", + " # these metric calls happen inside the run, so they are logged automatically\n", + " auto_mape = darts.metrics.mape(val, auto_predictions)\n", + " auto_rmse = darts.metrics.rmse(val, auto_predictions)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show logged metrics\n", + "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", + "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", + "\n", + "# plot\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "train[-36:].plot(label=\"Train\", ax=ax)\n", + "val.plot(label=\"Actual\", ax=ax)\n", + "auto_predictions.plot(\n", + " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", + ")\n", + "ax.set_title(\"Linear Regression — autolog run\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f484330f", + "metadata": {}, + "source": [ + "## Open the MLflow UI\n", + "\n", + "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", + "\n", + "The UI lets you:\n", + "- **Compare runs** side-by-side in the Experiments table\n", + "- **Inspect** individual run parameters, metrics, and logged artifacts\n", + "- **Visualize** metrics across runs with built-in charts\n", + "- **Register** models to the Model Registry for versioning" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "254ef24eb5984c54bc7efcdf6b504f11", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "execution_count": 11, + "id": "1a01cd2f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:50.021527Z", + "iopub.status.busy": "2026-06-24T15:18:50.021439Z", + "iopub.status.idle": "2026-06-24T15:18:50.023116Z", + "shell.execute_reply": "2026-06-24T15:18:50.022824Z" + } }, - "text/plain": [ - "Validation: | | 0/? [00:00 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `val_mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", + ">\n", + "![Mlflow Overview](./static/images/mlflow_overview.png)" + ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "1452432791254a928b131d34abb67463", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_charts.png)" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7650d19876444051a760005979b86ea5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: | | 0/? [00:00`), quantile metrics (`q`, `q_interval`) add the quantile (e.g. `val_mql_q0.5`), per-label classification (`label_reduction=None`) adds the class (e.g. `val_f1_label1`), and per-timestep metrics (`time_reduction=None`) are charted across MLflow steps.\n", + "\n", + "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is saved as a CSV artifact under `per_series_metrics/`." ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6b32c477b2194b868114c8d3643541f7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_charts.png)" - ] - }, - { - "cell_type": "markdown", - "id": "3f0828c2", - "metadata": {}, - "source": [ - "## Forecast Metrics\n", - "\n", - "With `log_metrics=True` (the default), `autolog()` patches every darts metric function. Any metric you call **inside an active run** is logged automatically with no extra arguments needed.\n", - "\n", - "The metric key is derived from the result: a scalar is logged under `{metric}`, and when the variable name of the actual series can be detected it is prefixed (e.g. calling `darts.metrics.mae(val, pred)` logs `val_mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "df8e85b6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.372445Z", - "iopub.status.busy": "2026-06-24T15:18:53.372367Z", - "iopub.status.idle": "2026-06-24T15:18:53.470125Z", - "shell.execute_reply": "2026-06-24T15:18:53.469722Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/06/24 17:34:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n", - "2026/06/24 17:34:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] + "cell_type": "markdown", + "id": "22685423", + "metadata": {}, + "source": [ + "### Load the Best Model" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "All logged metrics (5):\n", - " manual_mape: 10.7420\n", - " val_mae: 46.0220\n", - " val_mape: 10.7420\n", - " val_rmse: 51.1820\n", - " val_smape: 10.1015\n" - ] - } - ], - "source": [ - "# log_metrics=True (the default) patches every darts metric so that calls made\n", - "# inside an active run are logged automatically\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", - " lr_model = LinearRegressionModel(lags=12)\n", - " lr_model.fit(train)\n", - " lr_pred = lr_model.predict(n=len(val))\n", - "\n", - " # each metric called here is auto-logged; the key is prefixed with the\n", - " # variable name of the first argument (here \"val\"): val_mae, val_rmse, val_smape\n", - " darts.metrics.mae(val, lr_pred)\n", - " darts.metrics.rmse(val, lr_pred)\n", - " darts.metrics.smape(val, lr_pred)\n", - " # you can still log a custom-named metric explicitly\n", - " mlflow.log_metric(\"manual_mape\", darts.metrics.mape(val, lr_pred))\n", - " run_id = run.info.run_id\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show what was logged\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_metrics = client.get_run(run_id).data.metrics\n", - "metric_names = sorted(run_metrics.keys())\n", - "print(f\"All logged metrics ({len(metric_names)}):\")\n", - "for name in metric_names:\n", - " print(f\" {name}: {run_metrics[name]:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "8511fc08", - "metadata": {}, - "source": [ - "## Saving and Loading Models Locally\n", - "\n", - "You can also save and load models to/from local paths without MLflow runs." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "645ef079", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.471252Z", - "iopub.status.busy": "2026-06-24T15:18:53.471178Z", - "iopub.status.idle": "2026-06-24T15:18:53.478682Z", - "shell.execute_reply": "2026-06-24T15:18:53.478330Z" - } - }, - "outputs": [ + "cell_type": "code", + "execution_count": 18, + "id": "7b09db6a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.497560Z", + "iopub.status.busy": "2026-06-24T15:18:53.497496Z", + "iopub.status.idle": "2026-06-24T15:18:53.572540Z", + "shell.execute_reply": "2026-06-24T15:18:53.572133Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading best model from run: exponential-smoothing-baseline\n", + "Model URI: models:/m-e61e8518e2a04143ace1d627ed4a775b\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", + "\n", + "if runs:\n", + " best_run = runs[0]\n", + " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", + " # from the run outputs and load it with a models:/ URI\n", + " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", + " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", + "\n", + " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", + " print(f\"Model URI: {best_model_uri}\")\n", + "\n", + " best_model = load_model(best_model_uri)\n", + " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", + " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", + " if isinstance(best_model, GlobalForecastingModel):\n", + " best_predictions = best_model.predict(n=len(val), series=train)\n", + " else:\n", + " best_predictions = best_model.predict(n=len(val))\n", + "\n", + " train[-50:].plot(label=\"Training\")\n", + " val.plot(label=\"Actual\")\n", + " best_predictions.plot(label=\"Best Model Forecast\")\n", + " plt.legend()\n", + " plt.title(\"Best Model Predictions\")\n", + " plt.show()" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/06/24 17:34:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] + "cell_type": "markdown", + "id": "6f1ec89e", + "metadata": {}, + "source": [ + "## Model Registry\n", + "\n", + "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived).\n", + "\n", + "```python\n", + "# Register a model from a run\n", + "result = mlflow.register_model(\n", + " model_uri=f\"runs:/{best_run.info.run_id}/model\",\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")\n", + "```\n", + "\n", + "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", + "\n", + "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_models.png)" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Files in model directory:\n", - " - python_env.yaml\n", - " - requirements.txt\n", - " - MLmodel\n", - " - model.pkl\n", - " - conda.yaml\n" - ] - } - ], - "source": [ - "# Save model to local directory\n", - "local_model_path = os.path.join(tmpdir, \"my_model\")\n", - "save_model(model, path=local_model_path)\n", - "\n", - "print(\"\\nFiles in model directory:\")\n", - "for file in os.listdir(local_model_path):\n", - " print(f\" - {file}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "254ba153", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.479679Z", - "iopub.status.busy": "2026-06-24T15:18:53.479604Z", - "iopub.status.idle": "2026-06-24T15:18:53.484973Z", - "shell.execute_reply": "2026-06-24T15:18:53.484638Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "7af49ea9", + "metadata": {}, + "source": [ + "## Important Note: Custom Flavor\n", + "\n", + "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", + "\n", + "**Always use:**\n", + "```python\n", + "from darts.utils.mlflow import load_model\n", + "model = load_model(model_uri)\n", + "```\n", + "\n", + "**Instead of:**\n", + "```python\n", + "import mlflow\n", + "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", + "```\n", + "\n", + "This custom flavor is necessary to properly handle:\n", + "- TimeSeries objects\n", + "- Darts-specific model parameters\n", + "- Covariate handling (past, future, static)\n", + "- PyTorch model state preservation" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model successfully!\n", - "Predictions shape: (5, 1)\n" - ] - } - ], - "source": [ - "# Load model from local directory\n", - "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", - "\n", - "# Test it\n", - "local_predictions = local_loaded_model.predict(n=5)\n", - "print(\"Loaded model successfully!\")\n", - "print(f\"Predictions shape: {local_predictions.values().shape}\")" - ] - }, - { - "cell_type": "markdown", - "id": "aab0d1e0", - "metadata": {}, - "source": [ - "## Querying Experiments\n", - "\n", - "You can programmatically query and compare runs." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "109a9812", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.485914Z", - "iopub.status.busy": "2026-06-24T15:18:53.485859Z", - "iopub.status.idle": "2026-06-24T15:18:53.496380Z", - "shell.execute_reply": "2026-06-24T15:18:53.496048Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "40621b13", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 4 runs in experiment 'darts-quickstart':\n", - "\n", - "1. exponential-smoothing-baseline\n", - " Run ID: 3d1f7f864f7240599e3b080109e246bf\n", - " Validation MAPE: 7.864181481214469\n", - "\n", - "2. linear-regression-full-metrics\n", - " Run ID: c655521973ca47b69ad3d423e5302759\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "3. linear-regression-autolog\n", - " Run ID: e4e4ae8b46004a5b8309337d5d58cbd2\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "4. nbeats-epoch-metrics\n", - " Run ID: d5a971cffab244e192839ae3ba1652e5\n", - " Validation MAPE: 13.639569217869525\n", - "\n" - ] - } - ], - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.val_mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"val_mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" - ] - }, - { - "cell_type": "markdown", - "id": "22685423", - "metadata": {}, - "source": [ - "### Load the Best Model" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "7b09db6a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.497560Z", - "iopub.status.busy": "2026-06-24T15:18:53.497496Z", - "iopub.status.idle": "2026-06-24T15:18:53.572540Z", - "shell.execute_reply": "2026-06-24T15:18:53.572133Z" - } - }, - "outputs": [ + "cell_type": "code", + "execution_count": 19, + "id": "51fc7c4a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.573724Z", + "iopub.status.busy": "2026-06-24T15:18:53.573637Z", + "iopub.status.idle": "2026-06-24T15:18:53.575115Z", + "shell.execute_reply": "2026-06-24T15:18:53.574817Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpvwnlx3yj\n" + ] + } + ], + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading best model from run: exponential-smoothing-baseline\n", - "Model URI: models:/m-f42705a59eb34300b377f0219577bfa4\n" - ] + "cell_type": "markdown", + "id": "ca40afc1", + "metadata": {}, + "source": [ + "# Final Remarks" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "c4c86a23", + "metadata": {}, + "source": [ + "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", - "\n", - "if runs:\n", - " best_run = runs[0]\n", - " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", - " # from the run outputs and load it with a models:/ URI\n", - " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", - " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", - "\n", - " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", - " print(f\"Model URI: {best_model_uri}\")\n", - "\n", - " best_model = load_model(best_model_uri)\n", - " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", - " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", - " if isinstance(best_model, GlobalForecastingModel):\n", - " best_predictions = best_model.predict(n=len(val), series=train)\n", - " else:\n", - " best_predictions = best_model.predict(n=len(val))\n", - "\n", - " train[-50:].plot(label=\"Training\")\n", - " val.plot(label=\"Actual\")\n", - " best_predictions.plot(label=\"Best Model Forecast\")\n", - " plt.legend()\n", - " plt.title(\"Best Model Predictions\")\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "6f1ec89e", - "metadata": {}, - "source": [ - "## Model Registry\n", - "\n", - "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived).\n", - "\n", - "```python\n", - "# Register a model from a run\n", - "result = mlflow.register_model(\n", - " model_uri=f\"runs:/{best_run.info.run_id}/model\",\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")\n", - "```\n", - "\n", - "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", - "\n", - "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_models.png)" - ] - }, - { - "cell_type": "markdown", - "id": "7af49ea9", - "metadata": {}, - "source": [ - "## Important Note: Custom Flavor\n", - "\n", - "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", - "\n", - "**Always use:**\n", - "```python\n", - "from darts.utils.mlflow import load_model\n", - "model = load_model(model_uri)\n", - "```\n", - "\n", - "**Instead of:**\n", - "```python\n", - "import mlflow\n", - "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", - "```\n", - "\n", - "This custom flavor is necessary to properly handle:\n", - "- TimeSeries objects\n", - "- Darts-specific model parameters\n", - "- Covariate handling (past, future, static)\n", - "- PyTorch model state preservation" - ] - }, - { - "cell_type": "markdown", - "id": "40621b13", - "metadata": {}, - "source": [ - "## Cleanup" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "51fc7c4a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.573724Z", - "iopub.status.busy": "2026-06-24T15:18:53.573637Z", - "iopub.status.idle": "2026-06-24T15:18:53.575115Z", - "shell.execute_reply": "2026-06-24T15:18:53.574817Z" } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpyqkqfzoe\n" - ] + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.11.9)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01ac1053789e45fab75e2cde894b417a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02cefe41f8814ddf9de26418b26783c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "03569ea4478d4d74b0ae4c5416c40d6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "055bae1119db45caa5b6cd91921c76d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", + "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", + "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" + ], + "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", + "tabbable": null, + "tooltip": null + } + }, + "05d25d3b3bd9497f86849702e5a19515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "071709416bab4673a582978e2e3592a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e8c0b16c2d430ea8bb6798e9b4f103": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", + "placeholder": "​", + "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "0deaf695a8544725ac4904ff7388f489": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "11dbeaae3ae640c3995e784abfda15c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", + "placeholder": "​", + "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "12524abe09304f9bb20bd9978ac2a44d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", + "placeholder": "​", + "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 189.90it/s]" + } + }, + "13af542c17d64851a3ef54ce9610bb99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "153af823c040405dbc075bf50a28ff17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "16656416b10a43c8b81c6c4b2a02ec0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "16ce59abc5bb4ffe978736017f60e21a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", + "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", + "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" + ], + "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", + "tabbable": null, + "tooltip": null + } + }, + "19382158e51343918122512753ca25c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "20cca542fe2a4e19846e2e1cb07dd165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "252a64f9c6d440e2a3d3c3f62f44d764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", + "placeholder": "​", + "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", + "tabbable": null, + "tooltip": null, + "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" + } + }, + "27e25633e2a549dcbfafe1129839043d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b154733d72e4e468c339683e83c30a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b197d3911154085bb86f0dbba2c8b98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c4ee939558d44a4a3bc9040a940693f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", + "placeholder": "​", + "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 199.01it/s]" + } + }, + "2e727ab68ed64ee98bfb9d81f1e39c1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", + "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", + "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" + ], + "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", + "tabbable": null, + "tooltip": null + } + }, + "2ec00b06939145ec95930e3c1490efcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", + "placeholder": "​", + "style": "IPY_MODEL_19382158e51343918122512753ca25c7", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "30a18f8c59754940a9785cd152a67daa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "32e9a01e1a2b4914989eda6f6832f989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "331f7f90d7d049a6adc72c260c06570e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "33a28231831d473aa27d32e1c15a8989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35778f5ef201497d8d453772f80a7978": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "366e2af2827540728d29bfa6d931dbdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", + "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", + "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" + ], + "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", + "tabbable": null, + "tooltip": null + } + }, + "3799be676aea4d12b87992115e4b90ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a36a442c4a94ab585d8522e57f45c34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3b44dec6a3354f7ebc4117e7d7f50b1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", + "placeholder": "​", + "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "3c3d34b732664135a79031e8bc9e2984": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3cde338fcaf548de8e8216a98e66f9bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", + "placeholder": "​", + "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 195.74it/s]" + } + }, + "3dddd89019c849f0872e9a9700e14ad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", + "placeholder": "​", + "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", + "tabbable": null, + "tooltip": null, + "value": "Predicting DataLoader 0: 100%" + } + }, + "40b8f5c6c7844bd0bb071f043f97a639": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "40df96a9f08440a893ffe9d57d176e1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41e23a2458044b888fb76fd882428b39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "42360fe280a14e44831c8e62f6ad249e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "425a21a3b7604c8cb49871c1b2850f68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4297b4158e4f43da9226bfc00272f9c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "43eab5ba00014d7ba62f97acd9e93eba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44c3cc7783594142a19ffad035eea9d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "4787d389023845a8ae398eb5d1155ab1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "480afa5d41c145d0ac88e2adaca7b1e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", + "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", + "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" + ], + "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", + "tabbable": null, + "tooltip": null + } + }, + "4b3f0ca06bf54eb9bab4e081dabcf139": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f10caf0abca4aa59053c4cb374ea3d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "50e4f1e4cd994abeae53d0f84b6afd44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "522af0834c254f0eb2fe7c9efa74c5f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "54aad655289741b59d3c83b8508e68b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", + "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", + "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" + ], + "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", + "tabbable": null, + "tooltip": null + } + }, + "55e102413ba54377b2fd1995b98c7858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "579cbbe7cfb34e429bffd11ec774ba50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "57cd2f911c6840da87c1d6c8a78521e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "57db1d3f28d347878d9f48d0ceef5589": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", + "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", + "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" + ], + "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", + "tabbable": null, + "tooltip": null + } + }, + "580c0814097844e186ef642094968d3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "590ebae9a3664214be16b105941c7ee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59413112366944be8e0d6600880dc1a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dcf47d8b9c0420898fe491a81bab8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", + "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", + "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" + ], + "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", + "tabbable": null, + "tooltip": null + } + }, + "61734f2b95c34e13971fd65cd7da2e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "641b5ae5b9e7475db63a31e67b13b601": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "642a06d187834b96af41b74a25d13e1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6da83aee80314ceb9ace5fa0c4c76529": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9e33a121da334db899669d702f9d54ce", + "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", + "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" + ], + "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", + "tabbable": null, + "tooltip": null + } + }, + "6dad7db23e9e4397bfb93655cd8b08b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e794979a2793408791ee570d3af6f371", + "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", + "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" + ], + "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", + "tabbable": null, + "tooltip": null + } + }, + "6eb691aae3a44a25b1e7471929151f47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71c1aa3663804753bf3a75a227412072": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72125343cca3416fbd3f012232e63ae5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "761dbbe1bf4e4804a3649858898b78e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7adbf399ea5e4a7c990cdff60674b593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", + "max": 3, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", + "tabbable": null, + "tooltip": null, + "value": 3 + } + }, + "7d599e5710f4485a8f7580c7efca3bc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e0ad83f116b4933a35870525656df5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "81e281800a094e34b2e43021bea6fd11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", + "placeholder": "​", + "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 174.77it/s]" + } + }, + "859b368a8a6d4500960a6e2285f4c016": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86bfcc40b08440af98f64a732df1ea5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8766872fa61844458d70112fcf44bdb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8825c219393f4040890a639a17210bc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "89dc0773756b4b7b93cce8e6cfe47202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", + "placeholder": "​", + "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 100.83it/s]" + } + }, + "8d829381b5034ed9807b86d514b1fdbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "8e6984bd5a00425bb9071deba84f4cea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8f2ac8fd36964f11bd556782c96b0f72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "924315df026a41fb97d7cc8488bb8503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95daeef1bd3e4f77b883d3d71fcd1fac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", + "placeholder": "​", + "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", + "tabbable": null, + "tooltip": null, + "value": "Sanity Checking DataLoader 0: 100%" + } + }, + "97b2d3e5a7e847739b237fc9c5cdc3a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9914744ed44845fd9d00727c7da93d32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "9a20b5d724584e289863cf63a4c13259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b1dd53c1fdd45dabf3660e9e0be1310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", + "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", + "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" + ], + "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", + "tabbable": null, + "tooltip": null + } + }, + "9b8b6898ef244336989227f5469a2d11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b933a5d5aa14741904151b4ea7e3f50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", + "placeholder": "​", + "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 88.28it/s]" + } + }, + "9e33a121da334db899669d702f9d54ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", + "placeholder": "​", + "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", + "tabbable": null, + "tooltip": null, + "value": "Epoch 9: 100%" + } + }, + "9fd5c0e984d04e4aa0e106ec89434720": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "a30948d8cfd6491484d6b63591b65a84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a5f3118f4f9040ebbdb1a7acae012087": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1dc954934944e92914a1c129d8c7dcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b23efdc3bb5747af96dd5e539a14b5c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", + "placeholder": "​", + "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "b35ce184b43b48daaa39ccef748eeac6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "b4d7ddbd507e4e1681cc0888680abb5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b4e804d6e4b44314a8847c2f5be857d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b6625b52007b4434a7804cfd824452cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", + "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", + "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" + ], + "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", + "tabbable": null, + "tooltip": null + } + }, + "b676b1571a00427587827caac8158c14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "be1dd700617141cf9517ee7ef1153746": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c198ffce01de4b7294649c1619b5b7e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c255e442c01446699af3179f14eb8fc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", + "placeholder": "​", + "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "c2906f9d5f47471ca6bf44d8754f8d30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c325a187e8a54e639300ff5a29640f03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c60add7b277344feaad65a884c7fbf37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c7c373a0b1c14b809041651ffcdd4559": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c99d9a52749b40628b8d148c64e75e88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb3cebaf14cc445a8055d1aac2f0d05c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", + "placeholder": "​", + "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 180.77it/s]" + } + }, + "cc7d97d8845d46ff9d946020b1b8e4cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "cd4d74958b704246a2cb2462a784d502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce45f3190357423a9563bfae253f2f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce49dfd502074696aefcfa2cff18e4f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce97bb2d961e4dc9bf44a646cb3d3aff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d04931a3bb0c47329cdd67701a7be0ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", + "placeholder": "​", + "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 192.16it/s]" + } + }, + "d473da3081af4d4a810014019cd40b29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", + "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", + "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" + ], + "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", + "tabbable": null, + "tooltip": null + } + }, + "d4b49fabdd4543959d64e4e1c60dc360": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "d9fc58b33d2645488a8c53af72f21e7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "da4c6178632b4cfe96d2a9504cc3173b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc6cccb142db43b7ac9849983a154a20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dcb0a4350297443aa61691406923fb81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcced12e0ae04e32a811f60680db24f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", + "placeholder": "​", + "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "e09f041d857346029cbba27fb36f009e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e12d00f1e1b94e749f22904d3cec2445": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", + "placeholder": "​", + "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 186.36it/s]" + } + }, + "e19ea3de3e554c50a7300a7214c773f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e53d8d156b1c4db6aff2ba8395bf5415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e6dfb5d14dfe4a1193e551f414ea393e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7198635809b4f56bd1a30b6cbe661cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e742e68a86474f0db17ccb64db4264c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e794979a2793408791ee570d3af6f371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", + "placeholder": "​", + "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "ed4968eb8435434db1604e34ee657413": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eeb45b37592a4a599da1857d3444382e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", + "placeholder": "​", + "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f03f6404137144b8b600f8131c78ac63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f286ebc675c549678f70419f668a7baa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f299c926a6a64a769d3db2e71725f8af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f60411b259344a9e9a892d9552ecdabf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f609670bc6b840ed9f8698af8c7615a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f69737793cc648bd9aadfc0dd4b16569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", + "placeholder": "​", + "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f6f12cd135674388b0fc72167a0308eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fb53a4348865461783df6d1e5b16386b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", + "placeholder": "​", + "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.28it/s]" + } + }, + "fb7ccdb37f844e989de3f7a0b12b8924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fe3a78bc7ec842b08aac1b4e0fe1ed29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", + "placeholder": "​", + "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.93it/s]" + } + }, + "fe40606eebe6464db0b7f86e5abe1997": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", + "placeholder": "​", + "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 177.56it/s]" + } + }, + "fffac86b0934453d88f52df4b9ac6dd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } } - ], - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ] }, - { - "cell_type": "markdown", - "id": "ca40afc1", - "metadata": {}, - "source": [ - "# Final Remarks" - ] - }, - { - "cell_type": "markdown", - "id": "c4c86a23", - "metadata": {}, - "source": [ - "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv (3.11.9)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "01ac1053789e45fab75e2cde894b417a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "02cefe41f8814ddf9de26418b26783c3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "03569ea4478d4d74b0ae4c5416c40d6d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "055bae1119db45caa5b6cd91921c76d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", - "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", - "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" - ], - "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", - "tabbable": null, - "tooltip": null - } - }, - "05d25d3b3bd9497f86849702e5a19515": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "071709416bab4673a582978e2e3592a3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "07e8c0b16c2d430ea8bb6798e9b4f103": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", - "placeholder": "​", - "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "0deaf695a8544725ac4904ff7388f489": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "11dbeaae3ae640c3995e784abfda15c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", - "placeholder": "​", - "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "12524abe09304f9bb20bd9978ac2a44d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", - "placeholder": "​", - "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 189.90it/s]" - } - }, - "13af542c17d64851a3ef54ce9610bb99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "153af823c040405dbc075bf50a28ff17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "16656416b10a43c8b81c6c4b2a02ec0b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "16ce59abc5bb4ffe978736017f60e21a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", - "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", - "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" - ], - "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", - "tabbable": null, - "tooltip": null - } - }, - "19382158e51343918122512753ca25c7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "20cca542fe2a4e19846e2e1cb07dd165": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "252a64f9c6d440e2a3d3c3f62f44d764": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", - "placeholder": "​", - "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", - "tabbable": null, - "tooltip": null, - "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" - } - }, - "27e25633e2a549dcbfafe1129839043d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b154733d72e4e468c339683e83c30a7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b197d3911154085bb86f0dbba2c8b98": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2c4ee939558d44a4a3bc9040a940693f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", - "placeholder": "​", - "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 199.01it/s]" - } - }, - "2e727ab68ed64ee98bfb9d81f1e39c1d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", - "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", - "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" - ], - "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", - "tabbable": null, - "tooltip": null - } - }, - "2ec00b06939145ec95930e3c1490efcc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", - "placeholder": "​", - "style": "IPY_MODEL_19382158e51343918122512753ca25c7", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "30a18f8c59754940a9785cd152a67daa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "32e9a01e1a2b4914989eda6f6832f989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "331f7f90d7d049a6adc72c260c06570e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "33a28231831d473aa27d32e1c15a8989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "35778f5ef201497d8d453772f80a7978": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "366e2af2827540728d29bfa6d931dbdb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", - "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", - "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" - ], - "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", - "tabbable": null, - "tooltip": null - } - }, - "3799be676aea4d12b87992115e4b90ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3a36a442c4a94ab585d8522e57f45c34": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3b44dec6a3354f7ebc4117e7d7f50b1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", - "placeholder": "​", - "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "3c3d34b732664135a79031e8bc9e2984": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3cde338fcaf548de8e8216a98e66f9bc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", - "placeholder": "​", - "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 195.74it/s]" - } - }, - "3dddd89019c849f0872e9a9700e14ad0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", - "placeholder": "​", - "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", - "tabbable": null, - "tooltip": null, - "value": "Predicting DataLoader 0: 100%" - } - }, - "40b8f5c6c7844bd0bb071f043f97a639": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "40df96a9f08440a893ffe9d57d176e1f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41e23a2458044b888fb76fd882428b39": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "42360fe280a14e44831c8e62f6ad249e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "425a21a3b7604c8cb49871c1b2850f68": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4297b4158e4f43da9226bfc00272f9c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "43eab5ba00014d7ba62f97acd9e93eba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "44c3cc7783594142a19ffad035eea9d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "4787d389023845a8ae398eb5d1155ab1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "480afa5d41c145d0ac88e2adaca7b1e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", - "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", - "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" - ], - "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", - "tabbable": null, - "tooltip": null - } - }, - "4b3f0ca06bf54eb9bab4e081dabcf139": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4f10caf0abca4aa59053c4cb374ea3d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "50e4f1e4cd994abeae53d0f84b6afd44": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "522af0834c254f0eb2fe7c9efa74c5f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "54aad655289741b59d3c83b8508e68b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", - "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", - "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" - ], - "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", - "tabbable": null, - "tooltip": null - } - }, - "55e102413ba54377b2fd1995b98c7858": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "579cbbe7cfb34e429bffd11ec774ba50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "57cd2f911c6840da87c1d6c8a78521e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "57db1d3f28d347878d9f48d0ceef5589": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", - "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", - "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" - ], - "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", - "tabbable": null, - "tooltip": null - } - }, - "580c0814097844e186ef642094968d3a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "590ebae9a3664214be16b105941c7ee3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "59413112366944be8e0d6600880dc1a4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5dcf47d8b9c0420898fe491a81bab8af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", - "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", - "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" - ], - "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", - "tabbable": null, - "tooltip": null - } - }, - "61734f2b95c34e13971fd65cd7da2e1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "641b5ae5b9e7475db63a31e67b13b601": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "642a06d187834b96af41b74a25d13e1a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6da83aee80314ceb9ace5fa0c4c76529": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9e33a121da334db899669d702f9d54ce", - "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", - "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" - ], - "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", - "tabbable": null, - "tooltip": null - } - }, - "6dad7db23e9e4397bfb93655cd8b08b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e794979a2793408791ee570d3af6f371", - "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", - "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" - ], - "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", - "tabbable": null, - "tooltip": null - } - }, - "6eb691aae3a44a25b1e7471929151f47": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "71c1aa3663804753bf3a75a227412072": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "72125343cca3416fbd3f012232e63ae5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "761dbbe1bf4e4804a3649858898b78e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7adbf399ea5e4a7c990cdff60674b593": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", - "max": 3, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", - "tabbable": null, - "tooltip": null, - "value": 3 - } - }, - "7d599e5710f4485a8f7580c7efca3bc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e0ad83f116b4933a35870525656df5d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "81e281800a094e34b2e43021bea6fd11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", - "placeholder": "​", - "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 174.77it/s]" - } - }, - "859b368a8a6d4500960a6e2285f4c016": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "86bfcc40b08440af98f64a732df1ea5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8766872fa61844458d70112fcf44bdb3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8825c219393f4040890a639a17210bc5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "89dc0773756b4b7b93cce8e6cfe47202": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", - "placeholder": "​", - "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 100.83it/s]" - } - }, - "8d829381b5034ed9807b86d514b1fdbb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "8e6984bd5a00425bb9071deba84f4cea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8f2ac8fd36964f11bd556782c96b0f72": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "924315df026a41fb97d7cc8488bb8503": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "95daeef1bd3e4f77b883d3d71fcd1fac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", - "placeholder": "​", - "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", - "tabbable": null, - "tooltip": null, - "value": "Sanity Checking DataLoader 0: 100%" - } - }, - "97b2d3e5a7e847739b237fc9c5cdc3a9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9914744ed44845fd9d00727c7da93d32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "9a20b5d724584e289863cf63a4c13259": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b1dd53c1fdd45dabf3660e9e0be1310": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", - "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", - "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" - ], - "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", - "tabbable": null, - "tooltip": null - } - }, - "9b8b6898ef244336989227f5469a2d11": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b933a5d5aa14741904151b4ea7e3f50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", - "placeholder": "​", - "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 88.28it/s]" - } - }, - "9e33a121da334db899669d702f9d54ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", - "placeholder": "​", - "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", - "tabbable": null, - "tooltip": null, - "value": "Epoch 9: 100%" - } - }, - "9fd5c0e984d04e4aa0e106ec89434720": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "a30948d8cfd6491484d6b63591b65a84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a5f3118f4f9040ebbdb1a7acae012087": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b1dc954934944e92914a1c129d8c7dcd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b23efdc3bb5747af96dd5e539a14b5c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", - "placeholder": "​", - "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "b35ce184b43b48daaa39ccef748eeac6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "b4d7ddbd507e4e1681cc0888680abb5b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b4e804d6e4b44314a8847c2f5be857d4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b6625b52007b4434a7804cfd824452cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", - "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", - "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" - ], - "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", - "tabbable": null, - "tooltip": null - } - }, - "b676b1571a00427587827caac8158c14": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "be1dd700617141cf9517ee7ef1153746": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c198ffce01de4b7294649c1619b5b7e6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c255e442c01446699af3179f14eb8fc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", - "placeholder": "​", - "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "c2906f9d5f47471ca6bf44d8754f8d30": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c325a187e8a54e639300ff5a29640f03": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c60add7b277344feaad65a884c7fbf37": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c7c373a0b1c14b809041651ffcdd4559": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c99d9a52749b40628b8d148c64e75e88": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cb3cebaf14cc445a8055d1aac2f0d05c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", - "placeholder": "​", - "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 180.77it/s]" - } - }, - "cc7d97d8845d46ff9d946020b1b8e4cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "cd4d74958b704246a2cb2462a784d502": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce45f3190357423a9563bfae253f2f16": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce49dfd502074696aefcfa2cff18e4f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ce97bb2d961e4dc9bf44a646cb3d3aff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d04931a3bb0c47329cdd67701a7be0ad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", - "placeholder": "​", - "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 192.16it/s]" - } - }, - "d473da3081af4d4a810014019cd40b29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", - "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", - "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" - ], - "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", - "tabbable": null, - "tooltip": null - } - }, - "d4b49fabdd4543959d64e4e1c60dc360": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d9fc58b33d2645488a8c53af72f21e7a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "da4c6178632b4cfe96d2a9504cc3173b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dc6cccb142db43b7ac9849983a154a20": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dcb0a4350297443aa61691406923fb81": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dcced12e0ae04e32a811f60680db24f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", - "placeholder": "​", - "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "e09f041d857346029cbba27fb36f009e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e12d00f1e1b94e749f22904d3cec2445": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", - "placeholder": "​", - "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 186.36it/s]" - } - }, - "e19ea3de3e554c50a7300a7214c773f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e53d8d156b1c4db6aff2ba8395bf5415": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e6dfb5d14dfe4a1193e551f414ea393e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e7198635809b4f56bd1a30b6cbe661cf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e742e68a86474f0db17ccb64db4264c9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e794979a2793408791ee570d3af6f371": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", - "placeholder": "​", - "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "ed4968eb8435434db1604e34ee657413": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "eeb45b37592a4a599da1857d3444382e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", - "placeholder": "​", - "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f03f6404137144b8b600f8131c78ac63": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f286ebc675c549678f70419f668a7baa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f299c926a6a64a769d3db2e71725f8af": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f60411b259344a9e9a892d9552ecdabf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f609670bc6b840ed9f8698af8c7615a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f69737793cc648bd9aadfc0dd4b16569": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", - "placeholder": "​", - "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f6f12cd135674388b0fc72167a0308eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fb53a4348865461783df6d1e5b16386b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", - "placeholder": "​", - "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.28it/s]" - } - }, - "fb7ccdb37f844e989de3f7a0b12b8924": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fe3a78bc7ec842b08aac1b4e0fe1ed29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", - "placeholder": "​", - "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.93it/s]" - } - }, - "fe40606eebe6464db0b7f86e5abe1997": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", - "placeholder": "​", - "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 177.56it/s]" - } - }, - "fffac86b0934453d88f52df4b9ac6dd6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } From a486b25996134f29c42c56a4bb6351d75596bf88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 15:15:06 +0200 Subject: [PATCH 081/154] feat: handle name param for metrics --- darts/tests/optional_deps/test_mlflow.py | 33 +++++++++++++++++ darts/utils/mlflow.py | 47 +++++++++++++++--------- examples/29-MLflow-quickstart.ipynb | 4 +- 3 files changed, 66 insertions(+), 18 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 228f665750..c28581e8bf 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -853,6 +853,39 @@ def test_autolog_metric_multi_series_per_component( assert got[("series_mae_linear_1", 0)] == pytest.approx(ref[0, 1], abs=1e-5) assert got[("series_mae_linear_1", 1)] == pytest.approx(ref[1, 1], abs=1e-5) + def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): + """The metric `name` kwarg overrides only the metric-name token in the key, + keeping the dataset/backtest prefix and the quantile/axis suffixes.""" + actual = self.ts_univariate + train = self.ts_univariate[:40] + qmodel = self._fit_qlr(train) + pred = qmodel.predict(n=10, num_samples=200) + target = self.ts_univariate[40:] + + with autolog_context(log_metrics=True): + # direct call: name replaces the metric token; suffix (_q0_5) preserved + with mlflow.start_run() as run_direct: + dm.mae(actual, actual * 1.1, name="custom") + dm.mql(target, pred, q=0.5, name="myq") + # backtest: name replaces the metric token; backtest_ prefix preserved + with mlflow.start_run() as run_bt: + self._fit_lr().backtest( + self.ts_univariate, + metric=dm.mae, + metric_kwargs={"name": "custom"}, + retrain=False, + stride=10, + ) + + direct = mlflow.get_run(run_direct.info.run_id).data.metrics + assert "actual_custom" in direct + assert "actual_mae" not in direct, "default metric name should be replaced" + assert "target_myq_q0_5" in direct, "quantile suffix should be preserved" + + bt = mlflow.get_run(run_bt.info.run_id).data.metrics + assert "backtest_custom" in bt + assert "backtest_mae" not in bt, "default metric name should be replaced" + def test_autolog_metric_multi_series_classification_labels_inferred( self, mlflow_tracking, autolog_context ): diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index bd5ec7c439..a38bf2aedd 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -423,19 +423,21 @@ def autolog( .. note:: - Logged metric keys depend on the result shape: - - * **Scalar** → ``{metric_name}`` - * **Per-component** (1-D, single series) → - ``{metric_name}_{component_name}`` - * **Per-series** (1-D, list of series) → - ``{metric_name}_{series_idx}`` - * **Per-series × per-component** (2-D) → - ``{metric_name}_{component_name}_{series_idx}`` - - When a dataset variable name can be captured via frame inspection, - it is inserted after the metric name (e.g. - ``{metric_name}_{dataset_name}_{component_name}``). + Logged metric keys follow the pattern + ``{dataset_name}_{metric_name}{component}{quantile_or_label}``, where + each part is included only when the corresponding axis is present: + + * ``dataset_name`` – variable name of the first argument, captured via + frame inspection (omitted when not found). + * ``metric_name`` – the metric function name, or the ``name`` keyword + argument when provided (it overrides only this token). + * ``component`` – the component name when ``component_reduction=None``. + * ``quantile_or_label`` – e.g. ``_q0.5`` / ``_qi0.1_0.9`` / ``_label1``. + + Per-timestep results (``time_reduction=None``) are charted across the + MLflow ``step``. For a list of series the logged value is the mean over + series and the full per-series breakdown is written to a + ``per_series_metrics/`` CSV artifact. Parameters ---------- @@ -879,7 +881,9 @@ def _log_backtest_metrics( (windows, timesteps, components × quantiles, metrics) inferred from the metric signatures and ``backtest_args``, logging every cell under a descriptive key with the time axis (or window axis when time is reduced) - mapped to the MLflow ``step``. + mapped to the MLflow ``step``. A metric's ``name`` entry in + ``metric_kwargs`` overrides the metric-name token in the key (the + ``backtest_`` prefix and axis suffixes are preserved). Shape inference respects all kwargs that affect output dimensions: @@ -927,8 +931,11 @@ def _log_backtest_metrics( # backtest accepts a single dict that applies to all metrics; broadcast it if len(metric_kwargs) != len(metric): metric_kwargs = [metric_kwargs[0]] * len(metric) + # the `name` entry in metric_kwargs overrides the metric-name token in the key metric_names = [ - _sanitize_mlflow_key(getattr(m, "__name__", f"metric_{i}")) + _sanitize_mlflow_key( + metric_kwargs[i].get("name") or getattr(m, "__name__", f"metric_{i}") + ) for i, m in enumerate(metric) ] n_metrics = len(metric) @@ -1207,7 +1214,8 @@ def _log_metric_result( Parameters ---------- metric_name - Base metric name used as the MLflow key. + Base metric name used as the MLflow key (the metric's ``name`` keyword + argument when provided, otherwise the metric function name). result The metric result to log. series @@ -1341,6 +1349,8 @@ def _make_metric_patch(metric_name: str) -> Callable: * ``dataset_name`` – Python variable name of the first argument in the caller's frame (captured via frame inspection, omitted if not found). + * ``metric_name`` – the metric function name, or the ``name`` keyword + argument when provided (it overrides only this token). * ``component`` – ``_{component_name}`` when ``component_reduction=None``. * ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.5``, ``_qi0.1_0.9``, ``_label1``) when applicable. @@ -1385,6 +1395,9 @@ def _patched_metric(original, *args, **kwargs): raw = _inspect_original_var_name(series, fallback_name=None) dataset_name = _sanitize_mlflow_key(raw) if raw else None + # the `name` kwarg overrides the metric-name token in the logged key + key_name = _sanitize_mlflow_key(kwargs.get("name") or metric_name) + # infer output axes from the metric signature + call kwargs has_time_axis, has_comp_axis, quantiles_num, quantiles_labels = ( _infer_metric_axes(original, kwargs) @@ -1403,7 +1416,7 @@ def _patched_metric(original, *args, **kwargs): _log_metric_result( autologging_client, run_id, - metric_name, + key_name, result, series, has_time_axis, diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index c64140f653..989ee5a94f 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -927,7 +927,9 @@ "\n", "Per-component results (`component_reduction=None`) add the component name (e.g. `val_mae_`), quantile metrics (`q`, `q_interval`) add the quantile (e.g. `val_mql_q0.5`), per-label classification (`label_reduction=None`) adds the class (e.g. `val_f1_label1`), and per-timestep metrics (`time_reduction=None`) are charted across MLflow steps.\n", "\n", - "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is saved as a CSV artifact under `per_series_metrics/`." + "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is saved as a CSV artifact under `per_series_metrics/`.\n", + "\n", + "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the prefix and suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `val_foo_q0.5`)." ] }, { From e2c67589fa8b353b0bb51fc25ce83bd887aa795b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 25 Jun 2026 15:43:22 +0200 Subject: [PATCH 082/154] chore: changelog --- CHANGELOG.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 541d12fa6d..b62e8f1ef8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,10 +11,19 @@ but cannot always guarantee backwards compatibility. Changes that may **break co **Improved** +- 🚀🚀 Added a custom MLflow model flavor for Darts, available under `darts.utils.mlflow`. It provides an MLflow integration for any Darts `ForecastingModel` (statistical, scikit-learn-like, and PyTorch-based). [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). + - Added `save_model()`, `load_model()`, and `log_model()` to persist and reload Darts models as MLflow models, including model and covariate metadata. + - Added `autolog()` to automatically log model creation parameters, covariate usage, metrics, and the trained model artifact on every `fit()`, `backtest()` and `historical_forecasts()` call within an active MLflow run. + - Metric functions from `darts.metrics` are automatically logged when called inside an active run, with keys reflecting the metric output shape (per-component, per-quantile/interval, per-label, and per-timestep results charted across MLflow steps). Multi-series results log the mean over series and write the full per-series breakdown to a CSV artifact. + - Added a new notebook for [MLflow quickstart](https://unit8co.github.io/darts/examples/29-MLflow-quickstart.html) with detailed usage examples. + - Note: model serving and deployment (MLflow's `pyfunc` flavor, model signatures, and input examples) are not yet supported. + **Fixed** **Dependencies** +- Added an optional `mlflow` extra (`mlflow>=3.0`) enabling the MLflow integration. [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). + ### For developers of the library: ## [0.45.0](https://github.com/unit8co/darts/tree/0.45.0) (2026-06-19) From de8e14928bdc236ca75d295d745ae0153190652d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 09:48:14 +0200 Subject: [PATCH 083/154] docs: documentation clarifications --- darts/utils/mlflow.py | 44 ++++++++++++++++++++++++++++--------------- 1 file changed, 29 insertions(+), 15 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index a38bf2aedd..1097046e17 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1,14 +1,19 @@ """ -MLflow Integration for Darts ------------------------------ +MLflow Integration +------------------ -Custom MLflow model flavor for darts forecasting models. Supports saving, loading, -logging and autolog for any darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) -to MLflow. +Custom MLflow model flavor for Darts forecasting models. Supports saving, loading, +and logging any Darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) +to MLflow, as well as automatic logging (``autolog()``) of: -This module is partly adapted from and inspired by the open-source -implementation of SKtime's MLflow integration, with modifications to support -autologging and handle Darts-specific model and covariate metadata. +* Model creation parameters and covariate usage information. +* The trained model artifact, after each ``fit()`` call. +* Darts metric function calls made inside an active MLflow run. +* ``backtest()`` evaluation metrics. +* Per-epoch training/validation metrics for PyTorch-based models. + +See the `MLflow quickstart example `_ +for an end-to-end walkthrough. References: https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py @@ -410,6 +415,9 @@ def autolog( 5. For PyTorch-based models: leverage ``mlflow.pytorch.autolog()`` to automatically log per-epoch training and validation metrics. 6. Log the trained model artifact at the end of training. + 7. Patch ``backtest()`` to log evaluation metrics under ``backtest_*`` keys. + 8. Patch ``historical_forecasts()`` so that its internal per-window + ``fit()`` calls don't each spawn their own logging. .. important:: @@ -432,7 +440,11 @@ def autolog( * ``metric_name`` – the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). * ``component`` – the component name when ``component_reduction=None``. - * ``quantile_or_label`` – e.g. ``_q0.5`` / ``_qi0.1_0.9`` / ``_label1``. + * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi0.100_0.900`` / ``_label1``. + + When ``series_reduction`` is set on a metric call, results are already + aggregated across series inside the metric itself, so the mean-over-series + logging described below does not apply. Per-timestep results (``time_reduction=None``) are charted across the MLflow ``step``. For a list of series the logged value is the mean over @@ -889,13 +901,15 @@ def _log_backtest_metrics( * ``time_reduction`` – collapses the time axis (``T=1``). * ``component_reduction`` – collapses the component axis (``C=1``). - * ``series_reduction`` – if non-``None``, windows are already aggregated + * ``series_reduction`` – if other than ``None``, windows are already aggregated inside the metric, so ``W=1`` regardless of ``backtest.reduction``. * ``q`` / ``q_interval`` – expand the component axis with one entry per quantile / interval. - * ``label_reduction`` / ``labels`` – expand the component axis for - classification metrics. - * ``reduction=None`` – no aggregation across windows → one value per window. + * ``labels`` - expand each component with one entry per label along + the component axis. + * ``label_reduction`` – collapses the labels along the component axis. + value; ``labels`` only restricts which classes are scored. + * ``reduction=None`` – no aggregation across windows -> one value per window. * ``last_points_only`` – collapses all windows into one TimeSeries before scoring, so there is effectively only one window regardless of reduction. @@ -940,7 +954,7 @@ def _log_backtest_metrics( ] n_metrics = len(metric) - # reduction=None means no aggregation across windows → one value per window. + # reduction=None means no aggregation across windows -> one value per window. # last_points_only collapses all windows into one TimeSeries before scoring, # so there is effectively only one window regardless of reduction. has_windows = backtest_args.get("reduction") is None and not backtest_args.get( @@ -1243,7 +1257,7 @@ def _log_metric_result( base_key = f"{dataset_name}_{metric_name}" if dataset_name else metric_name if series_reduced: - # series_reduction aggregated across series → single result, no series axis + # series_reduction aggregated across series -> single result, no series axis series_seq = [get_single_series(series)] results = [result] else: From 94eaafef5ce5ece95ba8d5010dc9a2f8c4ab0adc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 10:57:26 +0200 Subject: [PATCH 084/154] chore: small code review improvements --- darts/utils/mlflow.py | 86 ++++++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 34 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 1097046e17..3a473f1a12 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -21,16 +21,26 @@ import csv import inspect -import json -import os import re import sys import threading from collections.abc import Callable from operator import itemgetter +from pathlib import Path from typing import Any -import mlflow +from darts.logging import raise_log + +try: + import mlflow +except ImportError: + raise_log( + ImportError( + "MLflow is required for `darts.utils.mlflow`. Install it with `pip" + " install mlflow`." + ) + ) + import numpy as np import yaml from mlflow.entities import LoggedModel @@ -79,6 +89,12 @@ get_single_series, series2seq, ) +from darts.utils.utils import TORCH_AVAILABLE + +if TORCH_AVAILABLE: + from darts.models.forecasting.torch_forecasting_model import ( + TorchForecastingModel, + ) logger = get_logger(__name__) @@ -176,21 +192,20 @@ def save_model( raise_log( ValueError( "Model must be an instance of darts.models.forecasting.ForecastingModel." - ), - logger, + ) ) _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements) - path = os.path.abspath(path) - _validate_and_prepare_target_save_path(path) - code_dir_subpath = _validate_and_copy_code_paths(code_paths, path) + path = Path(path).resolve() + _validate_and_prepare_target_save_path(str(path)) + code_dir_subpath = _validate_and_copy_code_paths(code_paths, str(path)) is_torch = _is_torch_model(model) # clean=True excludes any timeseries or callbacks from the model file model_file = _MODEL_FILE_TORCH if is_torch else _MODEL_FILE_STAT - model.save(os.path.join(path, model_file), clean=True) + model.save(str(path / model_file), clean=True) model_class = _get_fully_qualified_class_name(model) @@ -201,7 +216,7 @@ def save_model( mlflow_model.signature = signature if input_example is not None: - _save_example(mlflow_model, input_example, path) + _save_example(mlflow_model, input_example, str(path)) if metadata is not None: mlflow_model.metadata = metadata @@ -213,7 +228,7 @@ def save_model( model_class=model_class, code=code_dir_subpath, ) - mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME)) + mlflow_model.save(str(path / MLMODEL_FILE_NAME)) if pip_requirements is None: default_reqs = get_default_pip_requirements() @@ -230,21 +245,21 @@ def save_model( else _process_conda_env(conda_env) ) - with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f: + with open(path / _CONDA_ENV_FILE_NAME, "w") as f: yaml.safe_dump(conda_env, stream=f, default_flow_style=False) if pip_constraints: - write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) + write_to(str(path / _CONSTRAINTS_FILE_NAME), "\n".join(pip_constraints)) - write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) - _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME)) + write_to(str(path / _REQUIREMENTS_FILE_NAME), "\n".join(pip_requirements)) + _PythonEnv.current().to_yaml(str(path / _PYTHON_ENV_FILE_NAME)) def load_model( model_uri: str, dst_path: str | None = None, **kwargs, -): +) -> ForecastingModel: """Load a darts model from an MLflow model URI. Parameters @@ -279,13 +294,12 @@ def load_model( raise_log( ValueError( f"Cannot load model: class `{model_cls_str}` is not a subclass of `ForecastingModel`." - ), - logger, + ) ) - model_path = os.path.join(local_path, flavor_conf["data"]) + model_path = Path(local_path) / flavor_conf["data"] - return model_cls.load(model_path, **kwargs) + return model_cls.load(str(model_path), **kwargs) def log_model( @@ -480,7 +494,12 @@ def autolog( try: import mlflow.pytorch - mlflow.pytorch.autolog(log_models=False, log_datasets=False, silent=silent) + mlflow.pytorch.autolog( + log_models=False, + log_datasets=False, + checkpoint=False, + silent=silent, + ) except ImportError: logger.info( "mlflow.pytorch not available; skipping per-epoch metrics logging." @@ -540,6 +559,7 @@ def _patched_fit(original, self, *args, **kwargs): """Patch function for ForecastingModel.fit() autologging. Logs model parameters, class, covariates and the model itself. + Parameters ---------- original @@ -553,6 +573,7 @@ def _patched_fit(original, self, *args, **kwargs): Returns ------- + ForecastingModel The result of calling the original fit method. """ # Create a training session to track the training process and log information @@ -730,8 +751,10 @@ def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: A dictionary of MLflow run tag keys and values describing the specified model. """ return { - "model_name": model.__class__.__name__, - "model_class": (model.__class__.__module__ + "." + model.__class__.__name__), + "model_class": model.__class__.__name__, + "model_reference": ( + model.__class__.__module__ + "." + model.__class__.__name__ + ), "model_likelihood": ( model.likelihood.__class__.__name__ if model.likelihood is not None @@ -772,11 +795,7 @@ def _log_covariate_info(model: ForecastingModel) -> None: ) != len(model.static_covariates.columns) # log complete information as JSON artifact - with TempDir() as tmp: - covariates_path = tmp.path("covariates.json") - with open(covariates_path, "w") as f: - json.dump(covariate_info, f, indent=2) - mlflow.log_artifact(covariates_path) + mlflow.log_dict(covariate_info, "covariates.json") def _is_torch_model(model) -> bool: @@ -792,8 +811,7 @@ def _is_torch_model(model) -> bool: bool True if the model is a `TorchForecastingModel`, False otherwise. """ - method = getattr(model, "predict_from_dataset", None) - return callable(method) + return TORCH_AVAILABLE and isinstance(model, TorchForecastingModel) def _extract_covariate_metadata( @@ -1284,7 +1302,7 @@ def _log_metric_result( c_size = (s.n_components if has_comp_axis else 1) * quantiles_num arr = np.asarray(r, dtype=float) # after stripping the C axis, the remainder is the time axis (or scalar) - rest, extra = divmod(arr.size, c_size) + n_times, extra = divmod(arr.size, c_size) if extra: logger.warning( "Metric logging skipped for `%s`: result size (%d) is not " @@ -1297,14 +1315,14 @@ def _log_metric_result( return if has_time_axis: - t_size = rest - elif rest != 1: + t_size = n_times + elif n_times != 1: logger.warning( "Metric logging skipped for `%s`: expected a single value per " "component/quantile after reduction, but got %d elements. " "Check time_reduction and component_reduction.", metric_name, - rest, + n_times, ) return else: From defe8aa75bd5c707b800cd741d8b840d62726dd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 10:58:37 +0200 Subject: [PATCH 085/154] chore: update gitignore --- .gitignore | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index a3e223d95f..36ca8d5296 100644 --- a/.gitignore +++ b/.gitignore @@ -25,6 +25,4 @@ docs_env .venv .env uv.lock -repl/ -mlruns/* -examples/mlruns/* +*mlruns/ From b5ba0bceed1c262cb3155d8edb6e3a306593b8b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 11:15:05 +0200 Subject: [PATCH 086/154] chore: change log_model=False by default and formatting --- darts/utils/mlflow.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 3a473f1a12..a3c8ef8507 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -408,7 +408,7 @@ def log_model( def autolog( - log_models: bool = True, + log_models: bool = False, log_params: bool = True, log_metrics: bool = True, log_torch_metrics: bool = True, @@ -609,7 +609,9 @@ def _patched_fit(original, self, *args, **kwargs): ) try: registered_model_name = get_autologging_config( - FLAVOR_NAME, "registered_model_name", None + flavor_name=FLAVOR_NAME, + config_key="registered_model_name", + default_value=None, ) log_model( result, From 44ca8da95fd8c5e7d2bd34621b9d98092e200565 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 11:46:02 +0200 Subject: [PATCH 087/154] feat: change on error from logs to raise --- darts/utils/mlflow.py | 168 ++++++++++++++++++------------------------ 1 file changed, 73 insertions(+), 95 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index a3c8ef8507..3204360ef1 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -501,18 +501,14 @@ def autolog( silent=silent, ) except ImportError: - logger.info( - "mlflow.pytorch not available; skipping per-epoch metrics logging." - ) + pass elif disable: try: import mlflow.pytorch mlflow.pytorch.autolog(disable=True) except (ImportError, Exception): - logger.info( - "mlflow.pytorch not available; skipping per-epoch metrics logging." - ) + pass _autolog( log_models=log_models, @@ -933,17 +929,22 @@ def _log_backtest_metrics( * ``last_points_only`` – collapses all windows into one TimeSeries before scoring, so there is effectively only one window regardless of reduction. - When ``label_reduction=None`` is used without explicit ``labels``, the - unique class values are inferred from ``series`` at runtime so structured - per-label keys are still produced. When two metrics have incompatible axis - layouts (different ``time_reduction`` / ``component_reduction`` / quantile - count), each series result is flattened to integer-indexed keys instead. + When two metrics have incompatible axis layouts (different + ``time_reduction`` / ``component_reduction`` / quantile count), each series + result is flattened to integer-indexed keys instead. When more than one series is scored, the logged value is the mean over series for each cell, and the granular per-series breakdown is written to a ``per_series_metrics/backtest_per_series.csv`` artifact. For a single series the mean is just the value itself and no artifact is written. + Raises + ------ + ValueError + On a shape/size mismatch between the metric result and the inferred + axes, or when ``label_reduction=None`` is requested without explicit + ``labels``. + Parameters ---------- autologging_client @@ -1000,9 +1001,6 @@ def _log_backtest_metrics( # Fall back to flat integer-indexed keys for this case. axes_inconsistent = any(ax[:3] != metric_axes[0][:3] for ax in metric_axes[1:]) - # quantiles_num=None means label_reduction=None was requested with labels=None, - labels_unknown = quantiles_num is None - series = backtest_args.get("series") forecast_horizon = backtest_args.get("forecast_horizon") @@ -1028,23 +1026,6 @@ def _log_backtest_metrics( }) continue - # resolve label names from series data when not provided explicitly. - # mirrors np.unique(np.concatenate([y_true, y_pred])) inside _confusion_matrix. - # NOTE: importantly this checks the series for labels, not just the windows, if - # this is an issue, then I'd suggest falling back to flat integer-indexed keys - # and enforcing explicit labels. - if labels_unknown: - inferred_labels = np.unique(s.values()) - quantiles_num = len(inferred_labels) - metric_axes = [ - ( - has_time_axis, - has_comp_axis, - quantiles_num, - [f"_label{x:g}" for x in inferred_labels], - ) - ] + list(metric_axes[1:]) - comps = s.components.tolist() # c_size = components × quantiles/intervals/labels per component c_size = (s.n_components if has_comp_axis else 1) * quantiles_num @@ -1052,30 +1033,29 @@ def _log_backtest_metrics( # after stripping C and M axes, rest = W*T (or W or T alone) rest, extra = divmod(arr.size, c_size * n_metrics) if extra: - logger.warning( - "Backtest metric logging skipped: result size (%d) is not " - "divisible by c_size * n_metrics (%d * %d = %d). " - "The metric output shape does not match the inferred axes.", - arr.size, - c_size, - n_metrics, - c_size * n_metrics, + raise_log( + ValueError( + f"Backtest metric logging failed: result size ({arr.size}) " + f"is not divisible by c_size * n_metrics ({c_size} * " + f"{n_metrics} = {c_size * n_metrics}). The metric output " + "shape does not match the inferred axes." + ) ) - return # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can # recover W and T only if forecast_horizon is known (T = forecast_horizon) if has_time_axis and has_windows: if not forecast_horizon or rest % forecast_horizon: - logger.warning( - "Backtest metric logging skipped: cannot split window/time " - "axes — %d elements remain after stripping component and " - "metric axes, but forecast_horizon=%r does not divide " - "evenly. Pass an explicit forecast_horizon to backtest().", - rest, - forecast_horizon, + raise_log( + ValueError( + f"Backtest metric logging failed: cannot split " + f"window/time axes — {rest} elements remain after " + f"stripping component and metric axes, but " + f"forecast_horizon={forecast_horizon!r} does not " + "divide evenly. Pass an explicit forecast_horizon to " + "backtest()." + ) ) - return t_size, w_size = forecast_horizon, rest // forecast_horizon elif has_time_axis: t_size, w_size = rest, 1 @@ -1083,13 +1063,14 @@ def _log_backtest_metrics( t_size, w_size = 1, rest else: if rest != 1: - logger.warning( - "Backtest metric logging skipped: expected a single scalar " - "per component/metric after reduction, but got %d elements. " - "Check time_reduction and component_reduction defaults.", - rest, + raise_log( + ValueError( + f"Backtest metric logging failed: expected a single " + f"scalar per component/metric after reduction, but got " + f"{rest} elements. Check time_reduction and " + "component_reduction defaults." + ) ) - return t_size, w_size = 1, 1 canonical = arr.reshape(w_size, t_size, c_size, n_metrics) @@ -1157,11 +1138,13 @@ def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: - ``has_time_axis`` – ``True`` when ``time_reduction`` is ``None`` (i.e. a per-timestep axis is present in the output). - ``has_comp_axis`` – ``True`` when components are expanded (not collapsed to a scalar). - - ``quantiles_num`` – number of quantile/interval/label entries; ``None`` when it - cannot be determined (e.g. ``label_reduction=None`` without explicit - ``labels``), signalling the caller to fall back to flat logging. - - ``quantiles_labels`` – one key suffix per ``quantiles_num`` entry (empty list when - ``quantiles_num`` is ``None``). + - ``quantiles_num`` – number of quantile/interval/label entries. + - ``quantiles_labels`` – one key suffix per ``quantiles_num`` entry. + + Raises + ------ + ValueError + If ``label_reduction=None`` is requested without explicit ``labels``. """ params = inspect.signature(metric).parameters @@ -1190,9 +1173,15 @@ def effective(param_name: str) -> Any: label_reduction = label_reduction.value labels = metric_kwargs.get("labels") # label_reduction=None means one output per label, but without explicit - # labels we can't know how many — signal the caller to fall back + # labels we can't know how many ahead of time if label_reduction is None and labels is None: - return (has_time_axis, has_comp_axis, None, []) + raise_log( + ValueError( + "`label_reduction=None` requires explicit `labels` to be " + "passed for MLflow autologging (the number of output " + "labels cannot be determined ahead of time otherwise)." + ) + ) quantiles_labels = ( [f"_label{x}" for x in np.atleast_1d(labels)] if label_reduction is None @@ -1212,7 +1201,7 @@ def _log_metric_result( series, has_time_axis: bool, has_comp_axis: bool, - quantiles_num: int | None, + quantiles_num: int, quantiles_labels: list[str], dataset_name: str | None = None, series_reduced: bool = False, @@ -1242,8 +1231,11 @@ def _log_metric_result( ``per_series_metrics/{base_key}_per_series.csv`` artifact. For a single series the mean is just the value itself and no artifact is written. - On a shape/size mismatch it warns and returns (does not raise), keeping - autologging non-fatal. + Raises + ------ + ValueError + On a shape/size mismatch between the metric result and the inferred + axes. Parameters ---------- @@ -1254,19 +1246,15 @@ def _log_metric_result( The metric result to log. series The ``actual_series`` argument passed to the metric (single series or - ``Sequence[TimeSeries]``); used for component names, series count, and - runtime label inference. + ``Sequence[TimeSeries]``); used for component names and series count. has_time_axis ``True`` when the result carries a per-timestep axis (``time_reduction=None``). has_comp_axis ``True`` when components are expanded (``component_reduction=None``). quantiles_num - Number of quantile/interval/label entries; ``None`` when it cannot be - determined ahead of time (``label_reduction=None`` without explicit - ``labels``), in which case labels are inferred from ``series`` at runtime. + Number of quantile/interval/label entries. quantiles_labels - One key suffix per ``quantiles_num`` entry (empty list when ``quantiles_num`` - is ``None``). + One key suffix per ``quantiles_num`` entry. dataset_name Sanitized variable name of ``actual_series`` in the caller's frame. Omitted from key when ``None``. @@ -1286,19 +1274,10 @@ def _log_metric_result( [result] if get_series_seq_type(series) == SeriesType.SINGLE else result ) - labels_unknown = quantiles_num is None - # agg maps (key, step) -> per-series values, averaged into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] for series_index, (s, r) in enumerate(zip(series_seq, results)): - # quantiles_num=None means label_reduction=None was requested without explicit labels - # so class labels are inferred per-series inside the loop. - if labels_unknown: - inferred_labels = np.unique(s.values()) - quantiles_num = len(inferred_labels) - quantiles_labels = [f"_label{x:g}" for x in inferred_labels] - comps = s.components.tolist() # c_size = components × quantiles/intervals/labels per component c_size = (s.n_components if has_comp_axis else 1) * quantiles_num @@ -1306,27 +1285,26 @@ def _log_metric_result( # after stripping the C axis, the remainder is the time axis (or scalar) n_times, extra = divmod(arr.size, c_size) if extra: - logger.warning( - "Metric logging skipped for `%s`: result size (%d) is not " - "divisible by the inferred component/quantile size (%d). " - "The metric output shape does not match the inferred axes.", - metric_name, - arr.size, - c_size, + raise_log( + ValueError( + f"Metric logging failed for `{metric_name}`: result size " + f"({arr.size}) is not divisible by the inferred " + f"component/quantile size ({c_size}). The metric output " + "shape does not match the inferred axes." + ) ) - return if has_time_axis: t_size = n_times elif n_times != 1: - logger.warning( - "Metric logging skipped for `%s`: expected a single value per " - "component/quantile after reduction, but got %d elements. " - "Check time_reduction and component_reduction.", - metric_name, - n_times, + raise_log( + ValueError( + f"Metric logging failed for `{metric_name}`: expected a " + f"single value per component/quantile after reduction, " + f"but got {n_times} elements. Check time_reduction and " + "component_reduction." + ) ) - return else: t_size = 1 From 965d8028bfb147220b724e2bbc550455cc11ad71 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 11:49:57 +0200 Subject: [PATCH 088/154] chore: raise on failure instead of log --- darts/utils/mlflow.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 3204360ef1..510afa2de0 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -616,9 +616,10 @@ def _patched_fit(original, self, *args, **kwargs): model_id=model.model_id, ) except Exception: - logger.info( - f"Failed to autolog model artifact for {type(self).__name__}.", - exc_info=True, + raise_log( + ValueError( + f"Failed to autolog model artifact for {type(self).__name__}." + ) ) param_logging_ops.await_completion() From eff901435ce2b4765fb88705ffb953831cd9f050 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 12:24:51 +0200 Subject: [PATCH 089/154] chore: remove quantile_num from _infer_metric_axes return tuple --- darts/utils/mlflow.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 510afa2de0..84faf2dc0b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -995,12 +995,16 @@ def _log_backtest_metrics( # check the dim axes from the metric kwargs for each metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metric, metric_kwargs)] - has_time_axis, has_comp_axis, quantiles_num, _ = metric_axes[0] + has_time_axis, has_comp_axis, quantiles_labels_0 = metric_axes[0] + quantiles_num = len(quantiles_labels_0) # Inconsistent axes across metrics (different has_time_axis, has_comp_axis, or # quantiles_num) means the result can't be reshaped into a single canonical array. # Fall back to flat integer-indexed keys for this case. - axes_inconsistent = any(ax[:3] != metric_axes[0][:3] for ax in metric_axes[1:]) + axes_key = (has_time_axis, has_comp_axis, quantiles_num) + axes_inconsistent = any( + (ax[0], ax[1], len(ax[2])) != axes_key for ax in metric_axes[1:] + ) series = backtest_args.get("series") forecast_horizon = backtest_args.get("forecast_horizon") @@ -1076,7 +1080,7 @@ def _log_backtest_metrics( canonical = arr.reshape(w_size, t_size, c_size, n_metrics) for m, metric_name in enumerate(metric_names): - quantiles_labels = metric_axes[m][3] + quantiles_labels = metric_axes[m][2] for w in range(w_size): for c in range(c_size): # c is a flat index into the (n_components × quantiles_num) C axis: @@ -1134,13 +1138,12 @@ def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: Returns ------- tuple - ``(has_time_axis, has_comp_axis, quantiles_num, quantiles_labels)`` where + ``(has_time_axis, has_comp_axis, quantiles_labels)`` where - ``has_time_axis`` – ``True`` when ``time_reduction`` is ``None`` (i.e. a per-timestep axis is present in the output). - ``has_comp_axis`` – ``True`` when components are expanded (not collapsed to a scalar). - - ``quantiles_num`` – number of quantile/interval/label entries. - - ``quantiles_labels`` – one key suffix per ``quantiles_num`` entry. + - ``quantiles_labels`` – one key suffix per quantile/interval/label entry. Raises ------ @@ -1191,7 +1194,7 @@ def effective(param_name: str) -> Any: else: quantiles_labels = [""] - return (has_time_axis, has_comp_axis, len(quantiles_labels), quantiles_labels) + return (has_time_axis, has_comp_axis, quantiles_labels) def _log_metric_result( @@ -1202,7 +1205,6 @@ def _log_metric_result( series, has_time_axis: bool, has_comp_axis: bool, - quantiles_num: int, quantiles_labels: list[str], dataset_name: str | None = None, series_reduced: bool = False, @@ -1252,10 +1254,8 @@ def _log_metric_result( ``True`` when the result carries a per-timestep axis (``time_reduction=None``). has_comp_axis ``True`` when components are expanded (``component_reduction=None``). - quantiles_num - Number of quantile/interval/label entries. quantiles_labels - One key suffix per ``quantiles_num`` entry. + One key suffix per quantile/interval/label entry. dataset_name Sanitized variable name of ``actual_series`` in the caller's frame. Omitted from key when ``None``. @@ -1264,6 +1264,7 @@ def _log_metric_result( metric, so the result has no leading series axis even for list input. """ base_key = f"{dataset_name}_{metric_name}" if dataset_name else metric_name + quantiles_num = len(quantiles_labels) if series_reduced: # series_reduction aggregated across series -> single result, no series axis @@ -1412,8 +1413,8 @@ def _patched_metric(original, *args, **kwargs): key_name = _sanitize_mlflow_key(kwargs.get("name") or metric_name) # infer output axes from the metric signature + call kwargs - has_time_axis, has_comp_axis, quantiles_num, quantiles_labels = ( - _infer_metric_axes(original, kwargs) + has_time_axis, has_comp_axis, quantiles_labels = _infer_metric_axes( + original, kwargs ) # series_reduction collapses the series axis inside the metric, so the @@ -1434,7 +1435,6 @@ def _patched_metric(original, *args, **kwargs): series, has_time_axis, has_comp_axis, - quantiles_num, quantiles_labels, dataset_name=dataset_name, series_reduced=series_reduced, From 5e6a71891f2db77a8d9c63cf82d5bb4984585c2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 12:38:26 +0200 Subject: [PATCH 090/154] feat: remove dataset_name from logged metric pattern --- darts/utils/mlflow.py | 32 +++++++++----------------------- 1 file changed, 9 insertions(+), 23 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 84faf2dc0b..cf3969a168 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -50,7 +50,7 @@ from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS from mlflow.tracking.artifact_utils import _download_artifact_from_uri from mlflow.tracking.fluent import _initialize_logged_model -from mlflow.utils import _get_fully_qualified_class_name, _inspect_original_var_name +from mlflow.utils import _get_fully_qualified_class_name from mlflow.utils.autologging_utils import ( autologging_integration, get_autologging_config, @@ -446,11 +446,9 @@ def autolog( .. note:: Logged metric keys follow the pattern - ``{dataset_name}_{metric_name}{component}{quantile_or_label}``, where - each part is included only when the corresponding axis is present: + ``{metric_name}{component}{quantile_or_label}``, where each part is + included only when the corresponding axis is present: - * ``dataset_name`` – variable name of the first argument, captured via - frame inspection (omitted when not found). * ``metric_name`` – the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). * ``component`` – the component name when ``component_reduction=None``. @@ -1206,7 +1204,6 @@ def _log_metric_result( has_time_axis: bool, has_comp_axis: bool, quantiles_labels: list[str], - dataset_name: str | None = None, series_reduced: bool = False, ) -> None: """Log a metric result to the active MLflow run. @@ -1221,7 +1218,7 @@ def _log_metric_result( The logged MLflow key follows the pattern:: - {dataset_name}_{metric_name}{component}{quantile_or_label} + {metric_name}{component}{quantile_or_label} where each optional part is included only when the corresponding axis is present: @@ -1231,7 +1228,7 @@ def _log_metric_result( When more than one series is scored, the logged value is the mean over series for each cell, and the granular per-series breakdown is written to a - ``per_series_metrics/{base_key}_per_series.csv`` artifact. For a single + ``per_series_metrics/{metric_name}_per_series.csv`` artifact. For a single series the mean is just the value itself and no artifact is written. Raises @@ -1243,7 +1240,7 @@ def _log_metric_result( Parameters ---------- metric_name - Base metric name used as the MLflow key (the metric's ``name`` keyword + Metric name used as the MLflow key (the metric's ``name`` keyword argument when provided, otherwise the metric function name). result The metric result to log. @@ -1256,14 +1253,10 @@ def _log_metric_result( ``True`` when components are expanded (``component_reduction=None``). quantiles_labels One key suffix per quantile/interval/label entry. - dataset_name - Sanitized variable name of ``actual_series`` in the caller's frame. - Omitted from key when ``None``. series_reduced ``True`` when ``series_reduction`` collapsed the series axis inside the metric, so the result has no leading series axis even for list input. """ - base_key = f"{dataset_name}_{metric_name}" if dataset_name else metric_name quantiles_num = len(quantiles_labels) if series_reduced: @@ -1321,7 +1314,7 @@ def _log_metric_result( else "" ) key = _sanitize_mlflow_key( - base_key + comp_part + quantiles_labels[quantile_index] + metric_name + comp_part + quantiles_labels[quantile_index] ) for t in range(t_size): # MLflow step maps to the time axis when present @@ -1346,7 +1339,7 @@ def _log_metric_result( # write the granular per-series breakdown to a CSV artifact (multi-series only) if len(series_seq) > 1: - _write_per_series_csv(rows, f"{base_key}_per_series.csv") + _write_per_series_csv(rows, f"{metric_name}_per_series.csv") def _make_metric_patch(metric_name: str) -> Callable: @@ -1357,12 +1350,10 @@ def _make_metric_patch(metric_name: str) -> Callable: kwargs (via ``_infer_metric_axes``) and delegates to ``_log_metric_result``, which logs each cell under a key built as:: - {dataset_name}_{metric_name}{component}{quantile_or_label} + {metric_name}{component}{quantile_or_label} where: - * ``dataset_name`` – Python variable name of the first argument in the - caller's frame (captured via frame inspection, omitted if not found). * ``metric_name`` – the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). * ``component`` – ``_{component_name}`` when ``component_reduction=None``. @@ -1405,10 +1396,6 @@ def _patched_metric(original, *args, **kwargs): if series is None: return result - # capture the variable name of actual_series for metric key - raw = _inspect_original_var_name(series, fallback_name=None) - dataset_name = _sanitize_mlflow_key(raw) if raw else None - # the `name` kwarg overrides the metric-name token in the logged key key_name = _sanitize_mlflow_key(kwargs.get("name") or metric_name) @@ -1436,7 +1423,6 @@ def _patched_metric(original, *args, **kwargs): has_time_axis, has_comp_axis, quantiles_labels, - dataset_name=dataset_name, series_reduced=series_reduced, ) From ce8fd01ac0cd771a62c649d2dbb8b5944dc23b68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 12:38:53 +0200 Subject: [PATCH 091/154] fix: align tests to code review changes --- darts/tests/optional_deps/test_mlflow.py | 209 ++++++++++------------- 1 file changed, 88 insertions(+), 121 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index c28581e8bf..13439b4efc 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -250,7 +250,7 @@ def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): # verify the run has expected content last_run = runs.iloc[0] - assert last_run["tags.model_name"] == "ExponentialSmoothing" + assert last_run["tags.model_class"] == "ExponentialSmoothing" assert last_run["tags.mlflow.runName"] is not None # after context exits, autolog should be disabled @@ -274,7 +274,7 @@ def test_autolog_parameters(self, mlflow_tracking, autolog_context): last_run = runs.iloc[0] assert last_run["params.seasonal_periods"] == "12" - assert last_run["tags.model_name"] == "ExponentialSmoothing" + assert last_run["tags.model_class"] == "ExponentialSmoothing" @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): @@ -294,7 +294,7 @@ def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): assert len(runs) == 1, "Expected exactly one run" last_run = runs.iloc[0] last_run_id = last_run["run_id"] - assert last_run["tags.model_name"] == "NBEATSModel" + assert last_run["tags.model_class"] == "NBEATSModel" client = mlflow.tracking.MlflowClient() @@ -345,7 +345,7 @@ def assert_metric(history, key): runs = mlflow.search_runs() assert len(runs) == 1 run_id = runs.iloc[0]["run_id"] - assert runs.iloc[0]["tags.model_name"] == "NBEATSModel" + assert runs.iloc[0]["tags.model_class"] == "NBEATSModel" client = mlflow.tracking.MlflowClient() assert_metric(client.get_metric_history(run_id, "train_loss"), "train_loss") @@ -457,7 +457,7 @@ def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): assert len(runs) == 2, "Expected two separate runs for two fits" # verify different model classes logged - model_classes = set(runs["tags.model_name"]) + model_classes = set(runs["tags.model_class"]) assert "ExponentialSmoothing" in model_classes assert "LinearRegressionModel" in model_classes @@ -483,7 +483,7 @@ def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_contex assert len(runs) == 2, "Expected two separate runs for two fits" for _, run in runs.iterrows(): - assert run["tags.model_name"] in [ + assert run["tags.model_class"] in [ "NBEATSModel", "LinearRegressionModel", ] @@ -742,9 +742,8 @@ def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): with mlflow.start_run() as run: ref = dm.ae(actual, pred) - # the first-arg variable name ("actual") is captured as the key prefix ref = np.asarray(ref, dtype=float) # shape (n_timesteps,) - history = mlflow_tracking.get_metric_history(run.info.run_id, "actual_ae") + history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") assert len(history) == len(ref), "Expected one step per timestep" steps = sorted(m.step for m in history) assert steps == list(range(len(ref))) @@ -765,14 +764,9 @@ def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): with mlflow.start_run() as run: ref = dm.mql(actual, pred, q=[0.1, 0.5, 0.9]) - # the first-arg variable name ("actual") is captured as the key prefix ref = np.asarray(ref, dtype=float) # shape (n_quantiles,) m = mlflow.get_run(run.info.run_id).data.metrics - for i, key in enumerate(( - "actual_mql_q0_1", - "actual_mql_q0_5", - "actual_mql_q0_9", - )): + for i, key in enumerate(("mql_q0_1", "mql_q0_5", "mql_q0_9")): assert key in m, f"Expected quantile key {key}" assert m[key] == pytest.approx(ref[i], abs=1e-5) @@ -790,10 +784,9 @@ def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context with mlflow.start_run() as run: ref = dm.miw(actual, pred, q_interval=(0.1, 0.9)) - # the first-arg variable name ("actual") is captured as the key prefix m = mlflow.get_run(run.info.run_id).data.metrics - assert "actual_miw_qi0_1_0_9" in m - assert m["actual_miw_qi0_1_0_9"] == pytest.approx(float(ref), abs=1e-5) + assert "miw_qi0_1_0_9" in m + assert m["miw_qi0_1_0_9"] == pytest.approx(float(ref), abs=1e-5) def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): """A list of series logs the mean over series; per-series values go to a CSV.""" @@ -804,16 +797,13 @@ def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): with mlflow.start_run() as run: ref = dm.mae(series, pred) - # the first-arg variable name ("series") is captured as the key prefix ref = np.asarray(ref, dtype=float) # shape (n_series,) m = mlflow.get_run(run.info.run_id).data.metrics # aggregate = mean over series, no per-series _s{i} keys - assert m["series_mae"] == pytest.approx(float(np.mean(ref)), abs=1e-5) - assert not any(k.startswith("series_mae_s") for k in m) + assert m["mae"] == pytest.approx(float(np.mean(ref)), abs=1e-5) + assert not any(k.startswith("mae_s") for k in m) # granular per-series breakdown written to a CSV artifact - csv_rows = self._read_per_series_csv( - run.info.run_id, "series_mae_per_series.csv" - ) + csv_rows = self._read_per_series_csv(run.info.run_id, "mae_per_series.csv") by_series = {int(row["series_index"]): float(row["value"]) for row in csv_rows} assert by_series == pytest.approx({0: ref[0], 1: ref[1]}, abs=1e-5) @@ -829,33 +819,26 @@ def test_autolog_metric_multi_series_per_component( with mlflow.start_run() as run: ref = dm.mae(series, pred, component_reduction=None) - # the first-arg variable name ("series") is captured as the key prefix ref = np.asarray(ref, dtype=float) # shape (n_series, n_components) m = mlflow.get_run(run.info.run_id).data.metrics # aggregate per component = mean over series, no per-series _s{i} keys - assert m["series_mae_linear"] == pytest.approx( - float(ref[:, 0].mean()), abs=1e-5 - ) - assert m["series_mae_linear_1"] == pytest.approx( - float(ref[:, 1].mean()), abs=1e-5 - ) + assert m["mae_linear"] == pytest.approx(float(ref[:, 0].mean()), abs=1e-5) + assert m["mae_linear_1"] == pytest.approx(float(ref[:, 1].mean()), abs=1e-5) assert not any(k.endswith(("_s0", "_s1")) for k in m) # granular CSV: one row per (component, series) - csv_rows = self._read_per_series_csv( - run.info.run_id, "series_mae_per_series.csv" - ) + csv_rows = self._read_per_series_csv(run.info.run_id, "mae_per_series.csv") got = { (row["key"], int(row["series_index"])): float(row["value"]) for row in csv_rows } - assert got[("series_mae_linear", 0)] == pytest.approx(ref[0, 0], abs=1e-5) - assert got[("series_mae_linear", 1)] == pytest.approx(ref[1, 0], abs=1e-5) - assert got[("series_mae_linear_1", 0)] == pytest.approx(ref[0, 1], abs=1e-5) - assert got[("series_mae_linear_1", 1)] == pytest.approx(ref[1, 1], abs=1e-5) + assert got[("mae_linear", 0)] == pytest.approx(ref[0, 0], abs=1e-5) + assert got[("mae_linear", 1)] == pytest.approx(ref[1, 0], abs=1e-5) + assert got[("mae_linear_1", 0)] == pytest.approx(ref[0, 1], abs=1e-5) + assert got[("mae_linear_1", 1)] == pytest.approx(ref[1, 1], abs=1e-5) def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): """The metric `name` kwarg overrides only the metric-name token in the key, - keeping the dataset/backtest prefix and the quantile/axis suffixes.""" + keeping the backtest prefix and the quantile/axis suffixes.""" actual = self.ts_univariate train = self.ts_univariate[:40] qmodel = self._fit_qlr(train) @@ -878,23 +861,22 @@ def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): ) direct = mlflow.get_run(run_direct.info.run_id).data.metrics - assert "actual_custom" in direct - assert "actual_mae" not in direct, "default metric name should be replaced" - assert "target_myq_q0_5" in direct, "quantile suffix should be preserved" + assert "custom" in direct + assert "mae" not in direct, "default metric name should be replaced" + assert "myq_q0_5" in direct, "quantile suffix should be preserved" bt = mlflow.get_run(run_bt.info.run_id).data.metrics assert "backtest_custom" in bt assert "backtest_mae" not in bt, "default metric name should be replaced" - def test_autolog_metric_multi_series_classification_labels_inferred( + def test_autolog_metric_multi_series_classification_labels_explicit( self, mlflow_tracking, autolog_context ): - """f1 with label_reduction=None on a list of binary series infers class labels - per-series, logs the per-label mean over series, and writes the per-series CSV. + """f1 with label_reduction=None and explicit labels on a list of binary + series logs the per-label mean over series and writes the per-series CSV. - This exercises the labels_unknown branch inside the per-series loop so that - each series' own class set is inferred rather than reusing the first series'. - """ + ``labels`` must be explicit (``label_reduction=None`` without it raises, + since the number of output labels can't be determined ahead of time).""" # two independent binary series (same classes, deterministic) binary1 = tg.constant_timeseries(value=0.0, length=50).with_values( np.array([0.0, 1.0] * 25, dtype=np.float32).reshape(-1, 1) @@ -907,35 +889,35 @@ def test_autolog_metric_multi_series_classification_labels_inferred( with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = dm.f1(series, pred, label_reduction=None) + ref = dm.f1(series, pred, label_reduction=None, labels=[0, 1]) ref = [np.asarray(r, dtype=float).flatten() for r in ref] m = mlflow.get_run(run.info.run_id).data.metrics # aggregate per label = mean over series, no per-series _s{i} keys - assert m["series_f1_label0"] == pytest.approx( + assert m["f1_label0"] == pytest.approx( float(np.mean([ref[0][0], ref[1][0]])), abs=1e-5 ) - assert m["series_f1_label1"] == pytest.approx( + assert m["f1_label1"] == pytest.approx( float(np.mean([ref[0][1], ref[1][1]])), abs=1e-5 ) assert not any(k.endswith(("_s0", "_s1")) for k in m) # granular CSV: one row per (label, series) - csv_rows = self._read_per_series_csv( - run.info.run_id, "series_f1_per_series.csv" - ) + csv_rows = self._read_per_series_csv(run.info.run_id, "f1_per_series.csv") got = { (row["key"], int(row["series_index"])): float(row["value"]) for row in csv_rows } for i in range(2): - assert got[("series_f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) - assert got[("series_f1_label1", i)] == pytest.approx(ref[i][1], abs=1e-5) + assert got[("f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) + assert got[("f1_label1", i)] == pytest.approx(ref[i][1], abs=1e-5) - def test_autolog_metric_size_mismatch_warns_and_skips( + def test_autolog_metric_size_mismatch_raises_internally( self, mlflow_tracking, autolog_context, caplog ): - """When the inferred C-axis size doesn't divide the result, a warning is logged - and no metrics are written (non-fatal — autologging must not raise).""" + """When the inferred C-axis size doesn't divide the result, logging raises + (logged as an error) and no metrics are written. The public metric call + itself doesn't crash, since MLflow's safe_patch wrapper catches exceptions + raised from inside a patch function.""" actual = self.ts_univariate[40:] # mae with component_reduction=None on a univariate series produces shape (T,), # which is size T — divisible by c_size=1 (1 component × 1 quantile), so we @@ -951,7 +933,7 @@ def test_autolog_metric_size_mismatch_warns_and_skips( from darts.utils import mlflow as mlflow_utils - fake_axes = (False, True, 3, ["_c0", "_c1", "_c2"]) + fake_axes = (False, True, ["_c0", "_c1", "_c2"]) with mock.patch.object( mlflow_utils, "_infer_metric_axes", return_value=fake_axes ): @@ -982,7 +964,7 @@ def test_autolog_metric_per_series_csv_schema_and_single_series_skip( dm.mae(multi, pred_multi) csv_rows = self._read_per_series_csv( - run_multi.info.run_id, "multi_mae_per_series.csv" + run_multi.info.run_id, "mae_per_series.csv" ) assert list(csv_rows[0].keys()) == ["key", "series_index", "step", "value"] assert {int(r["series_index"]) for r in csv_rows} == {0, 1} @@ -1210,62 +1192,47 @@ def test_autolog_backtest_classification_labels_not_in_data( assert np.isnan(m["backtest_f1_label5"]) assert np.isnan(m["backtest_f1_label10"]) - def test_autolog_backtest_classification_labels_inferred( - self, mlflow_tracking, autolog_context - ): - """f1 with label_reduction=None and no explicit labels infers class names - from series values and logs structured per-label keys instead of flat - integer-indexed ones.""" - # binary classification series: values are 0.0 and 1.0 - rng = np.random.default_rng(42) - vals = rng.choice([0.0, 1.0], size=50).astype(np.float32).reshape(-1, 1) - ts_bin = tg.constant_timeseries(value=0.0, length=50).with_values(vals) + def test_log_backtest_metrics_unknown_labels_raises(self, mlflow_tracking): + """label_reduction=None without explicit labels raises rather than + inferring class names from the series at runtime. - model = LinearRegressionModel(lags=4) - model.fit(ts_bin) + This is tested by calling _log_backtest_metrics directly so the raise + is not swallowed by MLflow's safe_patch wrapper. + """ + ts_bin = tg.constant_timeseries(value=0.0, length=10) + backtest_args = { + "metric": dm.f1, + "metric_kwargs": {"label_reduction": None}, + "series": ts_bin, + "forecast_horizon": 1, + "reduction": np.mean, + "last_points_only": True, + } - with autolog_context(log_metrics=True): - with mlflow.start_run() as run: - model.backtest( - series=ts_bin, - metric=dm.f1, - metric_kwargs={"label_reduction": None}, - retrain=False, - stride=10, + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + with pytest.raises(ValueError, match="requires explicit `labels`"): + _log_backtest_metrics( + client, run.info.run_id, np.array([0.5]), backtest_args ) - m = mlflow.get_run(run.info.run_id).data.metrics - # unique values are 0.0 and 1.0 → keys should use actual class values - assert "backtest_f1_label0" in m, "Expected 'backtest_f1_label0' for class 0.0" - assert "backtest_f1_label1" in m, "Expected 'backtest_f1_label1' for class 1.0" - # no flat integer-indexed keys - flat_keys = [ - k - for k in m - if k.startswith("backtest_f1_") and k[-1].isdigit() and "_label" not in k - ] - assert not flat_keys, f"Did not expect flat fallback keys: {flat_keys}" - - def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking, caplog): - """When the inferred label count does not divide the metric output size, - logging is skipped with a warning rather than raising — keeping autologging - non-fatal for the surrounding backtest call. - - This is tested by calling _log_backtest_metrics directly so the warning is + def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): + """When the explicit label count does not divide the metric output size, + logging raises rather than silently producing incomplete metrics. + + This is tested by calling _log_backtest_metrics directly so the raise is not swallowed by MLflow's safe_patch wrapper. """ - # Series has 3 unique classes so np.unique(series.values()) → [0, 1, 2]. - vals = np.array([0.0, 1.0, 2.0] * 17, dtype=np.float32)[:50].reshape(-1, 1) - ts_3class = tg.constant_timeseries(value=0.0, length=50).with_values(vals) + ts_3class = tg.constant_timeseries(value=0.0, length=50) # Simulate a backtest result with only 2 entries — as if the metric was - # evaluated on windows that only contained classes 0 and 1. - # quantiles_num will be inferred as 3 (from series) but result has 2 → mismatch. + # evaluated on windows that only contained 2 of the 3 explicit labels. + # quantiles_num is 3 (len(labels)) but result has 2 → mismatch. fake_result = np.array([0.8, 0.6], dtype=float) backtest_args = { "metric": dm.f1, - "metric_kwargs": {"label_reduction": None}, + "metric_kwargs": {"label_reduction": None, "labels": [0, 1, 2]}, "series": ts_3class, "forecast_horizon": 1, "reduction": np.mean, # not None → has_windows=False → single window @@ -1274,13 +1241,10 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking, caplog with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() - with caplog.at_level(logging.WARNING): - # must not raise — logging is skipped on shape mismatch + with pytest.raises(ValueError, match="not divisible"): _log_backtest_metrics( client, run.info.run_id, fake_result, backtest_args ) - assert "not divisible" in caplog.text - client.flush(synchronous=True) assert not mlflow.get_run(run.info.run_id).data.metrics @@ -1317,30 +1281,33 @@ def _fit_qlr(self, series=None): ], ) def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): - _attr_idx = {"has_time_axis": 0, "has_comp_axis": 1, "quantiles_num": 2} - axes = _infer_metric_axes(getattr(dm, metric_name), metric_kwargs) + has_time_axis, has_comp_axis, quantiles_labels = _infer_metric_axes( + getattr(dm, metric_name), metric_kwargs + ) + actual = { + "has_time_axis": has_time_axis, + "has_comp_axis": has_comp_axis, + "quantiles_num": len(quantiles_labels), + } for attr, value in expected.items(): - assert axes[_attr_idx[attr]] == value + assert actual[attr] == value def test_infer_metric_axes_quantiles(): - _, _, quantiles_num, quantiles_labels = _infer_metric_axes( - dm.mql, {"q": [0.1, 0.5, 0.9]} - ) - assert quantiles_num == 3 + _, _, quantiles_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) assert quantiles_labels == ["_q0.1", "_q0.5", "_q0.9"] def test_infer_metric_axes_quantile_interval(): - has_time, _, quantiles_num, quantiles_labels = _infer_metric_axes( + has_time, _, quantiles_labels = _infer_metric_axes( dm.iw, {"q_interval": (0.1, 0.9)} ) - assert quantiles_num == 1 assert quantiles_labels == ["_qi0.1_0.9"] assert has_time is True -def test_infer_metric_axes_unknown_labels(): - """label_reduction=None with no explicit labels cannot determine QL.""" - _, _, quantiles_num, _ = _infer_metric_axes(dm.f1, {"label_reduction": None}) - assert quantiles_num is None +def test_infer_metric_axes_unknown_labels_raises(): + """label_reduction=None with no explicit labels cannot determine the number + of output labels ahead of time, so this raises rather than falling back.""" + with pytest.raises(ValueError, match="requires explicit `labels`"): + _infer_metric_axes(dm.f1, {"label_reduction": None}) From a93ad196bbfb481e16d08210a4cf34ad72c689be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 12:54:57 +0200 Subject: [PATCH 092/154] chore: remove classificaition metrics check --- darts/utils/mlflow.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index cf3969a168..b262fcc00b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -80,7 +80,6 @@ import darts from darts.logging import get_logger, raise_log -from darts.metrics import CLASSIFICATION_METRICS from darts.metrics.utils import _LabelReduction from darts.models.forecasting.forecasting_model import ForecastingModel from darts.utils.ts_utils import ( @@ -1167,9 +1166,7 @@ def effective(param_name: str) -> Any: quantiles_labels = [f"_qi{lo:g}_{hi:g}" for lo, hi in intervals] elif "q" in params and q is not None: quantiles_labels = [f"_q{v:g}" for v in np.atleast_1d(np.array(q, dtype=float))] - elif "label_reduction" in params and getattr(metric, "__name__", "") in { - m.__name__ for m in CLASSIFICATION_METRICS - }: + elif "label_reduction" in params and getattr(metric, "__name__", ""): label_reduction = effective("label_reduction") if isinstance(label_reduction, _LabelReduction): label_reduction = label_reduction.value From 554e02f19788aeafdf7442dddad51b864a1c1e2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 15:59:29 +0200 Subject: [PATCH 093/154] feat: change model import approach --- darts/utils/mlflow.py | 42 +++++++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 13 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index b262fcc00b..f3094562bd 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -124,8 +124,10 @@ ), ] -# Thread-local flag set during historical_forecasts to suppress per-iteration -# autologging in _patched_fit (which would otherwise spawn one run per iteration). +# Thread-local flags used by _patched_fit to suppress nested/re-entrant +# autologging: in_historical_forecasts covers historical_forecasts' internal +# fit() calls, in_fit covers nested fit() calls (e.g. ensembles, super()), +# so only the outermost call logs. _autolog_state = threading.local() @@ -517,19 +519,25 @@ def autolog( def _get_forecasting_models(): - """ - Returns: - A list of (name, class) tuples for all forecasting models in the Darts library. - """ - import darts.models + """Find all ``ForecastingModel`` subclasses currently loaded in memory. - classes = inspect.getmembers(darts.models, inspect.isclass) + Traverses ``__subclasses__()``, avoiding force-importing all of the forecasting + models. - classes = [ - (name, cls) for name, cls in classes if issubclass(cls, ForecastingModel) - ] + Returns: + A list of (name, class) tuples for all matching classes. + """ + seen: set[type] = set() + stack = [ForecastingModel] + while stack: + current = stack.pop() + for sub in current.__subclasses__(): + if sub not in seen: + seen.add(sub) + stack.append(sub) - return sorted(set(classes), key=itemgetter(0)) + classes = [(cls.__name__, cls) for cls in seen] + return sorted(classes, key=itemgetter(0)) @autologging_integration(FLAVOR_NAME) @@ -575,10 +583,18 @@ def _patched_fit(original, self, *args, **kwargs): if getattr(_autolog_state, "in_historical_forecasts", False): return original(self, *args, **kwargs) + # handle nested fit() calls + if getattr(_autolog_state, "in_fit", False): + return original(self, *args, **kwargs) + # Track which model is active so metric patches can prefix their keys _autolog_state.current_model_name = type(self).__name__ - result = original(self, *args, **kwargs) + _autolog_state.in_fit = True + try: + result = original(self, *args, **kwargs) + finally: + _autolog_state.in_fit = False active_run = mlflow.active_run() if active_run is None: From e36b551b14146540f9c2b2ed4b22d1be68c58e0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 15:59:51 +0200 Subject: [PATCH 094/154] chore: remove redundant dependencies --- pyproject.toml | 2 -- 1 file changed, 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 3781cd521a..44e8206957 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,10 +30,8 @@ classifiers = [ "Programming Language :: Python :: Implementation :: PyPy", ] dependencies = [ - "coolname>=4.2.0", "holidays>=0.11.1", "joblib>=0.16.0", - "loguru>=0.7.3", "matplotlib>=3.3.0", "narwhals>=1.25.1", "nfoursid>=1.0.0", From 9f934404e20ac0b086243e78ed746765fe40e43c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 16:00:48 +0200 Subject: [PATCH 095/154] feat: add new import logic tests --- darts/tests/optional_deps/test_mlflow.py | 39 +++++++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 13439b4efc..71d5e53d68 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -25,7 +25,12 @@ import mlflow from mlflow.utils.autologging_utils.client import MlflowAutologgingQueueingClient -from darts.models import ExponentialSmoothing, LinearRegressionModel +from darts.models import ( + ExponentialSmoothing, + LinearRegressionModel, + NaiveSeasonal, + RegressionEnsembleModel, +) from darts.utils.mlflow import ( _infer_metric_axes, _log_backtest_metrics, @@ -461,6 +466,38 @@ def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): assert "ExponentialSmoothing" in model_classes assert "LinearRegressionModel" in model_classes + def test_autolog_ensemble_model_fit_logs_once( + self, mlflow_tracking, autolog_context + ): + """Fitting a composite/ensemble model must log exactly one model artifact + for the outer model, not one per sub-model too. + + RegressionEnsembleModel.fit() internally calls fit() on each of its + forecasting_models. Since every ForecastingModel subclass is patched + independently, an unguarded patch would re-trigger autologging for each + inner fit() call as well as the outer one. + """ + model = RegressionEnsembleModel( + forecasting_models=[ + NaiveSeasonal(K=12), + LinearRegressionModel(lags=12), + ], + regression_train_n_points=12, + ) + + with autolog_context(log_models=True): + with mlflow.start_run() as run: + model.fit(self.ts_univariate) + + logged_models = mlflow_tracking.search_logged_models( + experiment_ids=[run.info.experiment_id] + ) + assert len(logged_models) == 1, ( + f"Expected exactly one logged model, got {len(logged_models)}: " + f"{[m.name for m in logged_models]}" + ) + assert logged_models[0].name == "RegressionEnsembleModel" + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_context): """Test autolog with multiple fits of a torch model""" From d1e80d2428e74c998df852db44a8bfc3e36aa9f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 17:09:07 +0200 Subject: [PATCH 096/154] feat: improve metric logging approach and fix import-order issue --- darts/metrics/utils.py | 23 +++++ darts/utils/mlflow.py | 189 +++++++++++++++++++---------------------- 2 files changed, 112 insertions(+), 100 deletions(-) diff --git a/darts/metrics/utils.py b/darts/metrics/utils.py index aa2a84d605..9d5cbec313 100644 --- a/darts/metrics/utils.py +++ b/darts/metrics/utils.py @@ -155,6 +155,22 @@ def wrapper_classification_support(*args, **kwargs): return wrapper_classification_support +_metric_callbacks: list[Callable] = [] + + +def register_metric_callback(callback: Callable) -> None: + """Register a callback to be invoked after every top-level metric call.""" + _metric_callbacks.append(callback) + + +def unregister_metric_callback(callback: Callable) -> None: + """Remove a previously registered metric callback, if present.""" + try: + _metric_callbacks.remove(callback) + except ValueError: + pass + + def multi_ts_support(func) -> Callable[..., METRIC_OUTPUT_TYPE]: """ This decorator further adapts the metrics that took as input two (or three for scaled metrics with `insample`) @@ -169,6 +185,9 @@ def multi_ts_support(func) -> Callable[..., METRIC_OUTPUT_TYPE]: @wraps(func) def wrapper_multi_ts_support(*args, **kwargs): + original_args = args + original_kwargs = dict(kwargs) + actual_series = ( kwargs["actual_series"] if "actual_series" in kwargs else args[0] ) @@ -312,6 +331,10 @@ def wrapper_multi_ts_support(*args, **kwargs): elif series_seq_type == SeriesType.SINGLE: vals = vals[0] + # invoke registered callbacks (e.g. MLflow autologging) + for cb in _metric_callbacks: + cb(func=func, result=vals, args=original_args, kwargs=original_kwargs) + # flatten along series axis if n series == 1 return vals diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index f3094562bd..b213528940 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -80,7 +80,11 @@ import darts from darts.logging import get_logger, raise_log -from darts.metrics.utils import _LabelReduction +from darts.metrics.utils import ( + _LabelReduction, + register_metric_callback, + unregister_metric_callback, +) from darts.models.forecasting.forecasting_model import ForecastingModel from darts.utils.ts_utils import ( SeriesType, @@ -424,9 +428,8 @@ def autolog( 1. Start an MLflow run (or reuse the currently active one). 2. Log model creation parameters (``model.model_params``). 3. Log covariate usage information (past, future, and static covariates). - 4. Patch all darts metric functions so that any call made inside an active - MLflow run automatically logs the result. Repeated calls overwrite - the previous value. + 4. Log the result of any darts metric call made inside an active MLflow + run. Repeated calls overwrite the previous value. 5. For PyTorch-based models: leverage ``mlflow.pytorch.autolog()`` to automatically log per-epoch training and validation metrics. 6. Log the trained model artifact at the end of training. @@ -434,16 +437,6 @@ def autolog( 8. Patch ``historical_forecasts()`` so that its internal per-window ``fit()`` calls don't each spawn their own logging. - .. important:: - - Metric functions imported with ``from darts.metrics import `` - before ``autolog()`` is enabled will **not** log to MLflow (function - reference is copied out of the module before the patch is applied). - - To avoid this restriction, use ``import darts.metrics as dm`` and call - ``dm.()`` instead (module attribute lookups are resolved at call - time and will always see the patched version). - .. note:: Logged metric keys follow the pattern @@ -471,8 +464,8 @@ def autolog( log_params If ``True`` (default), log model creation parameters. log_metrics - If ``True`` (default), patch all darts metric functions so that any - call made inside an active MLflow run is automatically logged. + If ``True`` (default), log the result of any darts metric call made + inside an active MLflow run. log_torch_metrics If ``True`` (default), enable ``mlflow.pytorch.autolog(log_models=False)`` around PyTorch-based model training to automatically log per-epoch @@ -509,6 +502,13 @@ def autolog( except (ImportError, Exception): pass + # Register/unregister the metric-logging callback with darts.metrics.utils + # directly, rather than via mlflow's safe_patch on each darts.metrics + # attribute (which is import-order sensitive) + unregister_metric_callback(_mlflow_metric_callback) + if log_metrics and not disable: + register_metric_callback(_mlflow_metric_callback) + _autolog( log_models=log_models, log_params=log_params, @@ -707,30 +707,6 @@ def _patched_backtest(original, self, *args, **kwargs): _patched_backtest, ) - if log_metrics: - import darts.metrics - - # TODO: To log metrics post-fitting, only patching the metric methods may not be enough. - # This is becuase `model.fit()` method would terminate the active MLflow run at the end of training, - # so any metric calls made after that would not be logged. - # To address this, we need to implement three things: - # 1. Implement a singleton `_AutologgingMetricsManager` (`mlflow.sklearn`) to maintain a mapping between fitted - # models and their prediction outputs. - # 2. Patch the `model.predict()` method to create a mapping between the model (run_id) and prediction output. - # 3. Patch the metric functions to find the model (run_id) from the input series, then log the metrics to - # the corresponding run. - # This way, even if the metric calls are made after `fit()` has terminated the active run, we can still log - # the metrics to the correct run. - - # patch all metric functions to log results - for metric_name in darts.metrics.__all__: - safe_patch( - FLAVOR_NAME, - darts.metrics, - metric_name, - _make_metric_patch(metric_name), - ) - def get_default_pip_requirements(): """Return the default pip requirements for logging a darts model. @@ -1355,13 +1331,29 @@ def _log_metric_result( _write_per_series_csv(rows, f"{metric_name}_per_series.csv") -def _make_metric_patch(metric_name: str) -> Callable: - """Create a ``safe_patch``-compatible patch function for a darts metric. - - The returned patch calls the original metric and, when an active MLflow - run exists, infers the output axes from the metric signature and call - kwargs (via ``_infer_metric_axes``) and delegates to ``_log_metric_result``, - which logs each cell under a key built as:: +# TODO: To log metrics post-fitting, only patching the metric methods may not be enough. +# This is becuase `model.fit()` method would terminate the active MLflow run at the end of training, +# so any metric calls made after that would not be logged. +# To address this, we need to implement three things: +# 1. Implement a singleton `_AutologgingMetricsManager` (`mlflow.sklearn`) to maintain a mapping between fitted +# models and their prediction outputs. +# 2. Patch the `model.predict()` method to create a mapping between the model (run_id) and prediction output. +# 3. Patch the metric functions to find the model (run_id) from the input series, then log the metrics to +# the corresponding run. +# This way, even if the metric calls are made after `fit()` has terminated the active run, we can still log +# the metrics to the correct run. +def _mlflow_metric_callback(func, result, args, kwargs) -> None: + """Metric callback registered with ``darts.metrics.utils`` for autologging. + + Invoked by ``multi_ts_support`` (the outermost decorator on every darts + metric) after every top-level metric call, so it fires regardless of how + the metric was imported. It is not invoked for internal metric-to-metric + calls (e.g. ``rmse`` calling ``mse`` internally via ``_get_wrapped_metric``), + since those bypass ``multi_ts_support`` entirely. + + When an active MLflow run exists, infers the output axes from the metric + signature and call kwargs (via ``_infer_metric_axes``) and delegates to + ``_log_metric_result``, which logs each cell under a key built as:: {metric_name}{component}{quantile_or_label} @@ -1378,67 +1370,64 @@ def _make_metric_patch(metric_name: str) -> Callable: to a ``per_series_metrics/`` CSV artifact instead of per-series keys. The per-timestep axis (``time_reduction=None``) is mapped to the MLflow - ``step``. The original return value is always forwarded unchanged. + ``step``. Parameters ---------- - metric_name - The darts metric function name used as the MLflow metric key. + func + The darts metric function that was called (used for its name and + signature). + result + The metric's return value. + args + Positional arguments the metric was called with. + kwargs + Keyword arguments the metric was called with. """ + active_run = mlflow.active_run() + if active_run is None: + return - def _patched_metric(original, *args, **kwargs): - result = original(*args, **kwargs) - - active_run = mlflow.active_run() - if active_run is None: - return result - - # backtest() calls metric functions internally; _patched_backtest - # handles logging the aggregated result, so skip here to avoid - # generating one flat key per window (series_gen_mape_0, _1, …). - if getattr(_autolog_state, "in_backtest", False): - return result + # backtest() calls metric functions internally; _patched_backtest + # handles logging the aggregated result, so skip here to avoid + # generating one flat key per window (series_gen_mape_0, _1, …). + if getattr(_autolog_state, "in_backtest", False): + return - autologging_client = MlflowAutologgingQueueingClient() - run_id = active_run.info.run_id + if len(args) > 0: + series = args[0] + else: + series = kwargs.get("actual_series", None) + if series is None: + return - if len(args) > 0: - series = args[0] - else: - series = kwargs.get("actual_series", None) - if series is None: - return result + autologging_client = MlflowAutologgingQueueingClient() + run_id = active_run.info.run_id - # the `name` kwarg overrides the metric-name token in the logged key - key_name = _sanitize_mlflow_key(kwargs.get("name") or metric_name) + # the `name` kwarg overrides the metric-name token in the logged key + key_name = _sanitize_mlflow_key(kwargs.get("name") or func.__name__) - # infer output axes from the metric signature + call kwargs - has_time_axis, has_comp_axis, quantiles_labels = _infer_metric_axes( - original, kwargs - ) + # infer output axes from the metric signature + call kwargs + has_time_axis, has_comp_axis, quantiles_labels = _infer_metric_axes(func, kwargs) - # series_reduction collapses the series axis inside the metric, so the - # result has no leading series axis even for list input. - params = inspect.signature(original).parameters - series_reduced = False - if "series_reduction" in params: - effective_sr = kwargs.get( - "series_reduction", params["series_reduction"].default - ) - series_reduced = effective_sr is not None - - _log_metric_result( - autologging_client, - run_id, - key_name, - result, - series, - has_time_axis, - has_comp_axis, - quantiles_labels, - series_reduced=series_reduced, + # series_reduction collapses the series axis inside the metric, so the + # result has no leading series axis even for list input. + params = inspect.signature(func).parameters + series_reduced = False + if "series_reduction" in params: + effective_sr = kwargs.get( + "series_reduction", params["series_reduction"].default ) - - return result - - return _patched_metric + series_reduced = effective_sr is not None + + _log_metric_result( + autologging_client, + run_id, + key_name, + result, + series, + has_time_axis, + has_comp_axis, + quantiles_labels, + series_reduced=series_reduced, + ) From 0d51dc46ed1f6320cc29c0fb503bbcb044609546 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 21 Jul 2026 17:09:49 +0200 Subject: [PATCH 097/154] feat: new metric logging approach tests --- darts/tests/optional_deps/test_mlflow.py | 72 ++++++++++++++++-------- 1 file changed, 49 insertions(+), 23 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 71d5e53d68..9ee0c8a901 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -738,29 +738,54 @@ def test_autolog_log_metrics_false(self, mlflow_tracking, autolog_context): "mape should NOT be logged when log_metrics=False" ) - def test_autolog_public_namespace_patched(self, mlflow_tracking, autolog_context): - """Only darts.metrics (public namespace) is patched; darts.metrics.metrics is not. - - Patching only the public namespace avoids breaking internal metric-to-metric - calls within the implementation module (e.g. rmse calling mse internally). + def test_autolog_metric_any_import_path_logs( + self, mlflow_tracking, autolog_context + ): + """Metrics log identically regardless of which module path was used to + call them. The mlflow hook lives inside `multi_ts_support` (baked into + the function itself) rather than patching a specific module + attribute, and `darts.metrics.mae` and `darts.metrics.metrics.mae` are + the same function object. """ with autolog_context(log_metrics=True): - # public namespace → patched: call inside a run should log with mlflow.start_run() as run_public: dm.mae(self.ts_univariate, self.ts_univariate * 1.1) - - # implementation module → NOT patched: call inside a run should not log with mlflow.start_run() as run_impl: dmm.mae(self.ts_univariate, self.ts_univariate * 1.1) - run_data_public = mlflow.get_run(run_public.info.run_id).data - run_data_impl = mlflow.get_run(run_impl.info.run_id).data - assert "mae" in run_data_public.metrics, ( - "darts.metrics.mae should log to MLflow (public namespace is patched)" - ) - assert "mae" not in run_data_impl.metrics, ( - "darts.metrics.metrics.mae should NOT log (implementation module is not patched)" - ) + assert "mae" in mlflow.get_run(run_public.info.run_id).data.metrics + assert "mae" in mlflow.get_run(run_impl.info.run_id).data.metrics + + def test_autolog_metric_import_order_independent( + self, mlflow_tracking, autolog_context + ): + """A metric imported via `from darts.metrics import ` *before* + autolog() is enabled still logs correctly, since the hook lives inside + the metric's own `multi_ts_support` decorator rather than patching a + module attribute after the fact.""" + from darts.metrics import mae as mae_imported_before_autolog + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + mae_imported_before_autolog( + self.ts_univariate, self.ts_univariate * 1.1 + ) + + assert "mae" in mlflow.get_run(run.info.run_id).data.metrics + + def test_autolog_metric_internal_composite_call_not_double_logged( + self, mlflow_tracking, autolog_context + ): + """rmse calls mse internally via `_get_wrapped_metric`, which bypasses + `multi_ts_support` entirely, so autologging must fire once (for rmse), + not twice (rmse and the internal mse call).""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + dm.rmse(self.ts_univariate, self.ts_univariate * 1.1) + + metrics = mlflow.get_run(run.info.run_id).data.metrics + assert "rmse" in metrics + assert "mse" not in metrics def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): """A per-timestep metric (ae) logs one value per timestep across MLflow steps. @@ -948,13 +973,13 @@ def test_autolog_metric_multi_series_classification_labels_explicit( assert got[("f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) assert got[("f1_label1", i)] == pytest.approx(ref[i][1], abs=1e-5) - def test_autolog_metric_size_mismatch_raises_internally( + def test_autolog_metric_size_mismatch_raises( self, mlflow_tracking, autolog_context, caplog ): """When the inferred C-axis size doesn't divide the result, logging raises - (logged as an error) and no metrics are written. The public metric call - itself doesn't crash, since MLflow's safe_patch wrapper catches exceptions - raised from inside a patch function.""" + (and logs an error), propagating out of the public metric call — the + metric callback isn't invoked through MLflow's safe_patch, so nothing + catches it. No metrics are written for the failed call.""" actual = self.ts_univariate[40:] # mae with component_reduction=None on a univariate series produces shape (T,), # which is size T — divisible by c_size=1 (1 component × 1 quantile), so we @@ -976,11 +1001,12 @@ def test_autolog_metric_size_mismatch_raises_internally( ): with autolog_context(log_metrics=True): with mlflow.start_run() as run: - with caplog.at_level(logging.WARNING, logger="darts"): - dm.mae(actual, pred) + with caplog.at_level(logging.ERROR, logger="darts"): + with pytest.raises(ValueError, match="not divisible"): + dm.mae(actual, pred) assert any("not divisible" in record.message for record in caplog.records), ( - "Expected a 'not divisible' warning when axes don't match the result" + "Expected a 'not divisible' error to be logged when axes don't match" ) # no metrics should have been written for the (faked) mismatched call run_data = mlflow.get_run(run.info.run_id).data.metrics From ae8a07260b867c6c38ce74030918ac8da4e1d9ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 11:02:56 +0200 Subject: [PATCH 098/154] feat: change per-series saving logic to append --- darts/utils/mlflow.py | 62 +++++++++++++++++++++---------------------- 1 file changed, 30 insertions(+), 32 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index b213528940..864b5eed90 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -19,7 +19,6 @@ https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py """ -import csv import inspect import re import sys @@ -42,6 +41,7 @@ ) import numpy as np +import pandas as pd import yaml from mlflow.entities import LoggedModel from mlflow.models import Model, ModelInputExample, ModelSignature @@ -69,7 +69,7 @@ _PythonEnv, _validate_env_arguments, ) -from mlflow.utils.file_utils import TempDir, write_to +from mlflow.utils.file_utils import write_to from mlflow.utils.model_utils import ( _add_code_from_conf_to_system_path, _get_flavor_configuration, @@ -454,8 +454,9 @@ def autolog( Per-timestep results (``time_reduction=None``) are charted across the MLflow ``step``. For a list of series the logged value is the mean over - series and the full per-series breakdown is written to a - ``per_series_metrics/`` CSV artifact. + series, and the full per-series breakdown for every metric/backtest + call in the run is appended to a single ``metrics_per_series.json`` + table artifact. Parameters ---------- @@ -856,14 +857,15 @@ def _sanitize_mlflow_key(name: str) -> str: return re.sub(r"[^\w-]", "_", name) -def _write_per_series_csv(rows: list[dict], filename: str) -> None: - """Write the granular per-series metric breakdown to a CSV artifact. +def _log_per_series_table(rows: list[dict]) -> None: + """Append the granular per-series metric breakdown to a single, run-wide + table artifact. Each row is a single metric cell for one series, with columns ``key`` (the aggregate MLflow key, without any series suffix), ``series_index``, ``step`` - (the time or window index charted by MLflow), and ``value``. The file is - logged under the ``per_series_metrics`` artifact subdirectory of the active - run. Used when more than one series is scored, since the logged metric keys + (the time or window index charted by MLflow), and ``value``. All calls + within a run append to the same ``metrics_per_series.json`` artifact. + Used when more than one series is scored, since the logged metric keys only carry the mean over series. Parameters @@ -871,20 +873,11 @@ def _write_per_series_csv(rows: list[dict], filename: str) -> None: rows One dict per metric cell with keys ``key``, ``series_index``, ``step``, and ``value``. - filename - Basename of the CSV file (e.g. ``series_mae_per_series.csv``). """ if not rows: return - sorted_rows = sorted(rows, key=itemgetter("key", "series_index", "step")) - fieldnames = ["key", "series_index", "step", "value"] - with TempDir() as tmp: - path = tmp.path(filename) - with open(path, "w", newline="") as f: - writer = csv.DictWriter(f, fieldnames=fieldnames) - writer.writeheader() - writer.writerows(sorted_rows) - mlflow.log_artifact(path, artifact_path="per_series_metrics") + df = pd.DataFrame(rows).sort_values(["key", "series_index", "step"]) + mlflow.log_table(data=df, artifact_file="metrics_per_series.json") def _log_backtest_metrics( @@ -924,9 +917,10 @@ def _log_backtest_metrics( result is flattened to integer-indexed keys instead. When more than one series is scored, the logged value is the mean over - series for each cell, and the granular per-series breakdown is written to a - ``per_series_metrics/backtest_per_series.csv`` artifact. For a single series - the mean is just the value itself and no artifact is written. + series for each cell, and the granular per-series breakdown is appended to + the run's ``metrics_per_series.json`` table artifact (shared with + ``_log_metric_result``). For a single series the mean is just the value + itself and no artifact is written. Raises ------ @@ -1105,9 +1099,10 @@ def _log_backtest_metrics( for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) - # write the granular per-series breakdown to a CSV artifact (multi-series only) + # append the granular per-series breakdown to the run's table artifact + # (multi-series only) if len(series_seq) > 1: - _write_per_series_csv(rows, "backtest_per_series.csv") + _log_per_series_table(rows) def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: @@ -1216,9 +1211,10 @@ def _log_metric_result( * ``quantile_or_label`` – e.g. ``_q0.5`` / ``_qi0.1_0.9`` / ``_label1``. When more than one series is scored, the logged value is the mean over - series for each cell, and the granular per-series breakdown is written to a - ``per_series_metrics/{metric_name}_per_series.csv`` artifact. For a single - series the mean is just the value itself and no artifact is written. + series for each cell, and the granular per-series breakdown is appended to + the run's ``metrics_per_series.json`` table artifact (shared with + ``_log_backtest_metrics``). For a single series the mean is just the value + itself and no artifact is written. Raises ------ @@ -1326,9 +1322,10 @@ def _log_metric_result( autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) autologging_client.flush(synchronous=False).await_completion() - # write the granular per-series breakdown to a CSV artifact (multi-series only) + # append the granular per-series breakdown to the run's table artifact + # (multi-series only) if len(series_seq) > 1: - _write_per_series_csv(rows, f"{metric_name}_per_series.csv") + _log_per_series_table(rows) # TODO: To log metrics post-fitting, only patching the metric methods may not be enough. @@ -1366,8 +1363,9 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: ``_qi0.1_0.9``, ``_label1``) when applicable. When the input is a ``Sequence[TimeSeries]`` with more than one series, the - logged value is the mean over series and the per-series breakdown is written - to a ``per_series_metrics/`` CSV artifact instead of per-series keys. + logged value is the mean over series and the per-series breakdown is + appended to the run's ``metrics_per_series.json`` table artifact instead + of per-series keys. The per-timestep axis (``time_reduction=None``) is mapped to the MLflow ``step``. From b3f30314789e519ac5e1143e1186475f2496a57f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 11:04:57 +0200 Subject: [PATCH 099/154] feat: append on save logic tests --- darts/tests/optional_deps/test_mlflow.py | 58 +++++++++++------------- 1 file changed, 26 insertions(+), 32 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 9ee0c8a901..b7655795e5 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,4 +1,3 @@ -import csv import logging import os @@ -851,7 +850,7 @@ def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context assert m["miw_qi0_1_0_9"] == pytest.approx(float(ref), abs=1e-5) def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): - """A list of series logs the mean over series; per-series values go to a CSV.""" + """A list of series logs the mean over series; per-series values go to a table.""" series = [self.ts_univariate, self.ts_univariate * 1.2] pred = [s * 1.1 for s in series] @@ -864,9 +863,9 @@ def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): # aggregate = mean over series, no per-series _s{i} keys assert m["mae"] == pytest.approx(float(np.mean(ref)), abs=1e-5) assert not any(k.startswith("mae_s") for k in m) - # granular per-series breakdown written to a CSV artifact - csv_rows = self._read_per_series_csv(run.info.run_id, "mae_per_series.csv") - by_series = {int(row["series_index"]): float(row["value"]) for row in csv_rows} + # granular per-series breakdown written to a table artifact + rows = self._read_per_series_table(run.info.run_id) + by_series = {int(row["series_index"]): float(row["value"]) for row in rows} assert by_series == pytest.approx({0: ref[0], 1: ref[1]}, abs=1e-5) def test_autolog_metric_multi_series_per_component( @@ -888,10 +887,9 @@ def test_autolog_metric_multi_series_per_component( assert m["mae_linear_1"] == pytest.approx(float(ref[:, 1].mean()), abs=1e-5) assert not any(k.endswith(("_s0", "_s1")) for k in m) # granular CSV: one row per (component, series) - csv_rows = self._read_per_series_csv(run.info.run_id, "mae_per_series.csv") + rows = self._read_per_series_table(run.info.run_id) got = { - (row["key"], int(row["series_index"])): float(row["value"]) - for row in csv_rows + (row["key"], int(row["series_index"])): float(row["value"]) for row in rows } assert got[("mae_linear", 0)] == pytest.approx(ref[0, 0], abs=1e-5) assert got[("mae_linear", 1)] == pytest.approx(ref[1, 0], abs=1e-5) @@ -935,7 +933,7 @@ def test_autolog_metric_multi_series_classification_labels_explicit( self, mlflow_tracking, autolog_context ): """f1 with label_reduction=None and explicit labels on a list of binary - series logs the per-label mean over series and writes the per-series CSV. + series logs the per-label mean over series and writes the per-series table. ``labels`` must be explicit (``label_reduction=None`` without it raises, since the number of output labels can't be determined ahead of time).""" @@ -964,10 +962,9 @@ def test_autolog_metric_multi_series_classification_labels_explicit( ) assert not any(k.endswith(("_s0", "_s1")) for k in m) # granular CSV: one row per (label, series) - csv_rows = self._read_per_series_csv(run.info.run_id, "f1_per_series.csv") + rows = self._read_per_series_table(run.info.run_id) got = { - (row["key"], int(row["series_index"])): float(row["value"]) - for row in csv_rows + (row["key"], int(row["series_index"])): float(row["value"]) for row in rows } for i in range(2): assert got[("f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) @@ -1014,10 +1011,10 @@ def test_autolog_metric_size_mismatch_raises( "No mae metrics should be logged when the size check fails" ) - def test_autolog_metric_per_series_csv_schema_and_single_series_skip( + def test_autolog_metric_per_series_table_schema_and_single_series_skip( self, mlflow_tracking, autolog_context ): - """The per-series CSV has the expected schema for multi-series input, and no + """The per-series table has the expected schema for multi-series input, and no artifact is written for single-series input (mean == the value itself).""" # multi-series: artifact exists with the documented columns multi = [self.ts_univariate, self.ts_univariate * 1.2] @@ -1026,13 +1023,11 @@ def test_autolog_metric_per_series_csv_schema_and_single_series_skip( with mlflow.start_run() as run_multi: dm.mae(multi, pred_multi) - csv_rows = self._read_per_series_csv( - run_multi.info.run_id, "mae_per_series.csv" - ) - assert list(csv_rows[0].keys()) == ["key", "series_index", "step", "value"] - assert {int(r["series_index"]) for r in csv_rows} == {0, 1} + rows = self._read_per_series_table(run_multi.info.run_id) + assert list(rows[0].keys()) == ["key", "series_index", "step", "value"] + assert {int(r["series_index"]) for r in rows} == {0, 1} - # single-series: no per_series_metrics artifact directory should be created + # single-series: no per-series table artifact should be created single = self.ts_univariate pred_single = single * 1.1 with autolog_context(log_metrics=True): @@ -1040,8 +1035,8 @@ def test_autolog_metric_per_series_csv_schema_and_single_series_skip( dm.mae(single, pred_single) artifacts = mlflow_tracking.list_artifacts(run_single.info.run_id) - assert not any(a.path == "per_series_metrics" for a in artifacts), ( - "Single-series input should not write a per-series CSV artifact" + assert not any(a.path == "metrics_per_series.json" for a in artifacts), ( + "Single-series input should not write a per-series table artifact" ) def test_autolog_backtest_scalar(self, mlflow_tracking, autolog_context): @@ -1120,7 +1115,7 @@ def test_autolog_backtest_multi_metric(self, mlflow_tracking, autolog_context): ) def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): - """A list of series logs the mean over series; per-series values go to a CSV.""" + """A list of series logs the mean over series; per-series values go to a table.""" series = [self.ts_univariate, self.ts_univariate * 1.2] with autolog_context(log_metrics=True): with mlflow.start_run() as run: @@ -1134,9 +1129,9 @@ def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): float(np.mean(ref)), abs=1e-5 ) assert not any(k.startswith("backtest_mae_s") for k in run_data.metrics) - # granular per-series breakdown written to a CSV artifact - csv_rows = self._read_per_series_csv(run.info.run_id, "backtest_per_series.csv") - by_series = {int(row["series_index"]): float(row["value"]) for row in csv_rows} + # granular per-series breakdown written to a table artifact + rows = self._read_per_series_table(run.info.run_id) + by_series = {int(row["series_index"]): float(row["value"]) for row in rows} assert by_series == pytest.approx( {0: float(ref[0]), 1: float(ref[1])}, abs=1e-5 ) @@ -1312,13 +1307,12 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): assert not mlflow.get_run(run.info.run_id).data.metrics @staticmethod - def _read_per_series_csv(run_id, filename): - """Download and parse a per_series_metrics CSV artifact into row dicts.""" - local = mlflow.artifacts.download_artifacts( - run_id=run_id, artifact_path=f"per_series_metrics/{filename}" + def _read_per_series_table(run_id): + """Load the run's consolidated per-series metric table into row dicts.""" + df = mlflow.load_table( + artifact_file="metrics_per_series.json", run_ids=[run_id] ) - with open(local, newline="") as f: - return list(csv.DictReader(f)) + return df.to_dict("records") def _fit_lr(self, series=None): """Fit and return a fresh LinearRegressionModel (no active run).""" From 529c58f6a20dda96b339806f6c63c988bd2d487c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 11:24:13 +0200 Subject: [PATCH 100/154] feat: infer forecast horizon from backtest args --- darts/utils/mlflow.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 864b5eed90..92873f740b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -991,6 +991,17 @@ def _log_backtest_metrics( series = backtest_args.get("series") forecast_horizon = backtest_args.get("forecast_horizon") + historical_forecasts = backtest_args.get("historical_forecasts") + last_points_only = backtest_args.get("last_points_only", False) + + # if last_points_only is True, has_windows will be False, so fc_hzn is not needed + if historical_forecasts and not last_points_only: + first_series_hf = ( + historical_forecasts + if get_series_seq_type(series) == SeriesType.SINGLE + else historical_forecasts[0] + ) + forecast_horizon = len(first_series_hf[0]) series_seq = series2seq(series) results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result From 069c28a409078cc10baa1c587d64c86475524aab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 11:26:57 +0200 Subject: [PATCH 101/154] feat: fc_hzn inference unit test --- darts/tests/optional_deps/test_mlflow.py | 32 ++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index b7655795e5..3cee358623 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1172,6 +1172,38 @@ def test_autolog_backtest_per_timestep_per_window( logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, ref[0], atol=1e-5) + def test_autolog_backtest_historical_forecasts_horizon_inferred( + self, mlflow_tracking, autolog_context + ): + """When `historical_forecasts` is user-supplied, `backtest()` ignores the + `forecast_horizon` argument, autologging must infer the true window + length from the historical forecasts themselves, not from the (unused, + defaulted) `forecast_horizon` argument.""" + model = self._fit_lr() + hf = model.historical_forecasts( + self.ts_univariate, + retrain=False, + stride=10, + forecast_horizon=4, + last_points_only=False, + ) + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + # forecast_horizon is not passed (defaults to 1) and would be + # wrong; the real horizon (4) must come from `hf`. + ref = model.backtest( + self.ts_univariate, + historical_forecasts=hf, + metric=dm.ae, + reduction=None, + ) + + ref = np.asarray(ref, dtype=float) # shape (n_windows, forecast_horizon) + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae_w0") + assert len(history) == 4, "Expected one step per forecast horizon timestep" + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose(logged, ref[0], atol=1e-5) + def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile.""" with autolog_context(log_metrics=True): From 2d513a74664f8108902cd0a6dd71cee79e2ce293 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 11:42:22 +0200 Subject: [PATCH 102/154] fix: handle multi series covariate logging --- darts/utils/mlflow.py | 100 +++++++++++++++++++++++------------------- 1 file changed, 54 insertions(+), 46 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 92873f740b..8728442933 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -107,27 +107,6 @@ _MODEL_FILE_STAT = "model.pkl" _MODEL_FILE_TORCH = "model.pt" -_covariate_types = [ - ( - "past_covariates", - "uses_past_covariates", - "past_covariate_series", - "components", - ), - ( - "future_covariates", - "uses_future_covariates", - "future_covariate_series", - "components", - ), - ( - "static_covariates", - "uses_static_covariates", - "static_covariates", - "columns", - ), -] - # Thread-local flags used by _patched_fit to suppress nested/re-entrant # autologging: in_historical_forecasts covers historical_forecasts' internal # fit() calls, in_fit covers nested fit() calls (e.g. ensembles, super()), @@ -608,7 +587,13 @@ def _patched_fit(original, self, *args, **kwargs): if log_params: # Log the parameters for model creation autologging_client.log_params(run_id=run_id, params=self.model_params) - _log_covariate_info(self) + fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments + _log_covariate_info( + self, + series=fit_args.get("series"), + past_covariates=fit_args.get("past_covariates"), + future_covariates=fit_args.get("future_covariates"), + ) param_logging_ops = autologging_client.flush(synchronous=False) @@ -755,11 +740,11 @@ def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: } -def _log_covariate_info(model: ForecastingModel) -> None: +def _log_covariate_info(model, series, past_covariates, future_covariates) -> None: """Log covariate usage information to MLflow. Extracts information about past, future, and static covariates used during - training and logs them as tags, parameters, and a JSON artifact for easy + training and logs them as a JSON artifact for easy filtering, comparison, and documentation. Logs three types of information: @@ -771,17 +756,42 @@ def _log_covariate_info(model: ForecastingModel) -> None: ---------- model A fitted Darts forecasting model instance. + series + The ``series`` argument passed to ``fit()``: a single ``TimeSeries`` + or a ``Sequence[TimeSeries]``. + past_covariates + The past covariate argument passed to ``fit()``, or + ``None``. + future_covariates + The future covariate covariate argument passed to ``fit()``, or + ``None``. """ - covariate_info = { - cov_key: _extract_covariate_metadata(model, uses_attr, series_attr, names_attr) - for cov_key, uses_attr, series_attr, names_attr in _covariate_types + "past_covariates": _extract_covariate_metadata( + model.uses_past_covariates, + get_single_series(past_covariates), + "components", + ), + "future_covariates": _extract_covariate_metadata( + model.uses_future_covariates, + get_single_series(future_covariates), + "components", + ), } - if model.uses_static_covariates and model.static_covariates is not None: - covariate_info["static_covariates"]["is_global"] = len( - model.static_covariates - ) != len(model.static_covariates.columns) + first_series = get_single_series(series) + static_covariates = ( + first_series.static_covariates if first_series is not None else None + ) + covariate_info["static_covariates"] = _extract_covariate_metadata( + model.uses_static_covariates, static_covariates, "columns" + ) + if model.uses_static_covariates and static_covariates is not None: + # static covariates are global (one shared row) unless there is one row + # per series component, in which case they are component-specific + covariate_info["static_covariates"]["is_global"] = ( + len(static_covariates) != first_series.n_components + ) # log complete information as JSON artifact mlflow.log_dict(covariate_info, "covariates.json") @@ -803,21 +813,20 @@ def _is_torch_model(model) -> bool: return TORCH_AVAILABLE and isinstance(model, TorchForecastingModel) -def _extract_covariate_metadata( - model: ForecastingModel, uses_attr: str, series_attr: str, names_attr: str -) -> dict: - """Extract metadata for a single covariate type. +def _extract_covariate_metadata(uses: bool, single_cov, names_attr: str) -> dict: + """Extract metadata for a single covariate type from its (already + singular) value. Parameters ---------- - model - A Darts forecasting model instance. - uses_attr : str - Model attribute name indicating covariate usage. - series_attr : str - Model attribute name for the covariate series. + uses + Whether the model uses this covariate type. + single_cov + The covariate's value for one series: a ``TimeSeries`` (past/future + covariates) or a static-covariates ``DataFrame``, or ``None``. names_attr : str - Series attribute name for feature names ("components" or "columns"). + Attribute holding the feature names ("components" for a + ``TimeSeries``, "columns" for a static-covariates ``DataFrame``). Returns ------- @@ -826,11 +835,10 @@ def _extract_covariate_metadata( """ info = {"used": False, "count": 0, "names": []} - if getattr(model, uses_attr, False): + if uses: info["used"] = True - series = getattr(model, series_attr, None) - if series is not None: - names = getattr(series, names_attr).tolist() + if single_cov is not None: + names = getattr(single_cov, names_attr).tolist() info["names"] = names info["count"] = len(names) From aac668d2e73479299f5c6ad57ba216c5acc17aab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 11:43:00 +0200 Subject: [PATCH 103/154] feat: covariate tracking unit tests --- darts/tests/optional_deps/test_mlflow.py | 79 ++++++++++++++++++++++-- 1 file changed, 74 insertions(+), 5 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 3cee358623..387a3e8a48 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -363,12 +363,81 @@ def assert_metric(history, key): assert autologging_is_disabled("pytorch") - def test_covariate_artifact_schema(self, mlflow_tracking): - """Test that covariate artifact has correct JSON schema""" - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) + def test_autolog_covariate_info_single_series( + self, mlflow_tracking, autolog_context + ): + """The covariates.json artifact reports usage, count, and names for a + single-series fit.""" + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit( + self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40] + ) + + covariates = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/covariates.json" + ) + assert covariates["past_covariates"]["used"] is True + assert covariates["past_covariates"]["count"] == 1 + assert ( + covariates["past_covariates"]["names"] + == self.ts_past_cov.components.tolist() + ) + assert covariates["future_covariates"]["used"] is False + assert covariates["static_covariates"]["used"] is False + + def test_autolog_covariate_info_multi_series( + self, mlflow_tracking, autolog_context + ): + """Fitting on a list of series doesn't leave past_covariates unreported: + `model.past_covariate_series` stays None for a multi-series fit, so the + info must come from the actual `fit()` call arguments instead.""" + series = [self.ts_univariate, self.ts_univariate * 1.2] + past_covs = [self.ts_past_cov[:50], self.ts_past_cov[:50]] + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.fit(series, past_covariates=past_covs) + + covariates = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/covariates.json" + ) + assert covariates["past_covariates"]["used"] is True + assert covariates["past_covariates"]["count"] == 1 + assert ( + covariates["past_covariates"]["names"] + == self.ts_past_cov.components.tolist() + ) - # TODO: use autolog + def test_autolog_covariate_info_static_is_global( + self, mlflow_tracking, autolog_context + ): + """`is_global` is based on row count vs. the number of series + components, not the number of static-covariate columns.""" + # one shared row over 2 components -> global + global_target = self.ts_multivariate.with_static_covariates( + pd.DataFrame({"a": [1.0], "b": [2.0]}) + ) + with autolog_context(): + with mlflow.start_run() as run: + LinearRegressionModel(lags=5).fit(global_target) + covariates = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/covariates.json" + ) + assert covariates["static_covariates"]["is_global"] is True + + # one row per component (2 components, 2 rows) -> component-specific + per_component_target = self.ts_multivariate.with_static_covariates( + pd.DataFrame({"a": [1.0, 2.0]}) + ) + with autolog_context(): + with mlflow.start_run() as run: + LinearRegressionModel(lags=5).fit(per_component_target) + covariates = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/covariates.json" + ) + assert covariates["static_covariates"]["is_global"] is False def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" From 66a0b10685dee6d9d1da268296a941dbd4cbfe33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 12:30:45 +0200 Subject: [PATCH 104/154] docs: clarify explanation for pytorch autolog approach --- darts/utils/mlflow.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 8728442933..c620e4dd6b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -459,9 +459,13 @@ def autolog( """ # Enable/disable mlflow.pytorch.autolog for per-epoch metrics on torch models. # This must happen outside the @autologging_integration-decorated _autolog() - # because the decorator short-circuits on disable=True before the function - # body executes, and MLflow's session manager suppresses nested autolog - # patches if called from within a safe_patch context. + # because that decorator short-circuits _autolog()'s body entirely when + # disable=True, so a call placed inside it would never run. Unlike + # mlflow.sklearn, which exposes a private, undecorated _autolog(flavor_name=...) + # that other flavors (e.g. xgboost) call to tag its patches under their own + # integration name for cleanup, mlflow.pytorch has no such hook: its autolog() + # hardcodes its own patches under "pytorch", so darts can't fold pytorch's + # patch lifecycle into its own and must call mlflow.pytorch.autolog() directly. if log_torch_metrics and not disable: try: import mlflow.pytorch From 95709903b8de12528a1a645a7ad5fa190c0022b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 13:46:46 +0200 Subject: [PATCH 105/154] feat: remove extra explicit mlflow gorup --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 44e8206957..39256b1bb8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -70,7 +70,6 @@ notorch = [ "statsforecast>=1.4", "xgboost>=2.1.4", ] -mlflow = ["mlflow>=3.0"] all = ["darts[torch,notorch]"] [tool.uv] From 381cc15ab6216a81ed10cdf674c3efee95306d62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 14:25:42 +0200 Subject: [PATCH 106/154] chore: hide log_model mlflow params, expose model and kwargs only --- darts/utils/mlflow.py | 105 ++++++++---------------------------------- 1 file changed, 18 insertions(+), 87 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index c620e4dd6b..bbbe66f3b4 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -47,7 +47,6 @@ from mlflow.models import Model, ModelInputExample, ModelSignature from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example -from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS from mlflow.tracking.artifact_utils import _download_artifact_from_uri from mlflow.tracking.fluent import _initialize_logged_model from mlflow.utils import _get_fully_qualified_class_name @@ -286,72 +285,25 @@ def load_model( return model_cls.load(str(model_path), **kwargs) -def log_model( - model, - artifact_path: str | None = None, - conda_env: dict | str | None = None, - code_paths: list[str] | None = None, - registered_model_name: str | None = None, - signature: ModelSignature | None = None, - input_example: ModelInputExample | None = None, - await_registration_for: int = DEFAULT_AWAIT_MAX_SLEEP_SECONDS, - pip_requirements: list[str] | None = None, - extra_pip_requirements: list[str] | None = None, - metadata: dict[str, Any] | None = None, - name: str | None = None, - params: dict[str, Any] | None = None, - tags: dict[str, Any] | None = None, - model_type: str | None = None, - step: int = 0, - model_id: str | None = None, - **kwargs, -): - """Log a darts model to the current MLflow run. +def log_model(model, **kwargs): + """Log a darts model to the current MLflow run, using the darts MLflow flavor. + + This is a thin wrapper around ``mlflow.models.Model.log()`` that supplies + the darts flavor for saving/loading; every other argument is forwarded + as-is. See the `MLflow documentation + `_ + for the full list of accepted parameters (e.g. ``name``, + ``registered_model_name``, ``conda_env``, ``pip_requirements``, + ``metadata``, ``tags``, ...). Parameters ---------- model A fitted darts ``ForecastingModel`` instance. - artifact_path - The run-relative artifact path under which to log the model. - Defaults to ``"model"``. Deprecated in favour of ``name``. - conda_env - Conda environment specification (dict or path). - code_paths - A list of local filesystem paths to Python file dependencies (or directories - containing file dependencies). These files are prepended to the system path - when the model is loaded. - registered_model_name - If provided, the model is registered in the MLflow Model Registry - under this name. - signature - *Unsupported, see notes.* An ``mlflow.models.ModelSignature``. Use ``mlflow.models.infer_signature()`` - to automatically generate from example inputs. - input_example - *Unsupported, see notes.* An example model input. - await_registration_for - Number of seconds to wait for the model version to finish being created and is in ``READY`` status. - By default, the function waits for five minutes. Specify 0 to skip waiting. - pip_requirements - Pip requirements list. - extra_pip_requirements - A list of additional pip requirement strings to add to the model's environment, - in addition to the default requirements. - metadata - Optional dict of custom metadata. - name - The name for the model artifact. If provided, takes precedence over - ``artifact_path``. - params - Optional dictionary of parameters to log alongside the model. - tags - Optional dictionary of tags to log alongside the model. - model_type - Optional string for the model type. - step - Optional step value to log with the model's metrics. Defaults to 0. - model_id - Optional string for the model ID. + **kwargs + Forwarded to ``mlflow.models.Model.log()``. Use ``name`` to set the + run-relative artifact path. ``artifact_path`` parameter is deprecated + by MLflow and not exposed here. Returns ------- @@ -361,33 +313,12 @@ def log_model( Notes ----- - Signature and input_example params are currently not supported, as they - are used to support serving and input validation in the MLflow pyfunc flavor, - which is not implemented for darts models. They are accepted as params for - simplifying potential future extensibility, and to keep in line with MLflow API - conventions. + ``signature`` and ``input_example`` are currently not supported, as they + are used to support serving and input validation in the MLflow pyfunc + flavor, which is not implemented for darts models. """ - return Model.log( - artifact_path=artifact_path, - flavor=sys.modules[__name__], - registered_model_name=registered_model_name, - model=model, - conda_env=conda_env, - code_paths=code_paths, - pip_requirements=pip_requirements, - extra_pip_requirements=extra_pip_requirements, - signature=signature, - input_example=input_example, - await_registration_for=await_registration_for, - metadata=metadata, - name=name, - params=params, - tags=tags, - model_type=model_type, - step=step, - model_id=model_id, - **kwargs, + artifact_path=None, flavor=sys.modules[__name__], model=model, **kwargs ) From 9954928c44d82a8625f158f77dd912ba12535cbb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 14:26:29 +0200 Subject: [PATCH 107/154] chore: change default pip to core darts --- darts/utils/mlflow.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index bbbe66f3b4..d27623ae24 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -637,7 +637,7 @@ def get_default_pip_requirements(): list[str] A list of pip requirement strings. """ - reqs = [_get_pinned_requirement("darts[all]")] + reqs = [_get_pinned_requirement("darts")] return reqs From 16c881f1fe5a52c5ebe788e7f18f78e4dd610321 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 14:31:03 +0200 Subject: [PATCH 108/154] chore: clean up unreachable code --- darts/utils/mlflow.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index d27623ae24..0358a1613d 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1346,12 +1346,7 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: if getattr(_autolog_state, "in_backtest", False): return - if len(args) > 0: - series = args[0] - else: - series = kwargs.get("actual_series", None) - if series is None: - return + series = args[0] if len(args) > 0 else kwargs["actual_series"] autologging_client = MlflowAutologgingQueueingClient() run_id = active_run.info.run_id From 9081dff3a7d6b1c4aade6235c3aecf9ae8da9ffa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 15:22:13 +0200 Subject: [PATCH 109/154] feat: align backtesting windows on aggregation to end --- darts/utils/mlflow.py | 201 +++++++++++++++++++++++++----------------- 1 file changed, 122 insertions(+), 79 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 0358a1613d..5efcc08397 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -865,6 +865,14 @@ def _log_backtest_metrics( ``_log_metric_result``). For a single series the mean is just the value itself and no artifact is written. + Series of different lengths are assumed to share the same end date. Any + axis mapping to real dates -- the window axis (``has_windows``), or the + per-timestep axis when ``last_points_only`` stitches windows into one + series -- is aligned from the end rather than the start, so a shorter + series lines up on its last entry instead of its first. The + per-horizon-step axis is left as-is, since it means "steps ahead" rather + than a real date. + Raises ------ ValueError @@ -952,8 +960,9 @@ def _log_backtest_metrics( # agg maps (key, step) -> per-series values, averaged into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] - for series_index, (s, r) in enumerate(zip(series_seq, results)): - if axes_inconsistent: + + if axes_inconsistent: + for series_index, (s, r) in enumerate(zip(series_seq, results)): name_prefix = metric_names[0] if len(metric_names) == 1 else "metrics" flat = np.asarray(r, dtype=float).flatten() for i, val in enumerate(flat): @@ -966,84 +975,104 @@ def _log_backtest_metrics( "step": 0, "value": value, }) - continue - - comps = s.components.tolist() - # c_size = components × quantiles/intervals/labels per component - c_size = (s.n_components if has_comp_axis else 1) * quantiles_num - arr = np.asarray(r, dtype=float) - # after stripping C and M axes, rest = W*T (or W or T alone) - rest, extra = divmod(arr.size, c_size * n_metrics) - if extra: - raise_log( - ValueError( - f"Backtest metric logging failed: result size ({arr.size}) " - f"is not divisible by c_size * n_metrics ({c_size} * " - f"{n_metrics} = {c_size * n_metrics}). The metric output " - "shape does not match the inferred axes." - ) - ) - - # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can - # recover W and T only if forecast_horizon is known (T = forecast_horizon) - if has_time_axis and has_windows: - if not forecast_horizon or rest % forecast_horizon: + else: + # first pass: reshape each series' result into a canonical (W, T, C, M) + # array, recording its window-axis length for the alignment pass below. + series_shapes = [] + for s, r in zip(series_seq, results): + comps = s.components.tolist() + # c_size = components × quantiles/intervals/labels per component + c_size = (s.n_components if has_comp_axis else 1) * quantiles_num + arr = np.asarray(r, dtype=float) + # after stripping C and M axes, rest = W*T (or W or T alone) + rest, extra = divmod(arr.size, c_size * n_metrics) + if extra: raise_log( ValueError( - f"Backtest metric logging failed: cannot split " - f"window/time axes — {rest} elements remain after " - f"stripping component and metric axes, but " - f"forecast_horizon={forecast_horizon!r} does not " - "divide evenly. Pass an explicit forecast_horizon to " - "backtest()." + f"Backtest metric logging failed: result size ({arr.size}) " + f"is not divisible by c_size * n_metrics ({c_size} * " + f"{n_metrics} = {c_size * n_metrics}). The metric output " + "shape does not match the inferred axes." ) ) - t_size, w_size = forecast_horizon, rest // forecast_horizon - elif has_time_axis: - t_size, w_size = rest, 1 - elif has_windows: - t_size, w_size = 1, rest - else: - if rest != 1: - raise_log( - ValueError( - f"Backtest metric logging failed: expected a single " - f"scalar per component/metric after reduction, but got " - f"{rest} elements. Check time_reduction and " - "component_reduction defaults." + + # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can + # recover W and T only if forecast_horizon is known (T = forecast_horizon) + if has_time_axis and has_windows: + if not forecast_horizon or rest % forecast_horizon: + raise_log( + ValueError( + f"Backtest metric logging failed: cannot split " + f"window/time axes — {rest} elements remain after " + f"stripping component and metric axes, but " + f"forecast_horizon={forecast_horizon!r} does not " + "divide evenly. Pass an explicit forecast_horizon to " + "backtest()." + ) ) - ) - t_size, w_size = 1, 1 - - canonical = arr.reshape(w_size, t_size, c_size, n_metrics) - for m, metric_name in enumerate(metric_names): - quantiles_labels = metric_axes[m][2] - for w in range(w_size): - for c in range(c_size): - # c is a flat index into the (n_components × quantiles_num) C axis: - # c = comp_i * quantiles_num + q_i - component_index, quantile_index = divmod(c, quantiles_num) - comp_part = ( - "_" + _sanitize_mlflow_key(comps[component_index]) - if has_comp_axis - else "" + t_size, w_size = forecast_horizon, rest // forecast_horizon + elif has_time_axis: + t_size, w_size = rest, 1 + elif has_windows: + t_size, w_size = 1, rest + else: + if rest != 1: + raise_log( + ValueError( + f"Backtest metric logging failed: expected a single " + f"scalar per component/metric after reduction, but got " + f"{rest} elements. Check time_reduction and " + "component_reduction defaults." + ) ) - key = f"backtest_{metric_name}{comp_part}{quantiles_labels[quantile_index]}" - if has_time_axis and has_windows: - key += f"_w{w}" - key = _sanitize_mlflow_key(key) - for t in range(t_size): - # MLflow step maps to the axis the UI should chart: - # time when present, otherwise window index - step = t if has_time_axis else w - value = float(canonical[w, t, c, m]) - agg.setdefault((key, step), []).append(value) - rows.append({ - "key": key, - "series_index": series_index, - "step": step, - "value": value, - }) + t_size, w_size = 1, 1 + + canonical = arr.reshape(w_size, t_size, c_size, n_metrics) + series_shapes.append((comps, c_size, t_size, w_size, canonical)) + + # align the calendar-relative axes from the end + max_w_size = max((w_size for _, _, _, w_size, _ in series_shapes), default=0) + t_axis_is_calendar = has_time_axis and not has_windows and last_points_only + max_t_size = ( + max((t_size for _, _, t_size, _, _ in series_shapes), default=0) + if t_axis_is_calendar + else 0 + ) + + for series_index, (comps, c_size, t_size, w_size, canonical) in enumerate( + series_shapes + ): + w_offset = max_w_size - w_size if has_windows else 0 + t_offset = max_t_size - t_size if t_axis_is_calendar else 0 + for m, metric_name in enumerate(metric_names): + quantiles_labels = metric_axes[m][2] + for w in range(w_size): + aligned_w = w + w_offset + for c in range(c_size): + # c is a flat index into the (n_components × quantiles_num) C axis: + # c = comp_i * quantiles_num + q_i + component_index, quantile_index = divmod(c, quantiles_num) + comp_part = ( + "_" + _sanitize_mlflow_key(comps[component_index]) + if has_comp_axis + else "" + ) + key = f"backtest_{metric_name}{comp_part}{quantiles_labels[quantile_index]}" + if has_time_axis and has_windows: + key += f"_w{aligned_w}" + key = _sanitize_mlflow_key(key) + for t in range(t_size): + # MLflow step maps to the axis the UI should chart: + # time when present, otherwise window index + step = t + t_offset if has_time_axis else aligned_w + value = float(canonical[w, t, c, m]) + agg.setdefault((key, step), []).append(value) + rows.append({ + "key": key, + "series_index": series_index, + "step": step, + "value": value, + }) # log the mean over series for each (key, step); for a single series this is # just the value itself. @@ -1170,6 +1199,10 @@ def _log_metric_result( ``_log_backtest_metrics``). For a single series the mean is just the value itself and no artifact is written. + Series of different lengths are assumed to share the same end date, so the + time axis is aligned from the end rather than the start: a shorter series + lines up on its last value instead of its first. + Raises ------ ValueError @@ -1208,10 +1241,10 @@ def _log_metric_result( [result] if get_series_seq_type(series) == SeriesType.SINGLE else result ) - # agg maps (key, step) -> per-series values, averaged into the logged metric. - agg: dict[tuple[str, int], list[float]] = {} - rows: list[dict] = [] - for series_index, (s, r) in enumerate(zip(series_seq, results)): + # first pass: reshape each series' result into a canonical (T, C) array, + # recording its time-axis length for the alignment pass below. + series_shapes = [] + for s, r in zip(series_seq, results): comps = s.components.tolist() # c_size = components × quantiles/intervals/labels per component c_size = (s.n_components if has_comp_axis else 1) * quantiles_num @@ -1243,6 +1276,16 @@ def _log_metric_result( t_size = 1 canonical = arr.reshape(t_size, c_size) + series_shapes.append((comps, c_size, t_size, canonical)) + + # align the time axis from the end (see docstring) + max_t_size = max((t_size for _, _, t_size, _ in series_shapes), default=0) + + # agg maps (key, step) -> per-series values, averaged into the logged metric. + agg: dict[tuple[str, int], list[float]] = {} + rows: list[dict] = [] + for series_index, (comps, c_size, t_size, canonical) in enumerate(series_shapes): + step_offset = max_t_size - t_size if has_time_axis else 0 for c in range(c_size): # c is a flat index into the (n_components × quantiles_num) C axis: # c = comp_i * quantiles_num + q_i @@ -1257,7 +1300,7 @@ def _log_metric_result( ) for t in range(t_size): # MLflow step maps to the time axis when present - step = t if has_time_axis else 0 + step = t + step_offset if has_time_axis else 0 value = float(canonical[t, c]) agg.setdefault((key, step), []).append(value) rows.append({ From c1abac29e627716eb13ab0e526b038f6a56c0088 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 15:22:37 +0200 Subject: [PATCH 110/154] feat: windows alignment on backtest aggregation tests --- darts/tests/optional_deps/test_mlflow.py | 92 ++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 387a3e8a48..a866c1ee95 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -880,6 +880,38 @@ def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, ref, atol=1e-5) + def test_autolog_metric_aligns_time_axis_by_end_date( + self, mlflow_tracking, autolog_context + ): + """A shorter series' time axis aligns from the end, not the start, so + its steps overlap the tail of a longer series rather than the head.""" + ts_long = self.ts_univariate # length 50 + ts_short = ts_long[10:] # length 40, same end, starts 10 steps later + + # distinct constant error per series, so a step's mean reveals exactly + # which series contributed to it + pred_long = ts_long + 1.0 + pred_short = ts_short + 2.0 + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + dm.ae([ts_long, ts_short], [pred_long, pred_short]) + + history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") + by_step = {m.step: m.value for m in history} + assert len(by_step) == 50 + for step in range(10): + assert by_step[step] == pytest.approx(1.0, abs=1e-4), step + for step in range(10, 50): + assert by_step[step] == pytest.approx(1.5, abs=1e-4), step + + rows = self._read_per_series_table(run.info.run_id) + steps_by_series = {0: set(), 1: set()} + for r in rows: + steps_by_series[r["series_index"]].add(r["step"]) + assert steps_by_series[0] == set(range(50)) + assert steps_by_series[1] == set(range(10, 50)) + def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile with matching values.""" train = self.ts_univariate[:40] @@ -1407,6 +1439,66 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): assert not mlflow.get_run(run.info.run_id).data.metrics + def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): + """A shorter series' window axis aligns from the end, not the start, + so its windows overlap the tail of a longer series rather than the + head. Calls _log_backtest_metrics directly with a fabricated result + so the window counts per series are exact.""" + backtest_args = { + "metric": dm.mae, + "metric_kwargs": {}, + "series": [self.ts_univariate, self.ts_univariate], + "forecast_horizon": 1, + "reduction": None, + "last_points_only": False, + } + # series 0 has 5 windows; series 1 (shorter, later-starting) has 3 + result = [np.array([1.0, 2.0, 3.0, 4.0, 5.0]), np.array([10.0, 20.0, 30.0])] + + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + client.flush(synchronous=True) + + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") + logged = {m.step: m.value for m in history} + assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) + + rows = self._read_per_series_table(run.info.run_id) + by_step = {(r["series_index"], r["step"]): r["value"] for r in rows} + assert by_step[(0, 0)] == pytest.approx(1.0) + assert by_step[(0, 4)] == pytest.approx(5.0) + assert by_step[(1, 2)] == pytest.approx(10.0) + assert by_step[(1, 4)] == pytest.approx(30.0) + assert (1, 0) not in by_step + assert (1, 1) not in by_step + + def test_log_backtest_metrics_aligns_last_points_only_time_axis( + self, mlflow_tracking + ): + """last_points_only stitches windows into one series scored per real + timestep -- a separate code path from the window-axis case above that + needs the same end-date alignment.""" + backtest_args = { + "metric": dm.ae, + "metric_kwargs": {}, + "series": [self.ts_univariate, self.ts_univariate], + "forecast_horizon": 1, + "reduction": None, + "last_points_only": True, + } + # series 0 has 5 timesteps; series 1 (shorter, later-starting) has 3 + result = [np.array([1.0, 2.0, 3.0, 4.0, 5.0]), np.array([10.0, 20.0, 30.0])] + + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + client.flush(synchronous=True) + + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") + logged = {m.step: m.value for m in history} + assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) + @staticmethod def _read_per_series_table(run_id): """Load the run's consolidated per-series metric table into row dicts.""" From ce7e0a2a06cdc436b39d0f6b93301896f8d6ea72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 20:49:38 +0200 Subject: [PATCH 111/154] chore: change quantile formatting to :3f --- darts/utils/mlflow.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 5efcc08397..7a7e1347c0 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -356,7 +356,7 @@ def autolog( * ``metric_name`` – the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). * ``component`` – the component name when ``component_reduction=None``. - * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi0.100_0.900`` / ``_label1``. + * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. When ``series_reduction`` is set on a metric call, results are already aggregated across series inside the metric itself, so the mean-over-series @@ -1133,9 +1133,11 @@ def effective(param_name: str) -> Any: q_interval, q = metric_kwargs.get("q_interval"), metric_kwargs.get("q") if "q_interval" in params and q_interval is not None: intervals = np.atleast_2d(np.array(q_interval, dtype=float)) - quantiles_labels = [f"_qi{lo:g}_{hi:g}" for lo, hi in intervals] + quantiles_labels = [f"_qi_{100 * (hi - lo):.3f}" for lo, hi in intervals] elif "q" in params and q is not None: - quantiles_labels = [f"_q{v:g}" for v in np.atleast_1d(np.array(q, dtype=float))] + quantiles_labels = [ + f"_q{v:.3f}" for v in np.atleast_1d(np.array(q, dtype=float)) + ] elif "label_reduction" in params and getattr(metric, "__name__", ""): label_reduction = effective("label_reduction") if isinstance(label_reduction, _LabelReduction): @@ -1191,7 +1193,7 @@ def _log_metric_result( present: * ``component`` – ``_{component_name}`` when ``has_comp_axis``. - * ``quantile_or_label`` – e.g. ``_q0.5`` / ``_qi0.1_0.9`` / ``_label1``. + * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. When more than one series is scored, the logged value is the mean over series for each cell, and the granular per-series breakdown is appended to @@ -1356,8 +1358,8 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: * ``metric_name`` – the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). * ``component`` – ``_{component_name}`` when ``component_reduction=None``. - * ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.5``, - ``_qi0.1_0.9``, ``_label1``) when applicable. + * ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, + ``_qi_80.000``, ``_label1``) when applicable. When the input is a ``Sequence[TimeSeries]`` with more than one series, the logged value is the mean over series and the per-series breakdown is From 6f30c900b788a637c34361ee129fe606c3945fd2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 20:50:18 +0200 Subject: [PATCH 112/154] chore: align quantile label tests to :3f format --- darts/tests/optional_deps/test_mlflow.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index a866c1ee95..917e9c6b3b 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -928,7 +928,7 @@ def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): ref = np.asarray(ref, dtype=float) # shape (n_quantiles,) m = mlflow.get_run(run.info.run_id).data.metrics - for i, key in enumerate(("mql_q0_1", "mql_q0_5", "mql_q0_9")): + for i, key in enumerate(("mql_q0_100", "mql_q0_500", "mql_q0_900")): assert key in m, f"Expected quantile key {key}" assert m[key] == pytest.approx(ref[i], abs=1e-5) @@ -947,8 +947,8 @@ def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context ref = dm.miw(actual, pred, q_interval=(0.1, 0.9)) m = mlflow.get_run(run.info.run_id).data.metrics - assert "miw_qi0_1_0_9" in m - assert m["miw_qi0_1_0_9"] == pytest.approx(float(ref), abs=1e-5) + assert "miw_qi_80_000" in m + assert m["miw_qi_80_000"] == pytest.approx(float(ref), abs=1e-5) def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): """A list of series logs the mean over series; per-series values go to a table.""" @@ -1007,7 +1007,7 @@ def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): target = self.ts_univariate[40:] with autolog_context(log_metrics=True): - # direct call: name replaces the metric token; suffix (_q0_5) preserved + # direct call: name replaces the metric token; suffix (_q0_500) preserved with mlflow.start_run() as run_direct: dm.mae(actual, actual * 1.1, name="custom") dm.mql(target, pred, q=0.5, name="myq") @@ -1024,7 +1024,7 @@ def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): direct = mlflow.get_run(run_direct.info.run_id).data.metrics assert "custom" in direct assert "mae" not in direct, "default metric name should be replaced" - assert "myq_q0_5" in direct, "quantile suffix should be preserved" + assert "myq_q0_500" in direct, "quantile suffix should be preserved" bt = mlflow.get_run(run_bt.info.run_id).data.metrics assert "backtest_custom" in bt @@ -1319,7 +1319,11 @@ def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): ) m = mlflow.get_run(run.info.run_id).data.metrics - for key in ("backtest_mql_q0_1", "backtest_mql_q0_5", "backtest_mql_q0_9"): + for key in ( + "backtest_mql_q0_100", + "backtest_mql_q0_500", + "backtest_mql_q0_900", + ): assert key in m, f"Expected quantile key {key}" assert np.isfinite(m[key]) @@ -1545,14 +1549,14 @@ def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): def test_infer_metric_axes_quantiles(): _, _, quantiles_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) - assert quantiles_labels == ["_q0.1", "_q0.5", "_q0.9"] + assert quantiles_labels == ["_q0.100", "_q0.500", "_q0.900"] def test_infer_metric_axes_quantile_interval(): has_time, _, quantiles_labels = _infer_metric_axes( dm.iw, {"q_interval": (0.1, 0.9)} ) - assert quantiles_labels == ["_qi0.1_0.9"] + assert quantiles_labels == ["_qi_80.000"] assert has_time is True From fc6ce68c0627823b4dd63fa7565e428996d09bc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 20:58:37 +0200 Subject: [PATCH 113/154] chore: rename quantile/interval/labels labels to axis labels --- darts/utils/mlflow.py | 60 +++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 31 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 7a7e1347c0..50242c3e6f 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -929,13 +929,13 @@ def _log_backtest_metrics( # check the dim axes from the metric kwargs for each metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metric, metric_kwargs)] - has_time_axis, has_comp_axis, quantiles_labels_0 = metric_axes[0] - quantiles_num = len(quantiles_labels_0) + has_time_axis, has_comp_axis, axis_labels_0 = metric_axes[0] + axis_size = len(axis_labels_0) # Inconsistent axes across metrics (different has_time_axis, has_comp_axis, or - # quantiles_num) means the result can't be reshaped into a single canonical array. + # axis_size) means the result can't be reshaped into a single canonical array. # Fall back to flat integer-indexed keys for this case. - axes_key = (has_time_axis, has_comp_axis, quantiles_num) + axes_key = (has_time_axis, has_comp_axis, axis_size) axes_inconsistent = any( (ax[0], ax[1], len(ax[2])) != axes_key for ax in metric_axes[1:] ) @@ -982,7 +982,7 @@ def _log_backtest_metrics( for s, r in zip(series_seq, results): comps = s.components.tolist() # c_size = components × quantiles/intervals/labels per component - c_size = (s.n_components if has_comp_axis else 1) * quantiles_num + c_size = (s.n_components if has_comp_axis else 1) * axis_size arr = np.asarray(r, dtype=float) # after stripping C and M axes, rest = W*T (or W or T alone) rest, extra = divmod(arr.size, c_size * n_metrics) @@ -1045,19 +1045,21 @@ def _log_backtest_metrics( w_offset = max_w_size - w_size if has_windows else 0 t_offset = max_t_size - t_size if t_axis_is_calendar else 0 for m, metric_name in enumerate(metric_names): - quantiles_labels = metric_axes[m][2] + axis_labels = metric_axes[m][2] for w in range(w_size): aligned_w = w + w_offset for c in range(c_size): - # c is a flat index into the (n_components × quantiles_num) C axis: - # c = comp_i * quantiles_num + q_i - component_index, quantile_index = divmod(c, quantiles_num) + # c is a flat index into the (n_components × axis_size) C axis: + # c = comp_i * axis_size + axis_idx + component_index, axis_idx = divmod(c, axis_size) comp_part = ( "_" + _sanitize_mlflow_key(comps[component_index]) if has_comp_axis else "" ) - key = f"backtest_{metric_name}{comp_part}{quantiles_labels[quantile_index]}" + key = ( + f"backtest_{metric_name}{comp_part}{axis_labels[axis_idx]}" + ) if has_time_axis and has_windows: key += f"_w{aligned_w}" key = _sanitize_mlflow_key(key) @@ -1105,12 +1107,12 @@ def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: Returns ------- tuple - ``(has_time_axis, has_comp_axis, quantiles_labels)`` where + ``(has_time_axis, has_comp_axis, axis_labels)`` where - ``has_time_axis`` – ``True`` when ``time_reduction`` is ``None`` (i.e. a per-timestep axis is present in the output). - ``has_comp_axis`` – ``True`` when components are expanded (not collapsed to a scalar). - - ``quantiles_labels`` – one key suffix per quantile/interval/label entry. + - ``axis_labels`` – one key suffix per quantile/interval/label entry. Raises ------ @@ -1133,11 +1135,9 @@ def effective(param_name: str) -> Any: q_interval, q = metric_kwargs.get("q_interval"), metric_kwargs.get("q") if "q_interval" in params and q_interval is not None: intervals = np.atleast_2d(np.array(q_interval, dtype=float)) - quantiles_labels = [f"_qi_{100 * (hi - lo):.3f}" for lo, hi in intervals] + axis_labels = [f"_qi_{100 * (hi - lo):.3f}" for lo, hi in intervals] elif "q" in params and q is not None: - quantiles_labels = [ - f"_q{v:.3f}" for v in np.atleast_1d(np.array(q, dtype=float)) - ] + axis_labels = [f"_q{v:.3f}" for v in np.atleast_1d(np.array(q, dtype=float))] elif "label_reduction" in params and getattr(metric, "__name__", ""): label_reduction = effective("label_reduction") if isinstance(label_reduction, _LabelReduction): @@ -1153,15 +1153,15 @@ def effective(param_name: str) -> Any: "labels cannot be determined ahead of time otherwise)." ) ) - quantiles_labels = ( + axis_labels = ( [f"_label{x}" for x in np.atleast_1d(labels)] if label_reduction is None else [""] ) else: - quantiles_labels = [""] + axis_labels = [""] - return (has_time_axis, has_comp_axis, quantiles_labels) + return (has_time_axis, has_comp_axis, axis_labels) def _log_metric_result( @@ -1172,7 +1172,7 @@ def _log_metric_result( series, has_time_axis: bool, has_comp_axis: bool, - quantiles_labels: list[str], + axis_labels: list[str], series_reduced: bool = False, ) -> None: """Log a metric result to the active MLflow run. @@ -1225,13 +1225,13 @@ def _log_metric_result( ``True`` when the result carries a per-timestep axis (``time_reduction=None``). has_comp_axis ``True`` when components are expanded (``component_reduction=None``). - quantiles_labels + axis_labels One key suffix per quantile/interval/label entry. series_reduced ``True`` when ``series_reduction`` collapsed the series axis inside the metric, so the result has no leading series axis even for list input. """ - quantiles_num = len(quantiles_labels) + axis_size = len(axis_labels) if series_reduced: # series_reduction aggregated across series -> single result, no series axis @@ -1249,7 +1249,7 @@ def _log_metric_result( for s, r in zip(series_seq, results): comps = s.components.tolist() # c_size = components × quantiles/intervals/labels per component - c_size = (s.n_components if has_comp_axis else 1) * quantiles_num + c_size = (s.n_components if has_comp_axis else 1) * axis_size arr = np.asarray(r, dtype=float) # after stripping the C axis, the remainder is the time axis (or scalar) n_times, extra = divmod(arr.size, c_size) @@ -1289,17 +1289,15 @@ def _log_metric_result( for series_index, (comps, c_size, t_size, canonical) in enumerate(series_shapes): step_offset = max_t_size - t_size if has_time_axis else 0 for c in range(c_size): - # c is a flat index into the (n_components × quantiles_num) C axis: - # c = comp_i * quantiles_num + q_i - component_index, quantile_index = divmod(c, quantiles_num) + # c is a flat index into the (n_components × axis_size) C axis: + # c = comp_i * axis_size + axis_idx + component_index, axis_idx = divmod(c, axis_size) comp_part = ( "_" + _sanitize_mlflow_key(comps[component_index]) if has_comp_axis else "" ) - key = _sanitize_mlflow_key( - metric_name + comp_part + quantiles_labels[quantile_index] - ) + key = _sanitize_mlflow_key(metric_name + comp_part + axis_labels[axis_idx]) for t in range(t_size): # MLflow step maps to the time axis when present step = t + step_offset if has_time_axis else 0 @@ -1400,7 +1398,7 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: key_name = _sanitize_mlflow_key(kwargs.get("name") or func.__name__) # infer output axes from the metric signature + call kwargs - has_time_axis, has_comp_axis, quantiles_labels = _infer_metric_axes(func, kwargs) + has_time_axis, has_comp_axis, axis_labels = _infer_metric_axes(func, kwargs) # series_reduction collapses the series axis inside the metric, so the # result has no leading series axis even for list input. @@ -1420,6 +1418,6 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: series, has_time_axis, has_comp_axis, - quantiles_labels, + axis_labels, series_reduced=series_reduced, ) From 109adc755f8c43720e65199a61f5b5c9f16b93a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 20:58:54 +0200 Subject: [PATCH 114/154] chore: align test to new axis naming convention --- darts/tests/optional_deps/test_mlflow.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 917e9c6b3b..00777c74dc 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1422,7 +1422,7 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): # Simulate a backtest result with only 2 entries — as if the metric was # evaluated on windows that only contained 2 of the 3 explicit labels. - # quantiles_num is 3 (len(labels)) but result has 2 → mismatch. + # axis_size is 3 (len(labels)) but result has 2 → mismatch. fake_result = np.array([0.8, 0.6], dtype=float) backtest_args = { @@ -1529,34 +1529,32 @@ def _fit_qlr(self, series=None): @pytest.mark.parametrize( "metric_name, metric_kwargs, expected", [ - ("mae", {}, dict(has_time_axis=False, has_comp_axis=False, quantiles_num=1)), - ("ae", {}, dict(has_time_axis=True, has_comp_axis=False, quantiles_num=1)), + ("mae", {}, dict(has_time_axis=False, has_comp_axis=False, axis_size=1)), + ("ae", {}, dict(has_time_axis=True, has_comp_axis=False, axis_size=1)), ("mae", {"component_reduction": None}, dict(has_comp_axis=True)), ], ) def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): - has_time_axis, has_comp_axis, quantiles_labels = _infer_metric_axes( + has_time_axis, has_comp_axis, axis_labels = _infer_metric_axes( getattr(dm, metric_name), metric_kwargs ) actual = { "has_time_axis": has_time_axis, "has_comp_axis": has_comp_axis, - "quantiles_num": len(quantiles_labels), + "axis_size": len(axis_labels), } for attr, value in expected.items(): assert actual[attr] == value def test_infer_metric_axes_quantiles(): - _, _, quantiles_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) - assert quantiles_labels == ["_q0.100", "_q0.500", "_q0.900"] + _, _, axis_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) + assert axis_labels == ["_q0.100", "_q0.500", "_q0.900"] def test_infer_metric_axes_quantile_interval(): - has_time, _, quantiles_labels = _infer_metric_axes( - dm.iw, {"q_interval": (0.1, 0.9)} - ) - assert quantiles_labels == ["_qi_80.000"] + has_time, _, axis_labels = _infer_metric_axes(dm.iw, {"q_interval": (0.1, 0.9)}) + assert axis_labels == ["_qi_80.000"] assert has_time is True From 19b2a8bc7ff1a0d263c9b00ee7dde80f13b8a66d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 21:00:25 +0200 Subject: [PATCH 115/154] docs: clean up backtest docstrinjg --- darts/utils/mlflow.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 50242c3e6f..58eee65c9c 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -865,13 +865,11 @@ def _log_backtest_metrics( ``_log_metric_result``). For a single series the mean is just the value itself and no artifact is written. - Series of different lengths are assumed to share the same end date. Any - axis mapping to real dates -- the window axis (``has_windows``), or the - per-timestep axis when ``last_points_only`` stitches windows into one - series -- is aligned from the end rather than the start, so a shorter - series lines up on its last entry instead of its first. The - per-horizon-step axis is left as-is, since it means "steps ahead" rather - than a real date. + Series of different lengths are assumed to share the same end date, so any + axis mapping to real dates (the window axis, or the per-timestep axis + when ``last_points_only`` stitches windows into one series) is aligned + from the end rather than the start. The per-horizon-step axis is left + as-is, since it means "steps ahead" rather than a real date. Raises ------ From 603eb8e978cabd39a05d87a97ddede28d460c564 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 22 Jul 2026 21:19:04 +0200 Subject: [PATCH 116/154] feat: add agg_func option to autolog() and unit tests --- darts/tests/optional_deps/test_mlflow.py | 42 ++++++++++++ darts/utils/mlflow.py | 87 ++++++++++++++++-------- 2 files changed, 100 insertions(+), 29 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 00777c74dc..b27857abc6 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -969,6 +969,24 @@ def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): by_series = {int(row["series_index"]): float(row["value"]) for row in rows} assert by_series == pytest.approx({0: ref[0], 1: ref[1]}, abs=1e-5) + def test_autolog_metric_multi_series_custom_agg_func( + self, mlflow_tracking, autolog_context + ): + """autolog()'s agg_func controls how per-series values are aggregated + into the single logged metric (default np.mean).""" + # 3 series with distinct, asymmetric per-series errors so median != mean + series = [self.ts_univariate * f for f in (1.0, 1.2, 5.0)] + pred = [s * 1.1 for s in series] + + with autolog_context(log_metrics=True, agg_func=np.median): + with mlflow.start_run() as run: + ref = dm.mae(series, pred) + + ref = np.asarray(ref, dtype=float) + assert float(np.median(ref)) != pytest.approx(float(np.mean(ref)), abs=1e-3) + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["mae"] == pytest.approx(float(np.median(ref)), abs=1e-5) + def test_autolog_metric_multi_series_per_component( self, mlflow_tracking, autolog_context ): @@ -1237,6 +1255,30 @@ def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): {0: float(ref[0]), 1: float(ref[1])}, abs=1e-5 ) + def test_autolog_backtest_multi_series_custom_agg_func(self, mlflow_tracking): + """autolog()'s agg_func also controls the backtest() aggregation + (default np.mean). Calls _log_backtest_metrics directly with a + fabricated result so the per-series values are exact.""" + backtest_args = { + "metric": dm.mae, + "metric_kwargs": {}, + "series": [self.ts_univariate, self.ts_univariate, self.ts_univariate], + "forecast_horizon": 1, + "reduction": np.mean, + "last_points_only": True, + } + result = [1.0, 2.0, 100.0] # asymmetric -> median != mean + + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _log_backtest_metrics( + client, run.info.run_id, result, backtest_args, agg_func=np.median + ) + client.flush(synchronous=True) + + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["backtest_mae"] == pytest.approx(2.0) + def test_autolog_backtest_per_timestep_scalar( self, mlflow_tracking, autolog_context ): diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 58eee65c9c..30a809bb22 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -327,6 +327,7 @@ def autolog( log_params: bool = True, log_metrics: bool = True, log_torch_metrics: bool = True, + agg_func: Callable = np.mean, disable: bool = False, silent: bool = False, ) -> None: @@ -359,14 +360,14 @@ def autolog( * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. When ``series_reduction`` is set on a metric call, results are already - aggregated across series inside the metric itself, so the mean-over-series - logging described below does not apply. + aggregated across series inside the metric itself, so the + cross-series aggregation described below does not apply. Per-timestep results (``time_reduction=None``) are charted across the - MLflow ``step``. For a list of series the logged value is the mean over - series, and the full per-series breakdown for every metric/backtest - call in the run is appended to a single ``metrics_per_series.json`` - table artifact. + MLflow ``step``. For a list of series the logged value is + ``agg_func`` applied over series, and the full per-series breakdown + for every metric/backtest call in the run is appended to a single + ``metrics_per_series.json`` table artifact. Parameters ---------- @@ -381,6 +382,11 @@ def autolog( If ``True`` (default), enable ``mlflow.pytorch.autolog(log_models=False)`` around PyTorch-based model training to automatically log per-epoch training and validation metrics. Only effective for PyTorch-based models. + agg_func + Function used to aggregate a metric's per-series values into the + single value logged for a list of series (e.g. ``np.mean``, the + default, or ``np.median``). Called as ``agg_func(values)`` on a list + of floats. disable If ``True``, restore the original ``fit()`` methods and stop autologging. @@ -428,6 +434,7 @@ def autolog( log_models=log_models, log_params=log_params, log_metrics=log_metrics, + agg_func=agg_func, disable=disable, silent=silent, ) @@ -460,6 +467,7 @@ def _autolog( log_models: bool = True, log_params: bool = True, log_metrics: bool = True, + agg_func: Callable = np.mean, disable: bool = False, silent: bool = False, ) -> None: @@ -595,7 +603,11 @@ def _patched_backtest(original, self, *args, **kwargs): autologging_client = MlflowAutologgingQueueingClient() _log_backtest_metrics( - autologging_client, active_run.info.run_id, result, backtest_args + autologging_client, + active_run.info.run_id, + result, + backtest_args, + agg_func=agg_func, ) autologging_client.flush(synchronous=False).await_completion() return result @@ -809,7 +821,7 @@ def _log_per_series_table(rows: list[dict]) -> None: (the time or window index charted by MLflow), and ``value``. All calls within a run append to the same ``metrics_per_series.json`` artifact. Used when more than one series is scored, since the logged metric keys - only carry the mean over series. + only carry the aggregate over series. Parameters ---------- @@ -828,6 +840,7 @@ def _log_backtest_metrics( run_id: str, result, backtest_args: dict, + agg_func: Callable = np.mean, ) -> None: """Log backtest metric result(s) to MLflow. @@ -859,11 +872,11 @@ def _log_backtest_metrics( ``time_reduction`` / ``component_reduction`` / quantile count), each series result is flattened to integer-indexed keys instead. - When more than one series is scored, the logged value is the mean over - series for each cell, and the granular per-series breakdown is appended to - the run's ``metrics_per_series.json`` table artifact (shared with - ``_log_metric_result``). For a single series the mean is just the value - itself and no artifact is written. + When more than one series is scored, the logged value is ``agg_func`` + applied over series for each cell, and the granular per-series breakdown + is appended to the run's ``metrics_per_series.json`` table artifact + (shared with ``_log_metric_result``). For a single series the aggregate + is just the value itself and no artifact is written. Series of different lengths are assumed to share the same end date, so any axis mapping to real dates (the window axis, or the per-timestep axis @@ -889,6 +902,10 @@ def _log_backtest_metrics( backtest_args Bound arguments of the ``backtest()`` call (from ``inspect.BoundArguments.arguments`` after ``apply_defaults``). + agg_func + Function used to aggregate a metric's per-series values into the + single value logged for a list of series. Called as + ``agg_func(values)`` on a list of floats. """ metric = backtest_args.get("metric") metric = metric if isinstance(metric, list) else [metric] @@ -955,7 +972,7 @@ def _log_backtest_metrics( series_seq = series2seq(series) results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result - # agg maps (key, step) -> per-series values, averaged into the logged metric. + # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] @@ -1074,11 +1091,11 @@ def _log_backtest_metrics( "value": value, }) - # log the mean over series for each (key, step); for a single series this is - # just the value itself. + # aggregate across series for each (key, step); for a single series this + # is just the value itself. metrics_by_step: dict[int, dict[str, float]] = {} for (key, step), values in agg.items(): - metrics_by_step.setdefault(step, {})[key] = float(np.mean(values)) + metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) @@ -1172,6 +1189,7 @@ def _log_metric_result( has_comp_axis: bool, axis_labels: list[str], series_reduced: bool = False, + agg_func: Callable = np.mean, ) -> None: """Log a metric result to the active MLflow run. @@ -1193,11 +1211,11 @@ def _log_metric_result( * ``component`` – ``_{component_name}`` when ``has_comp_axis``. * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. - When more than one series is scored, the logged value is the mean over - series for each cell, and the granular per-series breakdown is appended to - the run's ``metrics_per_series.json`` table artifact (shared with - ``_log_backtest_metrics``). For a single series the mean is just the value - itself and no artifact is written. + When more than one series is scored, the logged value is ``agg_func`` + applied over series for each cell, and the granular per-series breakdown + is appended to the run's ``metrics_per_series.json`` table artifact + (shared with ``_log_backtest_metrics``). For a single series the + aggregate is just the value itself and no artifact is written. Series of different lengths are assumed to share the same end date, so the time axis is aligned from the end rather than the start: a shorter series @@ -1228,6 +1246,10 @@ def _log_metric_result( series_reduced ``True`` when ``series_reduction`` collapsed the series axis inside the metric, so the result has no leading series axis even for list input. + agg_func + Function used to aggregate a metric's per-series values into the + single value logged for a list of series. Called as + ``agg_func(values)`` on a list of floats. """ axis_size = len(axis_labels) @@ -1281,7 +1303,7 @@ def _log_metric_result( # align the time axis from the end (see docstring) max_t_size = max((t_size for _, _, t_size, _ in series_shapes), default=0) - # agg maps (key, step) -> per-series values, averaged into the logged metric. + # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] for series_index, (comps, c_size, t_size, canonical) in enumerate(series_shapes): @@ -1308,11 +1330,11 @@ def _log_metric_result( "value": value, }) - # log the mean over series for each (key, step); for a single series this is - # just the value itself. + # aggregate across series for each (key, step); for a single series this + # is just the value itself. metrics_by_step: dict[int, dict[str, float]] = {} for (key, step), values in agg.items(): - metrics_by_step.setdefault(step, {})[key] = float(np.mean(values)) + metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) autologging_client.flush(synchronous=False).await_completion() @@ -1358,9 +1380,9 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: ``_qi_80.000``, ``_label1``) when applicable. When the input is a ``Sequence[TimeSeries]`` with more than one series, the - logged value is the mean over series and the per-series breakdown is - appended to the run's ``metrics_per_series.json`` table artifact instead - of per-series keys. + logged value is ``autolog()``'s ``agg_func`` applied over series, and the + per-series breakdown is appended to the run's ``metrics_per_series.json`` + table artifact instead of per-series keys. The per-timestep axis (``time_reduction=None``) is mapped to the MLflow ``step``. @@ -1408,6 +1430,12 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: ) series_reduced = effective_sr is not None + # _mlflow_metric_callback is a bare registered callback, not a closure over + # autolog()'s call kwargs, so agg_func is read back from the autologging + # config store that autolog() populated. + agg_func = get_autologging_config( + flavor_name=FLAVOR_NAME, config_key="agg_func", default_value=np.mean + ) _log_metric_result( autologging_client, run_id, @@ -1418,4 +1446,5 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: has_comp_axis, axis_labels, series_reduced=series_reduced, + agg_func=agg_func, ) From 69b9ca5c06d05ec1888f3333969288a61b76de2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 14:48:49 +0200 Subject: [PATCH 117/154] feat: log model creation params as json + tests --- darts/tests/optional_deps/test_mlflow.py | 15 +++++++++++++++ darts/utils/mlflow.py | 4 +++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index b27857abc6..39bd7943b4 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -280,6 +280,21 @@ def test_autolog_parameters(self, mlflow_tracking, autolog_context): assert last_run["params.seasonal_periods"] == "12" assert last_run["tags.model_class"] == "ExponentialSmoothing" + def test_autolog_model_params_json_artifact(self, mlflow_tracking, autolog_context): + """The model_params.json artifact mirrors model.model_params, preserving + JSON-native types and falling back to str() for non-serializable values + (e.g. enums) instead of the flat params store's blanket stringification.""" + with autolog_context(): + with mlflow.start_run() as run: + model = ExponentialSmoothing(seasonal_periods=12) + model.fit(self.ts_univariate) + + params = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/model_params.json" + ) + assert params["seasonal_periods"] == 12 + assert params["trend"] == str(model.model_params["trend"]) + @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): """Test that autolog logs training metrics for torch models""" diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 30a809bb22..6eb0b5f096 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -337,7 +337,8 @@ def autolog( will automatically: 1. Start an MLflow run (or reuse the currently active one). - 2. Log model creation parameters (``model.model_params``). + 2. Log model creation parameters (``model.model_params``), both as MLflow + params and as a ``model_params.json`` artifact. 3. Log covariate usage information (past, future, and static covariates). 4. Log the result of any darts metric call made inside an active MLflow run. Repeated calls overwrite the previous value. @@ -530,6 +531,7 @@ def _patched_fit(original, self, *args, **kwargs): if log_params: # Log the parameters for model creation autologging_client.log_params(run_id=run_id, params=self.model_params) + mlflow.log_dict(self.model_params, "model_params.json") fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments _log_covariate_info( self, From 4c3d014b5f09645e92e741ffb674b0451a0ca250 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 15:44:50 +0200 Subject: [PATCH 118/154] docs: cleanup --- CHANGELOG.md | 4 ++-- darts/utils/mlflow.py | 12 ++++++++---- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 979163fe40..68a40920cc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,7 +13,7 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - 🚀🚀 Added a custom MLflow model flavor for Darts, available under `darts.utils.mlflow`. It provides an MLflow integration for any Darts `ForecastingModel` (statistical, scikit-learn-like, and PyTorch-based). [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). - Added `save_model()`, `load_model()`, and `log_model()` to persist and reload Darts models as MLflow models, including model and covariate metadata. - - Added `autolog()` to automatically log model creation parameters, covariate usage, metrics, and the trained model artifact on every `fit()`, `backtest()` and `historical_forecasts()` call within an active MLflow run. + - Added `autolog()` to automatically log model creation parameters, covariate usage, metrics, and the trained model artifact when `log_models=True` (default `False`) on every `fit()`, `backtest()` and `historical_forecasts()` call within an active MLflow run. - Metric functions from `darts.metrics` are automatically logged when called inside an active run, with keys reflecting the metric output shape (per-component, per-quantile/interval, per-label, and per-timestep results charted across MLflow steps). Multi-series results log the mean over series and write the full per-series breakdown to a CSV artifact. - Added a new notebook for [MLflow quickstart](https://unit8co.github.io/darts/examples/29-MLflow-quickstart.html) with detailed usage examples. - Note: model serving and deployment (MLflow's `pyfunc` flavor, model signatures, and input examples) are not yet supported. @@ -26,7 +26,7 @@ but cannot always guarantee backwards compatibility. Changes that may **break co **Dependencies** -- Added an optional `mlflow` extra (`mlflow>=3.0`) enabling the MLflow integration. [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). +- Added `mlflow>=3.0` to the optional dependency group, enabling the MLflow integration. [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). ### For developers of the library: diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 6eb0b5f096..1e6b2eb39c 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -7,7 +7,8 @@ to MLflow, as well as automatic logging (``autolog()``) of: * Model creation parameters and covariate usage information. -* The trained model artifact, after each ``fit()`` call. +* The trained model artifact after each ``fit()`` call when ``log_models=True`` + (default ``False``). * Darts metric function calls made inside an active MLflow run. * ``backtest()`` evaluation metrics. * Per-epoch training/validation metrics for PyTorch-based models. @@ -344,7 +345,8 @@ def autolog( run. Repeated calls overwrite the previous value. 5. For PyTorch-based models: leverage ``mlflow.pytorch.autolog()`` to automatically log per-epoch training and validation metrics. - 6. Log the trained model artifact at the end of training. + 6. When ``log_models=True``: log the trained model artifact at the end of + training (default ``False``). 7. Patch ``backtest()`` to log evaluation metrics under ``backtest_*`` keys. 8. Patch ``historical_forecasts()`` so that its internal per-window ``fit()`` calls don't each spawn their own logging. @@ -373,7 +375,8 @@ def autolog( Parameters ---------- log_models - If ``True`` (default), log the trained model artifact after ``fit()``. + If ``True``, log the trained model artifact after ``fit()``. Defaults to + ``False``. log_params If ``True`` (default), log model creation parameters. log_metrics @@ -483,7 +486,8 @@ def _autolog( def _patched_fit(original, self, *args, **kwargs): """Patch function for ForecastingModel.fit() autologging. - Logs model parameters, class, covariates and the model itself. + Logs model parameters, class, and covariates; optionally logs the + model artifact when ``log_models=True``. Parameters ---------- From c9e56e1cc347eb6a847b7f9ba0c030e97dd1785e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 16:43:14 +0200 Subject: [PATCH 119/154] feat: ensure same amount of components for logging --- darts/tests/optional_deps/test_mlflow.py | 42 +++++++ darts/utils/mlflow.py | 137 +++++++++++++++-------- 2 files changed, 130 insertions(+), 49 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 39bd7943b4..fc7ffe4ca0 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1104,6 +1104,22 @@ def test_autolog_metric_multi_series_classification_labels_explicit( assert got[("f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) assert got[("f1_label1", i)] == pytest.approx(ref[i][1], abs=1e-5) + def test_autolog_metric_component_count_mismatch_raises( + self, mlflow_tracking, autolog_context + ): + """A list of series with different numbers of components raises rather + than taking component names from the first series only and silently + mislabeling the rest.""" + series = [self.ts_univariate, self.ts_multivariate] + pred = [s * 1.1 for s in series] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + with pytest.raises(ValueError, match="same number of components"): + dm.mae(series, pred) + + assert not mlflow.get_run(run.info.run_id).data.metrics + def test_autolog_metric_size_mismatch_raises( self, mlflow_tracking, autolog_context, caplog ): @@ -1444,6 +1460,32 @@ def test_autolog_backtest_classification_labels_not_in_data( assert np.isnan(m["backtest_f1_label5"]) assert np.isnan(m["backtest_f1_label10"]) + def test_log_backtest_metrics_component_count_mismatch_raises( + self, mlflow_tracking + ): + """A list of series with different numbers of components raises rather + than taking component names from the first series only. + + Calls _log_backtest_metrics directly so the raise is not swallowed by + MLflow's safe_patch wrapper. + """ + backtest_args = { + "metric": dm.mae, + "metric_kwargs": {}, + "series": [self.ts_univariate, self.ts_multivariate], + "forecast_horizon": 1, + "reduction": np.mean, + "last_points_only": True, + } + result = [1.0, np.array([1.0, 2.0])] + + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + with pytest.raises(ValueError, match="same number of components"): + _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + + assert not mlflow.get_run(run.info.run_id).data.metrics + def test_log_backtest_metrics_unknown_labels_raises(self, mlflow_tracking): """label_reduction=None without explicit labels raises rather than inferring class names from the series at runtime. diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 1e6b2eb39c..1b0956871d 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -370,7 +370,9 @@ def autolog( MLflow ``step``. For a list of series the logged value is ``agg_func`` applied over series, and the full per-series breakdown for every metric/backtest call in the run is appended to a single - ``metrics_per_series.json`` table artifact. + ``metrics_per_series.json`` table artifact. All series scored + together in one call must have the same number of components; + component names are taken from the first series. Parameters ---------- @@ -882,7 +884,9 @@ def _log_backtest_metrics( applied over series for each cell, and the granular per-series breakdown is appended to the run's ``metrics_per_series.json`` table artifact (shared with ``_log_metric_result``). For a single series the aggregate - is just the value itself and no artifact is written. + is just the value itself and no artifact is written. All series scored + together must have the same number of components; names are taken from + the first series. Series of different lengths are assumed to share the same end date, so any axis mapping to real dates (the window axis, or the per-timestep axis @@ -894,7 +898,8 @@ def _log_backtest_metrics( ------ ValueError On a shape/size mismatch between the metric result and the inferred - axes, or when ``label_reduction=None`` is requested without explicit + axes, when series in a sequence have different numbers of components, + or when ``label_reduction=None`` is requested without explicit ``labels``. Parameters @@ -977,13 +982,21 @@ def _log_backtest_metrics( series_seq = series2seq(series) results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result + n_components = {s.n_components for s in series_seq} + if len(n_components) > 1: + raise_log( + ValueError( + "Backtest metric logging failed: all series must have the same " + f"number of components, got {sorted(n_components)}." + ) + ) # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] if axes_inconsistent: - for series_index, (s, r) in enumerate(zip(series_seq, results)): + for series_index, r in enumerate(results): name_prefix = metric_names[0] if len(metric_names) == 1 else "metrics" flat = np.asarray(r, dtype=float).flatten() for i, val in enumerate(flat): @@ -997,13 +1010,35 @@ def _log_backtest_metrics( "value": value, }) else: + # component names/count from the first series (all series share n_components) + comps = series_seq[0].components.tolist() + # c_size = components × quantiles/intervals/labels per component + c_size = (series_seq[0].n_components if has_comp_axis else 1) * axis_size + # base_keys[m][c]: sanitized key without the optional window suffix + base_keys = [] + for m, metric_name in enumerate(metric_names): + axis_labels = metric_axes[m][2] + keys_m = [] + for c in range(c_size): + # c is a flat index into the (n_components × axis_size) C axis: + # c = comp_i * axis_size + axis_idx + component_index, axis_idx = divmod(c, axis_size) + comp_part = ( + "_" + _sanitize_mlflow_key(comps[component_index]) + if has_comp_axis + else "" + ) + keys_m.append( + _sanitize_mlflow_key( + f"backtest_{metric_name}{comp_part}{axis_labels[axis_idx]}" + ) + ) + base_keys.append(keys_m) + # first pass: reshape each series' result into a canonical (W, T, C, M) # array, recording its window-axis length for the alignment pass below. series_shapes = [] - for s, r in zip(series_seq, results): - comps = s.components.tolist() - # c_size = components × quantiles/intervals/labels per component - c_size = (s.n_components if has_comp_axis else 1) * axis_size + for r in results: arr = np.asarray(r, dtype=float) # after stripping C and M axes, rest = W*T (or W or T alone) rest, extra = divmod(arr.size, c_size * n_metrics) @@ -1048,42 +1083,31 @@ def _log_backtest_metrics( ) t_size, w_size = 1, 1 - canonical = arr.reshape(w_size, t_size, c_size, n_metrics) - series_shapes.append((comps, c_size, t_size, w_size, canonical)) + series_shapes.append(( + t_size, + w_size, + arr.reshape(w_size, t_size, c_size, n_metrics), + )) # align the calendar-relative axes from the end - max_w_size = max((w_size for _, _, _, w_size, _ in series_shapes), default=0) + max_w_size = max((w_size for _, w_size, _ in series_shapes), default=0) t_axis_is_calendar = has_time_axis and not has_windows and last_points_only max_t_size = ( - max((t_size for _, _, t_size, _, _ in series_shapes), default=0) + max((t_size for t_size, _, _ in series_shapes), default=0) if t_axis_is_calendar else 0 ) - for series_index, (comps, c_size, t_size, w_size, canonical) in enumerate( - series_shapes - ): + for series_index, (t_size, w_size, canonical) in enumerate(series_shapes): w_offset = max_w_size - w_size if has_windows else 0 t_offset = max_t_size - t_size if t_axis_is_calendar else 0 - for m, metric_name in enumerate(metric_names): - axis_labels = metric_axes[m][2] + for m in range(n_metrics): for w in range(w_size): aligned_w = w + w_offset for c in range(c_size): - # c is a flat index into the (n_components × axis_size) C axis: - # c = comp_i * axis_size + axis_idx - component_index, axis_idx = divmod(c, axis_size) - comp_part = ( - "_" + _sanitize_mlflow_key(comps[component_index]) - if has_comp_axis - else "" - ) - key = ( - f"backtest_{metric_name}{comp_part}{axis_labels[axis_idx]}" - ) + key = base_keys[m][c] if has_time_axis and has_windows: - key += f"_w{aligned_w}" - key = _sanitize_mlflow_key(key) + key = f"{key}_w{aligned_w}" for t in range(t_size): # MLflow step maps to the axis the UI should chart: # time when present, otherwise window index @@ -1231,7 +1255,8 @@ def _log_metric_result( ------ ValueError On a shape/size mismatch between the metric result and the inferred - axes. + axes, or when series in a sequence have different numbers of + components. Parameters ---------- @@ -1243,6 +1268,8 @@ def _log_metric_result( series The ``actual_series`` argument passed to the metric (single series or ``Sequence[TimeSeries]``); used for component names and series count. + All series in a sequence must have the same number of components; + names are taken from the first series. has_time_axis ``True`` when the result carries a per-timestep axis (``time_reduction=None``). has_comp_axis @@ -1268,14 +1295,36 @@ def _log_metric_result( results = ( [result] if get_series_seq_type(series) == SeriesType.SINGLE else result ) + n_components = {s.n_components for s in series_seq} + if len(n_components) > 1: + raise_log( + ValueError( + f"Metric logging failed for `{metric_name}`: all series must " + f"have the same number of components, got " + f"{sorted(n_components)}." + ) + ) + + # component names/count from the first series (all series share n_components) + comps = series_seq[0].components.tolist() + # c_size = components × quantiles/intervals/labels per component + c_size = (series_seq[0].n_components if has_comp_axis else 1) * axis_size + keys = [] + for c in range(c_size): + # c is a flat index into the (n_components × axis_size) C axis: + # c = comp_i * axis_size + axis_idx + component_index, axis_idx = divmod(c, axis_size) + comp_part = ( + "_" + _sanitize_mlflow_key(comps[component_index]) if has_comp_axis else "" + ) + keys.append( + _sanitize_mlflow_key(metric_name + comp_part + axis_labels[axis_idx]) + ) # first pass: reshape each series' result into a canonical (T, C) array, # recording its time-axis length for the alignment pass below. series_shapes = [] - for s, r in zip(series_seq, results): - comps = s.components.tolist() - # c_size = components × quantiles/intervals/labels per component - c_size = (s.n_components if has_comp_axis else 1) * axis_size + for r in results: arr = np.asarray(r, dtype=float) # after stripping the C axis, the remainder is the time axis (or scalar) n_times, extra = divmod(arr.size, c_size) @@ -1303,27 +1352,17 @@ def _log_metric_result( else: t_size = 1 - canonical = arr.reshape(t_size, c_size) - series_shapes.append((comps, c_size, t_size, canonical)) + series_shapes.append((t_size, arr.reshape(t_size, c_size))) # align the time axis from the end (see docstring) - max_t_size = max((t_size for _, _, t_size, _ in series_shapes), default=0) + max_t_size = max((t_size for t_size, _ in series_shapes), default=0) # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] - for series_index, (comps, c_size, t_size, canonical) in enumerate(series_shapes): + for series_index, (t_size, canonical) in enumerate(series_shapes): step_offset = max_t_size - t_size if has_time_axis else 0 - for c in range(c_size): - # c is a flat index into the (n_components × axis_size) C axis: - # c = comp_i * axis_size + axis_idx - component_index, axis_idx = divmod(c, axis_size) - comp_part = ( - "_" + _sanitize_mlflow_key(comps[component_index]) - if has_comp_axis - else "" - ) - key = _sanitize_mlflow_key(metric_name + comp_part + axis_labels[axis_idx]) + for c, key in enumerate(keys): for t in range(t_size): # MLflow step maps to the time axis when present step = t + step_offset if has_time_axis else 0 From 644374c02fa744d67dec0e09d380ae0626f81ac3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 16:47:30 +0200 Subject: [PATCH 120/154] docs: align changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 68a40920cc..d2181cf832 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,7 +14,7 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - 🚀🚀 Added a custom MLflow model flavor for Darts, available under `darts.utils.mlflow`. It provides an MLflow integration for any Darts `ForecastingModel` (statistical, scikit-learn-like, and PyTorch-based). [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). - Added `save_model()`, `load_model()`, and `log_model()` to persist and reload Darts models as MLflow models, including model and covariate metadata. - Added `autolog()` to automatically log model creation parameters, covariate usage, metrics, and the trained model artifact when `log_models=True` (default `False`) on every `fit()`, `backtest()` and `historical_forecasts()` call within an active MLflow run. - - Metric functions from `darts.metrics` are automatically logged when called inside an active run, with keys reflecting the metric output shape (per-component, per-quantile/interval, per-label, and per-timestep results charted across MLflow steps). Multi-series results log the mean over series and write the full per-series breakdown to a CSV artifact. + - Metric functions from `darts.metrics` are automatically logged when called inside an active run, with keys reflecting the metric output shape (per-component, per-quantile/interval, per-label, and per-timestep results charted across MLflow steps). Multi-series results log the aggregate over series and write the full per-series breakdown to a JSON artifact. - Added a new notebook for [MLflow quickstart](https://unit8co.github.io/darts/examples/29-MLflow-quickstart.html) with detailed usage examples. - Note: model serving and deployment (MLflow's `pyfunc` flavor, model signatures, and input examples) are not yet supported. - 🔴 Improved `TransformerModel` with proper encoder-decoder transformer architecture using teacher forcing during training and autoregressive inference, aligning the implementation with [Vaswani et al., 2017](https://arxiv.org/abs/1706.03762). Previously trained checkpoints are incompatible and must be retrained. [#1915](https://github.com/unit8co/darts/pull/1915) by [Jan Fidor](https://github.com/JanFidor) and [Dennis Bader](https://github.com/dennisbader). From a3dde9c1f9939df5de20693a5833d6f7f1e815cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 18:53:54 +0200 Subject: [PATCH 121/154] feat: align notebook to code review changes --- examples/29-MLflow-quickstart.ipynb | 12004 +++++++++++++------------- 1 file changed, 6038 insertions(+), 5966 deletions(-) diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index 989ee5a94f..54f8d90a83 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -1,6067 +1,6139 @@ { - "cells": [ + "cells": [ + { + "cell_type": "markdown", + "id": "aeddb542", + "metadata": {}, + "source": [ + "# MLflow for Darts\n", + "\n", + "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", + "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", + "\n", + "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", + "\n", + "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." + ] + }, + { + "cell_type": "markdown", + "id": "f72894af", + "metadata": {}, + "source": [ + "## Installing MLflow\n", + "\n", + "MLflow is available as an optional dependency for Darts. Install it with:\n", + "\n", + "```bash\n", + "pip install mlflow\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "42e3dcea", + "metadata": {}, + "source": [ + "## Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b346ce8f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.049165Z", + "iopub.status.busy": "2026-06-24T15:18:43.049088Z", + "iopub.status.idle": "2026-06-24T15:18:43.053693Z", + "shell.execute_reply": "2026-06-24T15:18:43.053435Z" + } + }, + "outputs": [], + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "13b13fe4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.054776Z", + "iopub.status.busy": "2026-06-24T15:18:43.054722Z", + "iopub.status.idle": "2026-06-24T15:18:46.599643Z", + "shell.execute_reply": "2026-06-24T15:18:46.599208Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import mlflow\n", + "import numpy as np\n", + "\n", + "import darts.metrics as metrics\n", + "from darts.datasets import AirPassengersDataset\n", + "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", + "from darts.utils.mlflow import autolog, load_model, log_model, save_model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4d424e08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.600906Z", + "iopub.status.busy": "2026-06-24T15:18:46.600748Z", + "iopub.status.idle": "2026-06-24T15:18:46.634540Z", + "shell.execute_reply": "2026-06-24T15:18:46.634100Z" + } + }, + "outputs": [], + "source": [ + "# use darts plotting style\n", + "from darts import set_option\n", + "\n", + "set_option(\"plotting.use_darts_style\", True)" + ] + }, + { + "cell_type": "markdown", + "id": "2f9c40d6", + "metadata": {}, + "source": [ + "## MLflow Setup\n", + "\n", + "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "88320df5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.636640Z", + "iopub.status.busy": "2026-06-24T15:18:46.636565Z", + "iopub.status.idle": "2026-06-24T15:18:47.268439Z", + "shell.execute_reply": "2026-06-24T15:18:47.268081Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "aeddb542", - "metadata": {}, - "source": [ - "# MLflow for Darts\n", - "\n", - "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", - "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", - "\n", - "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", - "\n", - "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", + "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Updating database tables\n", + "2026/07/23 18:50:08 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" + ] }, { - "cell_type": "markdown", - "id": "f72894af", - "metadata": {}, - "source": [ - "## Installing MLflow\n", - "\n", - "MLflow is available as an optional dependency for Darts. Install it with:\n", - "\n", - "```bash\n", - "pip install mlflow\n", - "```" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", + "Experiment: darts-quickstart\n" + ] + } + ], + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ] + }, + { + "cell_type": "markdown", + "id": "03d5209e", + "metadata": {}, + "source": [ + "## Load Sample Data\n", + "\n", + "We'll use the classic AirPassengers dataset for this example." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1596e07e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.269628Z", + "iopub.status.busy": "2026-06-24T15:18:47.269548Z", + "iopub.status.idle": "2026-06-24T15:18:47.356588Z", + "shell.execute_reply": "2026-06-24T15:18:47.356201Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "42e3dcea", - "metadata": {}, - "source": [ - "## Setup and Imports" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Training series: 107 points\n", + "Validation series: 37 points\n" + ] }, { - "cell_type": "code", - "execution_count": 2, - "id": "b346ce8f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.049165Z", - "iopub.status.busy": "2026-06-24T15:18:43.049088Z", - "iopub.status.idle": "2026-06-24T15:18:43.053693Z", - "shell.execute_reply": "2026-06-24T15:18:43.053435Z" - } - }, - "outputs": [], - "source": [ - "# fix python path if working locally\n", - "from utils import fix_pythonpath_if_working_locally\n", - "\n", - "fix_pythonpath_if_working_locally()\n", - "\n", - "import warnings\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning)" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "34858645", + "metadata": {}, + "source": [ + "## Basic Model Logging\n", + "\n", + "Let's train a simple model and log it to MLflow manually." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bc8f520d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.357581Z", + "iopub.status.busy": "2026-06-24T15:18:47.357516Z", + "iopub.status.idle": "2026-06-24T15:18:47.450374Z", + "shell.execute_reply": "2026-06-24T15:18:47.449925Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 3, - "id": "13b13fe4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.054776Z", - "iopub.status.busy": "2026-06-24T15:18:43.054722Z", - "iopub.status.idle": "2026-06-24T15:18:46.599643Z", - "shell.execute_reply": "2026-06-24T15:18:46.599208Z" - } - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import os\n", - "import tempfile\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import mlflow\n", - "import numpy as np\n", - "\n", - "import darts.metrics\n", - "from darts.datasets import AirPassengersDataset\n", - "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", - "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] }, { - "cell_type": "code", - "execution_count": 4, - "id": "4d424e08", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.600906Z", - "iopub.status.busy": "2026-06-24T15:18:46.600748Z", - "iopub.status.idle": "2026-06-24T15:18:46.634540Z", - "shell.execute_reply": "2026-06-24T15:18:46.634100Z" - } - }, - "outputs": [], - "source": [ - "# use darts plotting style\n", - "from darts import set_option\n", - "\n", - "set_option(\"plotting.use_darts_style\", True)" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = ExponentialSmoothing()\n", + "model.fit(train)\n", + "\n", + "predictions = model.predict(n=len(val))\n", + "\n", + "# calculate metrics you want to log to MLflow\n", + "mape_score = metrics.mape(val, predictions)\n", + "rmse_score = metrics.rmse(val, predictions)\n", + "\n", + "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", + "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", + "\n", + "train[-50:].plot(label=\"Training\")\n", + "val.plot(label=\"Actual\")\n", + "predictions.plot(label=\"Forecast\")\n", + "plt.legend()\n", + "plt.title(\"Exponential Smoothing Forecast\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "35dc864c", + "metadata": {}, + "source": [ + "Now let's log this model to MLflow.\n", + "\n", + "Tags can live in two places in MLflow 3:\n", + "\n", + "- **Run tags** (`mlflow.set_tags(...)`) – shown on the run page in the UI. This is also where `autolog()` writes its tags (`model_class`, …).\n", + "- **LoggedModel tags** (`log_model(..., tags=...)`) – attached to the logged model entity itself (open the model from the run's **Outputs** / Models view)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "61406cd9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.451366Z", + "iopub.status.busy": "2026-06-24T15:18:47.451297Z", + "iopub.status.idle": "2026-06-24T15:18:47.906785Z", + "shell.execute_reply": "2026-06-24T15:18:47.906380Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "2f9c40d6", - "metadata": {}, - "source": [ - "## MLflow Setup\n", - "\n", - "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] }, { - "cell_type": "code", - "execution_count": 5, - "id": "88320df5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.636640Z", - "iopub.status.busy": "2026-06-24T15:18:46.636565Z", - "iopub.status.idle": "2026-06-24T15:18:47.268439Z", - "shell.execute_reply": "2026-06-24T15:18:47.268081Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026/06/25 13:57:21 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", - "2026/06/25 13:57:21 INFO mlflow.store.db.utils: Updating database tables\n", - "2026/06/25 13:57:22 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpvwnlx3yj/mlflow.db\n", - "Experiment: darts-quickstart\n" - ] - } - ], - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", + "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" + ] + } + ], + "source": [ + "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", + " model_info = log_model(\n", + " model=model,\n", + " name=\"exponential-smoothing-model\",\n", + " # alternatively, use mlflow.set_tag(key, value) in the run\n", + " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", + " )\n", + "\n", + " # log calculated metrics you want\n", + " mlflow.log_metric(\"mape\", mape_score)\n", + " mlflow.log_metric(\"rmse\", rmse_score)\n", + "\n", + " print(f\"Run ID: {run.info.run_id}\")\n", + " print(f\"Model URI: {model_info.model_uri}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0728690e", + "metadata": {}, + "source": [ + "### Load the Model Back\n", + "\n", + "We can load the model from MLflow using its URI:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cae35ffa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.907880Z", + "iopub.status.busy": "2026-06-24T15:18:47.907802Z", + "iopub.status.idle": "2026-06-24T15:18:47.914695Z", + "shell.execute_reply": "2026-06-24T15:18:47.914326Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "03d5209e", - "metadata": {}, - "source": [ - "## Load Sample Data\n", - "\n", - "We'll use the classic AirPassengers dataset for this example." - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model predictions match: True\n" + ] + } + ], + "source": [ + "loaded_model = load_model(model_info.model_uri)\n", + "\n", + "loaded_predictions = loaded_model.predict(n=len(val))\n", + "\n", + "# verify predictions match\n", + "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", + "print(f\"Loaded model predictions match: {predictions_match}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6bd4597c", + "metadata": {}, + "source": [ + "## Automatic Logging with `autolog()`\n", + "\n", + "`autolog()` patches darts models and metrics so that the following are logged automatically, with no extra code needed:\n", + "\n", + "- **`fit()`** – model creation parameters and covariate metadata (and the trained model artifact when ``log_models=True``; default ``False``).\n", + "- **Darts metric functions** – any call made inside an active MLflow run.\n", + "- **`backtest()`** – evaluation metrics under `backtest_*` keys.\n", + "- **`historical_forecasts()`** – patched so its internal per-window `fit()` calls don't each spawn their own logging.\n", + "- **PyTorch-based models** – per-epoch `train_loss` / `val_loss` via MLflow's PyTorch autologging (see the section below for details)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5ef7f73a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.915629Z", + "iopub.status.busy": "2026-06-24T15:18:47.915566Z", + "iopub.status.idle": "2026-06-24T15:18:50.020337Z", + "shell.execute_reply": "2026-06-24T15:18:50.019951Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 6, - "id": "1596e07e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.269628Z", - "iopub.status.busy": "2026-06-24T15:18:47.269548Z", - "iopub.status.idle": "2026-06-24T15:18:47.356588Z", - "shell.execute_reply": "2026-06-24T15:18:47.356201Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "findfont: Failed to find font weight 600, now using 700.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training series: 107 points\n", - "Validation series: 37 points\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" + ] }, { - "cell_type": "markdown", - "id": "34858645", - "metadata": {}, - "source": [ - "## Basic Model Logging\n", - "\n", - "Let's train a simple model and log it to MLflow manually." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "autolog()\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", + " auto_model = LinearRegressionModel(lags=12)\n", + " auto_model.fit(train) # autolog logs params and covariate metadata\n", + "\n", + " auto_predictions = auto_model.predict(n=len(val))\n", + " # these metric calls happen inside the run, so they are logged automatically\n", + " auto_mape = metrics.mape(val, auto_predictions)\n", + " auto_rmse = metrics.rmse(val, auto_predictions)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show logged metrics\n", + "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", + "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", + "\n", + "# plot\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "train[-36:].plot(label=\"Train\", ax=ax)\n", + "val.plot(label=\"Actual\", ax=ax)\n", + "auto_predictions.plot(\n", + " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", + ")\n", + "ax.set_title(\"Linear Regression — autolog run\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f484330f", + "metadata": {}, + "source": [ + "## Open the MLflow UI\n", + "\n", + "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", + "\n", + "The UI lets you:\n", + "- **Compare runs** side-by-side in the Experiments table\n", + "- **Inspect** individual run parameters, metrics, and logged artifacts\n", + "- **Visualize** metrics across runs with built-in charts\n", + "- **Register** models to the Model Registry for versioning" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1a01cd2f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:50.021527Z", + "iopub.status.busy": "2026-06-24T15:18:50.021439Z", + "iopub.status.idle": "2026-06-24T15:18:50.023116Z", + "shell.execute_reply": "2026-06-24T15:18:50.022824Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 7, - "id": "bc8f520d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.357581Z", - "iopub.status.busy": "2026-06-24T15:18:47.357516Z", - "iopub.status.idle": "2026-06-24T15:18:47.450374Z", - "shell.execute_reply": "2026-06-24T15:18:47.449925Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = ExponentialSmoothing()\n", - "model.fit(train)\n", - "\n", - "predictions = model.predict(n=len(val))\n", - "\n", - "# calculate metrics you want to log to MLflow\n", - "mape_score = darts.metrics.mape(val, predictions)\n", - "rmse_score = darts.metrics.rmse(val, predictions)\n", - "\n", - "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", - "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", - "\n", - "train[-50:].plot(label=\"Training\")\n", - "val.plot(label=\"Actual\")\n", - "predictions.plot(label=\"Forecast\")\n", - "plt.legend()\n", - "plt.title(\"Exponential Smoothing Forecast\")\n", - "plt.show()" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Launch the MLflow UI with this command in your terminal:\n", + "\n", + " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", + "\n", + "Then open: http://localhost:5000\n" + ] + } + ], + "source": [ + "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", + "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", + "print(\"Then open: http://localhost:5000\")" + ] + }, + { + "cell_type": "markdown", + "id": "88b0d285", + "metadata": {}, + "source": [ + "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", + ">\n", + "![Mlflow Overview](./static/images/mlflow_overview.png)" + ] + }, + { + "cell_type": "markdown", + "id": "e2b133bc", + "metadata": {}, + "source": [ + "## Per-epoch Metrics with Torch Models\n", + "\n", + "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", + "\n", + "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "d01783d1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:50.024161Z", + "iopub.status.busy": "2026-06-24T15:18:50.024087Z", + "iopub.status.idle": "2026-06-24T15:18:53.370946Z", + "shell.execute_reply": "2026-06-24T15:18:53.370531Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "35dc864c", - "metadata": {}, - "source": [ - "Now let's log this model to MLflow:" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: GPU available: True (mps), used: False\n", + "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", + "INFO: TPU available: False, using: 0 TPU cores\n", + "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", + "INFO: HPU available: False, using: 0 HPUs\n", + "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", + "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/trainer/setup.py:177: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", + "\n", + " | Name | Type | Params | Mode \n", + "-------------------------------------------------------------\n", + "0 | criterion | MSELoss | 0 | train\n", + "1 | train_criterion | MSELoss | 0 | train\n", + "2 | val_criterion | MSELoss | 0 | train\n", + "3 | train_metrics | MetricCollection | 0 | train\n", + "4 | val_metrics | MetricCollection | 0 | train\n", + "5 | stacks | ModuleList | 6.2 M | train\n", + "-------------------------------------------------------------\n", + "6.2 M Trainable params\n", + "1.4 K Non-trainable params\n", + "6.2 M Total params\n", + "24.787 Total estimated model params size (MB)\n", + "400 Modules in train mode\n", + "0 Modules in eval mode\n" + ] }, { - "cell_type": "code", - "execution_count": 8, - "id": "61406cd9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.451366Z", - "iopub.status.busy": "2026-06-24T15:18:47.451297Z", - "iopub.status.idle": "2026-06-24T15:18:47.906785Z", - "shell.execute_reply": "2026-06-24T15:18:47.906380Z" - } + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "33ff56f2bbbb46ddb71bf5ac409bc3c7", + "version_major": 2, + "version_minor": 0 }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026/06/25 13:57:23 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run ID: 22b3b299ce8d4d72b1646564a35b04ee\n", - "Model URI: models:/m-e61e8518e2a04143ace1d627ed4a775b\n" - ] - } - ], - "source": [ - "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", - " model_info = log_model(\n", - " model=model,\n", - " name=\"exponential-smoothing-model\",\n", - " # alternatively, use mlflow.set_tag(key, value) in the run\n", - " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", - " )\n", - "\n", - " # log calculated metrics you want\n", - " mlflow.log_metric(\"val_mape\", mape_score)\n", - " mlflow.log_metric(\"val_rmse\", rmse_score)\n", - "\n", - " print(f\"Run ID: {run.info.run_id}\")\n", - " print(f\"Model URI: {model_info.model_uri}\")" + "text/plain": [ + "Sanity Checking: | | 0/? [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", - " auto_model = LinearRegressionModel(lags=12)\n", - " auto_model.fit(train) # autolog logs params, covariate metadata, and the model\n", - "\n", - " auto_predictions = auto_model.predict(n=len(val))\n", - " # these metric calls happen inside the run, so they are logged automatically\n", - " auto_mape = darts.metrics.mape(val, auto_predictions)\n", - " auto_rmse = darts.metrics.rmse(val, auto_predictions)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show logged metrics\n", - "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", - "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", - "\n", - "# plot\n", - "fig, ax = plt.subplots(figsize=(10, 4))\n", - "train[-36:].plot(label=\"Train\", ax=ax)\n", - "val.plot(label=\"Actual\", ax=ax)\n", - "auto_predictions.plot(\n", - " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", - ")\n", - "ax.set_title(\"Linear Regression — autolog run\")\n", - "ax.legend()\n", - "plt.tight_layout()\n", - "plt.show()" + "text/plain": [ + "Validation: | | 0/? [00:00 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `val_mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", - ">\n", - "![Mlflow Overview](./static/images/mlflow_overview.png)" + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "07ec6fb97dd6418594e5dedda8a087fc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_charts.png)" + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0759f953cc2e4aba9c4d4644279daf9c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00`), quantile metrics (`q`, `q_interval`) add the quantile (e.g. `val_mql_q0.5`), per-label classification (`label_reduction=None`) adds the class (e.g. `val_f1_label1`), and per-timestep metrics (`time_reduction=None`) are charted across MLflow steps.\n", - "\n", - "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is saved as a CSV artifact under `per_series_metrics/`.\n", - "\n", - "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the prefix and suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `val_foo_q0.5`)." + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1f198dc0926c4f40a60823608c789f05", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_charts.png)" + ] + }, + { + "cell_type": "markdown", + "id": "3f0828c2", + "metadata": {}, + "source": [ + "## Forecast Metrics\n", + "\n", + "With `log_metrics=True` (the default), `autolog()` patches every darts metric function. Any metric you call **inside an active run** is logged automatically with no extra arguments needed.\n", + "\n", + "The metric key is derived from the result: a scalar is logged under `{metric}` (e.g. calling `darts.metrics.mae(val, pred)` logs `mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "df8e85b6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.372445Z", + "iopub.status.busy": "2026-06-24T15:18:53.372367Z", + "iopub.status.idle": "2026-06-24T15:18:53.470125Z", + "shell.execute_reply": "2026-06-24T15:18:53.469722Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "aab0d1e0", - "metadata": {}, - "source": [ - "## Querying Experiments\n", - "\n", - "You can programmatically query and compare runs." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "All logged metrics (5):\n", + " mae: 46.0220\n", + " manual_mape: 10.7420\n", + " mape: 10.7420\n", + " rmse: 51.1820\n", + " smape: 10.1015\n" + ] + } + ], + "source": [ + "# log_metrics=True (the default) patches every darts metric so that calls made\n", + "# inside an active run are logged automatically\n", + "autolog(log_metrics=True)\n", + "\n", + "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", + " lr_model = LinearRegressionModel(lags=12)\n", + " lr_model.fit(train)\n", + " lr_pred = lr_model.predict(n=len(val))\n", + "\n", + " # each metric called here is auto-logged under its own name: mae, rmse, smape\n", + " metrics.mae(val, lr_pred)\n", + " metrics.rmse(val, lr_pred)\n", + " metrics.smape(val, lr_pred)\n", + " # you can still log a custom-named metric explicitly\n", + " mlflow.log_metric(\"manual_mape\", metrics.mape(val, lr_pred))\n", + " run_id = run.info.run_id\n", + "\n", + "autolog(disable=True)\n", + "\n", + "# show what was logged\n", + "client = mlflow.tracking.MlflowClient()\n", + "run_metrics = client.get_run(run_id).data.metrics\n", + "metric_names = sorted(run_metrics.keys())\n", + "print(f\"All logged metrics ({len(metric_names)}):\")\n", + "for name in metric_names:\n", + " print(f\" {name}: {run_metrics[name]:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b08e900a", + "metadata": {}, + "source": [ + "### Metric Shape and Per-Series Logging\n", + "\n", + "The logged key reflects the shape of the metric output, which `autolog()` infers from the metric and its keyword arguments. The general pattern is:\n", + "\n", + "`{metric_name}{component}{quantile_or_label}`\n", + "\n", + "- **Per-component** (`component_reduction=None`) adds the component name, e.g. `mae_`.\n", + "- **Quantile / interval** (`q`, `q_interval`) adds the quantile, e.g. `mql_q0.500`.\n", + "- **Per-label classification** (`label_reduction=None`) adds the class, e.g. `f1_label1`.\n", + "- **Per-timestep** (`time_reduction=None`) is charted across MLflow steps.\n", + "- **`series_reduction`**, when set on the metric call, aggregates across series inside the metric itself, so the mean-over-series logging described below does not apply.\n", + "\n", + "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is appended to a single run-wide table artifact, `metrics_per_series.json`, which you can read back with `mlflow.load_table()`.\n", + "\n", + "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `foo_q0.500`)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ecdbbf29", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Aggregate metrics: {'ae': 44.196, 'mae': 51.316}\n", + "Mean MAE over series: 51.316\n" + ] }, { - "cell_type": "code", - "execution_count": 17, - "id": "109a9812", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.485914Z", - "iopub.status.busy": "2026-06-24T15:18:53.485859Z", - "iopub.status.idle": "2026-06-24T15:18:53.496380Z", - "shell.execute_reply": "2026-06-24T15:18:53.496048Z" - } + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0305dca7a1b846f19da965d1b74319c5", + "version_major": 2, + "version_minor": 0 }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 5 runs in experiment 'darts-quickstart':\n", - "\n", - "1. exponential-smoothing-baseline\n", - " Run ID: 22b3b299ce8d4d72b1646564a35b04ee\n", - " Validation MAPE: 7.864181481214469\n", - "\n", - "2. linear-regression-full-metrics\n", - " Run ID: 91ea26f4a5d448269c704a772c53f695\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "3. linear-regression-autolog\n", - " Run ID: eed13fa115304f6e853dfd4bf755211c\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "4. nbeats-epoch-metrics\n", - " Run ID: a1acc6779c7b4f158ac95f26bb108b74\n", - " Validation MAPE: 13.639569217869525\n", - "\n", - "5. metric-shape-and-csv\n", - " Run ID: 13a91160d03f414892139f7831ba509d\n", - " Validation MAPE: N/A\n", - "\n" - ] - } - ], - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.val_mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"val_mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" + "text/plain": [ + "Downloading artifacts: 0%| | 0/1 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
keyseries_indexstepvalue
0mae0047.458874
1mae1055.172880
\n", + "
" ], - "source": [ - "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", - "\n", - "if runs:\n", - " best_run = runs[0]\n", - " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", - " # from the run outputs and load it with a models:/ URI\n", - " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", - " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", - "\n", - " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", - " print(f\"Model URI: {best_model_uri}\")\n", - "\n", - " best_model = load_model(best_model_uri)\n", - " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", - " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", - " if isinstance(best_model, GlobalForecastingModel):\n", - " best_predictions = best_model.predict(n=len(val), series=train)\n", - " else:\n", - " best_predictions = best_model.predict(n=len(val))\n", - "\n", - " train[-50:].plot(label=\"Training\")\n", - " val.plot(label=\"Actual\")\n", - " best_predictions.plot(label=\"Best Model Forecast\")\n", - " plt.legend()\n", - " plt.title(\"Best Model Predictions\")\n", - " plt.show()" + "text/plain": [ + " key series_index step value\n", + "0 mae 0 0 47.458874\n", + "1 mae 1 0 55.172880" ] - }, + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# build a small multi-series example from the univariate AirPassengers data\n", + "series_list = [train, train * 1.2]\n", + "val_list = [val, val * 1.2]\n", + "\n", + "multi_model = LinearRegressionModel(lags=12)\n", + "multi_model.fit(series_list)\n", + "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", + "\n", + "autolog(log_metrics=True)\n", + "\n", + "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", + " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", + " # under a single key, charted across MLflow steps\n", + " single_pred = multi_preds[0] # train == series_list[0]\n", + " metrics.ae(val, single_pred)\n", + "\n", + " # multiple series: the logged value is the MEAN over series, and the full\n", + " # per-series breakdown is appended to the run's table artifact\n", + " per_series_mae = metrics.mae(val_list, multi_preds)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "client = mlflow.tracking.MlflowClient()\n", + "run_id = run.info.run_id\n", + "\n", + "# aggregate metrics: mae is the mean over the two series\n", + "logged = client.get_run(run_id).data.metrics\n", + "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", + "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", + "\n", + "# load the per-series table artifact\n", + "per_series_df = mlflow.load_table(\n", + " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", + ")\n", + "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", + "per_series_df" + ] + }, + { + "cell_type": "markdown", + "id": "8511fc08", + "metadata": {}, + "source": [ + "## Saving and Loading Models Locally\n", + "\n", + "You can also save and load models to/from local paths without MLflow runs." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "645ef079", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.471252Z", + "iopub.status.busy": "2026-06-24T15:18:53.471178Z", + "iopub.status.idle": "2026-06-24T15:18:53.478682Z", + "shell.execute_reply": "2026-06-24T15:18:53.478330Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "6f1ec89e", - "metadata": {}, - "source": [ - "## Model Registry\n", - "\n", - "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived).\n", - "\n", - "```python\n", - "# Register a model from a run\n", - "result = mlflow.register_model(\n", - " model_uri=f\"runs:/{best_run.info.run_id}/model\",\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")\n", - "```\n", - "\n", - "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", - "\n", - "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_models.png)" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/07/23 18:50:10 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] }, { - "cell_type": "markdown", - "id": "7af49ea9", - "metadata": {}, - "source": [ - "## Important Note: Custom Flavor\n", - "\n", - "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", - "\n", - "**Always use:**\n", - "```python\n", - "from darts.utils.mlflow import load_model\n", - "model = load_model(model_uri)\n", - "```\n", - "\n", - "**Instead of:**\n", - "```python\n", - "import mlflow\n", - "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", - "```\n", - "\n", - "This custom flavor is necessary to properly handle:\n", - "- TimeSeries objects\n", - "- Darts-specific model parameters\n", - "- Covariate handling (past, future, static)\n", - "- PyTorch model state preservation" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Files in model directory:\n", + " - python_env.yaml\n", + " - requirements.txt\n", + " - MLmodel\n", + " - model.pkl\n", + " - conda.yaml\n" + ] + } + ], + "source": [ + "# Save model to local directory\n", + "local_model_path = os.path.join(tmpdir, \"my_model\")\n", + "save_model(model, path=local_model_path)\n", + "\n", + "print(\"\\nFiles in model directory:\")\n", + "for file in os.listdir(local_model_path):\n", + " print(f\" - {file}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "254ba153", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.479679Z", + "iopub.status.busy": "2026-06-24T15:18:53.479604Z", + "iopub.status.idle": "2026-06-24T15:18:53.484973Z", + "shell.execute_reply": "2026-06-24T15:18:53.484638Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "40621b13", - "metadata": {}, - "source": [ - "## Cleanup" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model successfully!\n", + "Predictions shape: (5, 1)\n" + ] + } + ], + "source": [ + "# Load model from local directory\n", + "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", + "\n", + "# Test it\n", + "local_predictions = local_loaded_model.predict(n=5)\n", + "print(\"Loaded model successfully!\")\n", + "print(f\"Predictions shape: {local_predictions.values().shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "aab0d1e0", + "metadata": {}, + "source": [ + "## Querying Experiments\n", + "\n", + "You can programmatically query and compare runs." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "109a9812", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.485914Z", + "iopub.status.busy": "2026-06-24T15:18:53.485859Z", + "iopub.status.idle": "2026-06-24T15:18:53.496380Z", + "shell.execute_reply": "2026-06-24T15:18:53.496048Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 19, - "id": "51fc7c4a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.573724Z", - "iopub.status.busy": "2026-06-24T15:18:53.573637Z", - "iopub.status.idle": "2026-06-24T15:18:53.575115Z", - "shell.execute_reply": "2026-06-24T15:18:53.574817Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpvwnlx3yj\n" - ] - } - ], - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 5 runs in experiment 'darts-quickstart':\n", + "\n", + "1. exponential-smoothing-baseline\n", + " Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", + " Validation MAPE: 7.864181481214469\n", + "\n", + "2. linear-regression-full-metrics\n", + " Run ID: 708095048f274913990375bbbd4310ad\n", + " Validation MAPE: 10.742044444678953\n", + "\n", + "3. linear-regression-autolog\n", + " Run ID: 36376b7a94454a13a4acba207459315e\n", + " Validation MAPE: 10.742044444678953\n", + "\n", + "4. nbeats-epoch-metrics\n", + " Run ID: f0d1b0ed9ac34232b5e36fe82a24a0a6\n", + " Validation MAPE: 13.639569217869525\n", + "\n", + "5. metric-shape-and-table\n", + " Run ID: 9be3e9d311b64d45b0204174835537cc\n", + " Validation MAPE: N/A\n", + "\n" + ] + } + ], + "source": [ + "from mlflow.tracking import MlflowClient\n", + "\n", + "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", + "\n", + "# get all runs\n", + "client = MlflowClient()\n", + "runs = client.search_runs(\n", + " experiment_ids=[experiment.experiment_id],\n", + " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", + ")\n", + "\n", + "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", + "for i, run in enumerate(runs, 1):\n", + " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", + " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", + " print(f\"{i}. {run_name}\")\n", + " print(f\" Run ID: {run.info.run_id}\")\n", + " print(f\" Validation MAPE: {mape_val}\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "22685423", + "metadata": {}, + "source": [ + "### Load the Best Model" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7b09db6a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.497560Z", + "iopub.status.busy": "2026-06-24T15:18:53.497496Z", + "iopub.status.idle": "2026-06-24T15:18:53.572540Z", + "shell.execute_reply": "2026-06-24T15:18:53.572133Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "ca40afc1", - "metadata": {}, - "source": [ - "# Final Remarks" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading best model from run: exponential-smoothing-baseline\n", + "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" + ] }, { - "cell_type": "markdown", - "id": "c4c86a23", - "metadata": {}, - "source": [ - "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv (3.11.9)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" + ], + "source": [ + "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", + "\n", + "if runs:\n", + " best_run = runs[0]\n", + " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", + " # from the run outputs and load it with a models:/ URI\n", + " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", + " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", + "\n", + " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", + " print(f\"Model URI: {best_model_uri}\")\n", + "\n", + " best_model = load_model(best_model_uri)\n", + " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", + " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", + " if isinstance(best_model, GlobalForecastingModel):\n", + " best_predictions = best_model.predict(n=len(val), series=train)\n", + " else:\n", + " best_predictions = best_model.predict(n=len(val))\n", + "\n", + " train[-50:].plot(label=\"Training\")\n", + " val.plot(label=\"Actual\")\n", + " best_predictions.plot(label=\"Best Model Forecast\")\n", + " plt.legend()\n", + " plt.title(\"Best Model Predictions\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6f1ec89e", + "metadata": {}, + "source": [ + "## Model Registry\n", + "\n", + "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived)." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "7c854bc4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T08:27:04.144511Z", + "iopub.status.busy": "2026-07-22T08:27:04.144439Z", + "iopub.status.idle": "2026-07-22T08:27:04.166315Z", + "shell.execute_reply": "2026-07-22T08:27:04.165897Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Registered version: 1\n" + ] }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "01ac1053789e45fab75e2cde894b417a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "02cefe41f8814ddf9de26418b26783c3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "03569ea4478d4d74b0ae4c5416c40d6d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "055bae1119db45caa5b6cd91921c76d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", - "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", - "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" - ], - "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", - "tabbable": null, - "tooltip": null - } - }, - "05d25d3b3bd9497f86849702e5a19515": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "071709416bab4673a582978e2e3592a3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "07e8c0b16c2d430ea8bb6798e9b4f103": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", - "placeholder": "​", - "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "0deaf695a8544725ac4904ff7388f489": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "11dbeaae3ae640c3995e784abfda15c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", - "placeholder": "​", - "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "12524abe09304f9bb20bd9978ac2a44d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", - "placeholder": "​", - "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 189.90it/s]" - } - }, - "13af542c17d64851a3ef54ce9610bb99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "153af823c040405dbc075bf50a28ff17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "16656416b10a43c8b81c6c4b2a02ec0b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "16ce59abc5bb4ffe978736017f60e21a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", - "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", - "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" - ], - "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", - "tabbable": null, - "tooltip": null - } - }, - "19382158e51343918122512753ca25c7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "20cca542fe2a4e19846e2e1cb07dd165": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "252a64f9c6d440e2a3d3c3f62f44d764": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", - "placeholder": "​", - "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", - "tabbable": null, - "tooltip": null, - "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" - } - }, - "27e25633e2a549dcbfafe1129839043d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b154733d72e4e468c339683e83c30a7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b197d3911154085bb86f0dbba2c8b98": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2c4ee939558d44a4a3bc9040a940693f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", - "placeholder": "​", - "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 199.01it/s]" - } - }, - "2e727ab68ed64ee98bfb9d81f1e39c1d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", - "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", - "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" - ], - "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", - "tabbable": null, - "tooltip": null - } - }, - "2ec00b06939145ec95930e3c1490efcc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", - "placeholder": "​", - "style": "IPY_MODEL_19382158e51343918122512753ca25c7", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "30a18f8c59754940a9785cd152a67daa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "32e9a01e1a2b4914989eda6f6832f989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "331f7f90d7d049a6adc72c260c06570e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "33a28231831d473aa27d32e1c15a8989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "35778f5ef201497d8d453772f80a7978": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "366e2af2827540728d29bfa6d931dbdb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", - "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", - "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" - ], - "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", - "tabbable": null, - "tooltip": null - } - }, - "3799be676aea4d12b87992115e4b90ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3a36a442c4a94ab585d8522e57f45c34": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3b44dec6a3354f7ebc4117e7d7f50b1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", - "placeholder": "​", - "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "3c3d34b732664135a79031e8bc9e2984": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3cde338fcaf548de8e8216a98e66f9bc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", - "placeholder": "​", - "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 195.74it/s]" - } - }, - "3dddd89019c849f0872e9a9700e14ad0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", - "placeholder": "​", - "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", - "tabbable": null, - "tooltip": null, - "value": "Predicting DataLoader 0: 100%" - } - }, - "40b8f5c6c7844bd0bb071f043f97a639": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "40df96a9f08440a893ffe9d57d176e1f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41e23a2458044b888fb76fd882428b39": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "42360fe280a14e44831c8e62f6ad249e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "425a21a3b7604c8cb49871c1b2850f68": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4297b4158e4f43da9226bfc00272f9c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "43eab5ba00014d7ba62f97acd9e93eba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "44c3cc7783594142a19ffad035eea9d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "4787d389023845a8ae398eb5d1155ab1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "480afa5d41c145d0ac88e2adaca7b1e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", - "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", - "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" - ], - "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", - "tabbable": null, - "tooltip": null - } - }, - "4b3f0ca06bf54eb9bab4e081dabcf139": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4f10caf0abca4aa59053c4cb374ea3d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "50e4f1e4cd994abeae53d0f84b6afd44": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "522af0834c254f0eb2fe7c9efa74c5f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "54aad655289741b59d3c83b8508e68b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", - "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", - "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" - ], - "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", - "tabbable": null, - "tooltip": null - } - }, - "55e102413ba54377b2fd1995b98c7858": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "579cbbe7cfb34e429bffd11ec774ba50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "57cd2f911c6840da87c1d6c8a78521e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "57db1d3f28d347878d9f48d0ceef5589": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", - "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", - "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" - ], - "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", - "tabbable": null, - "tooltip": null - } - }, - "580c0814097844e186ef642094968d3a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "590ebae9a3664214be16b105941c7ee3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "59413112366944be8e0d6600880dc1a4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5dcf47d8b9c0420898fe491a81bab8af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", - "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", - "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" - ], - "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", - "tabbable": null, - "tooltip": null - } - }, - "61734f2b95c34e13971fd65cd7da2e1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "641b5ae5b9e7475db63a31e67b13b601": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "642a06d187834b96af41b74a25d13e1a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6da83aee80314ceb9ace5fa0c4c76529": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9e33a121da334db899669d702f9d54ce", - "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", - "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" - ], - "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", - "tabbable": null, - "tooltip": null - } - }, - "6dad7db23e9e4397bfb93655cd8b08b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e794979a2793408791ee570d3af6f371", - "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", - "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" - ], - "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", - "tabbable": null, - "tooltip": null - } - }, - "6eb691aae3a44a25b1e7471929151f47": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "71c1aa3663804753bf3a75a227412072": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "72125343cca3416fbd3f012232e63ae5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "761dbbe1bf4e4804a3649858898b78e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7adbf399ea5e4a7c990cdff60674b593": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", - "max": 3, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", - "tabbable": null, - "tooltip": null, - "value": 3 - } - }, - "7d599e5710f4485a8f7580c7efca3bc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e0ad83f116b4933a35870525656df5d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "81e281800a094e34b2e43021bea6fd11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", - "placeholder": "​", - "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 174.77it/s]" - } - }, - "859b368a8a6d4500960a6e2285f4c016": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "86bfcc40b08440af98f64a732df1ea5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8766872fa61844458d70112fcf44bdb3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8825c219393f4040890a639a17210bc5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "89dc0773756b4b7b93cce8e6cfe47202": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", - "placeholder": "​", - "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 100.83it/s]" - } - }, - "8d829381b5034ed9807b86d514b1fdbb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "8e6984bd5a00425bb9071deba84f4cea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8f2ac8fd36964f11bd556782c96b0f72": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "924315df026a41fb97d7cc8488bb8503": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "95daeef1bd3e4f77b883d3d71fcd1fac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", - "placeholder": "​", - "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", - "tabbable": null, - "tooltip": null, - "value": "Sanity Checking DataLoader 0: 100%" - } - }, - "97b2d3e5a7e847739b237fc9c5cdc3a9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9914744ed44845fd9d00727c7da93d32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "9a20b5d724584e289863cf63a4c13259": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b1dd53c1fdd45dabf3660e9e0be1310": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", - "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", - "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" - ], - "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", - "tabbable": null, - "tooltip": null - } - }, - "9b8b6898ef244336989227f5469a2d11": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b933a5d5aa14741904151b4ea7e3f50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", - "placeholder": "​", - "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 88.28it/s]" - } - }, - "9e33a121da334db899669d702f9d54ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", - "placeholder": "​", - "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", - "tabbable": null, - "tooltip": null, - "value": "Epoch 9: 100%" - } - }, - "9fd5c0e984d04e4aa0e106ec89434720": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "a30948d8cfd6491484d6b63591b65a84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a5f3118f4f9040ebbdb1a7acae012087": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b1dc954934944e92914a1c129d8c7dcd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b23efdc3bb5747af96dd5e539a14b5c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", - "placeholder": "​", - "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "b35ce184b43b48daaa39ccef748eeac6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "b4d7ddbd507e4e1681cc0888680abb5b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b4e804d6e4b44314a8847c2f5be857d4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b6625b52007b4434a7804cfd824452cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", - "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", - "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" - ], - "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", - "tabbable": null, - "tooltip": null - } - }, - "b676b1571a00427587827caac8158c14": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "be1dd700617141cf9517ee7ef1153746": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c198ffce01de4b7294649c1619b5b7e6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c255e442c01446699af3179f14eb8fc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", - "placeholder": "​", - "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "c2906f9d5f47471ca6bf44d8754f8d30": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c325a187e8a54e639300ff5a29640f03": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c60add7b277344feaad65a884c7fbf37": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c7c373a0b1c14b809041651ffcdd4559": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c99d9a52749b40628b8d148c64e75e88": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cb3cebaf14cc445a8055d1aac2f0d05c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", - "placeholder": "​", - "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 180.77it/s]" - } - }, - "cc7d97d8845d46ff9d946020b1b8e4cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "cd4d74958b704246a2cb2462a784d502": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce45f3190357423a9563bfae253f2f16": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce49dfd502074696aefcfa2cff18e4f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ce97bb2d961e4dc9bf44a646cb3d3aff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d04931a3bb0c47329cdd67701a7be0ad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", - "placeholder": "​", - "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 192.16it/s]" - } - }, - "d473da3081af4d4a810014019cd40b29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", - "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", - "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" - ], - "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", - "tabbable": null, - "tooltip": null - } - }, - "d4b49fabdd4543959d64e4e1c60dc360": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d9fc58b33d2645488a8c53af72f21e7a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "da4c6178632b4cfe96d2a9504cc3173b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dc6cccb142db43b7ac9849983a154a20": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dcb0a4350297443aa61691406923fb81": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dcced12e0ae04e32a811f60680db24f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", - "placeholder": "​", - "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "e09f041d857346029cbba27fb36f009e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e12d00f1e1b94e749f22904d3cec2445": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", - "placeholder": "​", - "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 186.36it/s]" - } - }, - "e19ea3de3e554c50a7300a7214c773f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e53d8d156b1c4db6aff2ba8395bf5415": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e6dfb5d14dfe4a1193e551f414ea393e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e7198635809b4f56bd1a30b6cbe661cf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e742e68a86474f0db17ccb64db4264c9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e794979a2793408791ee570d3af6f371": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", - "placeholder": "​", - "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "ed4968eb8435434db1604e34ee657413": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "eeb45b37592a4a599da1857d3444382e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", - "placeholder": "​", - "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f03f6404137144b8b600f8131c78ac63": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f286ebc675c549678f70419f668a7baa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f299c926a6a64a769d3db2e71725f8af": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f60411b259344a9e9a892d9552ecdabf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f609670bc6b840ed9f8698af8c7615a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f69737793cc648bd9aadfc0dd4b16569": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", - "placeholder": "​", - "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f6f12cd135674388b0fc72167a0308eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fb53a4348865461783df6d1e5b16386b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", - "placeholder": "​", - "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.28it/s]" - } - }, - "fb7ccdb37f844e989de3f7a0b12b8924": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fe3a78bc7ec842b08aac1b4e0fe1ed29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", - "placeholder": "​", - "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.93it/s]" - } - }, - "fe40606eebe6464db0b7f86e5abe1997": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", - "placeholder": "​", - "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 177.56it/s]" - } - }, - "fffac86b0934453d88f52df4b9ac6dd6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - } - }, - "version_major": 2, - "version_minor": 0 - } + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Successfully registered model 'darts-air-passengers'.\n", + "Created version '1' of model 'darts-air-passengers'.\n" + ] } + ], + "source": [ + "# register the best model (from the \"Load the Best Model\" section above)\n", + "result = mlflow.register_model(\n", + " model_uri=best_model_uri,\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")" + ] + }, + { + "cell_type": "markdown", + "id": "da6cc83a", + "metadata": {}, + "source": [ + "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", + "\n", + "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_models.png)" + ] + }, + { + "cell_type": "markdown", + "id": "7af49ea9", + "metadata": {}, + "source": [ + "## Important Note: Custom Flavor\n", + "\n", + "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", + "\n", + "**Always use:**\n", + "```python\n", + "from darts.utils.mlflow import load_model\n", + "model = load_model(model_uri)\n", + "```\n", + "\n", + "**Instead of:**\n", + "```python\n", + "import mlflow\n", + "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", + "```\n", + "\n", + "This custom flavor is necessary to properly handle:\n", + "- TimeSeries objects\n", + "- Darts-specific model parameters\n", + "- Covariate handling (past, future, static)\n", + "- PyTorch model state preservation" + ] + }, + { + "cell_type": "markdown", + "id": "40621b13", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "51fc7c4a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.573724Z", + "iopub.status.busy": "2026-06-24T15:18:53.573637Z", + "iopub.status.idle": "2026-06-24T15:18:53.575115Z", + "shell.execute_reply": "2026-06-24T15:18:53.574817Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" + ] + } + ], + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ca40afc1", + "metadata": {}, + "source": [ + "# Final Remarks" + ] + }, + { + "cell_type": "markdown", + "id": "c4c86a23", + "metadata": {}, + "source": [ + "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.11.9)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01ac1053789e45fab75e2cde894b417a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02cefe41f8814ddf9de26418b26783c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "03569ea4478d4d74b0ae4c5416c40d6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "055bae1119db45caa5b6cd91921c76d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", + "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", + "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" + ], + "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", + "tabbable": null, + "tooltip": null + } + }, + "05d25d3b3bd9497f86849702e5a19515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "071709416bab4673a582978e2e3592a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e8c0b16c2d430ea8bb6798e9b4f103": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", + "placeholder": "​", + "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "0deaf695a8544725ac4904ff7388f489": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "11dbeaae3ae640c3995e784abfda15c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", + "placeholder": "​", + "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "12524abe09304f9bb20bd9978ac2a44d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", + "placeholder": "​", + "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 189.90it/s]" + } + }, + "13af542c17d64851a3ef54ce9610bb99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "153af823c040405dbc075bf50a28ff17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "16656416b10a43c8b81c6c4b2a02ec0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "16ce59abc5bb4ffe978736017f60e21a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", + "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", + "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" + ], + "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", + "tabbable": null, + "tooltip": null + } + }, + "19382158e51343918122512753ca25c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "20cca542fe2a4e19846e2e1cb07dd165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "252a64f9c6d440e2a3d3c3f62f44d764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", + "placeholder": "​", + "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", + "tabbable": null, + "tooltip": null, + "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" + } + }, + "27e25633e2a549dcbfafe1129839043d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b154733d72e4e468c339683e83c30a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b197d3911154085bb86f0dbba2c8b98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c4ee939558d44a4a3bc9040a940693f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", + "placeholder": "​", + "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 199.01it/s]" + } + }, + "2e727ab68ed64ee98bfb9d81f1e39c1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", + "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", + "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" + ], + "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", + "tabbable": null, + "tooltip": null + } + }, + "2ec00b06939145ec95930e3c1490efcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", + "placeholder": "​", + "style": "IPY_MODEL_19382158e51343918122512753ca25c7", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "30a18f8c59754940a9785cd152a67daa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "32e9a01e1a2b4914989eda6f6832f989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "331f7f90d7d049a6adc72c260c06570e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "33a28231831d473aa27d32e1c15a8989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35778f5ef201497d8d453772f80a7978": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "366e2af2827540728d29bfa6d931dbdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", + "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", + "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" + ], + "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", + "tabbable": null, + "tooltip": null + } + }, + "3799be676aea4d12b87992115e4b90ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a36a442c4a94ab585d8522e57f45c34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3b44dec6a3354f7ebc4117e7d7f50b1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", + "placeholder": "​", + "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "3c3d34b732664135a79031e8bc9e2984": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3cde338fcaf548de8e8216a98e66f9bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", + "placeholder": "​", + "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 195.74it/s]" + } + }, + "3dddd89019c849f0872e9a9700e14ad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", + "placeholder": "​", + "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", + "tabbable": null, + "tooltip": null, + "value": "Predicting DataLoader 0: 100%" + } + }, + "40b8f5c6c7844bd0bb071f043f97a639": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "40df96a9f08440a893ffe9d57d176e1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41e23a2458044b888fb76fd882428b39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "42360fe280a14e44831c8e62f6ad249e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "425a21a3b7604c8cb49871c1b2850f68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4297b4158e4f43da9226bfc00272f9c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "43eab5ba00014d7ba62f97acd9e93eba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44c3cc7783594142a19ffad035eea9d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "4787d389023845a8ae398eb5d1155ab1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "480afa5d41c145d0ac88e2adaca7b1e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", + "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", + "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" + ], + "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", + "tabbable": null, + "tooltip": null + } + }, + "4b3f0ca06bf54eb9bab4e081dabcf139": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f10caf0abca4aa59053c4cb374ea3d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "50e4f1e4cd994abeae53d0f84b6afd44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "522af0834c254f0eb2fe7c9efa74c5f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "54aad655289741b59d3c83b8508e68b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", + "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", + "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" + ], + "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", + "tabbable": null, + "tooltip": null + } + }, + "55e102413ba54377b2fd1995b98c7858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "579cbbe7cfb34e429bffd11ec774ba50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "57cd2f911c6840da87c1d6c8a78521e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "57db1d3f28d347878d9f48d0ceef5589": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", + "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", + "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" + ], + "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", + "tabbable": null, + "tooltip": null + } + }, + "580c0814097844e186ef642094968d3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "590ebae9a3664214be16b105941c7ee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59413112366944be8e0d6600880dc1a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dcf47d8b9c0420898fe491a81bab8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", + "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", + "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" + ], + "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", + "tabbable": null, + "tooltip": null + } + }, + "61734f2b95c34e13971fd65cd7da2e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "641b5ae5b9e7475db63a31e67b13b601": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "642a06d187834b96af41b74a25d13e1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6da83aee80314ceb9ace5fa0c4c76529": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9e33a121da334db899669d702f9d54ce", + "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", + "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" + ], + "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", + "tabbable": null, + "tooltip": null + } + }, + "6dad7db23e9e4397bfb93655cd8b08b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e794979a2793408791ee570d3af6f371", + "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", + "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" + ], + "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", + "tabbable": null, + "tooltip": null + } + }, + "6eb691aae3a44a25b1e7471929151f47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71c1aa3663804753bf3a75a227412072": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72125343cca3416fbd3f012232e63ae5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "761dbbe1bf4e4804a3649858898b78e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7adbf399ea5e4a7c990cdff60674b593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", + "max": 3, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", + "tabbable": null, + "tooltip": null, + "value": 3 + } + }, + "7d599e5710f4485a8f7580c7efca3bc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e0ad83f116b4933a35870525656df5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "81e281800a094e34b2e43021bea6fd11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", + "placeholder": "​", + "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 174.77it/s]" + } + }, + "859b368a8a6d4500960a6e2285f4c016": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86bfcc40b08440af98f64a732df1ea5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8766872fa61844458d70112fcf44bdb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8825c219393f4040890a639a17210bc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "89dc0773756b4b7b93cce8e6cfe47202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", + "placeholder": "​", + "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 100.83it/s]" + } + }, + "8d829381b5034ed9807b86d514b1fdbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "8e6984bd5a00425bb9071deba84f4cea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8f2ac8fd36964f11bd556782c96b0f72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "924315df026a41fb97d7cc8488bb8503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95daeef1bd3e4f77b883d3d71fcd1fac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", + "placeholder": "​", + "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", + "tabbable": null, + "tooltip": null, + "value": "Sanity Checking DataLoader 0: 100%" + } + }, + "97b2d3e5a7e847739b237fc9c5cdc3a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9914744ed44845fd9d00727c7da93d32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "9a20b5d724584e289863cf63a4c13259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b1dd53c1fdd45dabf3660e9e0be1310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", + "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", + "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" + ], + "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", + "tabbable": null, + "tooltip": null + } + }, + "9b8b6898ef244336989227f5469a2d11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b933a5d5aa14741904151b4ea7e3f50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", + "placeholder": "​", + "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 88.28it/s]" + } + }, + "9e33a121da334db899669d702f9d54ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", + "placeholder": "​", + "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", + "tabbable": null, + "tooltip": null, + "value": "Epoch 9: 100%" + } + }, + "9fd5c0e984d04e4aa0e106ec89434720": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "a30948d8cfd6491484d6b63591b65a84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a5f3118f4f9040ebbdb1a7acae012087": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1dc954934944e92914a1c129d8c7dcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b23efdc3bb5747af96dd5e539a14b5c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", + "placeholder": "​", + "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "b35ce184b43b48daaa39ccef748eeac6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "b4d7ddbd507e4e1681cc0888680abb5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b4e804d6e4b44314a8847c2f5be857d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b6625b52007b4434a7804cfd824452cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", + "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", + "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" + ], + "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", + "tabbable": null, + "tooltip": null + } + }, + "b676b1571a00427587827caac8158c14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "be1dd700617141cf9517ee7ef1153746": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c198ffce01de4b7294649c1619b5b7e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c255e442c01446699af3179f14eb8fc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", + "placeholder": "​", + "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "c2906f9d5f47471ca6bf44d8754f8d30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c325a187e8a54e639300ff5a29640f03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c60add7b277344feaad65a884c7fbf37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c7c373a0b1c14b809041651ffcdd4559": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c99d9a52749b40628b8d148c64e75e88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb3cebaf14cc445a8055d1aac2f0d05c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", + "placeholder": "​", + "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 180.77it/s]" + } + }, + "cc7d97d8845d46ff9d946020b1b8e4cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "cd4d74958b704246a2cb2462a784d502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce45f3190357423a9563bfae253f2f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce49dfd502074696aefcfa2cff18e4f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce97bb2d961e4dc9bf44a646cb3d3aff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d04931a3bb0c47329cdd67701a7be0ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", + "placeholder": "​", + "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 192.16it/s]" + } + }, + "d473da3081af4d4a810014019cd40b29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", + "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", + "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" + ], + "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", + "tabbable": null, + "tooltip": null + } + }, + "d4b49fabdd4543959d64e4e1c60dc360": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "d9fc58b33d2645488a8c53af72f21e7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "da4c6178632b4cfe96d2a9504cc3173b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc6cccb142db43b7ac9849983a154a20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dcb0a4350297443aa61691406923fb81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcced12e0ae04e32a811f60680db24f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", + "placeholder": "​", + "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "e09f041d857346029cbba27fb36f009e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e12d00f1e1b94e749f22904d3cec2445": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", + "placeholder": "​", + "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 186.36it/s]" + } + }, + "e19ea3de3e554c50a7300a7214c773f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e53d8d156b1c4db6aff2ba8395bf5415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e6dfb5d14dfe4a1193e551f414ea393e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7198635809b4f56bd1a30b6cbe661cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e742e68a86474f0db17ccb64db4264c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e794979a2793408791ee570d3af6f371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", + "placeholder": "​", + "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "ed4968eb8435434db1604e34ee657413": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eeb45b37592a4a599da1857d3444382e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", + "placeholder": "​", + "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f03f6404137144b8b600f8131c78ac63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f286ebc675c549678f70419f668a7baa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f299c926a6a64a769d3db2e71725f8af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f60411b259344a9e9a892d9552ecdabf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f609670bc6b840ed9f8698af8c7615a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f69737793cc648bd9aadfc0dd4b16569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", + "placeholder": "​", + "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f6f12cd135674388b0fc72167a0308eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fb53a4348865461783df6d1e5b16386b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", + "placeholder": "​", + "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.28it/s]" + } + }, + "fb7ccdb37f844e989de3f7a0b12b8924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fe3a78bc7ec842b08aac1b4e0fe1ed29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", + "placeholder": "​", + "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.93it/s]" + } + }, + "fe40606eebe6464db0b7f86e5abe1997": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", + "placeholder": "​", + "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 177.56it/s]" + } + }, + "fffac86b0934453d88f52df4b9ac6dd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 } From 10cf6a6e240e2ba9377c85b344dd09b81d6e1a5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 19:20:01 +0200 Subject: [PATCH 122/154] fix: restrict component count only when not comp reduction --- darts/tests/optional_deps/test_mlflow.py | 51 ++++++++++++++++--- darts/utils/mlflow.py | 62 +++++++++++++----------- 2 files changed, 78 insertions(+), 35 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index fc7ffe4ca0..4c35ab1dd8 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1104,19 +1104,33 @@ def test_autolog_metric_multi_series_classification_labels_explicit( assert got[("f1_label0", i)] == pytest.approx(ref[i][0], abs=1e-5) assert got[("f1_label1", i)] == pytest.approx(ref[i][1], abs=1e-5) + def test_autolog_metric_component_count_mismatch_allowed_when_reduced( + self, mlflow_tracking, autolog_context + ): + """Default mae reduces components to scalars, so mixed component counts + are valid and log under a single aggregated key.""" + series = [self.ts_univariate, self.ts_multivariate] + pred = [s * 1.1 for s in series] + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.mae(series, pred) + + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["mae"] == pytest.approx(float(np.mean(ref)), abs=1e-5) + def test_autolog_metric_component_count_mismatch_raises( self, mlflow_tracking, autolog_context ): - """A list of series with different numbers of components raises rather - than taking component names from the first series only and silently - mislabeling the rest.""" + """When components are preserved, mixed component counts raise rather + than taking names from the first series and mislabeling the rest.""" series = [self.ts_univariate, self.ts_multivariate] pred = [s * 1.1 for s in series] with autolog_context(log_metrics=True): with mlflow.start_run() as run: with pytest.raises(ValueError, match="same number of components"): - dm.mae(series, pred) + dm.mae(series, pred, component_reduction=None) assert not mlflow.get_run(run.info.run_id).data.metrics @@ -1460,18 +1474,41 @@ def test_autolog_backtest_classification_labels_not_in_data( assert np.isnan(m["backtest_f1_label5"]) assert np.isnan(m["backtest_f1_label10"]) + def test_log_backtest_metrics_component_count_mismatch_allowed_when_reduced( + self, mlflow_tracking + ): + """Default mae reduces components to scalars, so mixed component counts + aggregate normally. Calls _log_backtest_metrics directly.""" + backtest_args = { + "metric": dm.mae, + "metric_kwargs": {}, + "series": [self.ts_univariate, self.ts_multivariate], + "forecast_horizon": 1, + "reduction": np.mean, + "last_points_only": True, + } + result = [1.0, 3.0] + + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + client.flush(synchronous=True) + + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["backtest_mae"] == pytest.approx(2.0) + def test_log_backtest_metrics_component_count_mismatch_raises( self, mlflow_tracking ): - """A list of series with different numbers of components raises rather - than taking component names from the first series only. + """When components are preserved, mixed component counts raise rather + than taking names from the first series only. Calls _log_backtest_metrics directly so the raise is not swallowed by MLflow's safe_patch wrapper. """ backtest_args = { "metric": dm.mae, - "metric_kwargs": {}, + "metric_kwargs": {"component_reduction": None}, "series": [self.ts_univariate, self.ts_multivariate], "forecast_horizon": 1, "reduction": np.mean, diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 1b0956871d..0a5db5968b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -370,9 +370,10 @@ def autolog( MLflow ``step``. For a list of series the logged value is ``agg_func`` applied over series, and the full per-series breakdown for every metric/backtest call in the run is appended to a single - ``metrics_per_series.json`` table artifact. All series scored - together in one call must have the same number of components; - component names are taken from the first series. + ``metrics_per_series.json`` table artifact. When components are + preserved (``component_reduction=None``), all series scored together + must have the same number of components; names are taken from the + first series. Parameters ---------- @@ -884,9 +885,10 @@ def _log_backtest_metrics( applied over series for each cell, and the granular per-series breakdown is appended to the run's ``metrics_per_series.json`` table artifact (shared with ``_log_metric_result``). For a single series the aggregate - is just the value itself and no artifact is written. All series scored - together must have the same number of components; names are taken from - the first series. + is just the value itself and no artifact is written. When components + are preserved (``component_reduction=None``), all series scored together + must have the same number of components; names are taken from the first + series. Series of different lengths are assumed to share the same end date, so any axis mapping to real dates (the window axis, or the per-timestep axis @@ -898,9 +900,9 @@ def _log_backtest_metrics( ------ ValueError On a shape/size mismatch between the metric result and the inferred - axes, when series in a sequence have different numbers of components, - or when ``label_reduction=None`` is requested without explicit - ``labels``. + axes, when ``component_reduction=None`` and series in a sequence have + different numbers of components, or when ``label_reduction=None`` is + requested without explicit ``labels``. Parameters ---------- @@ -982,14 +984,16 @@ def _log_backtest_metrics( series_seq = series2seq(series) results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result - n_components = {s.n_components for s in series_seq} - if len(n_components) > 1: - raise_log( - ValueError( - "Backtest metric logging failed: all series must have the same " - f"number of components, got {sorted(n_components)}." + # component names are only used when the metric preserves components + if has_comp_axis: + n_components = {s.n_components for s in series_seq} + if len(n_components) > 1: + raise_log( + ValueError( + "Backtest metric logging failed: all series must have the same " + f"number of components, got {sorted(n_components)}." + ) ) - ) # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} @@ -1255,8 +1259,8 @@ def _log_metric_result( ------ ValueError On a shape/size mismatch between the metric result and the inferred - axes, or when series in a sequence have different numbers of - components. + axes, or when ``has_comp_axis`` is ``True`` and series in a sequence + have different numbers of components. Parameters ---------- @@ -1268,8 +1272,8 @@ def _log_metric_result( series The ``actual_series`` argument passed to the metric (single series or ``Sequence[TimeSeries]``); used for component names and series count. - All series in a sequence must have the same number of components; - names are taken from the first series. + When ``has_comp_axis`` is ``True``, all series in a sequence must have + the same number of components; names are taken from the first series. has_time_axis ``True`` when the result carries a per-timestep axis (``time_reduction=None``). has_comp_axis @@ -1295,15 +1299,17 @@ def _log_metric_result( results = ( [result] if get_series_seq_type(series) == SeriesType.SINGLE else result ) - n_components = {s.n_components for s in series_seq} - if len(n_components) > 1: - raise_log( - ValueError( - f"Metric logging failed for `{metric_name}`: all series must " - f"have the same number of components, got " - f"{sorted(n_components)}." + # component names are only used when the metric preserves components + if has_comp_axis: + n_components = {s.n_components for s in series_seq} + if len(n_components) > 1: + raise_log( + ValueError( + f"Metric logging failed for `{metric_name}`: all series must " + f"have the same number of components, got " + f"{sorted(n_components)}." + ) ) - ) # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() From 9c547aa2d32fc7b636fd106495af55a16629e2b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Thu, 23 Jul 2026 19:31:15 +0200 Subject: [PATCH 123/154] fix: log model params fix --- darts/utils/mlflow.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 0a5db5968b..377276d10e 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -318,8 +318,15 @@ def log_model(model, **kwargs): are used to support serving and input validation in the MLflow pyfunc flavor, which is not implemented for darts models. """ + # MLflow still requires "artifact_path" to be provided (it has no default), + # but it is deprecated in favour of "name". Accept it via kwargs for + # compatibility, defaulting to None so callers can use "name" alone. + artifact_path = kwargs.pop("artifact_path", None) return Model.log( - artifact_path=None, flavor=sys.modules[__name__], model=model, **kwargs + artifact_path, + flavor=sys.modules[__name__], + model=model, + **kwargs, ) From b9e6488d6113446a51a5abc2ef07a79bbe94d390 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 30 Jul 2026 17:47:13 +0200 Subject: [PATCH 124/154] minor updates to docs --- darts/utils/mlflow.py | 203 ++++++++++++++++++++++++------------------ 1 file changed, 114 insertions(+), 89 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 377276d10e..91fcc36559 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -6,12 +6,12 @@ and logging any Darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) to MLflow, as well as automatic logging (``autolog()``) of: -* Model creation parameters and covariate usage information. -* The trained model artifact after each ``fit()`` call when ``log_models=True`` - (default ``False``). -* Darts metric function calls made inside an active MLflow run. -* ``backtest()`` evaluation metrics. -* Per-epoch training/validation metrics for PyTorch-based models. +- Model parameters and data metadata: The model creation parameters and covariate usage information. +- Model storage: The trained model artifact after each ``fit()`` call when ``log_models=True`` (default ``False``). +- Metrics: + - The score for each metric called inside an active MLflow run. + - The score(s) from a ``backtest()`` call. + - Per-epoch training/validation metrics for PyTorch-based models. See the `MLflow quickstart example `_ for an end-to-end walkthrough. @@ -30,6 +30,7 @@ from typing import Any from darts.logging import raise_log +from darts.typing import TimeSeriesLike try: import mlflow @@ -79,6 +80,7 @@ from mlflow.utils.requirements_utils import _get_pinned_requirement import darts +from darts import TimeSeries from darts.logging import get_logger, raise_log from darts.metrics.utils import ( _LabelReduction, @@ -115,7 +117,7 @@ def save_model( - model, + model: ForecastingModel, path: str, conda_env: dict | str | None = None, code_paths: list[str] | None = None, @@ -126,18 +128,18 @@ def save_model( extra_pip_requirements: list[str] | None = None, metadata: dict[str, Any] | None = None, ) -> None: - """Save a darts forecasting model in MLflow format. + """Save a Darts forecasting model in MLflow format. Produces an MLflow model directory at ``path`` containing: - * The serialised darts model (delegated to the model's own ``save()`` method). - * An ``MLmodel`` YAML file with flavor metadata. - * ``conda.yaml`` and ``requirements.txt`` environment files. + - The serialized Darts model (delegated to the model's own ``save()`` method). + - An ``MLmodel`` YAML file with flavor metadata. + - ``conda.yaml`` and ``requirements.txt`` environment files. Parameters ---------- model - A fitted darts ``ForecastingModel`` instance. + A fitted Darts ``ForecastingModel`` instance. path Local filesystem path where the model directory will be created. conda_env @@ -168,7 +170,7 @@ def save_model( ----- Signature and input_example params are currently not supported, as they are used to support serving and input validation in the MLflow pyfunc flavor, - which is not implemented for darts models. They are accepted as params for + which is not implemented for Darts models. They are accepted as params for simplifying potential future extensibility, and to keep in line with MLflow API conventions. """ @@ -244,7 +246,7 @@ def load_model( dst_path: str | None = None, **kwargs, ) -> ForecastingModel: - """Load a darts model from an MLflow model URI. + """Load a Darts model from an MLflow model URI. Parameters ---------- @@ -255,12 +257,12 @@ def load_model( Optional local path for downloading remote artifacts. **kwargs Additional keyword arguments forwarded to the model's ``load()`` method - (e.g. ``map_location`` for Torch models). + (e.g. ``map_location`` for a `TorchForecastingModel`). Returns ------- ForecastingModel - The loaded darts forecasting model. + The loaded Darts forecasting model. """ local_path = _download_artifact_from_uri( artifact_uri=model_uri, output_path=dst_path @@ -286,11 +288,11 @@ def load_model( return model_cls.load(str(model_path), **kwargs) -def log_model(model, **kwargs): - """Log a darts model to the current MLflow run, using the darts MLflow flavor. +def log_model(model: ForecastingModel, **kwargs): + """Log a Darts model to the current MLflow run, using the Darts MLflow flavor. This is a thin wrapper around ``mlflow.models.Model.log()`` that supplies - the darts flavor for saving/loading; every other argument is forwarded + the Darts flavor for saving/loading; every other argument is forwarded as-is. See the `MLflow documentation `_ for the full list of accepted parameters (e.g. ``name``, @@ -300,7 +302,7 @@ def log_model(model, **kwargs): Parameters ---------- model - A fitted darts ``ForecastingModel`` instance. + A fitted Darts ``ForecastingModel`` instance. **kwargs Forwarded to ``mlflow.models.Model.log()``. Use ``name`` to set the run-relative artifact path. ``artifact_path`` parameter is deprecated @@ -316,7 +318,7 @@ def log_model(model, **kwargs): ----- ``signature`` and ``input_example`` are currently not supported, as they are used to support serving and input validation in the MLflow pyfunc - flavor, which is not implemented for darts models. + flavor, which is not implemented for Darts models. """ # MLflow still requires "artifact_path" to be provided (it has no default), # but it is deprecated in favour of "name". Accept it via kwargs for @@ -339,24 +341,24 @@ def autolog( disable: bool = False, silent: bool = False, ) -> None: - """Enable (or disable) automatic MLflow logging for darts models. - - When enabled, every call to ``model.fit()`` on any darts forecasting model - will automatically: - - 1. Start an MLflow run (or reuse the currently active one). - 2. Log model creation parameters (``model.model_params``), both as MLflow - params and as a ``model_params.json`` artifact. - 3. Log covariate usage information (past, future, and static covariates). - 4. Log the result of any darts metric call made inside an active MLflow - run. Repeated calls overwrite the previous value. - 5. For PyTorch-based models: leverage ``mlflow.pytorch.autolog()`` to - automatically log per-epoch training and validation metrics. - 6. When ``log_models=True``: log the trained model artifact at the end of - training (default ``False``). - 7. Patch ``backtest()`` to log evaluation metrics under ``backtest_*`` keys. - 8. Patch ``historical_forecasts()`` so that its internal per-window - ``fit()`` calls don't each spawn their own logging. + """Enable (or disable) automatic MLflow logging for Darts. + + When enabled, the following functionalities emit detailed logs: + + - Calling ``ForecastingModel.fit()``: + - Starts an MLflow run (or reuses the currently active one). + - Logs model creation parameters (``model.model_params``), both as MLflow + params and as a ``model_params.json`` artifact. + - Logs covariate usage information (past, future, and static covariates). + - Stores the trained model artifact when ``log_models=True`` (default: + ``False``). + - Logs per-epoch training and validation metrics for PyTorch-based models. + - Calling any Darts metric: + - Logs the result of that metric call as an MLflow metric. More information + in the notes below. + - Calling ``ForecastingModel.backtest()``: + - Logs all evaluation metrics under ``backtest_*`` keys. More information + in the notes below. .. note:: @@ -364,23 +366,32 @@ def autolog( ``{metric_name}{component}{quantile_or_label}``, where each part is included only when the corresponding axis is present: - * ``metric_name`` – the metric function name, or the ``name`` keyword - argument when provided (it overrides only this token). - * ``component`` – the component name when ``component_reduction=None``. - * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. + - ``metric_name`` – the metric function name, or the ``name`` metric + keyword argument when provided. + - ``component`` – the component name when ``component_reduction=None``. + - ``quantile_or_label``, e.g.: + – ``_q0.500`` for quantile metrics with keyword argument ``q=[0.5]`` + - ``_qi_80.000`` for quantile interval metrics with keyword argument + ``q_interval=[(0.1, 0.9)]`` (80% interval between quantiles 0.1 and + 0.9). + - ``_label1`` for classification metrics with keyword argument + ``labels`` when ``label_reduction=None``. + + Per-timestep metrics (``time_reduction=None``) are charted across the + MLflow ``step``. When ``series_reduction`` is set on a metric call, results are already aggregated across series inside the metric itself, so the cross-series aggregation described below does not apply. - Per-timestep results (``time_reduction=None``) are charted across the - MLflow ``step``. For a list of series the logged value is - ``agg_func`` applied over series, and the full per-series breakdown - for every metric/backtest call in the run is appended to a single - ``metrics_per_series.json`` table artifact. When components are - preserved (``component_reduction=None``), all series scored together - must have the same number of components; names are taken from the - first series. + For a list of series, the logged metric is aggregated over all series + using ``agg_func``. The detailed per-series metrics / backtest metrics + are logged under a single ``metrics_per_series.json`` table + artifact. + + When components are preserved (``component_reduction=None``), all + series scored together must have the same number of components; names + are taken from the first series. Parameters ---------- @@ -390,7 +401,7 @@ def autolog( log_params If ``True`` (default), log model creation parameters. log_metrics - If ``True`` (default), log the result of any darts metric call made + If ``True`` (default), log the result of any Darts metric call made inside an active MLflow run. log_torch_metrics If ``True`` (default), enable ``mlflow.pytorch.autolog(log_models=False)`` @@ -415,7 +426,7 @@ def autolog( # mlflow.sklearn, which exposes a private, undecorated _autolog(flavor_name=...) # that other flavors (e.g. xgboost) call to tag its patches under their own # integration name for cleanup, mlflow.pytorch has no such hook: its autolog() - # hardcodes its own patches under "pytorch", so darts can't fold pytorch's + # hardcodes its own patches under "pytorch", so Darts can't fold pytorch's # patch lifecycle into its own and must call mlflow.pytorch.autolog() directly. if log_torch_metrics and not disable: try: @@ -487,7 +498,7 @@ def _autolog( ) -> None: """Internal autolog implementation decorated with ``@autologging_integration``. - Handles patching of darts ``ForecastingModel.fit()`` and metric functions. + Handles patching of Darts ``ForecastingModel.fit()`` and metric functions. The ``mlflow.pytorch.autolog`` coordination is handled by the public ``autolog()`` wrapper because the decorator short-circuits on ``disable=True``. @@ -549,7 +560,7 @@ def _patched_fit(original, self, *args, **kwargs): fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments _log_covariate_info( self, - series=fit_args.get("series"), + series=fit_args["series"], past_covariates=fit_args.get("past_covariates"), future_covariates=fit_args.get("future_covariates"), ) @@ -619,10 +630,10 @@ def _patched_backtest(original, self, *args, **kwargs): autologging_client = MlflowAutologgingQueueingClient() _log_backtest_metrics( - autologging_client, - active_run.info.run_id, - result, - backtest_args, + autologging_client=autologging_client, + run_id=active_run.info.run_id, + result=result, + backtest_args=backtest_args, agg_func=agg_func, ) autologging_client.flush(synchronous=False).await_completion() @@ -658,7 +669,7 @@ def _patched_backtest(original, self, *args, **kwargs): def get_default_pip_requirements(): - """Return the default pip requirements for logging a darts model. + """Return the default pip requirements for logging a Darts model. Returns ------- @@ -670,7 +681,7 @@ def get_default_pip_requirements(): def get_default_conda_env(): - """Return a default conda environment dict for a darts model. + """Return a default conda environment dict for a Darts model. Returns ------- @@ -703,7 +714,12 @@ def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: } -def _log_covariate_info(model, series, past_covariates, future_covariates) -> None: +def _log_covariate_info( + model: ForecastingModel, + series: TimeSeriesLike, + past_covariates: TimeSeriesLike | None, + future_covariates: TimeSeriesLike | None, +) -> None: """Log covariate usage information to MLflow. Extracts information about past, future, and static covariates used during @@ -776,7 +792,9 @@ def _is_torch_model(model) -> bool: return TORCH_AVAILABLE and isinstance(model, TorchForecastingModel) -def _extract_covariate_metadata(uses: bool, single_cov, names_attr: str) -> dict: +def _extract_covariate_metadata( + uses: bool, single_cov: TimeSeries | pd.DataFrame | None, names_attr: str +) -> dict: """Extract metadata for a single covariate type from its (already singular) value. @@ -861,7 +879,7 @@ def _log_backtest_metrics( """Log backtest metric result(s) to MLflow. Reshapes each per-series result to a canonical ``(W, T, C, M)`` layout - (windows, timesteps, components × quantiles, metrics) inferred from the + (windows, timesteps, components x quantiles, metrics) inferred from the metric signatures and ``backtest_args``, logging every cell under a descriptive key with the time axis (or window axis when time is reduced) mapped to the MLflow ``step``. A metric's ``name`` entry in @@ -870,18 +888,18 @@ def _log_backtest_metrics( Shape inference respects all kwargs that affect output dimensions: - * ``time_reduction`` – collapses the time axis (``T=1``). - * ``component_reduction`` – collapses the component axis (``C=1``). - * ``series_reduction`` – if other than ``None``, windows are already aggregated + - ``time_reduction`` – collapses the time axis (``T=1``). + - ``component_reduction`` – collapses the component axis (``C=1``). + - ``series_reduction`` – if other than ``None``, windows are already aggregated inside the metric, so ``W=1`` regardless of ``backtest.reduction``. - * ``q`` / ``q_interval`` – expand the component axis with one entry per + - ``q`` / ``q_interval`` – expand the component axis with one entry per quantile / interval. - * ``labels`` - expand each component with one entry per label along + - ``labels`` - expand each component with one entry per label along the component axis. - * ``label_reduction`` – collapses the labels along the component axis. + - ``label_reduction`` – collapses the labels along the component axis. value; ``labels`` only restricts which classes are scored. - * ``reduction=None`` – no aggregation across windows -> one value per window. - * ``last_points_only`` – collapses all windows into one TimeSeries before scoring, + - ``reduction=None`` – no aggregation across windows -> one value per window. + - ``last_points_only`` – collapses all windows into one TimeSeries before scoring, so there is effectively only one window regardless of reduction. When two metrics have incompatible axis layouts (different @@ -981,7 +999,7 @@ def _log_backtest_metrics( last_points_only = backtest_args.get("last_points_only", False) # if last_points_only is True, has_windows will be False, so fc_hzn is not needed - if historical_forecasts and not last_points_only: + if historical_forecasts is not None and not last_points_only: first_series_hf = ( historical_forecasts if get_series_seq_type(series) == SeriesType.SINGLE @@ -998,7 +1016,9 @@ def _log_backtest_metrics( raise_log( ValueError( "Backtest metric logging failed: all series must have the same " - f"number of components, got {sorted(n_components)}." + f"number of components, got {sorted(n_components)}. Consider " + f"setting a metric `component_reduction`, or make sure all series " + f"have the same number of components." ) ) @@ -1023,15 +1043,15 @@ def _log_backtest_metrics( else: # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() - # c_size = components × quantiles/intervals/labels per component - c_size = (series_seq[0].n_components if has_comp_axis else 1) * axis_size + # c_size = components x quantiles/intervals/labels per component + c_size = (len(comps) if has_comp_axis else 1) * axis_size # base_keys[m][c]: sanitized key without the optional window suffix base_keys = [] for m, metric_name in enumerate(metric_names): axis_labels = metric_axes[m][2] keys_m = [] for c in range(c_size): - # c is a flat index into the (n_components × axis_size) C axis: + # c is a flat index into the (n_components x axis_size) C axis: # c = comp_i * axis_size + axis_idx component_index, axis_idx = divmod(c, axis_size) comp_part = ( @@ -1156,7 +1176,7 @@ def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: Parameters ---------- metric - A darts metric callable. + A Darts metric callable. metric_kwargs Keyword arguments that will be forwarded to ``metric``. @@ -1235,7 +1255,7 @@ def _log_metric_result( """Log a metric result to the active MLflow run. Reshapes each per-series result into a canonical ``(T, C)`` layout - (timesteps, components × quantiles/intervals/labels) inferred from the + (timesteps, components x quantiles/intervals/labels) inferred from the metric signature and call kwargs by ``_infer_metric_axes``, logging every cell under a descriptive key with the time axis mapped to the MLflow ``step``. This mirrors ``_log_backtest_metrics`` (without the @@ -1249,8 +1269,8 @@ def _log_metric_result( where each optional part is included only when the corresponding axis is present: - * ``component`` – ``_{component_name}`` when ``has_comp_axis``. - * ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. + - ``component`` – ``_{component_name}`` when ``has_comp_axis``. + - ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. When more than one series is scored, the logged value is ``agg_func`` applied over series for each cell, and the granular per-series breakdown @@ -1258,6 +1278,9 @@ def _log_metric_result( (shared with ``_log_backtest_metrics``). For a single series the aggregate is just the value itself and no artifact is written. + TODO: improve this, it's about predictions of different or different + intersection lengths between actual and pred (from the `Raises` + below, it sounds even that this wouldn't be supported?) Series of different lengths are assumed to share the same end date, so the time axis is aligned from the end rather than the start: a shorter series lines up on its last value instead of its first. @@ -1318,13 +1341,14 @@ def _log_metric_result( ) ) + # TODO: a lot of this seems duplicated from the backtest logic; improve # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() - # c_size = components × quantiles/intervals/labels per component - c_size = (series_seq[0].n_components if has_comp_axis else 1) * axis_size + # c_size = components x quantiles/intervals/labels per component + c_size = (len(comps) if has_comp_axis else 1) * axis_size keys = [] for c in range(c_size): - # c is a flat index into the (n_components × axis_size) C axis: + # c is a flat index into the (n_components x axis_size) C axis: # c = comp_i * axis_size + axis_idx component_index, axis_idx = divmod(c, axis_size) comp_part = ( @@ -1403,6 +1427,7 @@ def _log_metric_result( _log_per_series_table(rows) +# TODO: (does the below TODO still apply? we only support logging under an active run I thought) # TODO: To log metrics post-fitting, only patching the metric methods may not be enough. # This is becuase `model.fit()` method would terminate the active MLflow run at the end of training, # so any metric calls made after that would not be logged. @@ -1417,7 +1442,7 @@ def _log_metric_result( def _mlflow_metric_callback(func, result, args, kwargs) -> None: """Metric callback registered with ``darts.metrics.utils`` for autologging. - Invoked by ``multi_ts_support`` (the outermost decorator on every darts + Invoked by ``multi_ts_support`` (the outermost decorator on every Darts metric) after every top-level metric call, so it fires regardless of how the metric was imported. It is not invoked for internal metric-to-metric calls (e.g. ``rmse`` calling ``mse`` internally via ``_get_wrapped_metric``), @@ -1431,10 +1456,10 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: where: - * ``metric_name`` – the metric function name, or the ``name`` keyword + - ``metric_name`` – the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). - * ``component`` – ``_{component_name}`` when ``component_reduction=None``. - * ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, + - ``component`` – ``_{component_name}`` when ``component_reduction=None``. + - ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, ``_qi_80.000``, ``_label1``) when applicable. When the input is a ``Sequence[TimeSeries]`` with more than one series, the @@ -1448,7 +1473,7 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: Parameters ---------- func - The darts metric function that was called (used for its name and + The Darts metric function that was called (used for its name and signature). result The metric's return value. From 9568b3d8a9b5fe9aebebae0ff418cd65ee5bef2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 10:15:22 +0200 Subject: [PATCH 125/154] feat: docs cleanup --- INSTALL.md | 6 ++++++ darts/utils/mlflow.py | 15 +++++++++++---- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/INSTALL.md b/INSTALL.md index f52f9c2708..302c7d7421 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -22,6 +22,12 @@ Some models have additional dependencies that are not included in the `all` inst | `NeuralForecastModel` | neuralforecast>=3.0.0 | | `TiRexModel` | tirex-ts>=1.4.0 | +Some optional integrations also require additional dependencies: + +| Integration | Dependencies | +|-------------------------|--------------| +| `darts.utils.mlflow` | mlflow>=3.0 | + ## From conda-forge Create a conda environment (e.g., for Python 3.11): diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 91fcc36559..e672d62e19 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -16,8 +16,9 @@ See the `MLflow quickstart example `_ for an end-to-end walkthrough. -References: -https://github.com/sktime/sktime/blob/main/sktime/utils/mlflow_sktime.py +To keep auto-logged metrics comparable across runs, use the same evaluation +time frame, forecast horizon, and evaluation start date for every +``backtest()`` / metric call you intend to compare. """ import inspect @@ -37,8 +38,9 @@ except ImportError: raise_log( ImportError( - "MLflow is required for `darts.utils.mlflow`. Install it with `pip" - " install mlflow`." + "The `mlflow` module could not be imported. To enable MLflow support " + "in Darts, follow the detailed instructions in the installation guide: " + "https://github.com/unit8co/darts/blob/master/INSTALL.md" ) ) @@ -393,6 +395,11 @@ def autolog( series scored together must have the same number of components; names are taken from the first series. + Metric values are only comparable across runs when the evaluation + settings match. Use the same evaluation time frame, forecast horizon, + and evaluation start date for every ``backtest()`` / metric call you + intend to compare. + Parameters ---------- log_models From 1b3ac1e31e88f3c1ce40f46e89c5411e3c51ecf5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 10:34:50 +0200 Subject: [PATCH 126/154] docs: active run clarification --- darts/utils/mlflow.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index e672d62e19..4a31536dc8 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -347,18 +347,20 @@ def autolog( When enabled, the following functionalities emit detailed logs: - - Calling ``ForecastingModel.fit()``: - - Starts an MLflow run (or reuses the currently active one). + - Calling ``ForecastingModel.fit()`` inside an active MLflow run (e.g. within + ``with mlflow.start_run():``); does nothing if no run is active: - Logs model creation parameters (``model.model_params``), both as MLflow params and as a ``model_params.json`` artifact. - Logs covariate usage information (past, future, and static covariates). - Stores the trained model artifact when ``log_models=True`` (default: ``False``). - Logs per-epoch training and validation metrics for PyTorch-based models. - - Calling any Darts metric: + - Calling any Darts metric inside an active MLflow run; does nothing if no + run is active: - Logs the result of that metric call as an MLflow metric. More information in the notes below. - - Calling ``ForecastingModel.backtest()``: + - Calling ``ForecastingModel.backtest()`` inside an active MLflow run; does + nothing if no run is active: - Logs all evaluation metrics under ``backtest_*`` keys. More information in the notes below. @@ -606,8 +608,10 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): """Suppress per-iteration fit() autologging during historical_forecasts. Sets a thread-local flag so _patched_fit skips autologging for the - internal fit() calls. The outer safe_patch() on - historical_forecasts itself provides a single managed run. + internal fit() calls, so that at most the single top-level call site + (this patch, or an enclosing backtest()) logs anything. This patch + itself does not start or otherwise manage an MLflow run; it relies on + whatever run (if any) is already active. """ _autolog_state.in_historical_forecasts = True try: From efb6b9daa13aabcffd2e7ecbed4ad060a253786c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 10:57:09 +0200 Subject: [PATCH 127/154] feat: log target series info and encoder covs --- darts/tests/optional_deps/test_mlflow.py | 74 +++++++++++++++--------- darts/utils/mlflow.py | 61 ++++++++++++------- 2 files changed, 87 insertions(+), 48 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 4c35ab1dd8..7c60fca582 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -378,10 +378,9 @@ def assert_metric(history, key): assert autologging_is_disabled("pytorch") - def test_autolog_covariate_info_single_series( - self, mlflow_tracking, autolog_context - ): - """The covariates.json artifact reports usage, count, and names for a + def test_autolog_series_info_single_series(self, mlflow_tracking, autolog_context): + """The series_info.json artifact reports the target series' component + names/count, plus covariate usage, count, and names, for a single-series fit.""" with autolog_context(): with mlflow.start_run() as run: @@ -390,21 +389,21 @@ def test_autolog_covariate_info_single_series( self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40] ) - covariates = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/covariates.json" + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" ) - assert covariates["past_covariates"]["used"] is True - assert covariates["past_covariates"]["count"] == 1 + assert series_info["series"]["count"] == self.ts_univariate.n_components + assert series_info["series"]["names"] == self.ts_univariate.components.tolist() + assert series_info["past_covariates"]["used"] is True + assert series_info["past_covariates"]["count"] == 1 assert ( - covariates["past_covariates"]["names"] + series_info["past_covariates"]["names"] == self.ts_past_cov.components.tolist() ) - assert covariates["future_covariates"]["used"] is False - assert covariates["static_covariates"]["used"] is False + assert series_info["future_covariates"]["used"] is False + assert series_info["static_covariates"]["used"] is False - def test_autolog_covariate_info_multi_series( - self, mlflow_tracking, autolog_context - ): + def test_autolog_series_info_multi_series(self, mlflow_tracking, autolog_context): """Fitting on a list of series doesn't leave past_covariates unreported: `model.past_covariate_series` stays None for a multi-series fit, so the info must come from the actual `fit()` call arguments instead.""" @@ -415,17 +414,40 @@ def test_autolog_covariate_info_multi_series( model = LinearRegressionModel(lags=5, lags_past_covariates=3) model.fit(series, past_covariates=past_covs) - covariates = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/covariates.json" + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" ) - assert covariates["past_covariates"]["used"] is True - assert covariates["past_covariates"]["count"] == 1 + assert series_info["past_covariates"]["used"] is True + assert series_info["past_covariates"]["count"] == 1 assert ( - covariates["past_covariates"]["names"] + series_info["past_covariates"]["names"] == self.ts_past_cov.components.tolist() ) - def test_autolog_covariate_info_static_is_global( + def test_autolog_series_info_add_encoders(self, mlflow_tracking, autolog_context): + """Covariates generated purely via `add_encoders` (no explicit + covariate argument passed to `fit()`) are still reported in + `series_info.json`.""" + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel( + lags=5, + lags_future_covariates=[0], + add_encoders={"datetime_attribute": {"future": ["month"]}}, + ) + model.fit(self.ts_univariate[:40]) + + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" + ) + expected_names = model.encoders.future_components.tolist() + assert expected_names # sanity check: encoders actually generated something + assert series_info["future_covariates"]["used"] is True + assert series_info["future_covariates"]["count"] == len(expected_names) + assert series_info["future_covariates"]["names"] == expected_names + assert series_info["past_covariates"]["used"] is False + + def test_autolog_series_info_static_is_global( self, mlflow_tracking, autolog_context ): """`is_global` is based on row count vs. the number of series @@ -437,10 +459,10 @@ def test_autolog_covariate_info_static_is_global( with autolog_context(): with mlflow.start_run() as run: LinearRegressionModel(lags=5).fit(global_target) - covariates = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/covariates.json" + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" ) - assert covariates["static_covariates"]["is_global"] is True + assert series_info["static_covariates"]["is_global"] is True # one row per component (2 components, 2 rows) -> component-specific per_component_target = self.ts_multivariate.with_static_covariates( @@ -449,10 +471,10 @@ def test_autolog_covariate_info_static_is_global( with autolog_context(): with mlflow.start_run() as run: LinearRegressionModel(lags=5).fit(per_component_target) - covariates = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/covariates.json" + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" ) - assert covariates["static_covariates"]["is_global"] is False + assert series_info["static_covariates"]["is_global"] is False def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 4a31536dc8..dbfd5f4e59 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -6,7 +6,7 @@ and logging any Darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) to MLflow, as well as automatic logging (``autolog()``) of: -- Model parameters and data metadata: The model creation parameters and covariate usage information. +- Model parameters and data metadata: The model creation parameters, target series, and covariate usage information. - Model storage: The trained model artifact after each ``fit()`` call when ``log_models=True`` (default ``False``). - Metrics: - The score for each metric called inside an active MLflow run. @@ -351,7 +351,8 @@ def autolog( ``with mlflow.start_run():``); does nothing if no run is active: - Logs model creation parameters (``model.model_params``), both as MLflow params and as a ``model_params.json`` artifact. - - Logs covariate usage information (past, future, and static covariates). + - Logs target series info and covariate usage information (past, future, + and static covariates) as a ``series_info.json`` artifact. - Stores the trained model artifact when ``log_models=True`` (default: ``False``). - Logs per-epoch training and validation metrics for PyTorch-based models. @@ -567,7 +568,7 @@ def _patched_fit(original, self, *args, **kwargs): autologging_client.log_params(run_id=run_id, params=self.model_params) mlflow.log_dict(self.model_params, "model_params.json") fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments - _log_covariate_info( + _log_series_info( self, series=fit_args["series"], past_covariates=fit_args.get("past_covariates"), @@ -725,22 +726,24 @@ def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: } -def _log_covariate_info( +def _log_series_info( model: ForecastingModel, series: TimeSeriesLike, past_covariates: TimeSeriesLike | None, future_covariates: TimeSeriesLike | None, ) -> None: - """Log covariate usage information to MLflow. + """Log target series and covariate usage information to MLflow. - Extracts information about past, future, and static covariates used during - training and logs them as a JSON artifact for easy - filtering, comparison, and documentation. + Extracts information about the target series, and about past, future, + and static covariates used during training and logs them as a JSON + artifact for easy filtering, comparison, and documentation. - Logs three types of information: - - Tags: Boolean flags for filtering (e.g., "uses_past_covariates") - - Parameters: Feature counts and names (truncated by MLflow) - - Artifact: Complete covariate metadata as JSON file + Logs: + - Target series: component count and names + - Past / future covariates: usage, count, and names, including both + explicitly-passed covariates and any generated by ``add_encoders`` + - Static covariates: usage, count, names, and whether they are global + - Artifact: complete metadata as ``series_info.json`` Parameters ---------- @@ -756,35 +759,41 @@ def _log_covariate_info( The future covariate covariate argument passed to ``fit()``, or ``None``. """ - covariate_info = { + first_series = get_single_series(series) + series_info = { + "series": { + "count": first_series.n_components, + "names": first_series.components.tolist(), + }, "past_covariates": _extract_covariate_metadata( model.uses_past_covariates, get_single_series(past_covariates), "components", + encoded_names=model.encoders.past_components, ), "future_covariates": _extract_covariate_metadata( model.uses_future_covariates, get_single_series(future_covariates), "components", + encoded_names=model.encoders.future_components, ), } - first_series = get_single_series(series) static_covariates = ( first_series.static_covariates if first_series is not None else None ) - covariate_info["static_covariates"] = _extract_covariate_metadata( + series_info["static_covariates"] = _extract_covariate_metadata( model.uses_static_covariates, static_covariates, "columns" ) if model.uses_static_covariates and static_covariates is not None: # static covariates are global (one shared row) unless there is one row # per series component, in which case they are component-specific - covariate_info["static_covariates"]["is_global"] = ( + series_info["static_covariates"]["is_global"] = ( len(static_covariates) != first_series.n_components ) # log complete information as JSON artifact - mlflow.log_dict(covariate_info, "covariates.json") + mlflow.log_dict(series_info, "series_info.json") def _is_torch_model(model) -> bool: @@ -804,7 +813,10 @@ def _is_torch_model(model) -> bool: def _extract_covariate_metadata( - uses: bool, single_cov: TimeSeries | pd.DataFrame | None, names_attr: str + uses: bool, + single_cov: TimeSeries | pd.DataFrame | None, + names_attr: str, + encoded_names: pd.Index | list[str] | None = None, ) -> dict: """Extract metadata for a single covariate type from its (already singular) value. @@ -819,6 +831,10 @@ def _extract_covariate_metadata( names_attr : str Attribute holding the feature names ("components" for a ``TimeSeries``, "columns" for a static-covariates ``DataFrame``). + encoded_names + Additional covariate names generated by encoders (``add_encoders``), + appended to the names extracted from ``single_cov``. Ignored when + ``uses`` is ``False``. Returns ------- @@ -829,10 +845,11 @@ def _extract_covariate_metadata( if uses: info["used"] = True - if single_cov is not None: - names = getattr(single_cov, names_attr).tolist() - info["names"] = names - info["count"] = len(names) + names = list(getattr(single_cov, names_attr)) if single_cov is not None else [] + if encoded_names is not None: + names = names + list(encoded_names) + info["names"] = names + info["count"] = len(names) return info From f4840c540bdd1ce3e551655c651f92932b434518 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 11:03:15 +0200 Subject: [PATCH 128/154] chore: remove redudnant comment --- darts/utils/mlflow.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index dbfd5f4e59..ebf50c9a08 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1455,18 +1455,6 @@ def _log_metric_result( _log_per_series_table(rows) -# TODO: (does the below TODO still apply? we only support logging under an active run I thought) -# TODO: To log metrics post-fitting, only patching the metric methods may not be enough. -# This is becuase `model.fit()` method would terminate the active MLflow run at the end of training, -# so any metric calls made after that would not be logged. -# To address this, we need to implement three things: -# 1. Implement a singleton `_AutologgingMetricsManager` (`mlflow.sklearn`) to maintain a mapping between fitted -# models and their prediction outputs. -# 2. Patch the `model.predict()` method to create a mapping between the model (run_id) and prediction output. -# 3. Patch the metric functions to find the model (run_id) from the input series, then log the metrics to -# the corresponding run. -# This way, even if the metric calls are made after `fit()` has terminated the active run, we can still log -# the metrics to the correct run. def _mlflow_metric_callback(func, result, args, kwargs) -> None: """Metric callback registered with ``darts.metrics.utils`` for autologging. From e41595724f8c75ccaeb93231d5bd0698b1e457b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 15:01:38 +0200 Subject: [PATCH 129/154] feat: support logging for historical forecasts retrain=True without prior fit --- darts/tests/optional_deps/test_mlflow.py | 155 ++++++++++++++++++++ darts/utils/mlflow.py | 177 +++++++++++++++++++---- 2 files changed, 301 insertions(+), 31 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 7c60fca582..b447a28fbd 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -476,6 +476,161 @@ def test_autolog_series_info_static_is_global( ) assert series_info["static_covariates"]["is_global"] is False + def test_autolog_historical_forecasts_series_info_covariates( + self, mlflow_tracking, autolog_context + ): + """HF without a prior fit() still reports explicit covariates and static + covariates in series_info / tags (outer model stays unfitted).""" + target = self.ts_univariate.with_static_covariates( + pd.DataFrame({"static_feat": [1.0]}) + ) + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.historical_forecasts( + series=target, + past_covariates=self.ts_past_cov, + forecast_horizon=1, + retrain=True, + start=0.5, + ) + + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" + ) + assert series_info["past_covariates"]["used"] is True + assert ( + series_info["past_covariates"]["names"] + == self.ts_past_cov.components.tolist() + ) + assert series_info["static_covariates"]["used"] is True + assert series_info["static_covariates"]["names"] == ["static_feat"] + tags = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.tags + assert tags["model_uses_past_covariates"] == "True" + assert tags["model_uses_static_covariates"] == "True" + + def test_autolog_historical_forecasts_series_info_add_encoders( + self, mlflow_tracking, autolog_context + ): + """HF with add_encoders (no explicit cov args) marks future covariates + as used even though the outer model remains unfitted.""" + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel( + lags=5, + lags_future_covariates=[0], + add_encoders={"datetime_attribute": {"future": ["month"]}}, + ) + model.historical_forecasts( + series=self.ts_univariate, + forecast_horizon=1, + retrain=True, + start=0.5, + ) + + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" + ) + assert series_info["future_covariates"]["used"] is True + tags = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.tags + assert tags["model_uses_future_covariates"] == "True" + + def test_autolog_backtest_series_info_covariates( + self, mlflow_tracking, autolog_context + ): + """backtest(retrain=True) without a prior fit() reports covariates via + the internal historical_forecasts path.""" + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5, lags_past_covariates=3) + model.backtest( + series=self.ts_univariate, + past_covariates=self.ts_past_cov, + forecast_horizon=1, + retrain=True, + start=0.5, + metric=dm.mae, + ) + + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" + ) + assert series_info["past_covariates"]["used"] is True + assert ( + series_info["past_covariates"]["names"] + == self.ts_past_cov.components.tolist() + ) + + def test_autolog_historical_forecasts_logs_model_setup( + self, mlflow_tracking, autolog_context + ): + """historical_forecasts(retrain=True) without a prior fit() still logs + model params and series_info (but not the model artifact).""" + with autolog_context(): + with mlflow.start_run() as run: + model = NaiveSeasonal(K=1) + model.historical_forecasts( + series=self.ts_univariate, forecast_horizon=1, retrain=True + ) + + params = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/model_params.json" + ) + assert params["K"] == 1 + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" + ) + assert series_info["series"]["names"] == self.ts_univariate.components.tolist() + client = mlflow.tracking.MlflowClient() + artifact_paths = [a.path for a in client.list_artifacts(run.info.run_id)] + assert "model" not in artifact_paths + assert ( + client.get_run(run.info.run_id).data.tags["model_class"] == "NaiveSeasonal" + ) + + def test_autolog_historical_forecasts_retrain_false_skips_model_setup( + self, mlflow_tracking, autolog_context + ): + """historical_forecasts(retrain=False) does not log model setup.""" + model = LinearRegressionModel(lags=5) + model.fit(self.ts_univariate[:40]) + with autolog_context(): + with mlflow.start_run() as run: + model.historical_forecasts( + series=self.ts_univariate, + forecast_horizon=1, + retrain=False, + start=0.5, + ) + + client = mlflow.tracking.MlflowClient() + artifact_paths = [a.path for a in client.list_artifacts(run.info.run_id)] + assert "model_params.json" not in artifact_paths + assert "series_info.json" not in artifact_paths + + def test_autolog_historical_forecasts_overwrites_fit_setup( + self, mlflow_tracking, autolog_context + ): + """fit() then historical_forecasts(retrain=True) in the same run + overwrites model_params / series_info with the HF call's series.""" + with autolog_context(): + with mlflow.start_run() as run: + model = LinearRegressionModel(lags=5) + model.fit(self.ts_univariate[:30]) + model.historical_forecasts( + series=self.ts_multivariate, + forecast_horizon=1, + retrain=True, + start=0.5, + ) + + series_info = mlflow.artifacts.load_dict( + f"runs:/{run.info.run_id}/series_info.json" + ) + assert ( + series_info["series"]["names"] == self.ts_multivariate.components.tolist() + ) + def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" # create multivariate target with static covariates diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index ebf50c9a08..9de1944688 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -356,6 +356,13 @@ def autolog( - Stores the trained model artifact when ``log_models=True`` (default: ``False``). - Logs per-epoch training and validation metrics for PyTorch-based models. + - Calling ``ForecastingModel.historical_forecasts(retrain=True)`` inside an + active MLflow run; does nothing if no run is active or ``retrain`` is not + ``True``: + - Logs the same model creation parameters and ``series_info.json`` as + ``fit()`` (overwriting any prior ``fit()`` artifacts in the same run). + - Does not log the trained model artifact; call ``log_model()`` manually + if needed. - Calling any Darts metric inside an active MLflow run; does nothing if no run is active: - Logs the result of that metric call as an MLflow metric. More information @@ -560,20 +567,16 @@ def _patched_fit(original, self, *args, **kwargs): return result run_id = active_run.info.run_id - # Set tags to identify the model class and relevant information - autologging_client.set_tags(run_id=run_id, tags=_get_model_info_tags(self)) - - if log_params: - # Log the parameters for model creation - autologging_client.log_params(run_id=run_id, params=self.model_params) - mlflow.log_dict(self.model_params, "model_params.json") - fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments - _log_series_info( - self, - series=fit_args["series"], - past_covariates=fit_args.get("past_covariates"), - future_covariates=fit_args.get("future_covariates"), - ) + fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments + _log_model_setup( + self, + autologging_client, + run_id, + series=fit_args["series"], + past_covariates=fit_args.get("past_covariates"), + future_covariates=fit_args.get("future_covariates"), + log_params=log_params, + ) param_logging_ops = autologging_client.flush(synchronous=False) @@ -606,20 +609,45 @@ def _patched_fit(original, self, *args, **kwargs): return result def _patched_historical_forecasts(original, self, *args, **kwargs): - """Suppress per-iteration fit() autologging during historical_forecasts. - - Sets a thread-local flag so _patched_fit skips autologging for the - internal fit() calls, so that at most the single top-level call site - (this patch, or an enclosing backtest()) logs anything. This patch - itself does not start or otherwise manage an MLflow run; it relies on - whatever run (if any) is already active. + """Suppress per-iteration fit() autologging; log model setup once when + ``retrain=True``. + + Sets a thread-local flag so ``_patched_fit`` skips autologging for the + internal ``fit()`` calls. When ``retrain is True`` and an MLflow run is + active, logs model tags, creation parameters, and series info once after + the call (overwriting any prior ``fit()`` artifacts in the same run). + Does not start a run and does not log the trained model artifact. """ _autolog_state.in_historical_forecasts = True try: - return original(self, *args, **kwargs) + result = original(self, *args, **kwargs) finally: _autolog_state.in_historical_forecasts = False + active_run = mlflow.active_run() + if active_run is None: + return result + + bound = inspect.signature(ForecastingModel.historical_forecasts).bind( + self, *args, **kwargs + ) + bound.apply_defaults() + if bound.arguments["retrain"] is not True: + return result + + autologging_client = MlflowAutologgingQueueingClient() + _log_model_setup( + self, + autologging_client, + active_run.info.run_id, + series=bound.arguments["series"], + past_covariates=bound.arguments.get("past_covariates"), + future_covariates=bound.arguments.get("future_covariates"), + log_params=log_params, + ) + autologging_client.flush(synchronous=False).await_completion() + return result + def _patched_backtest(original, self, *args, **kwargs): """Wrap ``backtest`` to log metric result(s) to the active MLflow run. @@ -661,7 +689,8 @@ def _patched_backtest(original, self, *args, **kwargs): ) # patch `historical_forecasts()` for all forecasting models so that the - # N internal fit() calls don't each spawn their own MLflow run + # N internal fit() calls don't each log, and so that retrain=True calls + # log model setup once for _, cls in _get_forecasting_models(): safe_patch( FLAVOR_NAME, @@ -705,11 +734,59 @@ def get_default_conda_env(): ) -def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: +def _infer_covariate_usage( + model: ForecastingModel, + series: TimeSeriesLike, + past_covariates: TimeSeriesLike | None, + future_covariates: TimeSeriesLike | None, +) -> tuple[bool, bool, bool]: + """Infer past/future/static covariate usage from model state and call args. + + After ``historical_forecasts(retrain=True)`` the outer model is still + unfitted (training happens on internal copies), so ``model.uses_*`` stays + ``False``. Fall back to call args / ``add_encoders`` / static covariates on + ``series``, gated by ``supports_*`` / ``considers_static_covariates``. + """ + # encoder keys like "datetime_attribute" map to {"past": ..., "future": ...}; + # non-dict values ("tz", "transformer") are ignored by the isinstance check + enc_types = { + cov + for val in (model.add_encoders or {}).values() + if isinstance(val, dict) + for cov in ("past", "future") + if cov in val + } + first_series = get_single_series(series) + uses_past = model.uses_past_covariates or ( + model.supports_past_covariates + and (past_covariates is not None or "past" in enc_types) + ) + uses_future = model.uses_future_covariates or ( + model.supports_future_covariates + and (future_covariates is not None or "future" in enc_types) + ) + uses_static = model.uses_static_covariates or ( + first_series is not None + and first_series.static_covariates is not None + and model.supports_static_covariates + and model.considers_static_covariates + ) + return uses_past, uses_future, uses_static + + +def _get_model_info_tags( + model: ForecastingModel, + series: TimeSeriesLike, + past_covariates: TimeSeriesLike | None = None, + future_covariates: TimeSeriesLike | None = None, +) -> dict[str, Any]: """ Returns: A dictionary of MLflow run tag keys and values describing the specified model. """ + uses_past, uses_future, uses_static = _infer_covariate_usage( + model, series, past_covariates, future_covariates + ) return { "model_class": model.__class__.__name__, "model_reference": ( @@ -720,12 +797,47 @@ def _get_model_info_tags(model: ForecastingModel) -> dict[str, Any]: if model.likelihood is not None else None ), - "model_uses_past_covariates": model.uses_past_covariates, - "model_uses_future_covariates": model.uses_future_covariates, - "model_uses_static_covariates": model.uses_static_covariates, + "model_uses_past_covariates": uses_past, + "model_uses_future_covariates": uses_future, + "model_uses_static_covariates": uses_static, } +def _log_model_setup( + model: ForecastingModel, + autologging_client: MlflowAutologgingQueueingClient, + run_id: str, + series: TimeSeriesLike, + past_covariates: TimeSeriesLike | None = None, + future_covariates: TimeSeriesLike | None = None, + *, + log_params: bool = True, +) -> None: + """Log model tags, creation parameters, and series info to an active run. + + Shared by ``fit()`` and ``historical_forecasts(retrain=True)`` autologging. + Does not log the trained model artifact. + """ + autologging_client.set_tags( + run_id=run_id, + tags=_get_model_info_tags( + model, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + ), + ) + if log_params: + autologging_client.log_params(run_id=run_id, params=model.model_params) + mlflow.log_dict(model.model_params, "model_params.json") + _log_series_info( + model, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, + ) + + def _log_series_info( model: ForecastingModel, series: TimeSeriesLike, @@ -760,19 +872,22 @@ def _log_series_info( ``None``. """ first_series = get_single_series(series) + uses_past, uses_future, uses_static = _infer_covariate_usage( + model, series, past_covariates, future_covariates + ) series_info = { "series": { "count": first_series.n_components, "names": first_series.components.tolist(), }, "past_covariates": _extract_covariate_metadata( - model.uses_past_covariates, + uses_past, get_single_series(past_covariates), "components", encoded_names=model.encoders.past_components, ), "future_covariates": _extract_covariate_metadata( - model.uses_future_covariates, + uses_future, get_single_series(future_covariates), "components", encoded_names=model.encoders.future_components, @@ -783,9 +898,9 @@ def _log_series_info( first_series.static_covariates if first_series is not None else None ) series_info["static_covariates"] = _extract_covariate_metadata( - model.uses_static_covariates, static_covariates, "columns" + uses_static, static_covariates, "columns" ) - if model.uses_static_covariates and static_covariates is not None: + if uses_static and static_covariates is not None: # static covariates are global (one shared row) unless there is one row # per series component, in which case they are component-specific series_info["static_covariates"]["is_global"] = ( From 4424a0d8ab71073250618c05fb1449f4a060a721 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 19:57:12 +0200 Subject: [PATCH 130/154] fix: remove the redundant inconsintent axis logic --- darts/tests/optional_deps/test_mlflow.py | 11 +- darts/utils/mlflow.py | 230 ++++++++++------------- 2 files changed, 107 insertions(+), 134 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index b447a28fbd..ef4ffe722b 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1591,11 +1591,10 @@ def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): assert key in m, f"Expected quantile key {key}" assert np.isfinite(m[key]) - def test_autolog_backtest_inconsistent_axes_flat_fallback( + def test_autolog_backtest_mixed_degenerate_axes_keep_metric_names( self, mlflow_tracking, autolog_context ): - """Metrics with mismatched axes (mae has no time axis, ae does) cannot be - merged into a structured layout, so values are logged flat by index.""" + """Metrics whose differing axes have size one keep their metric names.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: self._fit_lr().backtest( @@ -1606,9 +1605,9 @@ def test_autolog_backtest_inconsistent_axes_flat_fallback( ) m = mlflow.get_run(run.info.run_id).data.metrics - flat_keys = [k for k in m if k.startswith("backtest_metrics_")] - assert flat_keys, "Expected flat fallback keys for inconsistent axes" - assert "backtest_mae" not in m, "No structured key on flat fallback" + assert "backtest_mae" in m + assert "backtest_ae" in m + assert not any(k.startswith("backtest_metrics_") for k in m) def test_autolog_backtest_classification_labels_in_data( self, mlflow_tracking, autolog_context diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 9de1944688..d7615c7c76 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1045,9 +1045,6 @@ def _log_backtest_metrics( - ``last_points_only`` – collapses all windows into one TimeSeries before scoring, so there is effectively only one window regardless of reduction. - When two metrics have incompatible axis layouts (different - ``time_reduction`` / ``component_reduction`` / quantile count), each series - result is flattened to integer-indexed keys instead. When more than one series is scored, the logged value is ``agg_func`` applied over series for each cell, and the granular per-series breakdown @@ -1128,14 +1125,6 @@ def _log_backtest_metrics( has_time_axis, has_comp_axis, axis_labels_0 = metric_axes[0] axis_size = len(axis_labels_0) - # Inconsistent axes across metrics (different has_time_axis, has_comp_axis, or - # axis_size) means the result can't be reshaped into a single canonical array. - # Fall back to flat integer-indexed keys for this case. - axes_key = (has_time_axis, has_comp_axis, axis_size) - axes_inconsistent = any( - (ax[0], ax[1], len(ax[2])) != axes_key for ax in metric_axes[1:] - ) - series = backtest_args.get("series") forecast_horizon = backtest_args.get("forecast_horizon") historical_forecasts = backtest_args.get("historical_forecasts") @@ -1169,131 +1158,116 @@ def _log_backtest_metrics( agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] - if axes_inconsistent: - for series_index, r in enumerate(results): - name_prefix = metric_names[0] if len(metric_names) == 1 else "metrics" - flat = np.asarray(r, dtype=float).flatten() - for i, val in enumerate(flat): - key = _sanitize_mlflow_key(f"backtest_{name_prefix}_{i}") - value = float(val) - agg.setdefault((key, 0), []).append(value) - rows.append({ - "key": key, - "series_index": series_index, - "step": 0, - "value": value, - }) - else: - # component names/count from the first series (all series share n_components) - comps = series_seq[0].components.tolist() - # c_size = components x quantiles/intervals/labels per component - c_size = (len(comps) if has_comp_axis else 1) * axis_size - # base_keys[m][c]: sanitized key without the optional window suffix - base_keys = [] - for m, metric_name in enumerate(metric_names): - axis_labels = metric_axes[m][2] - keys_m = [] - for c in range(c_size): - # c is a flat index into the (n_components x axis_size) C axis: - # c = comp_i * axis_size + axis_idx - component_index, axis_idx = divmod(c, axis_size) - comp_part = ( - "_" + _sanitize_mlflow_key(comps[component_index]) - if has_comp_axis - else "" + # component names/count from the first series (all series share n_components) + comps = series_seq[0].components.tolist() + # c_size = components x quantiles/intervals/labels per component + c_size = (len(comps) if has_comp_axis else 1) * axis_size + # base_keys[m][c]: sanitized key without the optional window suffix + base_keys = [] + for m, metric_name in enumerate(metric_names): + axis_labels = metric_axes[m][2] + keys_m = [] + for c in range(c_size): + # c is a flat index into the (n_components x axis_size) C axis: + # c = comp_i * axis_size + axis_idx + component_index, axis_idx = divmod(c, axis_size) + comp_part = ( + "_" + _sanitize_mlflow_key(comps[component_index]) + if has_comp_axis + else "" + ) + keys_m.append( + _sanitize_mlflow_key( + f"backtest_{metric_name}{comp_part}{axis_labels[axis_idx]}" ) - keys_m.append( - _sanitize_mlflow_key( - f"backtest_{metric_name}{comp_part}{axis_labels[axis_idx]}" - ) + ) + base_keys.append(keys_m) + + # first pass: reshape each series' result into a canonical (W, T, C, M) + # array, recording its window-axis length for the alignment pass below. + series_shapes = [] + for r in results: + arr = np.asarray(r, dtype=float) + # after stripping C and M axes, rest = W*T (or W or T alone) + rest, extra = divmod(arr.size, c_size * n_metrics) + if extra: + raise_log( + ValueError( + f"Backtest metric logging failed: result size ({arr.size}) " + f"is not divisible by c_size * n_metrics ({c_size} * " + f"{n_metrics} = {c_size * n_metrics}). The metric output " + "shape does not match the inferred axes." ) - base_keys.append(keys_m) - - # first pass: reshape each series' result into a canonical (W, T, C, M) - # array, recording its window-axis length for the alignment pass below. - series_shapes = [] - for r in results: - arr = np.asarray(r, dtype=float) - # after stripping C and M axes, rest = W*T (or W or T alone) - rest, extra = divmod(arr.size, c_size * n_metrics) - if extra: + ) + + # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can + # recover W and T only if forecast_horizon is known (T = forecast_horizon) + if has_time_axis and has_windows: + if not forecast_horizon or rest % forecast_horizon: raise_log( ValueError( - f"Backtest metric logging failed: result size ({arr.size}) " - f"is not divisible by c_size * n_metrics ({c_size} * " - f"{n_metrics} = {c_size * n_metrics}). The metric output " - "shape does not match the inferred axes." + f"Backtest metric logging failed: cannot split " + f"window/time axes — {rest} elements remain after " + f"stripping component and metric axes, but " + f"forecast_horizon={forecast_horizon!r} does not " + "divide evenly. Pass an explicit forecast_horizon to " + "backtest()." ) ) - - # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can - # recover W and T only if forecast_horizon is known (T = forecast_horizon) - if has_time_axis and has_windows: - if not forecast_horizon or rest % forecast_horizon: - raise_log( - ValueError( - f"Backtest metric logging failed: cannot split " - f"window/time axes — {rest} elements remain after " - f"stripping component and metric axes, but " - f"forecast_horizon={forecast_horizon!r} does not " - "divide evenly. Pass an explicit forecast_horizon to " - "backtest()." - ) - ) - t_size, w_size = forecast_horizon, rest // forecast_horizon - elif has_time_axis: - t_size, w_size = rest, 1 - elif has_windows: - t_size, w_size = 1, rest - else: - if rest != 1: - raise_log( - ValueError( - f"Backtest metric logging failed: expected a single " - f"scalar per component/metric after reduction, but got " - f"{rest} elements. Check time_reduction and " - "component_reduction defaults." - ) + t_size, w_size = forecast_horizon, rest // forecast_horizon + elif has_time_axis: + t_size, w_size = rest, 1 + elif has_windows: + t_size, w_size = 1, rest + else: + if rest != 1: + raise_log( + ValueError( + f"Backtest metric logging failed: expected a single " + f"scalar per component/metric after reduction, but got " + f"{rest} elements. Check time_reduction and " + "component_reduction defaults." ) - t_size, w_size = 1, 1 - - series_shapes.append(( - t_size, - w_size, - arr.reshape(w_size, t_size, c_size, n_metrics), - )) - - # align the calendar-relative axes from the end - max_w_size = max((w_size for _, w_size, _ in series_shapes), default=0) - t_axis_is_calendar = has_time_axis and not has_windows and last_points_only - max_t_size = ( - max((t_size for t_size, _, _ in series_shapes), default=0) - if t_axis_is_calendar - else 0 - ) + ) + t_size, w_size = 1, 1 + + series_shapes.append(( + t_size, + w_size, + arr.reshape(w_size, t_size, c_size, n_metrics), + )) + + # align the calendar-relative axes from the end + max_w_size = max((w_size for _, w_size, _ in series_shapes), default=0) + t_axis_is_calendar = has_time_axis and not has_windows and last_points_only + max_t_size = ( + max((t_size for t_size, _, _ in series_shapes), default=0) + if t_axis_is_calendar + else 0 + ) - for series_index, (t_size, w_size, canonical) in enumerate(series_shapes): - w_offset = max_w_size - w_size if has_windows else 0 - t_offset = max_t_size - t_size if t_axis_is_calendar else 0 - for m in range(n_metrics): - for w in range(w_size): - aligned_w = w + w_offset - for c in range(c_size): - key = base_keys[m][c] - if has_time_axis and has_windows: - key = f"{key}_w{aligned_w}" - for t in range(t_size): - # MLflow step maps to the axis the UI should chart: - # time when present, otherwise window index - step = t + t_offset if has_time_axis else aligned_w - value = float(canonical[w, t, c, m]) - agg.setdefault((key, step), []).append(value) - rows.append({ - "key": key, - "series_index": series_index, - "step": step, - "value": value, - }) + for series_index, (t_size, w_size, canonical) in enumerate(series_shapes): + w_offset = max_w_size - w_size if has_windows else 0 + t_offset = max_t_size - t_size if t_axis_is_calendar else 0 + for m in range(n_metrics): + for w in range(w_size): + aligned_w = w + w_offset + for c in range(c_size): + key = base_keys[m][c] + if has_time_axis and has_windows: + key = f"{key}_w{aligned_w}" + for t in range(t_size): + # MLflow step maps to the axis the UI should chart: + # time when present, otherwise window index + step = t + t_offset if has_time_axis else aligned_w + value = float(canonical[w, t, c, m]) + agg.setdefault((key, step), []).append(value) + rows.append({ + "key": key, + "series_index": series_index, + "step": step, + "value": value, + }) # aggregate across series for each (key, step); for a single series this # is just the value itself. From 8067aadf1f8a9ebb408118118114740e1d4df5b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Tue, 4 Aug 2026 20:24:21 +0200 Subject: [PATCH 131/154] chore: simplify block after hfc logic changes in #3165 --- darts/utils/mlflow.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index d7615c7c76..df22767e6f 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1203,17 +1203,6 @@ def _log_backtest_metrics( # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can # recover W and T only if forecast_horizon is known (T = forecast_horizon) if has_time_axis and has_windows: - if not forecast_horizon or rest % forecast_horizon: - raise_log( - ValueError( - f"Backtest metric logging failed: cannot split " - f"window/time axes — {rest} elements remain after " - f"stripping component and metric axes, but " - f"forecast_horizon={forecast_horizon!r} does not " - "divide evenly. Pass an explicit forecast_horizon to " - "backtest()." - ) - ) t_size, w_size = forecast_horizon, rest // forecast_horizon elif has_time_axis: t_size, w_size = rest, 1 From bb4487646cd08216d497755f63b2b504d72de9ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 10:09:46 +0200 Subject: [PATCH 132/154] chore: extract shared code into helpers from _log_{backtest/metric} --- darts/tests/optional_deps/test_mlflow.py | 90 +++++++++++ darts/utils/mlflow.py | 187 +++++++++++++++-------- 2 files changed, 213 insertions(+), 64 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index ef4ffe722b..7fbf099b5e 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -31,6 +31,8 @@ RegressionEnsembleModel, ) from darts.utils.mlflow import ( + _build_metric_keys, + _flush_logged_metrics, _infer_metric_axes, _log_backtest_metrics, autolog, @@ -1875,3 +1877,91 @@ def test_infer_metric_axes_unknown_labels_raises(): of output labels ahead of time, so this raises rather than falling back.""" with pytest.raises(ValueError, match="requires explicit `labels`"): _infer_metric_axes(dm.f1, {"label_reduction": None}) + + +def test_build_metric_keys_components_and_quantiles(): + """Shared key builder expands components x quantile suffixes per metric.""" + metric_axes = [ + (False, True, ["_q0.100", "_q0.900"]), + (False, True, ["_label0", "_label1"]), + ] + c_size, keys = _build_metric_keys( + ["mae", "f1"], + ["temp", "hum"], + has_comp_axis=True, + metric_axes=metric_axes, + prefix="backtest_", + ) + assert c_size == 4 + assert keys == [ + [ + "backtest_mae_temp_q0_100", + "backtest_mae_temp_q0_900", + "backtest_mae_hum_q0_100", + "backtest_mae_hum_q0_900", + ], + [ + "backtest_f1_temp_label0", + "backtest_f1_temp_label1", + "backtest_f1_hum_label0", + "backtest_f1_hum_label1", + ], + ] + + +def test_build_metric_keys_no_components_no_prefix(): + """Without components, each metric gets one key per axis label.""" + metric_axes = [(False, False, ["_q0.500"])] + c_size, keys = _build_metric_keys( + ["mql"], + ["ignored"], + has_comp_axis=False, + metric_axes=metric_axes, + ) + assert c_size == 1 + assert keys == [["mql_q0_500"]] + + +def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): + """Multi-series cells are aggregated with agg_func; per-series rows go to table.""" + agg = { + ("mae", 0): [1.0, 3.0], + ("mae", 1): [10.0, 30.0], + } + rows = [ + {"key": "mae", "series_index": 0, "step": 0, "value": 1.0}, + {"key": "mae", "series_index": 1, "step": 0, "value": 3.0}, + {"key": "mae", "series_index": 0, "step": 1, "value": 10.0}, + {"key": "mae", "series_index": 1, "step": 1, "value": 30.0}, + ] + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _flush_logged_metrics( + client, run.info.run_id, agg, rows, n_series=2, agg_func=np.mean + ) + client.flush(synchronous=True) + + history0 = mlflow_tracking.get_metric_history(run.info.run_id, "mae") + logged = {m.step: m.value for m in history0} + assert logged[0] == pytest.approx(2.0) + assert logged[1] == pytest.approx(20.0) + table = mlflow.load_table( + artifact_file="metrics_per_series.json", run_ids=[run.info.run_id] + ) + assert len(table) == 4 + + +def test_flush_logged_metrics_skips_table_for_single_series(mlflow_tracking): + """Single-series input logs the aggregate only; no per-series table.""" + agg = {("mae", 0): [1.5]} + rows = [{"key": "mae", "series_index": 0, "step": 0, "value": 1.5}] + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _flush_logged_metrics( + client, run.info.run_id, agg, rows, n_series=1, agg_func=np.mean + ) + client.flush(synchronous=True) + + assert mlflow.get_run(run.info.run_id).data.metrics["mae"] == pytest.approx(1.5) + artifacts = mlflow_tracking.list_artifacts(run.info.run_id) + assert not any(a.path == "metrics_per_series.json" for a in artifacts) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index df22767e6f..d0c0fc1a2b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -989,6 +989,61 @@ def _sanitize_mlflow_key(name: str) -> str: return re.sub(r"[^\w-]", "_", name) +def _build_metric_keys( + metric_names: list[str], + components: list[str], + has_comp_axis: bool, + metric_axes: list[tuple[bool, bool, list[str]]], + *, + prefix: str = "", +) -> tuple[int, list[list[str]]]: + """Build sanitized MLflow metric keys for each metric x component x axis label. + + Parameters + ---------- + metric_names + One sanitized metric-name token per metric. + components + Component names from the first series (used only when ``has_comp_axis``). + has_comp_axis + Whether components are preserved in the metric output. + metric_axes + Per-metric ``(has_time_axis, has_comp_axis, axis_labels)`` tuples from + ``_infer_metric_axes``. Axis size is taken from the first entry. + prefix + Optional key prefix (e.g. ``"backtest_"``). + + Returns + ------- + tuple[int, list[list[str]]] + ``(c_size, keys)`` where ``c_size`` is + ``(n_components if has_comp_axis else 1) * axis_size`` and ``keys[m][c]`` + is the sanitized key for metric ``m`` and flat component/axis index ``c``. + """ + axis_size = len(metric_axes[0][2]) + c_size = (len(components) if has_comp_axis else 1) * axis_size + keys: list[list[str]] = [] + for m, metric_name in enumerate(metric_names): + axis_labels = metric_axes[m][2] + keys_m = [] + for c in range(c_size): + # c is a flat index into the (n_components x axis_size) C axis: + # c = comp_i * axis_size + axis_idx + component_index, axis_idx = divmod(c, axis_size) + comp_part = ( + "_" + _sanitize_mlflow_key(components[component_index]) + if has_comp_axis + else "" + ) + keys_m.append( + _sanitize_mlflow_key( + f"{prefix}{metric_name}{comp_part}{axis_labels[axis_idx]}" + ) + ) + keys.append(keys_m) + return c_size, keys + + def _log_per_series_table(rows: list[dict]) -> None: """Append the granular per-series metric breakdown to a single, run-wide table artifact. @@ -1012,6 +1067,43 @@ def _log_per_series_table(rows: list[dict]) -> None: mlflow.log_table(data=df, artifact_file="metrics_per_series.json") +def _flush_logged_metrics( + autologging_client: MlflowAutologgingQueueingClient, + run_id: str, + agg: dict[tuple[str, int], list[float]], + rows: list[dict], + n_series: int, + agg_func: Callable, +) -> None: + """Aggregate per-series cells, log MLflow metrics, and optionally write the + per-series table artifact. + + Parameters + ---------- + autologging_client + MLflow autologging client used to queue metric writes. + run_id + ID of the active MLflow run. + agg + Map of ``(key, step) -> list of per-series float values``. + rows + Granular per-series cells for ``metrics_per_series.json``. + n_series + Number of series scored; the table artifact is written only when + ``n_series > 1``. + agg_func + Aggregation over the per-series values for each ``(key, step)``. + """ + metrics_by_step: dict[int, dict[str, float]] = {} + for (key, step), values in agg.items(): + metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) + for step, metrics in metrics_by_step.items(): + autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + + if n_series > 1: + _log_per_series_table(rows) + + def _log_backtest_metrics( autologging_client: MlflowAutologgingQueueingClient, run_id: str, @@ -1122,8 +1214,7 @@ def _log_backtest_metrics( # check the dim axes from the metric kwargs for each metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metric, metric_kwargs)] - has_time_axis, has_comp_axis, axis_labels_0 = metric_axes[0] - axis_size = len(axis_labels_0) + has_time_axis, has_comp_axis, _ = metric_axes[0] series = backtest_args.get("series") forecast_horizon = backtest_args.get("forecast_horizon") @@ -1160,28 +1251,13 @@ def _log_backtest_metrics( # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() - # c_size = components x quantiles/intervals/labels per component - c_size = (len(comps) if has_comp_axis else 1) * axis_size - # base_keys[m][c]: sanitized key without the optional window suffix - base_keys = [] - for m, metric_name in enumerate(metric_names): - axis_labels = metric_axes[m][2] - keys_m = [] - for c in range(c_size): - # c is a flat index into the (n_components x axis_size) C axis: - # c = comp_i * axis_size + axis_idx - component_index, axis_idx = divmod(c, axis_size) - comp_part = ( - "_" + _sanitize_mlflow_key(comps[component_index]) - if has_comp_axis - else "" - ) - keys_m.append( - _sanitize_mlflow_key( - f"backtest_{metric_name}{comp_part}{axis_labels[axis_idx]}" - ) - ) - base_keys.append(keys_m) + c_size, base_keys = _build_metric_keys( + metric_names, + comps, + has_comp_axis, + metric_axes, + prefix="backtest_", + ) # first pass: reshape each series' result into a canonical (W, T, C, M) # array, recording its window-axis length for the alignment pass below. @@ -1258,18 +1334,14 @@ def _log_backtest_metrics( "value": value, }) - # aggregate across series for each (key, step); for a single series this - # is just the value itself. - metrics_by_step: dict[int, dict[str, float]] = {} - for (key, step), values in agg.items(): - metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) - for step, metrics in metrics_by_step.items(): - autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) - - # append the granular per-series breakdown to the run's table artifact - # (multi-series only) - if len(series_seq) > 1: - _log_per_series_table(rows) + _flush_logged_metrics( + autologging_client, + run_id, + agg, + rows, + n_series=len(series_seq), + agg_func=agg_func, + ) def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: @@ -1424,8 +1496,6 @@ def _log_metric_result( single value logged for a list of series. Called as ``agg_func(values)`` on a list of floats. """ - axis_size = len(axis_labels) - if series_reduced: # series_reduction aggregated across series -> single result, no series axis series_seq = [get_single_series(series)] @@ -1447,22 +1517,15 @@ def _log_metric_result( ) ) - # TODO: a lot of this seems duplicated from the backtest logic; improve # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() - # c_size = components x quantiles/intervals/labels per component - c_size = (len(comps) if has_comp_axis else 1) * axis_size - keys = [] - for c in range(c_size): - # c is a flat index into the (n_components x axis_size) C axis: - # c = comp_i * axis_size + axis_idx - component_index, axis_idx = divmod(c, axis_size) - comp_part = ( - "_" + _sanitize_mlflow_key(comps[component_index]) if has_comp_axis else "" - ) - keys.append( - _sanitize_mlflow_key(metric_name + comp_part + axis_labels[axis_idx]) - ) + c_size, base_keys = _build_metric_keys( + [metric_name], + comps, + has_comp_axis, + [(has_time_axis, has_comp_axis, axis_labels)], + ) + keys = base_keys[0] # first pass: reshape each series' result into a canonical (T, C) array, # recording its time-axis length for the alignment pass below. @@ -1518,20 +1581,16 @@ def _log_metric_result( "value": value, }) - # aggregate across series for each (key, step); for a single series this - # is just the value itself. - metrics_by_step: dict[int, dict[str, float]] = {} - for (key, step), values in agg.items(): - metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) - for step, metrics in metrics_by_step.items(): - autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + _flush_logged_metrics( + autologging_client, + run_id, + agg, + rows, + n_series=len(series_seq), + agg_func=agg_func, + ) autologging_client.flush(synchronous=False).await_completion() - # append the granular per-series breakdown to the run's table artifact - # (multi-series only) - if len(series_seq) > 1: - _log_per_series_table(rows) - def _mlflow_metric_callback(func, result, args, kwargs) -> None: """Metric callback registered with ``darts.metrics.utils`` for autologging. From 805a471c60fdc0afc05b28de89ecfa3e9d2f09e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 10:13:22 +0200 Subject: [PATCH 133/154] docs: doc clarification --- darts/utils/mlflow.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index d0c0fc1a2b..2bf0302f07 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1456,17 +1456,14 @@ def _log_metric_result( (shared with ``_log_backtest_metrics``). For a single series the aggregate is just the value itself and no artifact is written. - TODO: improve this, it's about predictions of different or different - intersection lengths between actual and pred (from the `Raises` - below, it sounds even that this wouldn't be supported?) - Series of different lengths are assumed to share the same end date, so the - time axis is aligned from the end rather than the start: a shorter series - lines up on its last value instead of its first. + Series can have different lengths and intersect in different ways, + so the time axis is aligned from the end rather than the start: a shorter + series lines up on its last value instead of its first. Raises ------ ValueError - On a shape/size mismatch between the metric result and the inferred + On a shape mismatch between the metric result and the inferred axes, or when ``has_comp_axis`` is ``True`` and series in a sequence have different numbers of components. From c40a106480cd7ebd6a9ffc0e965a8c7dad77cf18 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 11:20:47 +0200 Subject: [PATCH 134/154] feat: agg timestep metrics --- darts/tests/optional_deps/test_mlflow.py | 39 ++++++++++------ darts/utils/mlflow.py | 58 +++++++++++++++--------- 2 files changed, 60 insertions(+), 37 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 7fbf099b5e..bbd0056466 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1367,7 +1367,13 @@ def test_autolog_metric_per_series_table_schema_and_single_series_skip( dm.mae(multi, pred_multi) rows = self._read_per_series_table(run_multi.info.run_id) - assert list(rows[0].keys()) == ["key", "series_index", "step", "value"] + assert list(rows[0].keys()) == [ + "key", + "series_index", + "step", + "window_index", + "value", + ] assert {int(r["series_index"]) for r in rows} == {0, 1} # single-series: no per-series table artifact should be created @@ -1520,8 +1526,8 @@ def test_autolog_backtest_per_timestep_scalar( def test_autolog_backtest_per_timestep_per_window( self, mlflow_tracking, autolog_context ): - """ae + reduction=None + forecast_horizon>1 logs one key per window, with - one step per forecast horizon timestep.""" + """Window-level ae results aggregate per horizon step in the chart and + remain available with their window index in the detailed table.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: ref = self._fit_lr().backtest( @@ -1534,10 +1540,16 @@ def test_autolog_backtest_per_timestep_per_window( ) ref = np.asarray(ref, dtype=float) # shape (n_windows, forecast_horizon) - history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae_w0") + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") assert len(history) == 4, "Expected one step per forecast horizon timestep" logged = [m.value for m in sorted(history, key=lambda m: m.step)] - np.testing.assert_allclose(logged, ref[0], atol=1e-5) + np.testing.assert_allclose(logged, np.nanmean(ref, axis=0), atol=1e-5) + + rows = self._read_per_series_table(run.info.run_id) + assert len(rows) == ref.size + for row in rows: + assert row["key"] == "backtest_ae" + assert row["window_index"] in range(len(ref)) def test_autolog_backtest_historical_forecasts_horizon_inferred( self, mlflow_tracking, autolog_context @@ -1566,10 +1578,10 @@ def test_autolog_backtest_historical_forecasts_horizon_inferred( ) ref = np.asarray(ref, dtype=float) # shape (n_windows, forecast_horizon) - history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae_w0") + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") assert len(history) == 4, "Expected one step per forecast horizon timestep" logged = [m.value for m in sorted(history, key=lambda m: m.step)] - np.testing.assert_allclose(logged, ref[0], atol=1e-5) + np.testing.assert_allclose(logged, np.nanmean(ref, axis=0), atol=1e-5) def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile.""" @@ -1923,7 +1935,7 @@ def test_build_metric_keys_no_components_no_prefix(): def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): - """Multi-series cells are aggregated with agg_func; per-series rows go to table.""" + """Cells are aggregated with agg_func; supplied table rows are persisted.""" agg = { ("mae", 0): [1.0, 3.0], ("mae", 1): [10.0, 30.0], @@ -1937,7 +1949,7 @@ def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() _flush_logged_metrics( - client, run.info.run_id, agg, rows, n_series=2, agg_func=np.mean + client, run.info.run_id, agg, agg_func=np.mean, table_rows=rows ) client.flush(synchronous=True) @@ -1951,15 +1963,12 @@ def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): assert len(table) == 4 -def test_flush_logged_metrics_skips_table_for_single_series(mlflow_tracking): - """Single-series input logs the aggregate only; no per-series table.""" +def test_flush_logged_metrics_skips_table_without_rows(mlflow_tracking): + """Omitting table rows logs the aggregate only.""" agg = {("mae", 0): [1.5]} - rows = [{"key": "mae", "series_index": 0, "step": 0, "value": 1.5}] with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() - _flush_logged_metrics( - client, run.info.run_id, agg, rows, n_series=1, agg_func=np.mean - ) + _flush_logged_metrics(client, run.info.run_id, agg, agg_func=np.mean) client.flush(synchronous=True) assert mlflow.get_run(run.info.run_id).data.metrics["mae"] == pytest.approx(1.5) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 2bf0302f07..be3dd22879 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1050,8 +1050,9 @@ def _log_per_series_table(rows: list[dict]) -> None: Each row is a single metric cell for one series, with columns ``key`` (the aggregate MLflow key, without any series suffix), ``series_index``, ``step`` - (the time or window index charted by MLflow), and ``value``. All calls - within a run append to the same ``metrics_per_series.json`` artifact. + (the time or window index charted by MLflow), ``window_index`` (the source + backtest window, or ``None``), and ``value``. All calls within a run append + to the same ``metrics_per_series.json`` artifact. Used when more than one series is scored, since the logged metric keys only carry the aggregate over series. @@ -1059,7 +1060,7 @@ def _log_per_series_table(rows: list[dict]) -> None: ---------- rows One dict per metric cell with keys ``key``, ``series_index``, ``step``, - and ``value``. + ``window_index``, and ``value``. """ if not rows: return @@ -1071,9 +1072,8 @@ def _flush_logged_metrics( autologging_client: MlflowAutologgingQueueingClient, run_id: str, agg: dict[tuple[str, int], list[float]], - rows: list[dict], - n_series: int, agg_func: Callable, + table_rows: list[dict] | None = None, ) -> None: """Aggregate per-series cells, log MLflow metrics, and optionally write the per-series table artifact. @@ -1086,13 +1086,11 @@ def _flush_logged_metrics( ID of the active MLflow run. agg Map of ``(key, step) -> list of per-series float values``. - rows - Granular per-series cells for ``metrics_per_series.json``. - n_series - Number of series scored; the table artifact is written only when - ``n_series > 1``. agg_func Aggregation over the per-series values for each ``(key, step)``. + table_rows + Granular cells for ``metrics_per_series.json``. ``None`` skips writing + the table artifact. """ metrics_by_step: dict[int, dict[str, float]] = {} for (key, step), values in agg.items(): @@ -1100,8 +1098,8 @@ def _flush_logged_metrics( for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) - if n_series > 1: - _log_per_series_table(rows) + if table_rows is not None: + _log_per_series_table(table_rows) def _log_backtest_metrics( @@ -1315,12 +1313,26 @@ def _log_backtest_metrics( w_offset = max_w_size - w_size if has_windows else 0 t_offset = max_t_size - t_size if t_axis_is_calendar else 0 for m in range(n_metrics): - for w in range(w_size): - aligned_w = w + w_offset - for c in range(c_size): - key = base_keys[m][c] - if has_time_axis and has_windows: - key = f"{key}_w{aligned_w}" + for c in range(c_size): + key = base_keys[m][c] + if has_time_axis and has_windows: + # Keep window-level values in the detailed table, but aggregate + # windows into one chart value per horizon step for this series. + for t in range(t_size): + values = canonical[:, t, c, m] + agg.setdefault((key, t), []).append(float(np.nanmean(values))) + for w, value in enumerate(values): + rows.append({ + "key": key, + "series_index": series_index, + "step": t, + "window_index": w + w_offset, + "value": float(value), + }) + continue + + for w in range(w_size): + aligned_w = w + w_offset for t in range(t_size): # MLflow step maps to the axis the UI should chart: # time when present, otherwise window index @@ -1331,6 +1343,7 @@ def _log_backtest_metrics( "key": key, "series_index": series_index, "step": step, + "window_index": None, "value": value, }) @@ -1338,9 +1351,10 @@ def _log_backtest_metrics( autologging_client, run_id, agg, - rows, - n_series=len(series_seq), agg_func=agg_func, + table_rows=( + rows if len(series_seq) > 1 or (has_time_axis and has_windows) else None + ), ) @@ -1575,6 +1589,7 @@ def _log_metric_result( "key": key, "series_index": series_index, "step": step, + "window_index": None, "value": value, }) @@ -1582,9 +1597,8 @@ def _log_metric_result( autologging_client, run_id, agg, - rows, - n_series=len(series_seq), agg_func=agg_func, + table_rows=rows if len(series_seq) > 1 else None, ) autologging_client.flush(synchronous=False).await_completion() From e0599384c012c01fd4d1867aed419b97fb1431e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 11:43:38 +0200 Subject: [PATCH 135/154] chore: align notebook to current solution --- examples/29-MLflow-quickstart.ipynb | 12069 +++++++++++++------------- 1 file changed, 6014 insertions(+), 6055 deletions(-) diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index 54f8d90a83..51ea86bbdd 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -1,6139 +1,6098 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "aeddb542", - "metadata": {}, - "source": [ - "# MLflow for Darts\n", - "\n", - "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", - "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", - "\n", - "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", - "\n", - "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ] - }, - { - "cell_type": "markdown", - "id": "f72894af", - "metadata": {}, - "source": [ - "## Installing MLflow\n", - "\n", - "MLflow is available as an optional dependency for Darts. Install it with:\n", - "\n", - "```bash\n", - "pip install mlflow\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "42e3dcea", - "metadata": {}, - "source": [ - "## Setup and Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b346ce8f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.049165Z", - "iopub.status.busy": "2026-06-24T15:18:43.049088Z", - "iopub.status.idle": "2026-06-24T15:18:43.053693Z", - "shell.execute_reply": "2026-06-24T15:18:43.053435Z" - } - }, - "outputs": [], - "source": [ - "# fix python path if working locally\n", - "from utils import fix_pythonpath_if_working_locally\n", - "\n", - "fix_pythonpath_if_working_locally()\n", - "\n", - "import warnings\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "13b13fe4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.054776Z", - "iopub.status.busy": "2026-06-24T15:18:43.054722Z", - "iopub.status.idle": "2026-06-24T15:18:46.599643Z", - "shell.execute_reply": "2026-06-24T15:18:46.599208Z" - } - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import os\n", - "import tempfile\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import mlflow\n", - "import numpy as np\n", - "\n", - "import darts.metrics as metrics\n", - "from darts.datasets import AirPassengersDataset\n", - "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", - "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4d424e08", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.600906Z", - "iopub.status.busy": "2026-06-24T15:18:46.600748Z", - "iopub.status.idle": "2026-06-24T15:18:46.634540Z", - "shell.execute_reply": "2026-06-24T15:18:46.634100Z" - } - }, - "outputs": [], - "source": [ - "# use darts plotting style\n", - "from darts import set_option\n", - "\n", - "set_option(\"plotting.use_darts_style\", True)" - ] - }, - { - "cell_type": "markdown", - "id": "2f9c40d6", - "metadata": {}, - "source": [ - "## MLflow Setup\n", - "\n", - "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "88320df5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.636640Z", - "iopub.status.busy": "2026-06-24T15:18:46.636565Z", - "iopub.status.idle": "2026-06-24T15:18:47.268439Z", - "shell.execute_reply": "2026-06-24T15:18:47.268081Z" - } - }, - "outputs": [ + "cells": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", - "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Updating database tables\n", - "2026/07/23 18:50:08 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MLflow for Darts\n", + "\n", + "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", + "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", + "\n", + "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", + "\n", + "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." + ], + "id": "aeddb542" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", - "Experiment: darts-quickstart\n" - ] - } - ], - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ] - }, - { - "cell_type": "markdown", - "id": "03d5209e", - "metadata": {}, - "source": [ - "## Load Sample Data\n", - "\n", - "We'll use the classic AirPassengers dataset for this example." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1596e07e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.269628Z", - "iopub.status.busy": "2026-06-24T15:18:47.269548Z", - "iopub.status.idle": "2026-06-24T15:18:47.356588Z", - "shell.execute_reply": "2026-06-24T15:18:47.356201Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installing MLflow\n", + "\n", + "MLflow is available as an optional dependency for Darts. Install it with:\n", + "\n", + "```bash\n", + "pip install \"mlflow>=3.0\"\n", + "```" + ], + "id": "f72894af" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training series: 107 points\n", - "Validation series: 37 points\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Imports" + ], + "id": "42e3dcea" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "34858645", - "metadata": {}, - "source": [ - "## Basic Model Logging\n", - "\n", - "Let's train a simple model and log it to MLflow manually." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bc8f520d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.357581Z", - "iopub.status.busy": "2026-06-24T15:18:47.357516Z", - "iopub.status.idle": "2026-06-24T15:18:47.450374Z", - "shell.execute_reply": "2026-06-24T15:18:47.449925Z" - } - }, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.049165Z", + "iopub.status.busy": "2026-06-24T15:18:43.049088Z", + "iopub.status.idle": "2026-06-24T15:18:43.053693Z", + "shell.execute_reply": "2026-06-24T15:18:43.053435Z" + } + }, + "source": [ + "# fix python path if working locally\n", + "from utils import fix_pythonpath_if_working_locally\n", + "\n", + "fix_pythonpath_if_working_locally()\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)" + ], + "execution_count": 2, + "outputs": [], + "id": "b346ce8f" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:43.054776Z", + "iopub.status.busy": "2026-06-24T15:18:43.054722Z", + "iopub.status.idle": "2026-06-24T15:18:46.599643Z", + "shell.execute_reply": "2026-06-24T15:18:46.599208Z" + } + }, + "source": [ + "%matplotlib inline\n", + "\n", + "import os\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import mlflow\n", + "import numpy as np\n", + "\n", + "import darts.metrics as metrics\n", + "from darts.datasets import AirPassengersDataset\n", + "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", + "from darts.utils.mlflow import autolog, load_model, log_model, save_model" + ], + "execution_count": 3, + "outputs": [], + "id": "13b13fe4" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = ExponentialSmoothing()\n", - "model.fit(train)\n", - "\n", - "predictions = model.predict(n=len(val))\n", - "\n", - "# calculate metrics you want to log to MLflow\n", - "mape_score = metrics.mape(val, predictions)\n", - "rmse_score = metrics.rmse(val, predictions)\n", - "\n", - "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", - "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", - "\n", - "train[-50:].plot(label=\"Training\")\n", - "val.plot(label=\"Actual\")\n", - "predictions.plot(label=\"Forecast\")\n", - "plt.legend()\n", - "plt.title(\"Exponential Smoothing Forecast\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "35dc864c", - "metadata": {}, - "source": [ - "Now let's log this model to MLflow.\n", - "\n", - "Tags can live in two places in MLflow 3:\n", - "\n", - "- **Run tags** (`mlflow.set_tags(...)`) – shown on the run page in the UI. This is also where `autolog()` writes its tags (`model_class`, …).\n", - "- **LoggedModel tags** (`log_model(..., tags=...)`) – attached to the logged model entity itself (open the model from the run's **Outputs** / Models view)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "61406cd9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.451366Z", - "iopub.status.busy": "2026-06-24T15:18:47.451297Z", - "iopub.status.idle": "2026-06-24T15:18:47.906785Z", - "shell.execute_reply": "2026-06-24T15:18:47.906380Z" - } - }, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.600906Z", + "iopub.status.busy": "2026-06-24T15:18:46.600748Z", + "iopub.status.idle": "2026-06-24T15:18:46.634540Z", + "shell.execute_reply": "2026-06-24T15:18:46.634100Z" + } + }, + "source": [ + "# use darts plotting style\n", + "from darts import set_option\n", + "\n", + "set_option(\"plotting.use_darts_style\", True)" + ], + "execution_count": 4, + "outputs": [], + "id": "4d424e08" + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MLflow Setup\n", + "\n", + "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." + ], + "id": "2f9c40d6" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] - } - ], - "source": [ - "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", - " model_info = log_model(\n", - " model=model,\n", - " name=\"exponential-smoothing-model\",\n", - " # alternatively, use mlflow.set_tag(key, value) in the run\n", - " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", - " )\n", - "\n", - " # log calculated metrics you want\n", - " mlflow.log_metric(\"mape\", mape_score)\n", - " mlflow.log_metric(\"rmse\", rmse_score)\n", - "\n", - " print(f\"Run ID: {run.info.run_id}\")\n", - " print(f\"Model URI: {model_info.model_uri}\")" - ] - }, - { - "cell_type": "markdown", - "id": "0728690e", - "metadata": {}, - "source": [ - "### Load the Model Back\n", - "\n", - "We can load the model from MLflow using its URI:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "cae35ffa", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.907880Z", - "iopub.status.busy": "2026-06-24T15:18:47.907802Z", - "iopub.status.idle": "2026-06-24T15:18:47.914695Z", - "shell.execute_reply": "2026-06-24T15:18:47.914326Z" - } - }, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:46.636640Z", + "iopub.status.busy": "2026-06-24T15:18:46.636565Z", + "iopub.status.idle": "2026-06-24T15:18:47.268439Z", + "shell.execute_reply": "2026-06-24T15:18:47.268081Z" + } + }, + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", + "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Updating database tables\n", + "2026/07/23 18:50:08 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" + ] + }, + { + "output_type": "stream", + "text": [ + "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", + "Experiment: darts-quickstart\n" + ] + } + ], + "id": "88320df5" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model predictions match: True\n" - ] - } - ], - "source": [ - "loaded_model = load_model(model_info.model_uri)\n", - "\n", - "loaded_predictions = loaded_model.predict(n=len(val))\n", - "\n", - "# verify predictions match\n", - "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", - "print(f\"Loaded model predictions match: {predictions_match}\")" - ] - }, - { - "cell_type": "markdown", - "id": "6bd4597c", - "metadata": {}, - "source": [ - "## Automatic Logging with `autolog()`\n", - "\n", - "`autolog()` patches darts models and metrics so that the following are logged automatically, with no extra code needed:\n", - "\n", - "- **`fit()`** – model creation parameters and covariate metadata (and the trained model artifact when ``log_models=True``; default ``False``).\n", - "- **Darts metric functions** – any call made inside an active MLflow run.\n", - "- **`backtest()`** – evaluation metrics under `backtest_*` keys.\n", - "- **`historical_forecasts()`** – patched so its internal per-window `fit()` calls don't each spawn their own logging.\n", - "- **PyTorch-based models** – per-epoch `train_loss` / `val_loss` via MLflow's PyTorch autologging (see the section below for details)." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5ef7f73a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.915629Z", - "iopub.status.busy": "2026-06-24T15:18:47.915566Z", - "iopub.status.idle": "2026-06-24T15:18:50.020337Z", - "shell.execute_reply": "2026-06-24T15:18:50.019951Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Sample Data\n", + "\n", + "We'll use the classic AirPassengers dataset for this example." + ], + "id": "03d5209e" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" - ] + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.269628Z", + "iopub.status.busy": "2026-06-24T15:18:47.269548Z", + "iopub.status.idle": "2026-06-24T15:18:47.356588Z", + "shell.execute_reply": "2026-06-24T15:18:47.356201Z" + } + }, + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Training series: 107 points\n", + "Validation series: 37 points\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + } + } + ], + "id": "1596e07e" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", - " auto_model = LinearRegressionModel(lags=12)\n", - " auto_model.fit(train) # autolog logs params and covariate metadata\n", - "\n", - " auto_predictions = auto_model.predict(n=len(val))\n", - " # these metric calls happen inside the run, so they are logged automatically\n", - " auto_mape = metrics.mape(val, auto_predictions)\n", - " auto_rmse = metrics.rmse(val, auto_predictions)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show logged metrics\n", - "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", - "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", - "\n", - "# plot\n", - "fig, ax = plt.subplots(figsize=(10, 4))\n", - "train[-36:].plot(label=\"Train\", ax=ax)\n", - "val.plot(label=\"Actual\", ax=ax)\n", - "auto_predictions.plot(\n", - " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", - ")\n", - "ax.set_title(\"Linear Regression — autolog run\")\n", - "ax.legend()\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f484330f", - "metadata": {}, - "source": [ - "## Open the MLflow UI\n", - "\n", - "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", - "\n", - "The UI lets you:\n", - "- **Compare runs** side-by-side in the Experiments table\n", - "- **Inspect** individual run parameters, metrics, and logged artifacts\n", - "- **Visualize** metrics across runs with built-in charts\n", - "- **Register** models to the Model Registry for versioning" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "1a01cd2f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:50.021527Z", - "iopub.status.busy": "2026-06-24T15:18:50.021439Z", - "iopub.status.idle": "2026-06-24T15:18:50.023116Z", - "shell.execute_reply": "2026-06-24T15:18:50.022824Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Model Logging\n", + "\n", + "Let's train a simple model and log it to MLflow manually." + ], + "id": "34858645" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Launch the MLflow UI with this command in your terminal:\n", - "\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", - "\n", - "Then open: http://localhost:5000\n" - ] - } - ], - "source": [ - "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", - "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", - "print(\"Then open: http://localhost:5000\")" - ] - }, - { - "cell_type": "markdown", - "id": "88b0d285", - "metadata": {}, - "source": [ - "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", - ">\n", - "![Mlflow Overview](./static/images/mlflow_overview.png)" - ] - }, - { - "cell_type": "markdown", - "id": "e2b133bc", - "metadata": {}, - "source": [ - "## Per-epoch Metrics with Torch Models\n", - "\n", - "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", - "\n", - "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "d01783d1", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:50.024161Z", - "iopub.status.busy": "2026-06-24T15:18:50.024087Z", - "iopub.status.idle": "2026-06-24T15:18:53.370946Z", - "shell.execute_reply": "2026-06-24T15:18:53.370531Z" - } - }, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.357581Z", + "iopub.status.busy": "2026-06-24T15:18:47.357516Z", + "iopub.status.idle": "2026-06-24T15:18:47.450374Z", + "shell.execute_reply": "2026-06-24T15:18:47.449925Z" + } + }, + "source": [ + "model = ExponentialSmoothing()\n", + "model.fit(train)\n", + "\n", + "predictions = model.predict(n=len(val))\n", + "\n", + "# calculate metrics you want to log to MLflow\n", + "mape_score = metrics.mape(val, predictions)\n", + "rmse_score = metrics.rmse(val, predictions)\n", + "\n", + "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", + "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", + "\n", + "train[-50:].plot(label=\"Training\")\n", + "val.plot(label=\"Actual\")\n", + "predictions.plot(label=\"Forecast\")\n", + "plt.legend()\n", + "plt.title(\"Exponential Smoothing Forecast\")\n", + "plt.show()" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + } + } + ], + "id": "bc8f520d" + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: GPU available: True (mps), used: False\n", - "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", - "INFO: TPU available: False, using: 0 TPU cores\n", - "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO: HPU available: False, using: 0 HPUs\n", - "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/trainer/setup.py:177: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", - "\n", - " | Name | Type | Params | Mode \n", - "-------------------------------------------------------------\n", - "0 | criterion | MSELoss | 0 | train\n", - "1 | train_criterion | MSELoss | 0 | train\n", - "2 | val_criterion | MSELoss | 0 | train\n", - "3 | train_metrics | MetricCollection | 0 | train\n", - "4 | val_metrics | MetricCollection | 0 | train\n", - "5 | stacks | ModuleList | 6.2 M | train\n", - "-------------------------------------------------------------\n", - "6.2 M Trainable params\n", - "1.4 K Non-trainable params\n", - "6.2 M Total params\n", - "24.787 Total estimated model params size (MB)\n", - "400 Modules in train mode\n", - "0 Modules in eval mode\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's log this model to MLflow.\n", + "\n", + "Tags can live in two places in MLflow 3:\n", + "\n", + "- **Run tags** (`mlflow.set_tags(...)`) – shown on the run page in the UI. This is also where `autolog()` writes its tags (`model_class`, …).\n", + "- **LoggedModel tags** (`log_model(..., tags=...)`) – attached to the logged model entity itself (open the model from the run's **Outputs** / Models view)." + ], + "id": "35dc864c" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "33ff56f2bbbb46ddb71bf5ac409bc3c7", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:47.451366Z", + "iopub.status.busy": "2026-06-24T15:18:47.451297Z", + "iopub.status.idle": "2026-06-24T15:18:47.906785Z", + "shell.execute_reply": "2026-06-24T15:18:47.906380Z" + } }, - "text/plain": [ - "Sanity Checking: | | 0/? [00:00" + ] + } + } + ], + "id": "5ef7f73a" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/core/module.py:512: You called `self.log('train_MAE', ..., logger=True)` but have no logger configured. You can enable one by doing `Trainer(logger=ALogger(...))`\n", - "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/core/module.py:512: You called `self.log('train_MSE', ..., logger=True)` but have no logger configured. You can enable one by doing `Trainer(logger=ALogger(...))`\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Open the MLflow UI\n", + "\n", + "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", + "\n", + "The UI lets you:\n", + "- **Compare runs** side-by-side in the Experiments table\n", + "- **Inspect** individual run parameters, metrics, and logged artifacts\n", + "- **Visualize** metrics across runs with built-in charts\n", + "- **Register** models to the Model Registry for versioning" + ], + "id": "f484330f" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "78af3a584caf477ba9c043c93a77ae56", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:50.021527Z", + "iopub.status.busy": "2026-06-24T15:18:50.021439Z", + "iopub.status.idle": "2026-06-24T15:18:50.023116Z", + "shell.execute_reply": "2026-06-24T15:18:50.022824Z" + } }, - "text/plain": [ - "Validation: | | 0/? [00:00 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", + ">\n", + "![Mlflow Overview](./static/images/mlflow_overview.png)" + ], + "id": "88b0d285" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bbd214c1629e47de8f36acad90896742", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_charts.png)" + ], + "id": "6fcc8f13" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "33e1f6444b504ddd8808d0b4bdf7cf34", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: | | 0/? [00:00`.\n", + "- **Quantile / interval** (`q`, `q_interval`) adds the quantile, e.g. `mql_q0.500`.\n", + "- **Per-label classification** (`label_reduction=None`) adds the class, e.g. `f1_label1`.\n", + "- **Per-timestep** (`time_reduction=None`) is charted across MLflow steps.\n", + "- **`series_reduction`**, when set on the metric call, aggregates across series inside the metric itself, so the mean-over-series logging described below does not apply.\n", + "\n", + "For `backtest()`, metric keys have a `backtest_` prefix. A time-dependent metric with `reduction=None` keeps its per-window values in the return value, but MLflow charts one value per horizon step: it applies `np.nanmean` over windows for each series, then aggregates across series. The detailed `metrics_per_series.json` table retains every source value with a `window_index`, including for a single-series backtest.\n", + "\n", + "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is appended to the same run-wide table artifact, `metrics_per_series.json`, which you can read back with `mlflow.load_table()`.\n", + "\n", + "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `foo_q0.500`)." + ], + "id": "b08e900a" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "82a6462bdf0a486a85887bef6ae73630", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: | | 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
keyseries_indexstepvalue
0mae0047.458874
1mae1055.172880
\n", + "" + ], + "text/plain": [ + " key series_index step value\n", + "0 mae 0 0 47.458874\n", + "1 mae 1 0 55.172880" + ] + } + } + ], + "id": "ecdbbf29" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: `Trainer.fit` stopped: `max_epochs=10` reached.\n", - "INFO:lightning.pytorch.utilities.rank_zero:`Trainer.fit` stopped: `max_epochs=10` reached.\n", - "INFO: GPU available: True (mps), used: False\n", - "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", - "INFO: TPU available: False, using: 0 TPU cores\n", - "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO: HPU available: False, using: 0 HPUs\n", - "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving and Loading Models Locally\n", + "\n", + "You can also save and load models to/from local paths without MLflow runs." + ], + "id": "8511fc08" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a9cf24e439244b4f99812eeea1c9aab8", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.471252Z", + "iopub.status.busy": "2026-06-24T15:18:53.471178Z", + "iopub.status.idle": "2026-06-24T15:18:53.478682Z", + "shell.execute_reply": "2026-06-24T15:18:53.478330Z" + } }, - "text/plain": [ - "Predicting: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_charts.png)" - ] - }, - { - "cell_type": "markdown", - "id": "3f0828c2", - "metadata": {}, - "source": [ - "## Forecast Metrics\n", - "\n", - "With `log_metrics=True` (the default), `autolog()` patches every darts metric function. Any metric you call **inside an active run** is logged automatically with no extra arguments needed.\n", - "\n", - "The metric key is derived from the result: a scalar is logged under `{metric}` (e.g. calling `darts.metrics.mae(val, pred)` logs `mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "df8e85b6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.372445Z", - "iopub.status.busy": "2026-06-24T15:18:53.372367Z", - "iopub.status.idle": "2026-06-24T15:18:53.470125Z", - "shell.execute_reply": "2026-06-24T15:18:53.469722Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All logged metrics (5):\n", - " mae: 46.0220\n", - " manual_mape: 10.7420\n", - " mape: 10.7420\n", - " rmse: 51.1820\n", - " smape: 10.1015\n" - ] - } - ], - "source": [ - "# log_metrics=True (the default) patches every darts metric so that calls made\n", - "# inside an active run are logged automatically\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", - " lr_model = LinearRegressionModel(lags=12)\n", - " lr_model.fit(train)\n", - " lr_pred = lr_model.predict(n=len(val))\n", - "\n", - " # each metric called here is auto-logged under its own name: mae, rmse, smape\n", - " metrics.mae(val, lr_pred)\n", - " metrics.rmse(val, lr_pred)\n", - " metrics.smape(val, lr_pred)\n", - " # you can still log a custom-named metric explicitly\n", - " mlflow.log_metric(\"manual_mape\", metrics.mape(val, lr_pred))\n", - " run_id = run.info.run_id\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show what was logged\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_metrics = client.get_run(run_id).data.metrics\n", - "metric_names = sorted(run_metrics.keys())\n", - "print(f\"All logged metrics ({len(metric_names)}):\")\n", - "for name in metric_names:\n", - " print(f\" {name}: {run_metrics[name]:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "b08e900a", - "metadata": {}, - "source": [ - "### Metric Shape and Per-Series Logging\n", - "\n", - "The logged key reflects the shape of the metric output, which `autolog()` infers from the metric and its keyword arguments. The general pattern is:\n", - "\n", - "`{metric_name}{component}{quantile_or_label}`\n", - "\n", - "- **Per-component** (`component_reduction=None`) adds the component name, e.g. `mae_`.\n", - "- **Quantile / interval** (`q`, `q_interval`) adds the quantile, e.g. `mql_q0.500`.\n", - "- **Per-label classification** (`label_reduction=None`) adds the class, e.g. `f1_label1`.\n", - "- **Per-timestep** (`time_reduction=None`) is charted across MLflow steps.\n", - "- **`series_reduction`**, when set on the metric call, aggregates across series inside the metric itself, so the mean-over-series logging described below does not apply.\n", - "\n", - "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is appended to a single run-wide table artifact, `metrics_per_series.json`, which you can read back with `mlflow.load_table()`.\n", - "\n", - "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `foo_q0.500`)." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "ecdbbf29", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.479679Z", + "iopub.status.busy": "2026-06-24T15:18:53.479604Z", + "iopub.status.idle": "2026-06-24T15:18:53.484973Z", + "shell.execute_reply": "2026-06-24T15:18:53.484638Z" + } + }, + "source": [ + "# Load model from local directory\n", + "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", + "\n", + "# Test it\n", + "local_predictions = local_loaded_model.predict(n=5)\n", + "print(\"Loaded model successfully!\")\n", + "print(f\"Predictions shape: {local_predictions.values().shape}\")" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Loaded model successfully!\n", + "Predictions shape: (5, 1)\n" + ] + } + ], + "id": "254ba153" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Aggregate metrics: {'ae': 44.196, 'mae': 51.316}\n", - "Mean MAE over series: 51.316\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Querying Experiments\n", + "\n", + "You can programmatically query and compare runs." + ], + "id": "aab0d1e0" }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0305dca7a1b846f19da965d1b74319c5", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.485914Z", + "iopub.status.busy": "2026-06-24T15:18:53.485859Z", + "iopub.status.idle": "2026-06-24T15:18:53.496380Z", + "shell.execute_reply": "2026-06-24T15:18:53.496048Z" + } }, - "text/plain": [ - "Downloading artifacts: 0%| | 0/1 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
keyseries_indexstepvalue
0mae0047.458874
1mae1055.172880
\n", - "" + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.497560Z", + "iopub.status.busy": "2026-06-24T15:18:53.497496Z", + "iopub.status.idle": "2026-06-24T15:18:53.572540Z", + "shell.execute_reply": "2026-06-24T15:18:53.572133Z" + } + }, + "source": [ + "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", + "\n", + "if runs:\n", + " best_run = runs[0]\n", + " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", + " # from the run outputs and load it with a models:/ URI\n", + " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", + " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", + "\n", + " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", + " print(f\"Model URI: {best_model_uri}\")\n", + "\n", + " best_model = load_model(best_model_uri)\n", + " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", + " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", + " if isinstance(best_model, GlobalForecastingModel):\n", + " best_predictions = best_model.predict(n=len(val), series=train)\n", + " else:\n", + " best_predictions = best_model.predict(n=len(val))\n", + "\n", + " train[-50:].plot(label=\"Training\")\n", + " val.plot(label=\"Actual\")\n", + " best_predictions.plot(label=\"Best Model Forecast\")\n", + " plt.legend()\n", + " plt.title(\"Best Model Predictions\")\n", + " plt.show()" ], - "text/plain": [ - " key series_index step value\n", - "0 mae 0 0 47.458874\n", - "1 mae 1 0 55.172880" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# build a small multi-series example from the univariate AirPassengers data\n", - "series_list = [train, train * 1.2]\n", - "val_list = [val, val * 1.2]\n", - "\n", - "multi_model = LinearRegressionModel(lags=12)\n", - "multi_model.fit(series_list)\n", - "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", - "\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", - " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", - " # under a single key, charted across MLflow steps\n", - " single_pred = multi_preds[0] # train == series_list[0]\n", - " metrics.ae(val, single_pred)\n", - "\n", - " # multiple series: the logged value is the MEAN over series, and the full\n", - " # per-series breakdown is appended to the run's table artifact\n", - " per_series_mae = metrics.mae(val_list, multi_preds)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_id = run.info.run_id\n", - "\n", - "# aggregate metrics: mae is the mean over the two series\n", - "logged = client.get_run(run_id).data.metrics\n", - "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", - "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", - "\n", - "# load the per-series table artifact\n", - "per_series_df = mlflow.load_table(\n", - " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", - ")\n", - "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", - "per_series_df" - ] - }, - { - "cell_type": "markdown", - "id": "8511fc08", - "metadata": {}, - "source": [ - "## Saving and Loading Models Locally\n", - "\n", - "You can also save and load models to/from local paths without MLflow runs." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "645ef079", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.471252Z", - "iopub.status.busy": "2026-06-24T15:18:53.471178Z", - "iopub.status.idle": "2026-06-24T15:18:53.478682Z", - "shell.execute_reply": "2026-06-24T15:18:53.478330Z" - } - }, - "outputs": [ + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Loading best model from run: exponential-smoothing-baseline\n", + "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHECAYAAADmnVpRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoK1JREFUeJztnQd4U2UXx0+6001bSmmBsvcWZIkoiKLi+FRw4MC99544PgXX50IUEffeuFFQFAeisvcus3Tv3eZ7/u/te3OTJm2SZtybnt/z5OlNbpLee3OT93/P+Z/zmiwWi4UYhmEYhmECTEigN4BhGIZhGAawKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYxiOWL19OP/30k0ev/eGHH2jFihW6P/J79uyhTz75hMrLy9XHNm3aJB7zZt9JX7wnwxgRE3d0ZRhbfv75Z8rPz1fvh4WFUXp6OvXv359iY2N9eri+++47SkpKolGjRrm1rcnJyXTsscc2WY9B7vPPP6eGhgbq06cPDRo0yGvbetxxx1FRURH9888/br+2b9++NHDgQDEQu/NZREVFUY8ePahfv37kD1599VW6/PLLafv27dSzZ0/x2IMPPkgPPfQQ1dbWinPDVTZs2EBbtmyhs846q8k6T9+TYYINPvsZxo67776b1q1bRyeddJK4j4ECV7K5ubl077330u233+6zY3b11VfT6NGj6YMPPnB5W//66y8xWGdnZ1NCQoLN+l9++YXOPPNMsXzrrbfSU089RUb+LPLy8ujPP/8UAvH9998X4sbf4H/jmIaEuBdofuedd+jxxx93GA3x9D0ZJthgUcIwDkC0QnsVj4HkuuuuozvuuINGjhxJxxxzjG6OW1paGhUWFgohc+WVV9qse/3116lr164iDREsnwUiDogknXHGGUIs+pvp06eLm97fk2GMCMtyhnEBk8lE5557rlh2lq44cOCASL/ghqiFIw4ePCh8GEuXLqVDhw7ZrMPAW1FRQfv37xfLuC1ZsqTFbUN05NRTT6U33njD5vHS0lL69NNP6aKLLmr29RjYv/rqK5EqwWscUV9fLyIU3377rdN9c/dYeArSPqeddhpt3rxZpFUgyHCs8D8BIitffPGFTdoHx/XXX3+lL7/8ktavX+/0vXfs2EFff/01rV271iP/R2VlJf3+++/0zTffiPeSIJq1detWsSw/W9zk8W7uPRGhgwcHxz4rK6vJemwrUnSgqqpKnFs//vij088SxwJ+HmwjjiFSewyjG+ApYRjGyqhRoywZGRlNDsnChQsxYlg+/fRTm8eLioos06ZNs0RGRlrGjh1rOeqooyxRUVGWW2+91dLQ0CCeg7+XX365ePzoo4+2nHDCCZbOnTtbZsyYYamurhbPOfPMMy3R0dGWTp06iWXcbrvttha3tU+fPpZvvvlGbNuWLVvUda+++qolIiLCsnXrVrEO26MlKyvLMmbMGEtsbKxl4sSJlr59+4rl559/3uZ527dvF+sSExMtxx13nFieP3++ZdKkSZYjjjjC7WMBsM3YP08/iyuuuELs0+rVqy1///23WH7jjTcsp5xyimX06NGWHj16WJYvXy6e++yzz1ri4uLEduO4p6SkiP3ev3+/+n61tbWWmTNnWkJDQ8X/xO2MM86wzJ07V7w3joFk1qxZ4jG8RsszzzxjSUhIsHTr1k38n169eom/+fn5Yh32Ga+Tny1uBw4ccPqedXV1lptvvtkSHh5uGT58uDiW+DzPOussS0lJifq8G2+8URxvHIshQ4ZYJk+eLM6hpKQky59//mmzjZ988ol4vH///papU6daBg4caBk2bJhlzZo1LX4WDOMPWJQwjB0YkPDD/fHHH4vbe++9Z7n//vst7dq1s5x77rlisNCCgTo1NdWyceNG9bHff/9dDCYYjMCiRYvEoCMHSoBBGu+tHWAyMzMtZ599tsufiRQl2KaOHTta7rrrLnXduHHjxACWm5vbRJTU19dbBg8eLP7fnj171Mexn3juZ599Ju7jfTGAYUDPzs5WX3vVVVeJ19qLEleORWtFCUQcBvyYmBhLRUWFKkoGDBhg+e2338RzKisrLfv27RPCDOsgLiQFBQViu/HeEoiCkJAQy3fffac+huXevXu7JEpefvll8diTTz5ps62LFy+27N27Vyzfeeed4jmOcPSejzzyiHjsgw8+UB/766+/xH5Pnz7dRpTg+F544YWW4uJi8VhZWZkQHCNHjlSfh88S4uzaa6+1+d8bNmxQjxvDBBoWJQxjBwYrs9msXs3+5z//EVequPp84YUXbJ6LH3MMHC+++GKT43jBBReIgRvMmzdPPA9Ri+bwVJSA22+/XQzgEA3btm0T/w8RFEeiBIMlHluwYIHN+2FQ7NKlixA02ue9//77Ns/DwI5jpBUlrh4Ld0WJViBi8EcEBgIC0RogRQkiHfYgGjV+/Pgmj8vI0ooVK8TxSk5Otpx22mlNnnf66ae3KEogLtPT09Vj5gx3RAneE9uEaJQ9iJ6YTCYR6ZKiBK+F+NMCgYTH8/Ly1M8M9x966KFmt5NhAgkbXRnGBXMlwP1p06aJnDwMrwA+C5nLh4+hUeirPgx4AJDbP/nkk6ldu3aisubss88W5bu4tW/f3mvH/+KLL6Ynn3xS+AlQddOxY0c64YQThOfCntWrV4u/9qXHKEc94ogj6Pvvvxf3V61aJf6OGDHC5nnYl169etk85uqxiIuLc2u/4NOQ1UioMpo4cSK9/PLLTcqbYUDWAm/Ovn37xP7I7QH4e/jwYdV/0qFDB+E/sd9HcOSRR4rXNgf+D7xCF154IXmLvXv3im1yVBqOcwj7sGbNGurSpYvqeRo+fLjN8+Q6HAOUjOMzw3mI0uOVK1fSiSeeKAzbAwYM8Np2M0xrYVHCMC6C/hLdu3enF198URUlGDABzIV//PFHk9egzBMDMgYImBkXLlwonvvWW2+J155zzjn02muvicG2taB3BwZRvB/MlhdccAGFhoY6fG5NTY34GxMT02QdHpPr5d/o6Ogmz8NjKJeWuHosvCEQHWEv8OT27Ny5U5TjOtoe9J9paR9bAiLM2bH0lJY+H1BdXa0+FhER0eQcwmPa7QOLFi2i9957T5h5Z8+eLSrKIEpwfIYOHeq17WcYT2FRwjBugOZp27ZtU++jkZfsAYIr+JZKd9HnBDcMOvPmzaObb75ZXA3feOON6hVva5g5cyZdc8016rIzUCYMUL0CoaUFj8n13bp1Uwd2DOASXKnv2rWLOnfu7NGx8AX2x65Tp04UGRkpIguvvPKK09ch8oUIEfbRHm0FjTNwDPB/UMnizvY1R0ZGhtgmfBb2yMfkZ+MOEKkQq7iBv//+m6ZOnSr648hIF8MEEi4JZhgXQRgcZZ3aMDlKcVNTU0VTLEellQjDyxC/dj2uYmW4PycnR30cYfbi4mKPPxOULSOic8MNNzTb9RRhfFxxv/DCCzZlqBiYUL6KCA5A0zJECyCgtHz00UdUUlJi85irx8JfmM1mmjFjhkj9QEDZg+OOaAP2D8cDzdi0qS4sf/bZZy3+H0QozjvvPBHNsRcmEDyyNBefLXDl88U2QSx8/PHHNqXjiHogdYXUmX26piWwHejAa5/yGjJkiM05yDCBhCMlDOMAhP5lygADLPwQL730EsXHx9Pzzz9vEzlBj4jTTz9dDBLnn3++8Cjg+egtgSgE+ocgbD537lzR8Kt3795icHnzzTdFyuGSSy5R3+/444+nZ599lp555hlxBZ6YmCjaubsKno+BzJWUCFJJuGLGgIztgi/i6aefpqOOOkpEc+RAinQVthHRHTwX0QOIs3HjxtkMcq4eC3+CYwlBAl8JGsuhcyrEBrwy6FsCbw2iHHge9mfMmDEi0gShhuOIaNNjjz3W4v/B54UW8oh6XXvttaLTLP7vhx9+KPqLwEeDzxEdW2+66Sbh9UEkBH+deWwgGCdMmCC2CWkWCBWk5iAg4Plxt/sr+p3AQ4L/iVQNzmWk2ZBusxedDBMoWJQwjB1IPSD0L82V+PFH6gU+Egzi9nn+sWPHipA6rrTRWA3mSYTW58yZI9YBDFRTpkwRAx2alOHqGlfxuEFISGbNmiXSJAirY8BAGqU5UYJt1U4W5wgMuvBPDB482OZxGG4xOMFPgG3CfkF4obOodv4VDMwYzN9++21atmyZ8K1gOxERsf/frhwLgIFRGjGbA/unbYLmTGBh//CZ2YMBH83qIAzQiA6DOQzAEH9I6eDYABxnNCHD/iNSBEGI44KUDgSYds4jRy3h0cAOExQisiKb40GYYFmmvXCsFy9eLJ6DG8Qujgm20dF7Yn+wTfAfwZgKPw6iYDA0Q+xJ8L4QlY5SQHhPGaGBKEQkB1Guf//9l8rKysRngGZy+P8Mowd4Qj6GYRiGYXQBe0oYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFbU6UoGHR7t27HbbBbqvwMeFjwucKf3/4N4V/Z/VAmxMlDMMwDMPoExYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlQcoXX3xBn332mc9fwzAMwzDeIsxr78S4zZw5c6iqqsrp+t69e9N5553n0ZGFwKirq6MzzjjD5dcsWrSI6uvr3XoNwzAMw3gLFiU6YcuWLfThhx/S7bffTtHR0a1+v9NPP93tmZBPO+20Vv9fhmEYhvEUFiUB5K677rKJbECU3HHHHZSSkiIe++ijj+jrr7+mXr160XfffUdms5muvPJKWrJkCf3222/iOe3ataMRI0bQuHHjmv1feC+InX79+tFPP/0kIjQnnngi9ezZs9Wv2bNnj9j+qKgomjBhAu3evZvKyspo+vTprTxCDMMwjDepqrbQS4uIMlKIpk80kd5gUaJjIArWrl1LISEhdNJJJ1GfPn2aPGf79u306KOP0owZM+iZZ55xmr7Be61bt47Cw8PphBNOEMLhzjvvpN9//52GDBniMH3T3GuGDRsmnrNixQqaNGkSjR8/nvr27UtPPvkkhYaG0uDBg1mUMAzD6Iw3vye6Za5FLLeLI5o8Ul/ChEWJzsnLy6MdO3ZQcnKy+thxxx0nbpKbb75ZCJbrrruOevTo4fS9EL1Amig+Pl7cnzJlCs2bN4/mz5/v9msWLFgg7t922230n//8h9555x1x/9ZbbxVeGIgShmEYRl9s2K0IEvDo2xYWJf4EaY3s7OwmjyMagKt5X5GWlkb//POPV94LUQitIJGsX79eRCxycnKEdwSpkw0bNjQrSiZOnKiKCzB06FD6999/m/3/zb2mvLxcbMPDDz+sru/cubONYGIYhmH0Q06hdfmXNUR/rLfQ2EH6iZYEdaQEguTAgQNkZKS/RAtEwP/+9z869dRTqVOnThQRESFSPIWFmrPNAbGxsTb3w8LCqLa21uPXHDp0SPzt0KFDE1HW0rYwDMMw/ienyPb+7Hct9NUcFiV+AYOjI/wRKfEV2PbZs2cLv8cpp5wiHoN35LHHHiN/07FjR/H38OHDNGDAABsxGBkZ6fftYRiGYZrncIHt/a//IFq300KDe+hDmAR1pMRRCgWpjqysLMrMzBTRBaOBKEVNTY1I10gWLlzYYsTDF8TExIiqnzfeeEOkeQAiU0uXLhXGXIZhGEbfkRIw510LvfcAixLGAyBGLrzwQnFDY7WDBw/SsmXLmqRZ/MVTTz0lfC8w5MLg+tVXX1FGRoYhBR/DMEwwU1dnofxiZXlQd6LsAqLcIqIPfyJ65FIL9cgIvDAJ6kiJkUA57axZs2wap6HPh6NGaq+99hp9+eWXtGnTJurfvz+9+OKLIloBE6qz5mmO3gvRDW3PEfvmaa68ZvTo0bRx40b6/PPPhWBCH5UHHnhA9E9hGIZh9EOuJkrSNY3o7Ikmuu9VC2GoePJ9C718W+BFiclisVjrg9oARk/f6O2YwD8C4SIrdHAfAuu5556jiy66iIwKnyd8XPhc4e9PsP2mrN1hoaGXKEP+ZVOJnrzaRF2mWai0giginGj3hyZKTwmsMOFRmWkVKAseM2YMXXXVVXTttdeKpmqInng6Zw/DMAzj+3Lg1HZEiXEmuuZ05X5NLdEzHwU+RsGihGkV6IsCY+uoUaNEWuett96i77//XnSBZRiGYfTDYa0oSVQiIjdNM1FkhPLYy4uICkoCK0zYU8J4pQT64osv5iPJMAxjkEhJhyTlb1qyiS49yULzviAqqySa+xnRAzMDtokcKWEYhmGYtkBOoTUKkppoffz2c00kW3e98KmF6ustxknf/Pjjj3TuuefS5MmTxeRr6JkhqayspAcffFCUiKKSAxUiWlpazzAMwzCMH9I3mgLJrh1NNGm4spxXTJRfQsZI3/zxxx+iL8X9999PAwcOFF4CNCgbO3asWP/ss8/Svn376O233xbT2WNG2a5du6qTs7W0nmEYhmEY/xhdtaRrZjSBMLFfr0tR8vLLL9M111xDRx11lLh/5plnquvQ6vy7774Tc7Kkp6eLGyZmQzMtiI6W1jMMwzAM4/turqhITrbOsyrQ3s9z0PVVd+kbpGkwhT2mssecKyeffLIQGDJ9g8nZKioqRI8KSZ8+fWjHjh0urWcYhmEYxvfz3qQkEIWG2vYjSUkw2URKAoXLkZKcnBzR/AUpm5deeknMtYL0C9qbX3HFFaJfhZwPRRIXF6c+3tJ6R0DwaD0rYoPDwsSsuJ4iu5xqu522dVo6JuvWraPU1FSfTjSoN/g84ePC5wp/f4LpN8VisaZvYHK1344kTaQktxhdXr1vdnWlaZzLokTO+oo5Vzp16iSWYXhFe3GIErPZLB5DNEQKDwgO2aa8pfWOeP3112nBggU2j02bNk20P28t8LboDQz+ODbo/eEumzdvppSUFGrfvr3Xj8nZZ58tjvkll1xCbQ09nid6gI8LHxM+T4z13SmtNFF1bRexHG+upKysHJv1lhqM0alieceeQsrK8r7btVu3bt4TJRjwEhISbJQOlmWXekzCBuGyfft2dQ4WLMuNaGm9I9D7YsaMGV6PlOCk6Ny5s67azG/YsEHMV4M5Y/bv328zC7ArnHjiiaKjKm7ePiZohJaUlCTaI7cV9HqeBBo+LnxM+Dwx5ndn+37rcpeO5ia/5/00KZv6kHaUmRkYp6vLosRkMgkfybvvvqsaVz/66CMaP3688kZhYaJMGJGN2bNnix7/P/zwAz399NMurXcExEdrBEhz4KTQ02CDqBCOD6IlX3zxhdM27fDmYEZe+HHkscHEfFVVVeKYrly5UjyGVu9///236LKqnRwP4gcCA0ZjGWEpLCykw4cPC4GJaihHxwWfv56Ol7/Q23miF/i48DHh88RY3528YgQQlCBCh3ZNUyntE63rMZNwoH733PqvqLzp0KGDECdIowwYMMCmk+ett94qoiEYXG+88UaR1hkxYoTL69sq8M2gTBrHd+bMmfTqq682ec7BgwfVGXrPOecc6tKlixAvAJPfQVR8+umndNNNN4lbfX09HXvssfTLL7/YvA/eH63gJfAH3XLLLfTQQw+JqiqInVWrVvlhrxmGYZjAdHM1NVmfommmZgijK0BK4eGHHxYDGK6c7YFxFRU5CFM5UlktrW+rwJeDqMfUqVNp0KBBoindzp07VW8JIhhI7cBUfODAAUpMTBTRDdl8bv78+UJ8XHfddeLmDs8//7w6eyXCivfdd58QmmvXrvXJvjIMwzCBnveGmtAuFhFxxRBrGFEicSRItLQkOPwlSEZc3kDZjSVQKhai+voMpaWuyTcu6LQkon8WuL6PCxcuFEIAKS4IEUREXnvtNXr00UfFejSoQyoGqR0IEoCUzEUXXeSV7a2urqZdu3ZRdnY2jRw5kh5//HEherRpH4ZhGCZIGqdF1FJDTRiFRFjHqbAwE7WLs1BBiYE6uhoNCJIDufrebUQoUGYNUbJixQrVDwJRgqhUaGioMATjb//+/b3+/+fNm0f33HOPiMJ07NhRLRODd4VFCcMwTHDNe9OnoohCL/qXlphDqM99vajLRZ3J1NizBP1LIEoMFykxCohYNEFESuooNDSMyOTH/+sEiA+U8cIXoqW0tFR0wEVKB2XT8Ihg7iCIB3ciWrI6SoL+MlpBhHTPt99+K7wkcGNDAKHBHfdxYRiGCb70zcSiQ0Q1DVRX00Abb99M+987QAOf6k8JQxPUrq7FZUS1dRYKD/PRINlWRYmjFIrinzggBuBA+1qwLai6eeyxx5r0ALn++uuF4RWiZMyYMaIsF8bW888/X30OKm5k6TD6wGgFB4ApGeXFEqRktB10d+/eLYQL0kXwqoDvv//eZ/vLMAzDBDZ906Oq1Obx4tUl9PvkFZR5SRdKj+qOJhBqBU5asv+3M6hFid5ZvHixEANo228PjK1TpkwRPg90UoUBFdU5uI8+Lyj9xaSGr7zying+JkiEaBk+fLiocEIKCO8B0yx6xEDUYBkRF8mQIUNE7xn0NjnmmGPok08+EQKJYRiGCT5REmJpoO7ViiiJSI2giKQIKttSRtRAlPXqXjovOpv2pfSnlXHtRQonEKKES2ACCMyrMKs66sI6YcIEUaK7fPlycf+BBx6gN954g/7880+aM2eOSOU888wz6vPxWL9+/WjWrFlqSTCMspdffrko+/3ggw+EsEEXXogUAM8I/CxIFSF9tHHjRlq0aBGNGjXKptMuxAv8JgzDMIxx0zedqisostE3mDSmHR21bAz1mdWbQqNR+UEUVVFDd+5bR2ENDQEzu5os9qaDIEeWv+ohfaMX+JjwMeFzhb8//JsSvL+zNbUWipxkoWOLDtFtBzaIx/rc34t63IR0DVHl/kr69/zVVLJeiaJc2msczZ0TQ2ce439PCY/KDMMwDBPE5DVW0/SosoY/4odYZ+AzdzJT8gRrrqZ9bVXAKnBYlDAMwzBMEHO4sV9Xj0qryTV+kGZaYAiTDOt8ayxKGIZhGIbxCTlFwquhVt5EpUdRZIrtvHJRTURJYJwdHClhGIZhmCCvvEmrqaSYhjpxP35wXJPnIIUjSeX0DcMwDMMwvkrfaPuTJGj8JBJzJ9tICfqUBAKOlDAMwzBMEJNTZLE1uQ5uKkrCk8IpxKxIAvaUMAzDMAzjs/RNcyZXgO7e5gyzVZQUsaeEYRiGYRgvc7jAQj0bIyVhSeEUlR7p8HkyhWNuqKfKAsV/4m84fcMwDMMwQUzVwWpKqFfmRkscEi+iIo6I0vhKoourRNM1f8OihPE7Dz30EJ111lluveaOO+6gGTNm+GybGIZhgpXoAyXNmlwdmV1T6gJjdmVREmAwP01iYqJ6Qwvik08+mVasWOHV/3PLLbeIeXaaA5PxYRvOOOOMJuswYzHWjR07ttXbgnl7ysrK3HpNRUUFlZeXu3wc5e2zzz4jo4OZpDHRIsMwjLtgJpnkXI2fpDlR0ugpAe1rAtPVlWcJDjAYoJOSkmjVqlXifkFBgRAHkydPpl27djmcrM8TWhrU5bZghuFvvvmG9u/fT506dVLXvfzyyxQTE0MlJQGapcnN4yjBNhud6upq3R53hmH0TXEZUbeKkmZNro4aqAWqVwlHSnQAJmeSV/bdu3enu+66S0QSNmxQJk6SfPHFFzRu3DhKS0ujkSNH0iuvvCJUsGT9+vU0depU6ty5Mw0dOpSeeOIJdbZgXG1/+eWX6v/55ZdfHG4LRNAJJ5wgZiSWrF27lrZt2+YwgjJv3jwaPHgwdejQQcxq/MMPPzR5zuzZs6lHjx7Uu3dvuvLKK8WsxPa0tG/uHkd5Cw8PF+t2795N06ZNo/T0dOrWrRvdcMMNNtGavXv3iue///77Yj+wHRBncjbnk046ScyUPGjQILr//vuFUNCC5+DY4/0R1XjzzTfVdYsXL1a3B+snTpxIy5Yts3l9dnY2XXjhhWLb+vTpI2Z6xnHCZ4YoF7ZfvsfcuXPdOi4Mw7Ttbq49GitvaiLCKLqrNRrSfK+SShYlDFFdXR29++67FBcXJwZAyQcffCAG9Ntuu01EA+bMmUOPPPIIvfTSS+pzTj31VDH4//777/Tee+9RcXExff/993TrrbcKP8aJJ55Ie/bsETcIAGdceumlQsRIUYDUzTnnnNMk6oDHIaDuu+8+WrlypUg7YfCGiJFg+5588kn63//+JwRLu3bthJDR4sq+tYaamho67rjjhED7+eef6cMPP6SlS5fSzJkzbWbwxPG65557hOdl06ZNdPzxx9OaNWto0qRJdMopp4h9hNjAflx//fXqa//9918aP3489evXT4iN1157TfwfzAgK8Hp53PEe//nPf8RnsXPnTvU9rrrqKsrPzxefF249e/YUxxfPg6hEWk++x+WXX+6V48IwTPBzaGc1pdQpF1Fl6XFOTa6y/bwkUL1Kgjp989vEP6kmx/aKFsMsBqddoVnkq0mZI1Ij6aifxrj8fHkVDHD1HhsbKwbOlJQU9Tm4OsdAjQEN4Iobjz3//PN0zTXXUFVVlRiwzjvvPOrSpYt4DgYzdZsiIkTUQP6f5oC4wCCJAXbMmDFCJH333Xf0+eef2zwP7w/BM336dHH/7rvvFoMxRAUiDuDxxx8XJtXTTjtN3Me6b7/91uZ9Wto3T44jQPRm69atYlvy8vKEoIDYAwsWLBDCbMuWLdS3b1+bfYKIgEhBpAL3zz//fLr66qvFekShXnjhBeGtwV+ku/773//ShAkThPiSaCNNYWFh6nbhLwQNIiCffPIJ3XnnneJxbCeiI4iSgOuuu059vdlsVqNADMMw7lCwupRkAXB9V+epGxBqDiVLQgSZimuEKNnHosS7QJBUHbIVJZI6CkwNtiNwFSy9EBgIIQIw0C9fvlykYXAFvWPHDjG440oeEQzcEAGAwAJRUVHiNWeeeaYwtB577LF09NFHCzHiLhhEkUrAFf/BgweFSBg1apSNKIF4chRxQcTgo48+Up+DaAGEjRbcl1EEV/bNk+MIMJDLtBaiTlKQgNGjRwuRtnHjRhtRMmTIEJv3RGSjsLBQ7JPcNmwXbth/iAg8B+kgZ0Awwie0aNEicTxra2uFx6dXr17qc3C8cQywrYjqQBhpt5dhGMYTKjaVqKIkvG/zogSEpUVRfXENJdVV05qCer/HLoI6UoKIhT0yUhIaGurTSIk7aK+C8RcpkXfeeUd4BxDCxyAGkFKB2NCiDcUhDfLjjz8KD8ONN95IRUVFYiAcMWKE2/twySWX0LBhw8QVPJYdpZmkgNGC+3Kd/Itjbf8ciav75grOognYDvvtxHvj+XIbJYh8aMH2QSw4Eh3x8coXHFEV6V1xBMQWUj6IrMBXgzQY0mkQXhJEmWBu/uqrr4QX6IILLqCFCxeqUSiGYRhPsOzQlAM7mIjPUa+S8q0lhF/t8oO4qGdR4jUcpVAwgOAqHVfV8kpaj2BwxNW0TEOkpqaqfgRnYKCFDwK3p59+WqRh8BfpCwzK2HdXQQQAhk38T2n41ILBH9sEP8UxxxyjPv7PP/+oKQg8B8ZZ+DJgHpWsXr1aHdBd3bfWgO1B9AnmVCk6YCLGfbmtzkCE5c8//6QHHnigxec4Aymtyy67TBVd+Bw2b94sjLNaIB5xg6cFQmbWrFlClLj72TEM0zw//Wuht3+w0A1nmmhYb19dnuqDyL2KybXKFEKdBrRcjRiXGUWyTrM2uwo1jORP9Dsqt1Ew+CDigYEbplEpNjBIPffcc0Jg4AobqRFcVcN7AVDCCx8IqmSQYsjJybEp64UXAuvsq0aaY8mSJSK94qwsGVUhTz31lBAiiD7BB4PIzM0336w+B/4J+ErWrVsnohIwr2oHcFf2rbXAEwIBevvtt4vSYRwbbBfEFNJjzQHPB6Ic8JagpBrb98cff9iYTfG+SG1h35CqQbrnwQcfFMcfoKIGPhrsF4Qmng//ixZERlDBg2OE/4PPSvvZoTonNzfXK8eDYdoyW/daaOpdFnrjO6LrnwvM/C7+ora4lmKKKsXy7qg46pDSsgBL7KapzsmFKPEvLEp0gLbcMzo6WoTyn3nmGTGYSpCOQdTj3nvvFeF/DFjwfKAqBuCqG+kWVODgPVCFgwEXV9sAPhO8LiEhodmSYC3wqTTna4DJFYMp/A94Lu7Pnz9fmD61gzpKjBEBQOUNBm/7zqwt7VtrwT58/fXXQgwhQoP3x2OoUGoJlO9CIH366afitcnJyWKfzj33XPU5SLtAkEFYwaSM6AtSVjISAuGGPiPYf7weVTfwjWjBvsLcis8HIhACBmZcgOOL6BfECZcEM4zn1NVZ6MJHLVTZeG2262BwH82S9db2CzvM8ZTaruXXaMuCwwv8L0pMFnebQRgcvaVvcGWNmwSCoiVzKp6PNIQzz4U2TWEPPBK4EsfgKX0W8pgglYKIhzMhgv+L19uvxymECAS23RmIAGB7MVjjffB/HDU2c7ZveH9sp7NmaM62zdGxwTbYe0zw3hAOEB44LxydJ4iS4LX2Hhn77YBAc/a/8X/xekRMxKycZtueAdgHPMfRZysrgvD+zj7ftvb90QN8TIxzTB5500IPLLQOeeFhRNVLTW7714xyTHbN20Nb7t8qlud37U+L/u3c4muK/i2iP47/Syz/0L4TPbtlAPmToDa6GgEMMM4GseZe0xzNDVjNlQXjfZv7sjjbVnyhmxMkQCsCmtt+Z+vsB29Xt83VY+NKya0rlUzNbYP2fzs7Xs0ZZrGNiKQwDOM+/2610MNv2F6D19YRlZQTJcQG5xEtWWs1uRanuVbNZ+5k/a1NrKyiqmoLRUX6z3ejHwnLMAzDMD6gstpC5z9iobrGLgORmuuLQDQI8xfFjaKk1mSi+k6uKa+I9hFUH6KIEPQqyffzDBcsShiGYZig5u75FtqyV1ke3pvo4hODX5TUlddR+U6ljiYrMpZSUlwb7k0hJqqMjwpYV1cWJQzDMExQUp1TTT/ctIP+eD0X5jcRIXn7PhN1TDYFvSgp3VRG1NhJYEdUPKW60RC6LkkRJbENdZR7UOkl5S/YU8IwDMMEJevu3Up1nx2iB9FDKTaZku/oR/27xlBKgtVbkldEQUnFHqXPFdgXGUODktx4cXsz0a5CsVi0q4roaPc7g3sKixKGYRgmKNm3tJCk9XxEWT6FPPoHba/oRimDuqqJgtwgFSWV+6xVnTkRUZSa6LpZNbyj1bBfuhfv03J7em/BooRhGIYJOmoKaiiq2LbPRkN1A22fs5PiMg7R0LC+tCY2mfKKETUJvq6ulQeUpmkgJzzKpR4ljnqVVB7wb68S9pQwDMMwQUfJOmvjsGXt06nbdV3JFKqID8uBCno0axVNy90dtJ6SKk2kJDfcTB3cSN8kdLWKknrRat5/sChhGIZhgo7itVa1kZ3Rjvo91IfGLRtD7UZZHZ/HFx0IWlFSuV+JlFSbQqg4NNwto2tyT2uvElMeixKGYRiGaRV5q6yRktouSuOw+P5xNPrrIymmV4xa8ppbGHxNzS3osr1fERO54VHocOlW+qZDb2ujx4hCaxrIH3CkhGEYhgk6iteVqJGCyO4xNn04orsqkYBwi4Wqc2so2KgtrKX68nrVTxIWStTOtYaugqTUMCoJVbpLx5RypIRhGIZhPB+US+qobq9SErsnKpY6ptpef5szNOmJAMyE62sqG6MkMlLSPhHTVLhu5sXUIYWNU2bEV1aTpd5/0SSOlDAMwzBBRelGzey4UfE2zdJAlKa6BBU6mD04mKjcp628MbuVupGUxSrHKBTRpMON0yr7ARYlDMMwTFCmbsDOqDhKT3Fe8ppSU0UFVg0TFFRpIyURUdTBA1FSlWA9RoW7/OcrYVHCMAzDBO3suDvNcdQx2flMuIGY38VflTee9CiR1De2mgd5O/yX4mJRwjAMwwRlpKSOTGIyuvQmosQ64KZClBQFr6ckB+kbN8qBJaYO1mNUvIdFCcMwDMO4TX1lPZVvU2bH3RsVQ7UhoU0iJZFpkWRptJm0r60MvkjJPiVSgvn48sMiKT3F/Y61kelWUVImWs37B46UMAzDMEFD6aZStVoEJleUwkZF2g7KIeEh1NAu0tqrJNgiJQcUEVEQFkl1ISGUmeb+e0R3tqa4qjUt630NixKGYRgmaCjWtJd3ZHKVmFKVQTexvpbyc5WeHsFAfVU91eTUWBunEVFmB/ffJ7FzpEh/gYbDHClhGIZhGLcp0VbemFEO3HJ6olxjDA0uP0mU+NvFA1GS0s5E+eFKNCkkn0UJwzAMw7hNcWPlDfwUux2YXCUxna2ipPpgVXCWA4ebKSqCPKq+SUmwRlrCK2qprryO/AGnbxiGYZigoKG2gco2K+mbAxExVBUa5jRSktjNKkr8mZ7wazlwRJSIkqBDq7ukJFpFCahq9Kn4GhYlDMMwTFBQtrWMGmoaTa5mZbIXZ5UnST2sA64/0xP+Tt9kepC6Acnx1vSPeF8WJQzDMAzjOsVrrSbXXVGKKHEWKdFWl0QVVQVpi/kojypvQHwMUUEkR0oYhmEYptUmV5QDA2fVN9r5b2LLgtVTEkVdOrifugFI+VQnaiIlmvf1JZy+YRiGYYJOlOwyNx8pCU8Mp5qwULGcVF1FldWWoPKUlIWEUUVouMfpG9CQbHboVfElLEoYhmEYw4OGaSWNswMXxpipLDS8WVGCSEB5XJS1gVqh8UWJpcGiej+kH8TT9A0ITdOUTWexKGEYhmEYlyjfWU715UoTtD0xSpQkMZbIbNfNVUtNY3oi0tJAuXtrDX+kqw9Xk6XW0urGaZK4lDARcQHlfmo1z5EShmEYJmgm4QObQ2XlTfOvsbS3RgLy/TgTrl8qbyLMFBJClNHe8/dDr5LsCCWFU3uoSpRc+xoWJQzDMIzhKdG0l98S3rzJVRKmnQk3KxhESaW6jEhJRgpReJhnRld7UUL1Fr+YXVmUMAzDMEHWXr55k6skKsMqSio0pbRGpXKfbY8ST9rLa0lJMNGhiGj1fsWeCvI1LEoYhmEYQ2OxWKzpm+RIKgpT5mxx1mJeEpdprS5BesLoVNlFSlrjJ5FdXQ+FW49RxW4WJQzDMAzTLJV7K6muWJmbpaaLEiUBHZObT120626NlFBuVfB1c01r3fshfWMbKfF9NIkjJQzDMEEUMWjLk/CBog6Kn8QVT0lqL6soCS8IBlFSKf7WmkxUGBZJmR42TtO2mj8kPSWcvmEYhmFcZcdTO+nHbj/R2mvXU3VudZs6cGVbytTlg/Gx6nJLnpIOqSFUEBYhls0lweMpyQuLIovJ5JVISX54lBA5gD0lDMMwTIs01DXQjmd3UV1pHR344CD9Muo3ynp9n2go1hbQGjz3hkS7HCmJjiLKi1CiJdGVNdRQ4/uSV19RW1JLdSV1XutRIj0lDSYT5TT6SpC+8XU0jtM3DMMwBqd8ezk1VFoHVPgrNt62if6Y8pdNaiNY0U5Ct6M2yuVICbq6lsZEqYNhlYHNrpU2PUqUfWpt9U2smSgywprCQXO6mtwa8iUsShiGYQyOVnhEd7dGCopXFdNvx/1JC6Zuopxs5So6GJGt1cPiwmhPabhL3VzV18YHR1lwpc3swGZKTiCKMbfOUwLR1ivDzuzq43bzbomSO++8k8aPH6/eTjrpJJv1VVVV9Mgjj9Dxxx9PZ5xxBn399ddurWcYhmFa16NjwBP9aPRXIym2T4y4b2ogyvhzH316za6gPLSY70WWwmLm34N5rqVuJPVJVlFSuKsqaGYHzmxllETSrytRth/LgpWm9i5SXV1NN910E5144omqitLy3HPP0e7du2nhwoW0Z88euueee6hr1640cOBAl9YzDMMw7lOs6WaaMDieIpIjaNyyMXT3CXvomHU7lN/rPdbnBBNIJzTUKD6H8I5RVHnYtdSNSqpVlBTsrAqSSEkUdfOSKOmfSbTYjxU4bqdvIiIiKDo6WtzMZuuG1tXV0bfffkvXXHMNde7cWURSJk6cSIsWLXJpPcMwDONZpKB0fYnaoRSCBHz7dwg9VddVrZyIKjbugOvqYFyniXq4GimBkJGUGbjVfGVjCstbPUok/TLturru1lH6BsydO5cmT55Ml156Ka1YsUJ9PDs7m8rLy6lv377qY/3796edO3e6tJ5hGIZxH4TT68rq1SgJqK+30F3zLaIsFOWhILbMuAOuqwbPigTrhXLHJNdeH93J+pqqA0b2lFSpy3kifdM6P4lN+saPkRK30jePP/441dfXU0VFBS1ZsoRuueUWevPNN6lXr15UVqbUicfEKHlMEBsbqz7e0npH1NTUiJvNBoeFiWiNpzQ0NNj8ZfiY8HnC35/WEOjflKI1xepy3OBYsR2vf0e0aY/VX9CxtpKi6+qoprhGmEGD6ZhU7LMOkoVRSnt5mb5x5f8nZIRTjSmEIiwNVHe4ymfb7OtjUtnoqykMjaCakFDqlGqhhobWl+/2TCeqDQsV/VyS6mqEKPF0H0IwbXELuHV2RkYqHzhSN+ecc46IlPz8889ClMhUDgSLFB6IjMjHW1rviNdff50WLFhg89i0adNo+vTp1Fr27dvX6vcINviY8DHhc8V435+c33LV5aq0KtqybS/dvyBd/XkXA3XjuL1z5S6K6mkduIPhmORssu7/riprhVFYQy5lZblwVV8brcyoW1NBptxK4Xe090vq/ZhYai1UnV1tUw4c0XCIsrK8U77buX06HdoZLURJdU4N7d6ym0LM7hfvduvWrcXntEoyh4eHi8gJSE9PF6Jlx44dNGTIEPEYlrt37+7SekdcfPHFNGPGDK9HSnBSwNfiimprC/Ax4WPC54pxvz85WXnWq9pJPei5n6Iou1C5P3UsUeQKM1GBcj+yMokyM100WxjkmOSXFFoNv/Ht1eXBfdtTZmbLr+9bQPRX+F4hSsJqGiijXQaFJyhlxUY5JhVZlbTFst2mcdrooR1F8zNvMKgH0aF/zTSAisT9lIYUisu0zjHkTVwWJcXFxaJq5sILL6TExET69ddf6ffff6cLLrhAFSiTJk0Sz3nsscdo7969tHjxYnrqqadcWu8IiI/WCJDmwEnBooSPCZ8n/P0x8m8KumuWrFeqaiLaR1BFTBQ9/r7cHqI5V5rogx22Ja/d/biN/jgm0lNiCjNRVrU1CpTR3kQhIS1HPFITLcIYKqk+WEOR7SINdUyqD1inFcC+oFNt+3Ymr0V8BnRtoL0aX0llVhUlDEyggIqS+Ph46tSpE1100UVUUFAgIh8PPPAADR48WH3ObbfdRvfff78QH1FRUcIMO3LkSJfXMwzDMK5TdaCKagtqVZPr7HeIihttejOnEA3oZqLQNOuAW7on+Myuao+SjCg6WGgdhF0tCcb8LjK6IL0Z8QN8EwXwRwVSbrhZ9CjxZgoKFTh/+amBmsuiBDsILwduSNmEhoY6FC7oRYLyX6y3PygtrWcYhmE86+Rq6R5Hcz9XlqMiiB66RPl9jczQdCzVVKoEA5jrp7ZI8ZGY0Tgtn9RurtFRro0vSHGgWsVREzKjlgN38VKPEkm/TLsKHB82UPMohuRIkNj7PpoTHC2tZxiGYdzr5LooO45qlKAJ3TSNqFOq8hsb29k6mNRmG2/AdXUwhig5lO9m4zRYC8JMVK5pNa8tMTZq47RMb4uSrnat5n1YFsxOT4ZhmCDo5Pr+nng1SnDnedaLvqTUMCoJbTRu5hpvwHV1MDalmqmiyr3GaZKGZI0oMWCvkir7FvNp3r3oj4s2UVxaOFWEhPq8gRqLEoZhGINHSkLjw2h3vTKwjupPlBhnHZQwMVteuGLcDC2sIku9b6ee9yfaqEZVouuzA9sTomk1r21CFihqS+po25wddPDTQ8LM7Ko4qwwJpdLQcK9HSkC/riY1hYOJC311HrEoYRiGMSDVh6vV3hSmHnEw/onlHmhR4sTIGVJvoeoca6VGMEVKis2aFvNuipJ2KaFU3BhNKteBKMl6JYt2PLmT1lyxjrY9uqNZYVJ1qEoVZ+JzNpm81mK+ia8kvDGFU2exSZ15ExYlDMMwBqS4cb4bUJqupG5Ajwzb0H1yvDKVvZE9E81VH0lyIzUt5pPdS19ohVsturrWBbbjd9Fqa5fenc/som2PORYm5bvK6c+TV1JDtbK9O6OUqiFfREr6d8UcOL43u7IoYRiGMSAlmsqbgwkaUWIXKUm2K3nVDuTBFCk5aHJ/Mj6tKFF7lTQoUahAUrHLdsDf+b9dtH22rTAp2VAiBEllY3luQXQUvZXak1CH4m76ytVIiY0o8ZHZlUUJwzCMASnWVN5sibD21ehuJ0riookKIm37cAQLMuoTkRJBB0qsw5m7g3JKgsmuV0nghJul3qIO+KHR1krXHU/vou1zFGFSsKKQVpzyN9XkKG3kY/vG0gN9R1JOhJk6tUeFq/erW5tW4PjmPGJRwjAMY0BkJ1cMXOsqop2KErRfqGmnjwHXmzTUNgg/hX05sKeREptoUgCPUdWhKmqoUSIiKROSqf+cvuq6HU/torVXraeVZ/1DdSVKf5bEEQk08KORtLs6ymepG9A+0UQ1yRwpYRiGYeyoLapVw/bxA+NoxyHlyjgtiSjG3PQq2ZKijwHXm1QdqhapFhCFxmnWKYDcjpS0T1Q6oeohmlSuSd1Ed4+mrpdnUv/ZVmFy8JND1FCp7HjKscl05Gcj6FCNda4eX5hcJe17RVE9KedX6U5O3zAMwzB2qRtz/zjKLnAcJZGEt49UB5PyIEnfyPbywNzZrEZKEtzo5mobKYnURVlwhcZAGt1NiYB1vSKT+j1mFSag4+lpNOK94RQWE0ZZ2dbHfRUpAX26hajeG6RvXClXdhdO3zAMwxi4k2tVZ23ljePnJyWa1F4lwZK+0QoHMe9NvmflwLLV/GGtiTPLdx1L3RElMY2iBHS7MpMGPTuAYnvHUI+bu9PQVwZTSIQyhGcdtr7e243TnFXgWMrrqLawsYVwIOa+YRiGYfTlJwGHk7SVNyangy48Ex1qq6i+sJbqK+ptTJRGxCbFkhqldnP1pPIEkZKi0AjRfMzcUO8zE6crlO+0Td9o6XxBJ3GzJyvbGrHokuq7bUMFzpcQJeVWARWRFOHV/8GREoZhGINOxBcSYaKdYTHq487SN+hVYlNdEgRlwdqIT2m02WOTq2zNHxpmouxGX0nlXt91LG2J8sZICT5bs2YyxeawjZT4astkWbD7FThl28pExZArsChhGIYxEHVldVS+Q7lUje0XR7sOm5z2KJEkx9uXvBrfV6Ldh/woz1vMg5AQkxBuamrChx1Lm8PSYC0HNmdGkynUtVSM1lPi7RmCtXRKJSqKdb+B2t639tOKk1e69FwWJQzDMAaiZGMpUeNFfMKQeNp5kFr0lARjAzXpKQkxh9hUn6S72c1Vm8LJ1kYBfNSxtDmqs6vVypoYu9RNc+zNUf6mtiMyR/rOU4Ly8uiu1u0qcbECR9voryVYlDAMwxgI7Q98/OB42nlAWY4xK4OSK304jG52RdWHFFbmTmY6WGAdiD3tZopj5I+Opa6kbrSVNy2xda9FLYf2ZeWNJLWf9RgVbK90KfqjNWa3BIsShmEYg5pcYwfG0Z7G0H33jsqVrCOU+W+CJ31TW6CYdYG5cxTtPGBptadCESW+71jqbjlwc9TVWejCRy0kK3MnjySf07t3OBU1Tl5Y5UKVEvqu1JUpn5UrsChhGIYxEJiETVKSHEO1dc2nboIxfaON9CBSsn2/dV3vzp69JxqoSaNrwCIlOzXlwC6kb2a/S7Rys3W/773Ad6kbR2bXkIJqqq+s91rqRrxnq7aOYRhGB6H8HTt20Pz58+m8886jq6++msrLrQN3sCG9FBHJ4bS70NrVAZESZyBSUhEaTuUhYUFRfaOdiA8t5rftU5ZRHZ0U77mnJCfC2rE0EKKkYrfrouTfrRZ6+A0lRIJJ+N6+1+R20zhPRUm2TU+XSpcqxVyF+5QwDGM4SktL6euvv6YlS5bQ0qVLKSsry2b9qFGjaObMmRRsNNRZ53uJ6mSmLYes63pkOB+Q2sUhtaNES2Kqy0SreYg5Z+kevaMVVSEdomh/buuiJHJSvnpTiDhGabWVVLG70u/HqLxRlJjCTKJ1vjMqqy10/iMWqmsMUtxzPtGR/f2znd06EuWYo4mKrY3m4vrGOn1+8drGJ7oIixKGYQxFTU0NDRs2jHbu3On0OVu3bqVgpFoz3wsiBFovRXPpm9BQE7WLs4gBt2t1GTVUN1BNXg1Ftre2VjdqpCRfMwNyr6Z9xVwGDeYAzK4QJXWlSsdSbzcHcwYEUEWjKDFnmikkzHki455XLLRlr7J8RB+i+y/yn3DCDMSmNDNRo5epbGcFdWjO5LpW8UBFdXTtXOP0DcMwhmL16tU2giQyMpImTZpEN998s/qYfeQkWLD1UkTZlAM3l76xNlCLDIoKHO2kgvss1lRC706eD87wlACb1IQfy4Jrcmqovry+SXt5e37610LPfqwsR0YoaZvwMP9GvOK6W4/RwdXOU6VIgUHcgfgh1s7DzcGihGEYQ7Fu3Tp1+c4776TCwkKRxnn00UfVx/fubbyMDDJsvBSdzbSrUZSEhLRcdaKYXc1BMVuwehxCiLZVRnonUpKg/A1UBY4r5cBFpRaaOdsaHZtzhYn6dfV/Ci71iHiqbUxrFf/ZOBtkC34S9NRxBRYlDMMYivXr16vLU6ZMIbNZGWjxt3379m0mUoJJ6GSPEsx3EhHe/ODUtNV8peGPQ1RaFG07ZPKKKJGdUA8FKFJiU3nTzbEouXeBhfY1Nko7dhjRDWdRQOjTO4y2mBUVF3Kogir2VrbcU4dFCcMwwS5KBg0aZLMuMzNT/D148CDV1np/BtNAo+0vUpsURUVlzc9506S6JAgaqKEEFX4Y2aNEWw7cq1VGVyJ0UM8Oj3a5ssRnPUp6OBYlX/6u/DVHEr1xj0m0xw8EMBSvibF2qcv/tXGKZjuK12gjJY2hqBbgSAnDMIYBZkApSjp27EjJyckORUlDQwPt368ZrYIEbcolO9TsksnVWaTEqOkbm2hRJ6soSUsiiov2fJBGlQ2OY6C6utqUA3drKkoKSixqldHIvojsBK5yqnMq0ZrYJPV+3rJ8h9/V4sZOrpEdIikqjY2uDMMEGdnZ2ZSfn+8wSqIVJcGawpFeCsz3srvcOt9Lj/SWB6jkBBPlh0fK4h3D9irRRotCO5jpcEHrUzfaCQ0rQ8OouLFjqV/TN7IcONQk/EL2rNMUmw3uQQEF/WCyEuLVvjeIlKDSRgv8OHXFisk1YahrfhLAkRKGYQxpcm1JlASb2RVXnlJImDPMtFPjpXA1UoI+HAVhyhVrlUE9JdoIT3GMNfLTmh4lEpkGk2bXqkMtdyz1WjnwrsZy4M5RFBIR0oIoCWx/GUSV0lNDaF2MMtlSTX4tlWKiSA3a+W5c9ZMAFiUMwwSFnyTYIyXomSFLRlEOvOugxeVyYG11iUzhVB+uofpqGTcxZqQkO1Tbo6T1A7VsQGeTwvGDrwSDuiydjXZicl2306KbSAnISIGvRJPC+SXfuZ9kMIsShmGCXJQMHjy4yfouXboErSix6VHS2bZHiUuRkkZRojW7Vh2sMmybfbC73ioevJW+AbZt1H2fwqnQzGcU7VSUKH9RiTuwGwWcjPbwlSQ79ZV4Ug4MOFLCMIzhREloaCj169evTUVKtD1K0GJelgNDbCTEuuApaRwX8mzMrsZL4WhLmTdXRPokfWNTgeOHXiWYSVcS46Dypr7eQht2K8s9M4hizIGfHqBTe6L9EdGU15gOLFhRSPVV9Wo6qqSxvXxEagRFutjNFbAoYRjGENTV1dGmTZvEcq9evSgqquncIO3ataPY2NigFCVaL0V4mnW+F1dSN9pIiU2vkv3GjZSEJ4bRpsNhbkWLXOlVgsnt/N2rxKYcuFtTUbLjAOa70U/qBmSkmETYZnVjtKShsoGK/i4Sy5V7K6m2qNHkOiTerfmDWJQwDGMIMBNwdXW1Uz8JwI+fjJbA6IrS4GBB66Uoio4ii8W9wVhGSmwbqOlDlFjqLS4/T6acEC2S5cAQE+bI1kcP0K49s4P/y4LLWygHXqcjk6s2fQNsfSUFrUrdABYlDMMEReWNRIoSCJjc3MZwQhCg9VIcNEU18UG0RGSESTQHy9FZ+mbfu/vph65LafXla9XwvzOqD1eTpVYRMKFpUVRY6j0/ifZ4okKp2hTit/SNrLwhEybji9a9yVWmb8BarShZltekk6urTdMkLEoYhgmKyptg95WokRIT0c4aq7Do7kKPEtv5b/SVvtnzchbVV9TToc+yadWFa5wKE0RJtj9tDRlUxnlndmCHvhKTSTW7IhVh34PD26izA3eKotDI5suBh+hElKD6BhSGR1JBUqxacVNbVGsTKYkfEufW+7IoYRgmKCpvgr0CxzrfSyTtynGvR4k2hVMaGk5VjVGAqgCnbzDYa1MXuUvzaNXMNU1KlRtqGmjNleto3xvWLr2HB1pnIOzd2XspDVkWLEVJQ3UDVR2qavV+brx9M+2cvocKfredwK6moEb1X0Q7qbxZ2yhK4qJbnnjRX6QlKxNBgq1JjdESC1Her/mqKIlIiaCo9Kber+ZgUcIwjKFESUxMDHXt2rVNRUrEfC+5NU0qb9xJ36i+EpNJnS0YnhJUSgSK6uxqYZDUkvtjHq26aLUqTOrK6+ifGavo0OfZ4r4pzERD5g+iTTGJ6mu8nb4Bh7QVOLtbl8LZMz9LCKqaXTW0+tJ1Ig2lvre28qZ7TJPXFpdZKEvZdRrUHUJAH54S+G86KL3TaGWUNYWz/70DVFtQ65HJFbAoYRhG95SVldGuXbvE8sCBAylEXqK1EVGiNaRqe5RERhClN4bRXSGlcRyXvhI0Y0O4PVBooyRJY9tRaEyoVZjMXCMG75Vn/kt5P+Wr7fWPeGcYZZyVbjsRn7fTN00aqHludi3dUkZbH9mu3q/Nr6V1129QxaD2GER3bxopWa+c9rryk9ibXX9raEemxlmq8dl50slVwqKEYRjds2HDBpf8JMEqSrTlwFEZ6OaqLHdLc+/K2VEFTiAn5tNGCdJOS6ORHwyn0OhGYfJDLv08/Fe1zDQsPoyO/GQEpU5WRkIpSlDC283FsmhXkOkwmwZqHkZKkHZae/U6kQISmKxpqqwFe12aiG+d1k/SUx9REnuza4UpjKKHWCNXnlbeABYlDMMEjclVzh4cHh4eVPPfaMuBa9tFUVWNZ705rA3UInVhdrVvGpY0NolGaIRJQ1WD2oBr9NdHUtJoJV+AKMO2RlHSNY0oovEq3RtgpuH2idb5b1pTFrz9yZ1Usk4pEYrpHUOdnrTm2rY8uI1KN5faHIPo7i1U3nQnXSHNrqBhiDWFI3FnIj4JixKGYYJKlCC106lTp6CKlGiFQ36kuUmqwVUwUzDI0UQBUF0SKBxFCZLHJdGI963CxJxppjHfjqL4AdYqjux8ovJK76dutMf1cLhZnVHZkwZqhX8X0c5nd6k+mMHzBlLcMbGUeYVixEb0BObdsq1l6muiM81OTa5goN5ESXurGCzqYW05DyKSw0VUz11YlDAME1SiRJvCKSoqopISa3liMLSYPxCi7VHiXoRATsqX3Wh09VdzMGdIPwUG7ahO1v1KPiqJjlo2hgY+3Z/GLRndJK2h9ZP09oEogdm1LiREbcnv7qR8dWV1tPaa9SRVTa87eqipjN7396TYfkoJbenGMjWSgiqVULMixCQNDRbVU4IUVXyMPtM3YF9iPIXFWTvsxg923+QKWJQwDKNrEKqXogSpmZSUlp2dweYr0fo+dtZYUy+epm+0Js5yPzQHc/a5qv05Ms0UEmY7HMX0iKEuMztTRFJEk9fK1I23Zge2Rx5XeZwwQ3NtseuG4M2ztqp+mcQRCdT9RusMeqFRoTT0lcEUYtePJLp70yjJ7kPWiJDeTK726Zv9BSYhJlvjJwEsShiG0TWHDh2i/Px8l6MkwShKpKcEZs/thYpfxrP0jfK3MCyS6htFQGWAIiU1OTWi+seZwbM5tu+z+ix6eWEiPntkQzqbiJKLKZycH3PVfipIQQ15aVATwRXfP476PNDL5jFH5cDrbEyupDtk9Q04kEvU/nirSmk3prFe2E2ssRaGYZggSN0EmyhB4y1ZEoxy4L2HreswT4snkRKLyUQl8WZqV1AuUhP4HyY/97+wKYV1V5T4IX0DbM2ulZQwtOWW6Vsf2aYu9324j0OxAbpekSnKZ/OW5TudHXjtDq3JVV+pmyaRklyiTvdkiDLu0Ogwaj/JunLbPgsVlRId2b/lfeBICcMwQS1KjF6Bo53vxdzJTAca20Akxro/hb30lICCaG3HUmszL39h0zTMTVEi0zcR4cpkfL5O37jqvaktqRM+ERA3IJa6zHSumCACB784SPRnQZVKp/Oa5uJsJ+Ij3REbbaIExR4jzktEhHrd3pO6X9vVxk/y0hcWGnWVa036OFLCMEzQiZJgajWvrbyBGfTAqqahc1eJMSsDeU2tEgXooRlwzR5USrQGm1JYB1ECZ8D8ueOANaIRGur9CELHZKKoCPQqca8suHSD1VTdbmS7Fo2emDJg9FdHOl2/rtHkGh3lfqrOn2bX4jIlfQOfkKN91oqrluBICcMwhhAlKPXt37+/S6/p3LlzEIkSqxHVkhJF1TVNQ+euggFDpnD2hWijAP43u7bUNMwZ+3JIPQa+KAeWxwkiwN0GatqJ6Dzp0aGlrMKiTieA9vK+EF/eQJ6H6J1T4KDQDUJFW9bcEixKGIbRLXV1dbRp0yax3Lt3b4qKcu1qHs9LS0sLDlGyzxopKY+3DpKeREqAFCW7GgJbFqyWA4eayNy5aeWJM3zVXt4eRGHKQsOpNFRJKJS7cIwwS662JLY1bNit79SNQ7OrtcO8yqF8ovxi19+PRQnDMLpl+/btVF1d7Vbqxt5Xguod+R5GpEoTKSmItIoyTyIl2gqcrJDWdyxtVTlwY/oG5t2QiBDPTK5enB3Yqa+kcWI+zKhsP3uxs0hJSISJ4hp7kXjK2h2ka5Oro14lSOG0JnUDWJQwDBNUfhJHZtf9+zUjmYE9JdlhUQ67aXpidkXHUjkXiycdS1tDTX4t1ZXWeVR5g0oOf0RKZFmwana12Daxswf7U76jXCzH9otzS2g5Yp22vbyeIyUpJpsKHHtYlDAMEzR4S5QYOYUjPSWYhXWfpnGax5GSxqwCOpaGpHrWsbS1VHipHNjX6Rtg4ytpJqJUsqFUCBdv+Em0JlfdixKbSImlWXHlChwpYRgmKEVJsFTgSE8JqmMOFJDX0jfA0qGxY2lBLdWWuN6x1KvlwA4moXNFlKAiJd3DY+BO+mZ/pLXPSPEq5+aI4rXFre5mqk1vyQgDSp4T44yRvmkuUhJm20HfKSxKGIbRLRs2bBB/Y2JiqFs3a6vuthIpgVCoK6mzlgNrfvQ9N7paB7jqlGi3qku8RfkuJc3hbqSkrs5Cuw4qyz0zUJHlu8Easw+junV9tLUzad4vSqOzlkyurRUlWdlEJeX6j5K0ZHStrrHQ5savXj/r17FZWJQwDKNL6uvrVTHRs2dPURLc1kSJ1k+ibZwWHkbUPtGz99Q2UCtPDEwFjrabqzuRkj3ZRHX1vk/dgMgIk4gC5EaY6VCUso1F/xSrXhh7StaVqGk2eEpawzqdN02zP5/Q+8aR0XXLXuvn5ep+sChhGEaXHD58WJQE2/cdaUuiRDsRn1kTKUFzL0+jBNr0TUG0NlJS4f/0jQmT8bkuSv7caF3ua83O+TyF869ZmWjOUmehgj8LmzyvrryOyrYroQ1U3YTaTbbnLmt3GqPyRvZ0kalE+/SNrbhybT9YlDAMo0v27dunLnsiShISEsTNyK3mtdUe4R2jKK+4dX4SrdEV5Gj6vvjT7KrODtwpyq0B/PNfrabJE470/WAtza5rYpPVx/KW5Tk2uTY0n7p5/Tui215Jpv05Lf/f5Wut+zm8N+kemcIpLCWqrLY4NLm6OqEgixKGYYJSlGijJXivhobme0zoPX1TFtv6xmn2kZL9Yf6PlNQU1lBtkfvlwBVVFvp+pbKM1NXYgeRzZFnwuph2ZGkcLfN+0biNGynRNk0b0nTSvsUrLXTZ40Sf/R5Lt7zY/P+srLbQr+uU5c6pRD19nKbyZa8S214rrr0XixKGYYJWlMgKnJqaGsrOziYjt5gvMLe+cZq9pyS7JpzCE8P86inRVt5Eu+En+eFvDNjK8mlH+aftuoyUlIeGU2Vn5cCVbSmjquxq5+3l7SIl5ZUWuuopa8Tg+78UA6gzfltnbaN//EglPaJ37GcLti9rxjmXZg02NQuLEobRMSgN/O9//0t33XUXlZQ4mFgiiPFmpMSovhKtpyQ7pPWN0+TswtIzjHSQ9HRUHqiihpoG/5pc3YiUaFM3/xnvn4FaekrAvgzFVwLyf813KEpMYSaK62/byfWhNyzCoCspryL6da3z//njP9b9nDxC/4LE/nyUkZLDBRY6XGA1uboqrliUMIyO+eabb+j++++nxx9/nE455RSqqPD/HCWBgkWJ1VMS0T6CDpSEeiVSAoNsu8biEMxJogqDhuY7lvokUuKiKKmts9BXfyjLcdFEk44gv6CdmXdNTJLD0mBhct1WJpZj+8ZSaJT1c1q9zUL/+6jp+367wtJsRAhgDPfXfvqiV8l6TfM3V/0kgEUJw+iY33//XV3+9ddf6cwzzzT0PC6eipKMDM0laxuJlCBqIdMEonGapltmazwlWrNrfglRdFf/lgWXaxun9bA2JmsORBZgogQnjVbKdf1BUrxJRJbAH3WJFBqtCI68ZfkiiglKN5U5NLnW11voiqcsVN9YEnvLdKLQEOU13/zp+P8dLrCoPgwYXFMSDRIp0YjkA3mWpn4SFytvAIsShtExq1atsrn//fff04wZM9RS2bYgSjp06ECRkdb26p6KEqNV4FQdqlLblmMWXW1jqtZESrSiBA26IrtYRUm5Hxqo2bSYz3RtduAvlvs/dWOfwtmVF0KJo5TmMNXZ1VS+TSkBLl7juJPr3M+I/tmiLPfvSvTo5URH9KpWu9Ju18zhI1n6r3V58ggyDLat5h3M3eOiyRWwKGEYnYIrMSlKYmNjyWxWfsA//fRTuvTSSw1ZTeIqtbW1Ynbf1vhJ9BgpQSfTvW/uo5qCRiejC+3l1W6uWlHSykiJ1uxaq+3q6odIiRQlUelRFGoOdel78MVyZRlNuk4cTX5FpnDwdTMNS26SwnFkct172EL3vmodlBfcbhLbfuwQq+hzFC354W/ra44faYwoieybIy0jMn0jTa6hoYoocxUWJQyjUzCzbV6eMhKNGzeOPv/8cwoPV1onvvXWW3T99derIeRg4+DBg+q+tUaUpKamUkREhC5ECfbn73NW0YZbNtEfx68QxtLmKN2i+BTUSEnjjz38IObI1g1Y2rLgiiRrtKJyj28jJbXFtWKGYBDd3ayWwKJktqTc8bmMaIMc6CYNJ4qP8XOkROMrKejRVJSUSJNrqIniBsSJz/ma/1movPFQXn060dhByjZrRYm9rwSv+/Ef67w+/ih59hYR4SZKbezGD/EMD9CmPcr9Pp2Jotw4X1mUMIwBUjfDhw+nE044gT744AMKxaUHEc2bN4/uvfdeCka8YXIFaE0vy4IhSgIp4qoP11DFzgp1npm/TltJVQcdC5PD3+bQlge2qvdje8fQwXzvpG7sG6gVRURRSKNHo9xLkZKyrWVUuamq2dSNNNje8ZKFptxmocEXWyi3qOnn87k2dXO0/6MHPTOs/3NbSCxFpCgit+C3AtFyvmyrksaJ7RsjIj+fLLNGQRBBmH2F9fW9MmrFBHvgl7VEZRXWfcMcMQcbo2EThvjPN+Mt5HmZXUBCkNTUetYm3yNRgqu3k046ie644w6bx6uqquixxx6jE088kaZPny7y3+6sZxjGyurVq21ECTjjjDPo9ddfVx+fPXs27dyp6eUcJHhLlGhTOKWlpVRUVESBwr45GYTJitP+biJM9r9/gFbNXEMN1Up6LvWE9mQamqT2rmht6gYkJ1gHvIJyE5m7NJYFZ1W2Wrjl/ZpPvx+zgvZcuJf2v3PAaTmwrLxB3w45Cd0F/7VQQ4Pt///8V+Uv0gOnjiO/o009bMwiSp6gVOHUldXTvnf2k6Ve2d74wYrSe/gN6/bPvclECbHWY419gFEXYNBeovGQ/NDYGA5MNlDqxr4CB8beHxsriNw1uXosSp588klKS0ujykrbUN8LL7xAW7dupZdeeomuueYa0V9h48aNLq9nGMZ5pERywQUX0K233urwecGCL0QJ2LOnMaYcALRVJ/KXF+WxK063CpNd8/bQuus2qANd+lkdafibQ+lggfWH3RuREu1kfofyrRU49RX1IqLTmvTMums3iDliwOZ7t1DZjnKn5cAQIPs0zbYWryR67G3r/S1ZFjGpGxg3iKhDkimwomQPUcoEawpn97wsGz8JGqXhObIM9j9HN30/KUrAN39anPQnIcOhFcva1NQQX0dKli9fLkoSjz7a9mijGuDrr7+ma6+9lrp27UrHHHMMTZw4kRYtWuTSeoZhbJFiA/O3dOvWzWbd6NHWX7Zt27YF3aHzpijp3t1q/d+9ezfpIVIy8Mn+qhBASgfCZNM9m2nL/daUTeblXWjIS4MoJDzEpnW3NyIl2hl2N2dZKLqrxuya5XkKZ+Mdm20iP/UVDbTminVqUzabcuDu0ZRbZO1eKpn1uoV++lcZ1D5vNLgGoupGgkgH2r2DjbuJko+29ivR7mvC0ASRtpCBJpT0OmoYduwwoiglA0TfrlC8JOjwumyN8hhSPgNsv+6GoJOmgdpv662P+zR9g8jIs88+S7fddluTdWjhXF5eTv3791cfw/KOHTtcWs8wjO0MuQcOKKHvYcOGNflx693bOksXoo/Bhq9Eya5dmo5OARQlSUcl0ahFI8mcaRUme+ZbS5Z73dWD+s/uS6bGmYBty4FbPzgP0F7970bUwtzqOXAOLcqmg58oFVNh8WEU0SVcNYJuf3xH03LgbtEiZSNJirdWuZz3iIUO5VnsurhSwJAioaiMqDDKTNE97Jq+hRDFD4izaRg2yMnsvjCxQpgAeEjQzwOzH1dUWaMkRmgtb482gldbZzVluyuilUkPXARplylTplCnTk1nCCorU5ziMTHWZjhxcXHq4y2tdwTmq8DNZoPDwlQ3vSfIMspgLqd0Fz4m+jsm//5rTTZDlNhvR48ePcQPF66yIEr8tZ3+Oi5SlMCoij4lrfl/iMxK4L/x9ra7ekxQDiwIQYlvJIVEhNCRXxxBK0//V3g5BCaifrP7UualncVnK/0d2pllOyY39V24CwQAqiVyCpWUhPmEKBvfh7vHCE3eNty6Sb3fd3ZvKksoo6yL95Gl1kI7n9tNyccmq5GSyA4RFGIOoT3Z1v1AczGYP+FHQHvyU++20D9brSmAzLTW77en9M+0el/W77JQxtFJqmkZxPaJJVOUyaY3x8ButturPU9OGh1C3zW+39d/WKhC0w/xuBHGHJ8Q4bEH/Um05zG+z14TJfjh++OPP+i9995zuF72UEAbbCk8EBmRj7e03hEw9C1YsMDmsWnTpgmTrDevxBg+Jno7T37++WebSIGjctb09HQRTdm8ebPwSvjz6srXx0XuLwSJjBh5iiyjBps2bfJZaXBzxwQ/ymU7FVES3jGc9h3SdKudm0b77zxItQfrqMNt7YmOa2iyjVt3I2Wg9IY31R6irCzPfR+SHh1TKafQLITJnhprr43cjbkUkeX69Sr2bd+NB6i2UCm3iJsUS3VH1pLZFEUpVyZT7tw80QRu1eVrqC5XuYQOSQ8V+7h2K/ZJSYfEhOXSYxdW0fodHSm7MEwVJOCYQUWUlWVtUuZvOsRhzFJCAb+tKqBp/RvbtDYS2iNE7M/KTcjzKGNaYsQ+yspqcHieDO6M46t0Zfvilyqqqcd3V2kQ2KeD49fpnZBa6z5JuqWWUFZWofW+XRraES6feevXrxc/Dscff7za3Ag+EZQpLl68WPxAousirkQGDx4snoNluREtrXfExRdfLLpXejtSgpMCP/SuqLa2AB8T/R0TrfcB3zmtWVOb/sR3ElUlEPcYwIPhuKBKLz8/X41yONp3d0BJMJrPISqLhmytfT9PjklNXg1tKd8uluN7xdtuQyZRj2U9hLk1JMzx64s1V9IjBnWkDlZbg8cc0Zfoz8bgRnkqfoeVc86UG+LWMdr7xj4q/8MaARk57wgKSwwTx2ToPYPp39WrqeD3QqrLsXYhTurbTvyPUo22OmJAexo+iOjDh4gm3kRUrxmXL5qaSJmZGneunzkaxtOFyvKh4iTqe0UcHbjzkNpevuOYjpSZ2YV2HFTuIwp1xKDOTs+TzMwQ6peplAGv3hWl+lAG9yAaMbh16cpAkeQgTTN2KM5121mTvSZKTjvtNCFAJIiYrF27lp544gn1agTG1YULF9KcOXNES2eIFUwk5sp6R0B8tEaANAd+PFiU8DHR63kiy4Gjo6Opb9++DrcBj//4449iefv27dSxY8egOC5onCbxlviBr2TdunUiooQre9nrxV/HRNuUDAZPh89rZpMO5imjX3iYUoGCSfVaC9ILso/9luww6psWKdqnI5Xk6jEv31lOW2cpYgsMen4gRaVEqemH0PBQYdZdPv4Pqiu2ipKY7jHif+zLsSqPrmnKfh09lGjOlRa6/SVl27p1JBrayxRQn4X2WG3KIopMihTG1uJVSvQmcVgC5RaZ1D4rg7o7T1XI8+TkMQ1ClGgzNcePdC3FoUcSYjFZYgOVaixJQ3u6f666vPcQFfCAyBuiHvhi4wpEgjLF+vp6UVlz2WWX0cyZM2nUqFEur2cYhkQvDWnIHDJkiNMBtE+fPkFpdvWmydXe7IoIb2vTQZ5gX3XiLrL6Bnl7bwgSoK3w2LgHFThK2qEmt0Y0BWsJiLt1128QZcSgy8zOlHpc08tlc4aZBv1vgM1j8hjsPazcxymu9STceg7R9Wcqjz15dWAFCYiNNlFmmtUYjH3vMlPxVsb0jBGixNbk2vJ7njym6T5NHmE8g6uz2YKhrTypInLL6KrlvPPOo7PPPtvmscTERJo7d64wpyLNYq/4WlrPMAzRmjVrHPYnaU6UBFNZsC9FCYDgk11e/YV91Yk7oFw0r9h7PUocihJU4HSNpsIVRWpZcPzA+Bb3qfAv5fmo3un7sLUizJ6Op6dRzg+5dODDg2QKN1HCMOW9sw5bB7OwMG2TMRM9fyNupBsGdlMavCESsC+HqMuMTpRydDJFpCqmZRhgW6q80YK+K/ExyqSIIDKCaPwQMjSotEH0R5adR0e5L7I8VgVIqzgzqWJdc4KjpfUM05Zx1jTNnmAtC/aHKPE35Q7aq7uKbD3urR4lknZxJjU6gQocGSmR3WZbQjsRXcbZ6RQW0/w17qDnBtDAp/vTiPeHU3RmtGg0lt8otro09gHRM/Zl1HJOotBIZSzTihJXenOEh5lEukYyfnDr5zQKNFrR7G5/EgkrA4bRsShBObAzUJovLwxYlLguSgLRll/tZGoitTeJq9j2KPH+1T+AOKht714DNTkRHUgYopnhzwloAocUT/tjlZ1AtEEi54PRMwO6mZqIEi3rGk8rZJpcnRX3lLHW95xypLEFiX36ZrAL0SJHsChhGJ2KEvi4BgywzcVrQbRRRktw9Q+/RDDgi0gJ+roEMlIi0zdRGVEUGuWeyda2m6t3By5tCudAmJuRkjVWUSLnfXEHmboB0q+hZ+w9OFrq6y2qUOmZ4Xra4rzjiK46jWjGZOWv0Tmij3W/j3F+PeUbTwnDMN4HvXu2bNkilgcNGtRi9Rl8JaiCQ3k+Blutz8ToogSiLDXVO3F9lJ/KZnP+FiU1hTVUW1TnucnVh5ES5epfGWC31kaTjCdVtDBbMI5j8TpFlER2iKSoNKXHhjtIkyvokqr/KAFKeBEFQfmufaRk50GiqhrXTa4S+GheulX/++4qpx1F9OodJoo1Ex01mCMlDGN4ULYqux825ycJ5gocKUqQnvKW9wzVgrITtb9FibbzZ7RHlTcWn3hK7H0S63PDKCw21CVRUrGnUi3xTRjqfpQE7D1sMVT6BtEPlCfLsmBtt9b1moygO6Ik2AgJMdGlU0109iTPhRanbxjGgH6SYBUlaHCGkmhvpm7sfSV5eXlUUmJNPejZ5OrrSInNDLhZJrUyqHJfFTXUNbjkJ4kf4pkoMVr6RiviyiuVShyJu5U3jHNYlDCMAStvgrUs2Bd+kkDPFtyacuAmoqS992fAleZEpCSkCRfdZZvzlWgrbxI8FCXa9I2chVfvDNREQVCxJNH2KPG06oRRYFHCMDoUJUhbyOkYmiPYyoL9JUr8mcLxVuM0zLjqi5JR7Qy4pp5WgVHwR4FfRAn2Ky7aGNGFAV0dV+BIUWKOJOqeHoANCyJYlDCMTqiurqYNGzaI5X79+okW8y0RHx9PaWlK7JtFiT5FiU2kJNM9UQJ/0cF836Ru7MuCQW5Xa1vVvGX5TrepZK3SYCQiNYIiPTC5olpFlgQbJXXjrAIH/VZ2HLCuDw01hsDSKyxKGEYnbNy4UVTRuJq6sU/h5OTkqH4MoxKMkRK1HDg9ikKj3SsHRv+Q6hrfpG4c9d/YFB5PYQlKUWb+8gKRxrGncm+lWk2EKIknLeCzC4jq6o3TOE3St4vSPl0bKdm0R6nIaesmV2/BooRhDGpyDUaza7CJktriWqrJV/rHRHd3r2mar02uDjuVZhElj1emIK4trKWS9SU+95MYofJGEhVpoh6N6Rm0U0fEx3bOG46StBYWJQxjUJOrhEWJa7Rv355iYmL82tXVxk/iicnVpnEa+QSbCpw9RCkTNCmcX/KbbZrmSifXFitvOhhrIJcpnMpqot2H7CtvArddwQKLEobRoSgZOnRomxYlaJ+flKRcsXsLpBlktGTPnj1ixnJDVd6kmHw+Ay5SEclHJzXrKylpbJrWmnJgo0ZK7D04SOG4Ozsw0zwsShhGB8BLgsZpoGfPnpSQ4PoVaLBU4MBAKUUJUje+mK5eihK05D9woNGd6I85bzwVJT5snOYohYMZawtio8ncOUrcxyzA9ZX1tp1cG9M3Ee0jKCrdfZMryMo2VuM0p3Pg7LGKktR2RB2SjBX10SMsShhGB8DjUFmp9IUYMsS9+cu7desmWrIbvVcJTLpos+8LP0mgfCU2jdN01mLe6dX/HhMlN6ZwGqobhDCRVO2votoCxSOTMNgzkyvYq5mML9NookST7vp5tYVyCpVljpJ4BxYlDKMDtAOkNvLhCmFhYeqEc9u3b6eGBuedONuqyTVQE/O1On3jB0+JoxlwbXwly/IcT8LnYepGm74JD0N0gQxF784o+1WWf7JmXFmUeAkWJQyjA7TGS+3VvLu+kqqqKtq7dy8ZEX+IkkBFSjBpXVhMmMeREgzeKZ55Sj3qvyErcEDerwVerbzRGl3RyRXzpRiJyAgT9cpQlrX6nytvvAOLEobRmSjRXs23JbNrsImSutI6qsmp8XgiPq0oSU/x7eAtZ8CVkZLI9pEUPyhONbbW5Nc0Mbl6OhFfcZmFisuMmbpxJOIknL7xDixKGEYHaAdIFiW+EyWZmZmqD8LXoqS1E/FVVVtE8zRf+0mczYArfSVkIcr/rcDW5JocTlEZihnWXWQnVyOaXJ2JEpxSjoQK4z4sShhGR5GSiIgIyshojA27AUdKXCMqKko9vr4WJa31k8j28r72kziaAReeD1tfST5VHayimrwa1U/iqclV26PEqKJkoMaDA3pmKMKOaT0sShhdlcV+/PHH9Pfff1NbAlegcoDs2rUrhUoXnRsEQ1nw/v37fR4p0aZwcnNzqbS0tFXvVZVdTWsuX0eHn8ulhroGn0zE549Iif0MuBt2EyWNbkchESa1iZpN07TBrTe5GrFxmsQ+KsKpG+/BooTRDQsWLKDp06fTUUcdRZs2baK2wuHDh6miosLj1A1ISUmhdu3aGbosWHpKMMkgbr7CW74SzAuz+rK1lP3FYSp4u5B2PbvbeaSk1eXAJr/PgIt5etodqZxTlVmVlP3lYS9V3hi3R4mkVyfFfCxhUeI9WJQwumHZsmXib01NDf3vf/+jtkJrTa4AoXSZwsHgLvt9GClaJCMlvoySeFOU7J63hwr/LLR+jk/tpsK/ixyLkq6KKJn9joV6nNNAny5rOtGdPf9s8U/jtOZmwFV9JUR06PNsdTlhqOelQMGQvgkPM4nSYAlX3ngPFiWMbtCmHd555x0RQWgLtLYc2JGvBP1KjEReXp4oZzaKKCnZWErbHtveJHKy9qp1oupGm75B59Pw+DCqrLbQAwsttOsg0WVPWKigxLkwySm00MtfKssR4UQTXJ91wKsz4KZMsJYGyxmDw9uFqx1fnbF6O9Hf2yKDrsW8lmG9NMvutRZimoFFCaML0PBLK0qqq6tp3rx51BZobeVNMJhd/VEO7C1RUl/dQGuvXkcNNcognXllFzIPVgbpij2VtPHuzVRXXkfV2dU2lTeb9xDVNXZsLypToibOePJ9izCcgitOQUmwye8z4KICBxGRsATb/ioJLZhc12y30NhriM5+NI0+UYKfDkVJ+0Qic6QxPSXgnvNNdNwIov9eZqLu6cbdD73BooTRBWj4Ja+UJRAlsvV6MOON9A1gUeIfUbJ9zg4q3ag02ojtF0u97+tJ6Q+nUWiMYlA+8P5B2vX87iaVNzCPannhM1t/heRwgYVe/FxZjowguvt8U8BmwDWFmmwaqbniJ3n9WwvVKJ3o6fH3lNScpLbOonpljBwlAf26mujH/4XQvReyIPEmLEoYXaC9spdXYQjpI43TlkQJ5rEJFlGCmXiXL19uMyjpIVKSmppK0dHRHomSghWFtOsFRV2Ywk009OVBFBoVShGdIqj/nL7q83Y8tauJyXXDbtvjUF1DIp1jz+PvWYQoAFed6p8oiaS/Zl6XLY2NgbWlwS11ckV05dNfrfdXbSP6S+NZP5hn7YJq1MZpjG9hUcLogi1btqjLV199tboMw6tR53JxFTkwduzYUR0sPQFRFinoAi1KCgoKaNiwYXT00UfT5Zdf3uJn6E9RgmMkoyUQTvX11llwmwNekbXXrBfNxEDvu3tS/EDrAJ1+dkfqeHpak9fJcmDtFPcxZuXvW4uJ1u20CpNDeRZ66Qtl2RxJdNcM/16F9+ls/X9bPRAlKzbaljKDuZ9Zgs5PwvgOFiWMLtAOoueff74YzKRY+f777ylYKSsrUw29rUndyMZg6HMij6crEQpf8ddff4lZf8HChQvplltucbo9+Izfe+89v4kS7bFGpdfBgwddes2m+7aI0ljQbnQidb+uWxOxM/Dp/hSVbmsCVdM3jaIkMZbowZnK4I9DctfL1uMy510LVSn9yejq04jSkv0rSmB2lWzZa1EjPdFdzapp15zZqKgc8MkvTT/jj35WUlJNK2847cE0hUUJo7tICdIQGMQkwVwerE0ftKbyRtK3b19V7Bw6dIj0kJICzz33HD3wwANNnvfPP//Q+PHj1XLgI444gnr10pQ16MRXcvi7HNr/zgGxDO/IkBcHCb+FPeGJ4TRk3kAizSoYXYtKLbQ/19qk7LozrJGC7/4i+nmVhQ7kWmj+V8pj0VFEd5zn/0G7j1aUZGnE1jMDqP3kFBr07ACnJlekbqSxFT08zj1WaUxXW0e04CtHjdN8tReMkWFRwuhKlLRv356SkpJo6tSp1LNnT/HY0qVLac2aNRSMeKvyRm++EntRAv773//SE088od7/+eef6dhjjxXeITBkyBD65ptvPG5f7ktRUr6jXP217P9YX7XviCOSxydT31m9yRRmooyz04VQ2bjHun5gN6XS5ZFLrft5x8sWeuxti/CZgGv/Q9Qhyf+iJCHWRGmNvtat1owapRydTCM/OII6TEl1+tq/t1jntZl0BNHVJxerJcYvf2kRJtdgaJzG+BYWJUzAKSkpUa/q5ZU+Wq3fdNNN6nOeeeYZCka8VXkjkcfPPvrkb3bs2KEu33nnnTbLqKr6/PPPacqUKSKiAxAtQfO8Dh38M1K5K0q6X9+NxnxzJGVe3oU6zchw6fnH75lEQ+YNskndaOdNmTGZaHDjR/7PFqJ5X1j9JrefG7jURt9M5W9OITXbS8Wej3+2PvesY4g6ta+nqWOU+/CZLPotOBqnMb6FRQkTcLRX9Nor/ZkzZ6qt099//32Xc/9tsXGa3kSJ3C/4XB577DF69NFH1XXXXnstnXXWWcLPARAVW7x4MSUmJvpt+7TH2lFUxxFouT5gTj+XIzmhZuscRtrKGznHTGioieZc2fS9rj8DPTwCKEo0KRxpdm0J+IU++UVZDgslOm2cNeKjNbzK9E1UhNKnhGHsYVHCBBzt4KkdVGNiYuiqq64Sy7W1tfTiiy9SsBGM6RtU2sj9wuAfEhJC99xzD9111102zwEXXHABffbZZ2Q2OzdP+gJpCPbHbMH2PUqQvpFMGUV07DDr/Vgz0W3nBNYAalOBo0nhNAciPVnZ1tRNUrx1WfpUflljfT9ESfyRpmOMB4sSRreREnDddddReHi4WJ4/f77L5ZtGQV6lx8bGCj9Na0H6IyEhIaCRkgMHDoiOvPZCCxETREkkSM+98cYb6ufrTxDBycjIcCtS4imIIshy4I7JRMkJ1sEYA/MTV5tEdAEgbaNdH8j0DdiS5Vr65hPNXD5nHaPdP6Lr/mO9L7++nLphnMGihNFtpASkp6fTiSeeKJbz8/MDmpLwNnV1daJPhowoeOPKEe8hj2FWVpY6+7A/0Q7y0qwst+3555+nr776ipYsWSKqqhBFCRRSAMNo68t5lg4XEOUXN42SSEb0NdHyuSZ6f5aJ7ruQAo5tWbB7qZvQUKLTj7Jdf+EUJQKkhStvGGewKGECjhQaERERNmF1ydixY236XwQLKIOFMPFW6kYvE/M1Z96FCIGHZNKkSQEP3w8ePFhdXrdunX9SN05sQ6MHmOicSSYKCQl8SgNRDHg+XPWUrN5GYpJBgFRUip0fJj7GRBdNsf8fgd9PRp+wKGECCtIxcuDEVXVYmO3kX2D06NHq8ooVKyhY8HbljV7MrtrKG2/ul7dBCbJfRImDyhs9A2HUu7F/3Y4Dynw1zaFtmHbWBMf7d60mhQM4fcM4g0UJE1CQvpBVGPapGwkaaskwfzBFSnwlSgJtdnWWvtEb3oqUoNy1tNK52LCpvPF8aiO/Is2pmNUYE/M1l7r5+GdlGV/R/yiNmB1OXjdxuPV+16bd+BlGwKKECSjaQdOZKIEJdNCgxn4PGzaovS2MjrfLgfUSKZH7hV4zmZka16TO6N+/vyp2PRElm/ZY6Ix7G6jLNKKJt2eIvh4tpW+0E97pmb4OOrs6Yt1OJZoCJgwhSm3nXJyh/DklgWjMAKJxyteZYZrAooTRVXt5Z4waNUotJUVr8mDA2+XA2veCIAiEKMGVs0zfdOnSJSCVNe5U4MhzbtOmTaLs3BX2HLLQzMcaaNBMC32+XHksvzSU3lviuPX6xkZR0j2dKDZa/+kb0LeLySWzq7Zh2rRjm9+3kf1MlPOliX6fZ6LwMGMcB8b/sChhdFt5E+y+Em1EAQO4t4iMjKRu3bqpkSh/zrKMCil06NW7n8TeV4IUYkupLkwqd8NzDdR7hoXe/B6Cw3b9B0ubvgbNwsoqjZW6sZ8DZ2vjxHwOUzeNc93As/yf8S2/L8zNgTY4M/qGRQmj2x4ljiIlweIrwQ+6FCW+iChIgYeSYPQN8RdG8ZO46yuZ97mFepxroRc+VSaYA+3ilJSEbBWPuV92HrAdwGV/kuYqb/RIH81Ezc4iJdv2KTcwfrD/ZzRmghMWJYwuIiVpaWlq0y9ng2x8fLwaKcGgbmQKCgp8GlHQRp38aXY1SuWNu6IELdHLK60z+N5zAdGuD0x05wwTnXec9Xkf/tRcJ1fjDNpIM3Vq37wo+V5zbXDKWOPsG6NvWJQwAaOwsJBycnJaTN0AGBKPPPJIsZydnU379rnY/7qNVd44ijr501fi6/3ypShZu3at0+edOUExaF5/JtHO90306OUhlBinDMTTjrE+74OltmJ5wy7jVd7Yp3AKSojyippeBHy/0mLTLp9hvAGLEkb3qZtg9JX4qvIm0BU4RkvfdOrUSZ30sblICXp3oOvq8zeGNElTdO1INLxnlZqu2agpAZaRErSR1/o0jEBznV0rqy20bLWynNGeaIDBBBejX1iUMLo3uQajr8RXlTeB7lWiTd/4Qmx5G5guZbQEs1Cj5bwzMKuvM6aOqmgSLUHTMTmYQ5BEhBsrxaGtwLHv7PrrWqIqpb0QTTmSJ9djvAeLEkbXPUqciZJgipT4QpSkpKRQUlJSwCIl8AhhlmcjoE3hrF+/3qP3OPnIctE8TFbhiNLo/UQ1tcZM3QBtZGeLXQXO939pUzfGEluMvmFRwui+R4kEs+jKq+9Vq1apnWCNiK/TN9qJ+TDHjj8azuF/yIntjJC68WZn1/aJDXTMUGUZzcRWbTOuydWV9I00uaIdznFH+He7mOCGRQkTcFGCJlau9umQvpKqqiqfzlfir/QNIhqyqsjbaIXetm3byNcYzeTqaA6c5syuLTF9onX5/SUWWq81ueo/k9UEeEVQaWSfvsnKtqalRvcn1fDLMN6ARQkTENA9Uw5ivXv3VjuQtgVfCQSV7B3iy8Hb32ZXo4qSAQMGqA29WiN0zxivGFplaTBasEuMmL6BuVf2K9l1iKi6RhFZi1danzPlSBYkjHdhUcIEhN27d6ttvV1J3QRTBQ72XfZZ8aUZ1N+9SoxWeSOJjo6mXr16ieWNGzdSXV1jdzQ3SU4gOkGpWqf9uUTfNWpmcyRRt45kSPo2Tl1UX0+086AjP0mANowJWliUMIaovNGG2iMiIgwdKfF15U2gepUYrXGaI18Jolja/XCXcyZZIwfS5Ipy2eYqd/RMn862FTioKFryr3Ifk+sN7x24bWOCExYljCF6lGjndRk+XJkDffv27WKuFaPhrzQHojBhYWFimdM3/vGVnDqOKErRzIZO3Tgzu/65gai0sfr5+JFKiodhvAmLEsZQkRJ7X8nKlZoEt0HwdeWNBPPpyDQKjK6+nphP7hemC5DlyG2pAgfEx5jo5DG2jxmx8sY+fSMn5rPt4mrc/WL0C4sSxhDlwMHkK/FX+kZ7bJGW2Lu3mTnoWwnKs+X7QwgZbSZYb4kScK4mhWPUyhtJr062kRLtfDeIlDCMt2FRwgQ0fZORkUGxsbFuvVZvFTjV1dV000030Y033mgjOOypr6+nZ599lpYsWaKWQnfs6FsHpL/Mrnv27FEjMUbzk4DMzEyKi4vziig5aQxRrDk40jfRUSbKTFOW1+4gWr1dWYaXpEOSsYQnYwxYlDB+B628pRfE3dQN6Nq1K6WmpqqixNdpiZZ477336LnnnqPnn39e7M+1115Lhw4dahIZOvroo+nmm28WUQtw3HHHiYkGfYm3za6IhkCEBUs5sKN289hHTBbpKeZIE115qrI8si9RegoZGukrkW3lAVfdML6CRQmj+/byjgYQGS0pKioShtdAok0hocx53rx5YmC+++67KTc3lx5//HEaOnQo/fHHH+rzrrvuOnr//fd9vm3e6lWCEmZEg7p160bnnXeeWs4t0VasGKkc2JnZ1dN285LHrzLR36+Y6JcXTIZLZdkje5Vo4f4kjK9gUcL4nU2bNnnsJ9Gjr2T16sbpUonU+V4qKytpzpw5Yg6Yu+66S40uYMD+9ddf6YUXXnA7bRXIifkQCcJN7u/ChQuDKlLibV8JSoBH9DWJqInR6Ztpuw/xMUSjBwRsc5ggh0UJ43fQoErbTdMT9OIrQaMteVWNBlzwlMBbInupyNQSrpZvueUWUW46fvx4v20fqmAwZ1BrIiXffPMN3XrrrTaPPfzwwzbz6bAoCV7sIyWY6yY8zPhii9EnLEoYv6MVJQMHDvToPUaOHKmGxQNZFozog/SIIEUDrwvMrCjBveSSS0SfEOwjUjdPP/206B7qb2QKBz6XkpISt14LwXXOOeeo4kp6eTDx3jPPPNMkfQPzbnp6OhkR7bnYml4lwYa2LBhwKTDjS1iUMH5nw4YN6mR0cpBzF0xiJ1MTCLU7Ml/6gzVr1qjLw4YNs6nmQIqjtLRUbJ823eRvPK3AgfCYOnWqGhGZNm0a/fzzz+o8RU888QTl5OQIwYLW+bLviq/Nu74C1Tcy9YRzFNVSDFHHZKI4jZaWrfQZxhcY89eDMSwFBQWUnZ3dqtSN5IgjlDnTYbqUQieQfhKtKJEgchBoo6MnFTiI/px++ulq75ERI0bQG2+8IQTO2WefLR6DWPnvf/8rJheUotCofhJ7X0lFRUWz5d1tCZy/UohMGErUpQOnbhjfwaKEMZyfxF6UgH//bZyQI4CREqRv9Ii7kRJU2iD1JA3EnTp1oi+//FJNPcEzIw29L7/8Mi1evFh9bbCIEm+YXYOJN+8x0XdPmuiLR1mQML6FRQnjV4JJlGDwlpESVNngpndRsnnz5haf/8EHH6jlyhAfX331lU2TNxhnYdqVUarbbrvN8OXAjkQJ+0psm6jBS5IYx6KE0ZEo2bdvH91777106qmn0sUXX0xLly61WY8QLnoyIA997rnn0g8//ODWeib48aYoQbpEpkYCIUr2798v0lF6jpLIZnMyyrFq1SqXqm0kr732msN9QzWOrOopLi4OmkiJtlcJR0oYRueiBKHaY489lubPn08zZsygWbNm2Qwyc+fOFfdRfXDppZeKskHtlVlL69sSuML8888/Re66LeFNUQJjYu/evdUqEcy/oic/iV6AMRWeENkOHgbW5pBpG/hh/vOf/zg99g888ECTx40uStAcTqam/DGzMsMwrRAlMLWhNTZCufjbv39/1WAIpzryzmixjRAu1kPALFq0yKX1bQ1EnMaOHSvKEKXxsy0gz5cOHTqI6pvWIlM4ECT+NrtqRYmeIyVAW/3TXF8XTAEge44MHz5czDTsjCuuuMJGhED8oOrIyKBy6LPPPhPiOVDmaYZpy7glSrRVBLjiQhmgzMGiB0J5ebkQKtorYfRrcGV9W+PDDz8Uf3EMUeWADqDBDlqu4+aNKIlERgACkcJxVg6sR7TN5prrgKsVLC2VMaNB3GOPPabe79Kli9o0zsgcf/zx4ncKPWYYhvEvbn/r0B4bVxIoB7zhhhuoX79+4nHZy0DbOhshXvl4S+sdgatf+5A8fiha88Mnm0AFchI3XI1qp5HHQACPzrvvvhuQ8lF/HRPtfCL40ffG/9OKgX/++UekBf11TGSkBOc0wv6BnhiwOY480tpcorlJDLWCBQ3q7J9nf1zOOOMMmjx5Mv3444+ij4mej4Gv0MNvit7gY8LHxBGu9DByW5RcdtllwqSKSdDgCZGpHOSfAa74pakOfgmzWZnDu6X1jnj99ddpwYIFNo/hh2/69OnUWmDaDRSY+8RR5ATVGyi3DBS+PibLly9Xl7GvWVlZrX7P5ORkIeRQCQOPjjfe05VjAnOn/F/oAxLI88lV8F1FxBKiBD04ZBM0LcuWLVOXUQrs7Hhq9xdeMbxv586dvX78jYQRzgF/w8eEj4kWXLx5XZRAROAGPwCukH777TchSjIyMkQEA/noQYMGiediWW5ES+sdgegBDLXejpTgi4If0EB1nkTVhgQtvCFIMKhiwjNcnUL0+RN/HROtdwbzv3jLfwCzK/pv4IaB1xsphJaOCTqbatMcRvBSwMP06aefijQqLgjsW/xjn2U0C6JxzJgxTSJ3zo6L0UuBW4MeflP0Bh8TPiae4rIowZwZSC9AJKDFNzwluPKV3R1hiINxFSWEs2fPFgMvmiph2ZX1jsDg4qscNX48AvUDoi3LRAUDfBGy1wPSDzAPBqItua+PiXZ2YAhTb/0vmF0hSJDqw/+AQdPXx0RbLooUkhEGI5xTECVyviBtTw6AYyjLe/FcR5EUPXx/9AofEz4mfJ60Hpd/VZA3hxhB+gRXuRg8J06caJNKuf3220V76mOOOYZmzpwpBIx2cG1pfVsB3geA0kNc5aMRFdJispfLaaedFnRhcESCZDkwJmxr166d1947EE3UjFIO7E4FjvYxrTGWYRhGd5ESXAVAROAGYSE9IloSExPppZdeEuuRZrF3r7e0vi2gNbliMJNXoy+++KJIZyEtgEnObrrpJvr8888pWEBvjPz8fK9W3jirwLn88svJX5U3OIe9vT++AhEknG8oz3dUgaN9rC1eLDAME3g8ir86EiT265sTHC2tD2a0V/LawRRpqk8++UTt3YFuucE0S6k3m6YFurMrRLVMRaGKKDIykowADOayYyk+D8xg7ChSggsQ7bnJMAzjLzgp7Ge0g6Y27QCSkpJowoQJYhkDhtaDYXR8KUq0nV3h9fB1Z1fttPZ6b5pmj0zLIJ32999/q4/D/Cp9MjDAakv3GYZh/AWLEh2JEoCKBwlKXIMFX4oS+86u2v/V1pumueorwXkpe0uwn4RhmEDBoiRAokSaXJsTJX/88QcFC/4SJf5I4RjR5NpSZ1f2kzAMowdYlPgRGD1lVY3W5KpFO99IsERKtJU36OWAKi5fihJZ3eSPSIl2Vlkj0KtXL7XyCZESfDZyWcKREoZhAgWLEh2lbqQJWPbZwLxAsmLFyKDbZ1FRkVj2VaWKNmLhjUgJOps++uijTaavh5dk7dq1YhmN/1BRZiRgYpUt51ERJUWyjJRAMMqpIxiGYfwNixKdiRL7FE5zk6cZBe1sq74SJRhM0e69tWZX+CowfQK6FC9cuJCOOuoo+uGHH9T1KNuGKdSIJldnvhI0Mjx48KC4j47C3BSNYZhAwaJEh6IE7cAlwZDC8bWfxFtmV3QzxYzNs2bNUtMaECBTp06ljz76yPB+Eme+Eq3w5dQNwzCBhEVJgEyu8qreEcFWgeNvUeJJCgfbiCjBV199Je6j74mcG6a2tlbMUTR//nwbP4lRIyX2MwZr/STcNI1hmEDCosRPwBuC+YLkYNbcvCKYnRU3OUeJ0ZuoaUUJmo3pTZR8/PHHIkKAma8BjKDffPMNffbZZ3TJJZeIxxA5ueqqq+iVV14xfKQEMyvD8CrnYdLOWs2REoZhAgmLEp2lbuyjJWVlZTaeDKOBwVw2gevatatPm3J5YnZ9//33xfxNWp8IXnvCCSeIrsMQIXfccYf6/IKCAnVgx8zXRkVGRDDXEoSvNO6mpqYGeMsYhmnLsCjRuSgxegoHJkrMMA18PUcMzK7azq5Iu7TE888/ry6ff/759Pvvv4vBWYI0zuOPPy5uzlrbGxFHERGOkjAME2hYlAR4zhtnBEsTNX/5SewFHyIALZldkRZbv369GsV56623xPwwjkC05NVXX1UrU6ZMmUJGxpF3hP0kDMMEGhYlOjO5aq/EMUmf0SMl/igH1qIVfC01UdOW97oS+bj00kuFB+PDDz+k66+/nozM4MGDm0ysyZEShmECDYsSnZlcJZh5Vl7179ixg3Jzc8mIBCpS4oookU3Q3OnMiufBgyIFo1FB12DtscL+GNW4yzBM8MCixA/g6todP0kwNVGTogRRCH90CkU3XBnx8IUoCSa0kRGIZQhhhmGYQBIW0P/eRnDX5OrM7HrKKaeQXkEaBPuJlMiuXbvEbffu3aog6969u1O/hjeJi4ujvn370ubNm4XZFd4SZ4NtMPQcaQ1aDwmnbhiG0QMsSgwkSvQEKlv+/vtvWrp0KS1ZskRsX3PVLv5MDcBXAlGC7YEwQVO05iIlCQkJlJmZSW0NiNxx48bRvn376Nprrw305jAMw7Ao8acoQaQAV/Gugj4YXbp0ob1794peEnV1daJ3RqBLfG+++WZavHgxlZaWtvj89PR0GjRoED300EPkLyBC3n77bTWF40iUwOeDfZGpGyOX93oKjK6//fab6CXTFvefYRj9wZESH4NmW0hjuGNytY+WQJRUVFSI8tVAmxEfeeQR+uSTT5o83qNHD5o4caKo6kCqBjdEH8xms9+3UVuBg2jO1Vdf3eQ5bd1PooUFCcMweoFFiU5NrlpRghJUgBRJoEXJL7/8Iv5CXKEKZdKkSeKGPh96QYo/9CFxZnZlUcIwDKM/uPrGx2gHRU9FiV6aqCHqs3XrVnVf3nvvPdG7Q0+CBCA6IyfTQ/UPokzNiZK2aHJlGIbRIyxKfExrJzvDgCmbXAXa7KotS9aKJT0iUzgNDQ20evVqp5U3iKj4o38KwzAM0zIsSnwIqj+WL18ultPS0lzq5GoPmlrJCAvKbHNycihQaEXR2LFjSc9oza32KZyamhp1kkB8JvadTRmGYZjAwKLEx1U3mOUXHHPMMR4bCvVSGqz930aJlEizq5YtW7ao5cucumEYhtEPLEp8yM8//6wuH3vssR6/jx58JTCN/vXXX2qpcufOnUnPoAxZtoK3j5Rom6a19cobhmEYPcGixIcsW7bMK6LkqKOOcvie/gSGURn10XuUBECQSMEBc25xcbG6jitvGIZh9AmLEh8B3wIaU8nIQs+ePT1+r9TUVOrfv7+aEiopKSF/Y6TUjSNfibY0mytvGIZh9AmLEh8BH4MsRW2Nn8Q+0oI0ijTP+hNt2sgoosSRrwTdS2X6pkOHDuLGMAzD6AMWJTr3kzh6j0CkcGSkBGkRzMRrBBxV4Bw8eFC0mAdscmUYhtEXLEp07ieRTJgwwaHg8Qd5eXm0fft2sYzyZKNMcY95huTMxDJSwn4ShmEY/cKixAdUV1fT77//LpYxoV63bt1a/Z4pKSmiogSgGVhRURH5CyM1TdOCyQtlVGfPnj1CXHHlDcMwjH5hUeIDUDpbVVXlNT+JfcQFXUq1nWJ9jRFNro58JUjhsMmVYRhGv7AoMYCfJNC+EiOLEntfiRQlSEH17t07gFvGMAzD2MOixECi5Oijj1ajLv7yldTV1dHKlSvFMhqmobzZqJESzHC8bds2sYwJ+5DeYRiGYfQDixIvg7SN9GDAS5KZmem1905KSlIbguGKH7P2+poNGzZQeXm5IaMkAP1hEhISxPLSpUtFSTDgyhuGYRj9waLEB6kOGF2ln8TbyMgLBldc+fsaI/Yn0RISEqJOaCgFCeD28gzDMPqDRYlBUjeO3tNbKZxXXnmF7r77btq3b5+hZwZ2xVciYVHCMAyjPzipbjBRMn78eHH1jwocb5hdFy9eTFdffbVYRrksREi7du2aiJKoqCjDpjy0vhIJixKGYRj9wZESL4K28nImXXgZOnXqRN4mMTGRhg0bJpbXr19Pubm5Hr9XbW0t3XTTTep9TFw3ffp08TjIycmhnTt3imWkQOSsu0aPlHTt2lX1mTAMwzD6gUWJl/0XckD3hZ/EUQSmNb6SuXPn0pYtW2weW7JkCV1//fXCf2HUpmn2oIEdms9JjBrxYRiGCXZYlBgodeNNX8nhw4fpwQcfFMsoM541a5YaCZk/fz49//zzhu5PogX7p03hcOqGYRhGn7AoaYaysjL66quvqLi4WFei5KijjqLQ0FCx7Kmv5N5776WSkhKxfPHFF9NFF10kDK+SW265hd56662gECVg9OjR6rKsxmEYhmH0BYuSZrjyyivp1FNPFXPOZGVltShg5KRvffr0oY4dO5KviI+PVwfWTZs2iaiHO6Cz6Wuvvaa+16OPPiqWL7jgAiFWAIy0mFEXoNeKL/fHH1x77bU0ZcoUIb5OOumkQG8OwzAM4wAWJU6Ap+Lbb78VyyiVnTRpEh06dMjhc2tqaujSSy8V3U997Sdpbct5iI0bbrhB7dmBFE5qaqq6/uGHH6azzjrL5jVGLQXWAk/Jd999R2+88YYaZWIYhmH0BYsSJyD6oJ2JF1UokydPpvz8/CYRklNOOYU++ugjcR+tyyFQfI2nvpJ3331X9Yr069ePrrvuOpv1KDd+8803bVIcwSBKGIZhGP3DosQJmzdvbvLYxo0bRQpAejHQ5h1C5YcffhD3zWYzLVq0yGGzLm8zbtw4de4WVyMlpaWldOedd6r3n332WQoPD2/yvOjoaPryyy9FmuPkk08WnhOGYRiG8TUsSpwAr4bk9ttvVz0V8GNMnTqVtm/fLibIk2Wz6HsBceIvv0JsbKwqftBfRPo/muOxxx5TU1CnnXYaHX/88U6fm56eTt988w19/fXXFBMT48UtZxiGYRjHsChxIVKC9Az6dyQnJ4v7y5cvF6kPRE5AWloa/frrr6Iqxp9oUzjYvuaA7+XFF18Uyyj9ffrpp32+fQzDMAzjDixKXBAlECD9+/cXLdlRrQLq6+vF3+7du9Nvv/1GgwcPJn+jjXRIU64zsI1I34Bp06ZRjx49fL59DMMwDOMOLEpaSN+gakN2A4X5EykNeEcASoUx2AdqgIcBVbZLh2CS1T+OwHZLkH5iGIZhGL3BosQBqLrJzs4Wy4iQaEGKBmkbVLGgrXwg+3fApHrCCSeo26ztwOpMlKC6Rr6GYRiGYfQEixIXUjf2dOvWjc477zxhNg00qI5xFA3RgnJmmGFldEU7CzDDMAzD6AUWJS1U3jgSJXoCJcqY26U5X4n2ca2IYRiGYRg9waKkhUiJffpGb6AbqywNXr9+Pe3du7fJc7QRFBYlDMMwjF5hUeJB+kZvaIWGfbSkvLxcba7WqVMnGjhwoN+3j2EYhmFcgUVJM+mbuLg4ysjIICOLkp9++omqq6vV58lUD8MwDMPoDRYldlRUVKgzAiNKYoRBfNiwYdShQwexvHTpUqqqqlLXceqGYRiGMQosSuxAlYqcQdcIqRtZ5ivb20NUyXQN9kOKksjISJo4cWJAt5NhGIZhmoNFiYErb1pK4WzYsIH2798vlo855hiew4ZhGIbRNYYTJd9//71P399IlTdajjvuOHXWYERHtFESwFU3DMMwjN4xnCg566yzqLa21mfvb7TKGwnazY8fP14s79q1S6ShWJQwDMMwRsJwogQlrqtWrfJ5+gYeDHRuNRLaaIhsgw/69OkjJg5kGIZhGD1jOFECfvnlF5+8LyIwO3bsUAfy0NBQMqooeeqpp6ihoaHJ4wzDMAyjVwwpSn799VefvC8EiZxp10ipGwmElIzuaMuCWZQwDMMwRsCQomT58uVUX1/v9fc1qp9Egp4q9gIEDeAwszHDMAzDBJUoQYnp7bffTmeeeSbdeOONtG7duibpj2effZbOOOMMuuiii9R+Ga6ud5WSkhJau3atW6+pqamhjz/+WGz7rbfeSmVlZc2WAxup8kaLvSiZPHkyRUREBGx7GIZhGMbrogSD+NNPPy2adOHvkCFD6LrrrqPDhw+rz3nxxRdp5cqV9N///pfOPvtsuu+++0QViKvrfZHC2bZtmxBSmPdl+vTp9MUXX9Dnn39Ojz76aNBFSmQ/ErPZrN7n1A3DMAwTdKIkJiaGXnvtNTr22GOpa9eudMkll1BycrIaLUE6ZdGiRXTDDTeIKAPEy4QJE4QIcGW9t82uP/zwgxig4bOA6TM3N9dm/UsvvURFRUUORQk6pPbq1YuMSFRUFE2ZMkUso2/JiSeeGOhNYhiGYRjvihL4FbTzwJSWloooCSIQ4NChQ+KxAQMGqM8ZNGiQGglpab2rtGvXTo2UyOoSe9DFdOrUqTbCJTw8XERnZOQA24LIjQTvtWXLFrHco0cPURJsVBDJuvjii+ntt9+mjh07BnpzGIZhGMYllBagboJuoUh/jBs3Tk1zSI9GbGysjclSPt7Semc+ENy04H9+/fXXVFBQIDwuAwcObPI69OiQDdYQ8bjiiivoggsuoPbt29P27dvpu+++EyIE/hZ4Y6Kjo2n37t1UWVkpXoN9ciZ4jEBmZia9+uqrYtmV/ZDPMfI+exs+Jnxc+Fzh7w//pngXZCF8Ikoef/xxESWZN2+eTdoAYGDHIC8nh5OPt7TeEa+//jotWLDA5rG0tDR1Gd4QCBt7wYQ0k+SVV14Rg7Sc/RemT0RLvvrqK8rLy6Mnn3ySZs6caRNVSU9PV2cKbkvs27cv0JugO/iY8HHhc4W/P/yb4h1caUjqtiiBPwMRCngytIZKDORIkaDFuYxeYBmCwJX1jkAKYsaMGTaPwcMi26djO+xfj6ocmFvBmDFj6Oijj25yBXzVVVcJUSKFz9133035+fnqc0aNGtXsdgUbOCYYfDt37uySkm0L8DHh48LnCn9/+DfF/7glSp5//nn6999/6eWXX24SoUAEAsbVN998k2bPnk0HDx4UZtOHHnrIpfWOwGvsy1mPPPJI8b/hCUG/Enuvy3vvvacuI2XjaJBFegbREogbDMYffPCB6icBEE1tcXDGPrfF/W4OPiZ8XPhc4e8P/6b4D5dHoOzsbHrrrbcoJyeHzj33XFE9g5u2egalt4g4QHzgOehHom3c1dJ6V0BFiXwNUkgyKiIrfKQowfNQAuyMu+66S12eM2eOiLpI+vbt69Y2MQzDMAzjx0gJTKLaWWcl2ogJSoTh5yguLhbVK/Z+kZbWuwpEDcyqAF4QlP2Cn3/+WURgAAQT/p8zxo4dK1I7qOLRVgAhhaE14zIMwzAMo7NICSan69ChQ5ObNK1qSUhIaFZwtLS+JbQ+EW0TNZTAalM3LXHPPfc0ecyonVwZhmEYxugY0kAwYsQIVQwhUoKKm/Lycvrss89U0YM+JS1x/PHH07Bhw2weM2onV4ZhGIYxOoYUJajiQfpFNkrbs2eP6BYre55MmzbNpUgMDLKovNHCooRhGIZhAoMhRYl9CgfRknfeeUe9f/7557v8PjDb9u7dW73PooRhGIZhAoNhRQnMrhLM/ovyYtClSxcaP348ueOVeeaZZ0S1zvDhw2n06NE+2V6GYRiGYXzQ0VUPoF8JKniqq6vp22+/VR9HszV3e22gUgd9T5AWgkhhGIZhGMb/GDZSAs8IOq/a407qxv79WJAwDMMwTOAwrCixT+EApF+4pJdhGIZhjElQiRJXepMwDMMwDKNPDC1KYEqFQRXAR3LOOecEepMYhmEYhmmLoiQmJkaNjlxyySWUlpYW6E1iGIZhGKYtihKwcOFC2rt3L73yyiuB3hSGYRiGYdpiSbC2Kysm0WMYhmEYxtgYPlLCMAzDMExwwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdYLJYLJZAbwTDMAzDMAxHShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QVhZFDee+89WrNmjVgeMWIETZ8+3WZ9fX09LVq0iNavX08JCQl09tlnU8eOHdX177zzDq1bt069Hx4eTo8++miT/1NXV0ePPfYYdejQga688krSM7/++it9/fXXYjktLY1uueUWh89Zvnw5hYSE0KmnnkoDBgxQ1y1btoy+/fZbm+fjPfBerqzXIzt37qT58+er9/FZhoXZnvabN28W+1VaWkrHHHOMuEl27NhBr7zyis3zca7hnJM0NDTQd999R3///TdlZGTQ+eefT2azmfQKzul77rlHvY/zukePHjbPycnJoY8//piys7Np0KBBdMYZZ6jHrbq6mu6//36b548ePVo8B6xevZref//9Jv/3iiuuoJ49e5Je+d///if2F0ydOpWOPvpom/WVlZX00UcfiXOqU6dOdN5551FsbKy6/qmnnhLHTYLn3HDDDer9iooK+vTTT8U5lZiYSKeffjp169aN9Mwnn3xCK1euFMuDBw8W57YW9N7Eb86qVasoLi6Opk2bRp07d1bX43j9888/Nq+ZM2eO+P1x5fV6ZMWKFfTZZ5+J5aSkJLrrrruaPOfPP/8Uv5f4bTj55JNp6NChNuvxHfr8889p06ZN1L9/f7HfoaGh6vqtW7fSF198QVVVVXTcccfRuHHjqK1g2EgJviDHH3881dbWig/Wnocfflh8oXAy1NTU0MUXX0xFRUXqeggSiBW8B2744B3x9ttvi5Pw33//Jb2TmZkp9gUCCttszwcffCCEV69evSg1NZWuvfZa2rBhg7p+z549VFZWph4T3LQ/ui2t1yP40cB2HnHEEfTTTz8JsaoFAygGy/j4eBo4cCA9/vjj4sdAkp+fT1u2bLHZZwgP+3Pt3XffFQIP4nb27NmkZzAgyH3566+/qLCw0GZ9QUEBzZgxQ3xfRo4cKQYNDCQSHEMcy4kTJ6rvgx9WCcS/9nh17dqVfv/9d12LVzB27Fixvfv376esrCybddjnq666SgywOCbbt2+nq6++2uZ8wkDUu3dvdb/HjBlj8x433XSTuCjA6zEYX3jhheJ/6Rmc09gXnDPaizjJE088QW+++SYNGTKETCYTXXLJJTbCDL/NEOja8wHPc/X1egRiE/vRpUsXcV7b8+WXX9J9990nzns89+abb7YZP3DO4NzBuTB8+HCxvwsWLFDX79q1iy677DKKiYkRFwu4gIDAaSsYNlKCAQQ3DKpasQHwI/vNN98IUYITQw6ouI8PW9KnTx+nYgTgBwNXwLgy/uOPP8gIogQ3nPQYbOxBdAg/jCeeeKJ65ffaa6+JK0TtgNLcMWlpvd5o166d2N59+/Y5jbjhivXyyy9Xn//000/Taaedpv54Qng522dE4vDDhKhcdHS0eKykpIT0DAYYuT+OBBRECH5M7733XnF/1KhRInKA745WWBx77LEUGRnZ5PV4jvZ5uNLGc/UuYBHtAfgs7YF4xW/I4sWLKSoqSnyHcI5gYMG+SRBBs78qBsXFxSIaAMGLYwvw24WLh7POOov0Sr9+/cQN0SHctOD3A5EfiAo8Bxw4cEBc/GgjRIiOOfr+uPp6vYHPDzec+zgfHP3OXnPNNXTmmWeqkclXX31VXBgBRGVxobxw4UL1N0b7m/H++++LaO11112nPobnaiO4wYxhIyXNgatboL2ixbJM90iWLFkiwtBQqfZXiwBXh/hyREREUDCAK2DtMUlPT6e1a9faPGfjxo3imDz//PO0e/fuJu/R0nojniv25wmuXA4ePKg+lpeXRw8++KAIzyNFowURA4T5MZA/8MAD4gfW6OeL/TFBVA2pG/vvD6JKiLzhR9bZFFoIU//4449C1BgZnAPJyclCkAAcD0Qk7Y8JImY4VyB2EXqX4KoXkdnDhw+L+4jw4jjjO2jk3xOkJ+x/U+yPyS+//CJ+M5BGxXF09/XB8JuCKBP2FcgoI4TKQw89JFJBWsG+bt06cSGgFctI5+C71BYISlECFYsfDxlaw48Dwmda4XHBBReIKxR8+PjAzznnHPElkSBCgvc46qijKFjAFYs8JhhEEG7GFZwMQUOJ42oY+UtcxSB/jEiApKX1RgSpLBwHOajK4yPPFay/4447xD4j533bbbeJqzsJruxwtQyxhrA8Imp6vspzBewzIgPwQAAIMQyiMiKJK0QIdqQ7unfvTi+//LJIYTkCAxIiSEceeSQZ/bsDoYpoCYBwRQpH+5ty++230wknnCAiJRBi+K7gKlmKGIjaRx55RJwfiL6ecsop4hgaFYgyfCfkdwbnCM4VbeQa+4nfVvzO4tjhvvTtuPJ6o//OAixDUMjvE34zPvzwQ3EfaStEhrQRy6KiIuE5kiB6C0GD3+q2gGHTN80BMYHBA1euMOnhJMAXQGskwuO4AVzFIZeJ0Cr+IpT20ksv2RgkgwHkNnFcEEYuLy8XJzsUujwuSHXJdNeUKVNEaPGtt96iJ5980qX1RgSfN7wC5557rvCVYPDAfuGqVnpStKFnXPXg3JChWQg6HEdc8UjhNnnyZDFgYXA3IvhsIcphvoPowNUt0nY4PgDni/aYwDsBgY+Qdfv27W3eCxGkk046STU2GnmgwTkCbxp+N/bu3StMqvI80aZ/5DGEkRwD0oQJE4Q4gWEa74NzBL9JMDpiWc/m3+bAdwWCHQPqV199JcQGfmdxwSKB10j6jfA7i3MEoh5+Nldeb0RuvPFGccOFCtI0OEfgNZPpXfxmwBOJ54C+ffsKf9Gtt94qxi58v6SYlWIN2Bv0g5Wg3Uv4BPBjCac7DEkYPJv7UDHYytAirnxxUjzzzDOqtwRXRvgCwZhlVIYNG6Y6vjHAwMAJ46ozMCChMsXT9UYAP4K4UsExwY8FfhRQjaKt1NKCgQgRNURWIF4Qbtb+gODKDzdt1M1o4Hsyd+5ccX5gP2B2hH8CfiVH4PuF1+D7oxUluA9vE35sgwEMIvhdgT8JAwl+D5wdE5xHOIfkbwouBLZt20Y//PCDehGAMD/OPZgijQq8NYgQYt/wXUAqorkreilyPX29EYAIk7+zECIYP3Jzc1VhjgsbbdoO54mMhEQ1njeHDh1S12MZj2ujJ8GMsS9fmgFhQPxAIuwOpYkfA1z5AajX3377TX0uQrAwnElFD0MSSl2lWxyGWFnFYWRgrMMPIq7o8KVA/huhVQlynTKNgWOEELQ0oLmy3ohggMGPJAQbwu4w/mrLX3Glq/UGIIKAAUka1OAn0Zqt8UMEoWdfYmskILKQ7sRni+8PyjoxmMjycaTs8CMrwXcLPhr7ARpmc7zG2cBtNPAbgX1BSheCDRU6iIgARD7wmASRMlwQye8HPCWIAGjFKl6jd/NvS6AaCYMl0lD4ziDigfYLkqVLl6rLiECjHYH2N6Ol1xsR/AZAZCBliYtdXBBr92n8+PHC/C0jIPiNwfgC7xbAdw6/M/JiB8ZrPGb0aGPQR0pwssP5jC8+PlxcteDDRp4WIP8LIx6ECa7mUYKFH1aADxcf9AsvvCBOBAwq+NARZgZQqtorZURJ8AOi96oTeGPg0sb2wlCHY4Ire+w7QCQAXhrsG35AUTWAHLj2h/S5554TP7xw2uPYaXuztLRejyBNhdSKFBa4KsUAKnvSwB+BiiT8MEKg4Nho9wmvxw8KeifgmCI3DG+ABFd5kyZNEs9BOSjOJXgGUlJSSM8g4gcxhrw20goQHjgOEKv4fsCwi/QlBBaeI6OGAKFohN9xzPDDiRJGGBlleForSow0wMjeR7hqh+iC+EJaSvphEPXBbwauWuGPgKFVigqUvc6aNUuIdTyG1yIkLy90IM5wnuAiAFWD+H3C7xZeo2dw8YYSV5ja8V3AbwqOh6wYQrQHPhFUW2Ewvuiii2zKw3/++WfhOcL3CukMiH/Zz8aV1+sRfPbz5s0T244LWhwTRD9kOgbfH6SFEYXFbyb8NIg0ShBtQ4kvLpLxfcP4hPNAXuicc845Yj2OC84lnIvakuFgx2RxZpvXOTgxIEjsw8gYGCT44uMHE1e2jgYJvAeeg9fJMj1HYLDCQC9LuvQKviQwKGrBwKFt9IUregyc2Gfc7JEGPggOeCK0PQVcWa838MMPs6UWRIu0ZZwQLBiMkPvVRkEkaKqGH1T8QOD8clRdg3MROXH4A/TejwPAkCuNdxJE0OQgiys9VAHI/DeEiBaIMxwT/HzgmCBl5ei44wrYXqzoFXwvpAlTggFSG2rH54xBAr4S+ygHjhkuDBCGx3ng7DcH4XykT/HeevcJ4LcP+6QFA7A22oFjhuOC80Be7WuB/wbvg99YR1Gzll6vN/Abat8QDue/tmIGUSEIU5w7jhrk4XuD8w2iH7858KVpqaurE5WR+J5ByOm5GaO3MawoYRiGYRgmuGgbSSqGYRiGYXQPixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXSBvovkGYZh3AC9U9AHBB1Ug2kyTYZpK7AoYRjGJdDgCp18AZqpYfp1LbL1OvClKEB3ZTSeAuiSqm1AhrlT0K1ZtoNnGMZYsChhGMblqR207a4xpQGmXgfowXjPPfeI7p0A3Tt9JQowuZ2clRkdY+27yTIMY1xYlDAM4xGY4VaKEky0JgWJMzClA6ItaMeOeajspznQpl4wFxWeixlSEfWQ7ckxP4qMkshJIjEXDeYmsp8zBULJ0XswDKNfWJQwDOM2mPsIggDzlmCuH0xmJx/XziAMMJEbJq/D5GwQI5g7CKkeRDkeeeQRMeeQNvWSnJwsBASehzlGMP8OJpXEJGeYLE87Gy8mjEP6BvOOaEUJ5hTBxIqO3oNhGP3C1TcMw7gNZonFQI/ZhTFhGwZ+CAk5o64WzNYNQYIJ1yBeMJU7JhnDpIAQK44mlrzsssto7ty5dO6554qIB1JFiLBghlU5Qy144IEHaPbs2eJxV9+DYRj9wqKEYRi3OfPMMykyMpK++OILeu2118RjGPztZ1jGTMSLFy8WyzDGIqqBqd1hUJVpHwgILYicSHEjUy6YLRXTxLuKN96DYRj/w6KEYRi3SUxMpJNOOklM0Q4DLETA1KlTmzwvJydHRFQA0jKSlJQUdRmeD/v3loSGhqrL7kxo7o33YBjG/7AoYRjGIxAZkZxxxhnCcGpPfHy8TdRE6zNx9ByGYdo2LEoYhvEImFYvvvhimjx5Mk2fPt3hc5KSklQD6rp169TH5TIqcOyrcFoC5lWJjMIwDBMccPUNwzAec+2117b4nPvuu088D9U6L7zwgoiofP3116K/yKxZs9z+n3379hUpGQgSmFcHDhwobhkZGR7uBcMweoFFCcMwLtGjRw8RFWkOiAMYSrWeEVTdfPzxx/Tdd9+Jkl4AkQJPivZ5AwYMECme1NRU9bH09HT1f8r0EIyrqKpBRQ9MssuWLRPvA1Hi6nswDKNPTBZ2fjEMwzAMowPYU8IwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwDOmB/wO4yGlRd4tdywAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + } + } + ], + "id": "7b09db6a" + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/07/23 18:50:10 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Registry\n", + "\n", + "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived)." + ], + "id": "6f1ec89e" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Files in model directory:\n", - " - python_env.yaml\n", - " - requirements.txt\n", - " - MLmodel\n", - " - model.pkl\n", - " - conda.yaml\n" - ] - } - ], - "source": [ - "# Save model to local directory\n", - "local_model_path = os.path.join(tmpdir, \"my_model\")\n", - "save_model(model, path=local_model_path)\n", - "\n", - "print(\"\\nFiles in model directory:\")\n", - "for file in os.listdir(local_model_path):\n", - " print(f\" - {file}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "254ba153", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.479679Z", - "iopub.status.busy": "2026-06-24T15:18:53.479604Z", - "iopub.status.idle": "2026-06-24T15:18:53.484973Z", - "shell.execute_reply": "2026-06-24T15:18:53.484638Z" - } - }, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T08:27:04.144511Z", + "iopub.status.busy": "2026-07-22T08:27:04.144439Z", + "iopub.status.idle": "2026-07-22T08:27:04.166315Z", + "shell.execute_reply": "2026-07-22T08:27:04.165897Z" + } + }, + "source": [ + "# register the best model (from the \"Load the Best Model\" section above)\n", + "result = mlflow.register_model(\n", + " model_uri=best_model_uri,\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")" + ], + "execution_count": 60, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Registered version: 1\n" + ] + }, + { + "output_type": "stream", + "text": [ + "Successfully registered model 'darts-air-passengers'.\n", + "Created version '1' of model 'darts-air-passengers'.\n" + ] + } + ], + "id": "7c854bc4" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model successfully!\n", - "Predictions shape: (5, 1)\n" - ] - } - ], - "source": [ - "# Load model from local directory\n", - "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", - "\n", - "# Test it\n", - "local_predictions = local_loaded_model.predict(n=5)\n", - "print(\"Loaded model successfully!\")\n", - "print(f\"Predictions shape: {local_predictions.values().shape}\")" - ] - }, - { - "cell_type": "markdown", - "id": "aab0d1e0", - "metadata": {}, - "source": [ - "## Querying Experiments\n", - "\n", - "You can programmatically query and compare runs." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "109a9812", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.485914Z", - "iopub.status.busy": "2026-06-24T15:18:53.485859Z", - "iopub.status.idle": "2026-06-24T15:18:53.496380Z", - "shell.execute_reply": "2026-06-24T15:18:53.496048Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", + "\n", + "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", + ">\n", + "![Mlflow Charts](./static/images/mlflow_models.png)" + ], + "id": "da6cc83a" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 5 runs in experiment 'darts-quickstart':\n", - "\n", - "1. exponential-smoothing-baseline\n", - " Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", - " Validation MAPE: 7.864181481214469\n", - "\n", - "2. linear-regression-full-metrics\n", - " Run ID: 708095048f274913990375bbbd4310ad\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "3. linear-regression-autolog\n", - " Run ID: 36376b7a94454a13a4acba207459315e\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "4. nbeats-epoch-metrics\n", - " Run ID: f0d1b0ed9ac34232b5e36fe82a24a0a6\n", - " Validation MAPE: 13.639569217869525\n", - "\n", - "5. metric-shape-and-table\n", - " Run ID: 9be3e9d311b64d45b0204174835537cc\n", - " Validation MAPE: N/A\n", - "\n" - ] - } - ], - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" - ] - }, - { - "cell_type": "markdown", - "id": "22685423", - "metadata": {}, - "source": [ - "### Load the Best Model" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "7b09db6a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.497560Z", - "iopub.status.busy": "2026-06-24T15:18:53.497496Z", - "iopub.status.idle": "2026-06-24T15:18:53.572540Z", - "shell.execute_reply": "2026-06-24T15:18:53.572133Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Important Note: Custom Flavor\n", + "\n", + "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", + "\n", + "**Always use:**\n", + "```python\n", + "from darts.utils.mlflow import load_model\n", + "model = load_model(model_uri)\n", + "```\n", + "\n", + "**Instead of:**\n", + "```python\n", + "import mlflow\n", + "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", + "```\n", + "\n", + "This custom flavor is necessary to properly handle:\n", + "- TimeSeries objects\n", + "- Darts-specific model parameters\n", + "- Covariate handling (past, future, static)\n", + "- PyTorch model state preservation" + ], + "id": "7af49ea9" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading best model from run: exponential-smoothing-baseline\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup" + ], + "id": "40621b13" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", - "\n", - "if runs:\n", - " best_run = runs[0]\n", - " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", - " # from the run outputs and load it with a models:/ URI\n", - " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", - " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", - "\n", - " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", - " print(f\"Model URI: {best_model_uri}\")\n", - "\n", - " best_model = load_model(best_model_uri)\n", - " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", - " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", - " if isinstance(best_model, GlobalForecastingModel):\n", - " best_predictions = best_model.predict(n=len(val), series=train)\n", - " else:\n", - " best_predictions = best_model.predict(n=len(val))\n", - "\n", - " train[-50:].plot(label=\"Training\")\n", - " val.plot(label=\"Actual\")\n", - " best_predictions.plot(label=\"Best Model Forecast\")\n", - " plt.legend()\n", - " plt.title(\"Best Model Predictions\")\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "6f1ec89e", - "metadata": {}, - "source": [ - "## Model Registry\n", - "\n", - "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived)." - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "7c854bc4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-22T08:27:04.144511Z", - "iopub.status.busy": "2026-07-22T08:27:04.144439Z", - "iopub.status.idle": "2026-07-22T08:27:04.166315Z", - "shell.execute_reply": "2026-07-22T08:27:04.165897Z" - } - }, - "outputs": [ + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-24T15:18:53.573724Z", + "iopub.status.busy": "2026-06-24T15:18:53.573637Z", + "iopub.status.idle": "2026-06-24T15:18:53.575115Z", + "shell.execute_reply": "2026-06-24T15:18:53.574817Z" + } + }, + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "text": [ + "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" + ] + } + ], + "id": "51fc7c4a" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Registered version: 1\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Final Remarks" + ], + "id": "ca40afc1" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Successfully registered model 'darts-air-passengers'.\n", - "Created version '1' of model 'darts-air-passengers'.\n" - ] - } - ], - "source": [ - "# register the best model (from the \"Load the Best Model\" section above)\n", - "result = mlflow.register_model(\n", - " model_uri=best_model_uri,\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")" - ] - }, - { - "cell_type": "markdown", - "id": "da6cc83a", - "metadata": {}, - "source": [ - "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", - "\n", - "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_models.png)" - ] - }, - { - "cell_type": "markdown", - "id": "7af49ea9", - "metadata": {}, - "source": [ - "## Important Note: Custom Flavor\n", - "\n", - "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", - "\n", - "**Always use:**\n", - "```python\n", - "from darts.utils.mlflow import load_model\n", - "model = load_model(model_uri)\n", - "```\n", - "\n", - "**Instead of:**\n", - "```python\n", - "import mlflow\n", - "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", - "```\n", - "\n", - "This custom flavor is necessary to properly handle:\n", - "- TimeSeries objects\n", - "- Darts-specific model parameters\n", - "- Covariate handling (past, future, static)\n", - "- PyTorch model state preservation" - ] - }, - { - "cell_type": "markdown", - "id": "40621b13", - "metadata": {}, - "source": [ - "## Cleanup" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "51fc7c4a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.573724Z", - "iopub.status.busy": "2026-06-24T15:18:53.573637Z", - "iopub.status.idle": "2026-06-24T15:18:53.575115Z", - "shell.execute_reply": "2026-06-24T15:18:53.574817Z" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." + ], + "id": "c4c86a23" } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" - ] + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.11.9)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01ac1053789e45fab75e2cde894b417a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02cefe41f8814ddf9de26418b26783c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "03569ea4478d4d74b0ae4c5416c40d6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "055bae1119db45caa5b6cd91921c76d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", + "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", + "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" + ], + "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", + "tabbable": null, + "tooltip": null + } + }, + "05d25d3b3bd9497f86849702e5a19515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "071709416bab4673a582978e2e3592a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e8c0b16c2d430ea8bb6798e9b4f103": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", + "placeholder": "​", + "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "0deaf695a8544725ac4904ff7388f489": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "11dbeaae3ae640c3995e784abfda15c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", + "placeholder": "​", + "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "12524abe09304f9bb20bd9978ac2a44d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", + "placeholder": "​", + "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 189.90it/s]" + } + }, + "13af542c17d64851a3ef54ce9610bb99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "153af823c040405dbc075bf50a28ff17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "16656416b10a43c8b81c6c4b2a02ec0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "16ce59abc5bb4ffe978736017f60e21a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", + "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", + "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" + ], + "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", + "tabbable": null, + "tooltip": null + } + }, + "19382158e51343918122512753ca25c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "20cca542fe2a4e19846e2e1cb07dd165": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "252a64f9c6d440e2a3d3c3f62f44d764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", + "placeholder": "​", + "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", + "tabbable": null, + "tooltip": null, + "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" + } + }, + "27e25633e2a549dcbfafe1129839043d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b154733d72e4e468c339683e83c30a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b197d3911154085bb86f0dbba2c8b98": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2c4ee939558d44a4a3bc9040a940693f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", + "placeholder": "​", + "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 199.01it/s]" + } + }, + "2e727ab68ed64ee98bfb9d81f1e39c1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", + "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", + "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" + ], + "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", + "tabbable": null, + "tooltip": null + } + }, + "2ec00b06939145ec95930e3c1490efcc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", + "placeholder": "​", + "style": "IPY_MODEL_19382158e51343918122512753ca25c7", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "30a18f8c59754940a9785cd152a67daa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "32e9a01e1a2b4914989eda6f6832f989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "331f7f90d7d049a6adc72c260c06570e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "33a28231831d473aa27d32e1c15a8989": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35778f5ef201497d8d453772f80a7978": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "366e2af2827540728d29bfa6d931dbdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", + "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", + "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" + ], + "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", + "tabbable": null, + "tooltip": null + } + }, + "3799be676aea4d12b87992115e4b90ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a36a442c4a94ab585d8522e57f45c34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3b44dec6a3354f7ebc4117e7d7f50b1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", + "placeholder": "​", + "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "3c3d34b732664135a79031e8bc9e2984": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "3cde338fcaf548de8e8216a98e66f9bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", + "placeholder": "​", + "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 195.74it/s]" + } + }, + "3dddd89019c849f0872e9a9700e14ad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", + "placeholder": "​", + "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", + "tabbable": null, + "tooltip": null, + "value": "Predicting DataLoader 0: 100%" + } + }, + "40b8f5c6c7844bd0bb071f043f97a639": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "40df96a9f08440a893ffe9d57d176e1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41e23a2458044b888fb76fd882428b39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "42360fe280a14e44831c8e62f6ad249e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "425a21a3b7604c8cb49871c1b2850f68": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4297b4158e4f43da9226bfc00272f9c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "43eab5ba00014d7ba62f97acd9e93eba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "44c3cc7783594142a19ffad035eea9d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "4787d389023845a8ae398eb5d1155ab1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "480afa5d41c145d0ac88e2adaca7b1e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", + "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", + "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" + ], + "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", + "tabbable": null, + "tooltip": null + } + }, + "4b3f0ca06bf54eb9bab4e081dabcf139": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f10caf0abca4aa59053c4cb374ea3d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "50e4f1e4cd994abeae53d0f84b6afd44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "522af0834c254f0eb2fe7c9efa74c5f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "54aad655289741b59d3c83b8508e68b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", + "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", + "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" + ], + "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", + "tabbable": null, + "tooltip": null + } + }, + "55e102413ba54377b2fd1995b98c7858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "579cbbe7cfb34e429bffd11ec774ba50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "57cd2f911c6840da87c1d6c8a78521e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "57db1d3f28d347878d9f48d0ceef5589": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", + "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", + "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" + ], + "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", + "tabbable": null, + "tooltip": null + } + }, + "580c0814097844e186ef642094968d3a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "590ebae9a3664214be16b105941c7ee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59413112366944be8e0d6600880dc1a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5dcf47d8b9c0420898fe491a81bab8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", + "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", + "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" + ], + "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", + "tabbable": null, + "tooltip": null + } + }, + "61734f2b95c34e13971fd65cd7da2e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "641b5ae5b9e7475db63a31e67b13b601": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "642a06d187834b96af41b74a25d13e1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6da83aee80314ceb9ace5fa0c4c76529": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9e33a121da334db899669d702f9d54ce", + "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", + "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" + ], + "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", + "tabbable": null, + "tooltip": null + } + }, + "6dad7db23e9e4397bfb93655cd8b08b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e794979a2793408791ee570d3af6f371", + "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", + "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" + ], + "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", + "tabbable": null, + "tooltip": null + } + }, + "6eb691aae3a44a25b1e7471929151f47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71c1aa3663804753bf3a75a227412072": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72125343cca3416fbd3f012232e63ae5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "761dbbe1bf4e4804a3649858898b78e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7adbf399ea5e4a7c990cdff60674b593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", + "max": 3, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", + "tabbable": null, + "tooltip": null, + "value": 3 + } + }, + "7d599e5710f4485a8f7580c7efca3bc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e0ad83f116b4933a35870525656df5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "81e281800a094e34b2e43021bea6fd11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", + "placeholder": "​", + "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 174.77it/s]" + } + }, + "859b368a8a6d4500960a6e2285f4c016": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86bfcc40b08440af98f64a732df1ea5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8766872fa61844458d70112fcf44bdb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8825c219393f4040890a639a17210bc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "89dc0773756b4b7b93cce8e6cfe47202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", + "placeholder": "​", + "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 100.83it/s]" + } + }, + "8d829381b5034ed9807b86d514b1fdbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "8e6984bd5a00425bb9071deba84f4cea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8f2ac8fd36964f11bd556782c96b0f72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "924315df026a41fb97d7cc8488bb8503": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95daeef1bd3e4f77b883d3d71fcd1fac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", + "placeholder": "​", + "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", + "tabbable": null, + "tooltip": null, + "value": "Sanity Checking DataLoader 0: 100%" + } + }, + "97b2d3e5a7e847739b237fc9c5cdc3a9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9914744ed44845fd9d00727c7da93d32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "9a20b5d724584e289863cf63a4c13259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b1dd53c1fdd45dabf3660e9e0be1310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", + "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", + "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" + ], + "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", + "tabbable": null, + "tooltip": null + } + }, + "9b8b6898ef244336989227f5469a2d11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b933a5d5aa14741904151b4ea7e3f50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", + "placeholder": "​", + "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 88.28it/s]" + } + }, + "9e33a121da334db899669d702f9d54ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", + "placeholder": "​", + "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", + "tabbable": null, + "tooltip": null, + "value": "Epoch 9: 100%" + } + }, + "9fd5c0e984d04e4aa0e106ec89434720": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "a30948d8cfd6491484d6b63591b65a84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a5f3118f4f9040ebbdb1a7acae012087": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1dc954934944e92914a1c129d8c7dcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b23efdc3bb5747af96dd5e539a14b5c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", + "placeholder": "​", + "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "b35ce184b43b48daaa39ccef748eeac6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "b4d7ddbd507e4e1681cc0888680abb5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "b4e804d6e4b44314a8847c2f5be857d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b6625b52007b4434a7804cfd824452cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", + "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", + "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" + ], + "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", + "tabbable": null, + "tooltip": null + } + }, + "b676b1571a00427587827caac8158c14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "be1dd700617141cf9517ee7ef1153746": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c198ffce01de4b7294649c1619b5b7e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c255e442c01446699af3179f14eb8fc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", + "placeholder": "​", + "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "c2906f9d5f47471ca6bf44d8754f8d30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c325a187e8a54e639300ff5a29640f03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c60add7b277344feaad65a884c7fbf37": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c7c373a0b1c14b809041651ffcdd4559": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c99d9a52749b40628b8d148c64e75e88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb3cebaf14cc445a8055d1aac2f0d05c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", + "placeholder": "​", + "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 180.77it/s]" + } + }, + "cc7d97d8845d46ff9d946020b1b8e4cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "cd4d74958b704246a2cb2462a784d502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce45f3190357423a9563bfae253f2f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce49dfd502074696aefcfa2cff18e4f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce97bb2d961e4dc9bf44a646cb3d3aff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d04931a3bb0c47329cdd67701a7be0ad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", + "placeholder": "​", + "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 192.16it/s]" + } + }, + "d473da3081af4d4a810014019cd40b29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", + "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", + "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" + ], + "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", + "tabbable": null, + "tooltip": null + } + }, + "d4b49fabdd4543959d64e4e1c60dc360": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "d9fc58b33d2645488a8c53af72f21e7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "da4c6178632b4cfe96d2a9504cc3173b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc6cccb142db43b7ac9849983a154a20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dcb0a4350297443aa61691406923fb81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dcced12e0ae04e32a811f60680db24f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", + "placeholder": "​", + "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "e09f041d857346029cbba27fb36f009e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e12d00f1e1b94e749f22904d3cec2445": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", + "placeholder": "​", + "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 186.36it/s]" + } + }, + "e19ea3de3e554c50a7300a7214c773f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e53d8d156b1c4db6aff2ba8395bf5415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e6dfb5d14dfe4a1193e551f414ea393e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7198635809b4f56bd1a30b6cbe661cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "e742e68a86474f0db17ccb64db4264c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e794979a2793408791ee570d3af6f371": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", + "placeholder": "​", + "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "ed4968eb8435434db1604e34ee657413": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eeb45b37592a4a599da1857d3444382e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", + "placeholder": "​", + "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f03f6404137144b8b600f8131c78ac63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f286ebc675c549678f70419f668a7baa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "f299c926a6a64a769d3db2e71725f8af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f60411b259344a9e9a892d9552ecdabf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f609670bc6b840ed9f8698af8c7615a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f69737793cc648bd9aadfc0dd4b16569": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", + "placeholder": "​", + "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", + "tabbable": null, + "tooltip": null, + "value": "Validation DataLoader 0: 100%" + } + }, + "f6f12cd135674388b0fc72167a0308eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fb53a4348865461783df6d1e5b16386b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", + "placeholder": "​", + "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.28it/s]" + } + }, + "fb7ccdb37f844e989de3f7a0b12b8924": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "fe3a78bc7ec842b08aac1b4e0fe1ed29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", + "placeholder": "​", + "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 191.93it/s]" + } + }, + "fe40606eebe6464db0b7f86e5abe1997": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", + "placeholder": "​", + "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 177.56it/s]" + } + }, + "fffac86b0934453d88f52df4b9ac6dd6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } } - ], - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ] }, - { - "cell_type": "markdown", - "id": "ca40afc1", - "metadata": {}, - "source": [ - "# Final Remarks" - ] - }, - { - "cell_type": "markdown", - "id": "c4c86a23", - "metadata": {}, - "source": [ - "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv (3.11.9)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "01ac1053789e45fab75e2cde894b417a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "02cefe41f8814ddf9de26418b26783c3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "03569ea4478d4d74b0ae4c5416c40d6d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "055bae1119db45caa5b6cd91921c76d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", - "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", - "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" - ], - "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", - "tabbable": null, - "tooltip": null - } - }, - "05d25d3b3bd9497f86849702e5a19515": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "071709416bab4673a582978e2e3592a3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "07e8c0b16c2d430ea8bb6798e9b4f103": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", - "placeholder": "​", - "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "0deaf695a8544725ac4904ff7388f489": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "11dbeaae3ae640c3995e784abfda15c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", - "placeholder": "​", - "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "12524abe09304f9bb20bd9978ac2a44d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", - "placeholder": "​", - "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 189.90it/s]" - } - }, - "13af542c17d64851a3ef54ce9610bb99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "153af823c040405dbc075bf50a28ff17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "16656416b10a43c8b81c6c4b2a02ec0b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "16ce59abc5bb4ffe978736017f60e21a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", - "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", - "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" - ], - "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", - "tabbable": null, - "tooltip": null - } - }, - "19382158e51343918122512753ca25c7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "20cca542fe2a4e19846e2e1cb07dd165": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "252a64f9c6d440e2a3d3c3f62f44d764": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", - "placeholder": "​", - "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", - "tabbable": null, - "tooltip": null, - "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" - } - }, - "27e25633e2a549dcbfafe1129839043d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b154733d72e4e468c339683e83c30a7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b197d3911154085bb86f0dbba2c8b98": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2c4ee939558d44a4a3bc9040a940693f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", - "placeholder": "​", - "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 199.01it/s]" - } - }, - "2e727ab68ed64ee98bfb9d81f1e39c1d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", - "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", - "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" - ], - "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", - "tabbable": null, - "tooltip": null - } - }, - "2ec00b06939145ec95930e3c1490efcc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", - "placeholder": "​", - "style": "IPY_MODEL_19382158e51343918122512753ca25c7", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "30a18f8c59754940a9785cd152a67daa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "32e9a01e1a2b4914989eda6f6832f989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "331f7f90d7d049a6adc72c260c06570e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "33a28231831d473aa27d32e1c15a8989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "35778f5ef201497d8d453772f80a7978": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "366e2af2827540728d29bfa6d931dbdb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", - "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", - "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" - ], - "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", - "tabbable": null, - "tooltip": null - } - }, - "3799be676aea4d12b87992115e4b90ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3a36a442c4a94ab585d8522e57f45c34": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3b44dec6a3354f7ebc4117e7d7f50b1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", - "placeholder": "​", - "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "3c3d34b732664135a79031e8bc9e2984": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3cde338fcaf548de8e8216a98e66f9bc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", - "placeholder": "​", - "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 195.74it/s]" - } - }, - "3dddd89019c849f0872e9a9700e14ad0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", - "placeholder": "​", - "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", - "tabbable": null, - "tooltip": null, - "value": "Predicting DataLoader 0: 100%" - } - }, - "40b8f5c6c7844bd0bb071f043f97a639": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "40df96a9f08440a893ffe9d57d176e1f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41e23a2458044b888fb76fd882428b39": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "42360fe280a14e44831c8e62f6ad249e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "425a21a3b7604c8cb49871c1b2850f68": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4297b4158e4f43da9226bfc00272f9c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "43eab5ba00014d7ba62f97acd9e93eba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "44c3cc7783594142a19ffad035eea9d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "4787d389023845a8ae398eb5d1155ab1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "480afa5d41c145d0ac88e2adaca7b1e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", - "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", - "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" - ], - "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", - "tabbable": null, - "tooltip": null - } - }, - "4b3f0ca06bf54eb9bab4e081dabcf139": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4f10caf0abca4aa59053c4cb374ea3d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "50e4f1e4cd994abeae53d0f84b6afd44": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "522af0834c254f0eb2fe7c9efa74c5f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "54aad655289741b59d3c83b8508e68b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", - "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", - "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" - ], - "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", - "tabbable": null, - "tooltip": null - } - }, - "55e102413ba54377b2fd1995b98c7858": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "579cbbe7cfb34e429bffd11ec774ba50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "57cd2f911c6840da87c1d6c8a78521e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "57db1d3f28d347878d9f48d0ceef5589": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", - "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", - "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" - ], - "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", - "tabbable": null, - "tooltip": null - } - }, - "580c0814097844e186ef642094968d3a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "590ebae9a3664214be16b105941c7ee3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "59413112366944be8e0d6600880dc1a4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5dcf47d8b9c0420898fe491a81bab8af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", - "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", - "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" - ], - "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", - "tabbable": null, - "tooltip": null - } - }, - "61734f2b95c34e13971fd65cd7da2e1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "641b5ae5b9e7475db63a31e67b13b601": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "642a06d187834b96af41b74a25d13e1a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6da83aee80314ceb9ace5fa0c4c76529": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9e33a121da334db899669d702f9d54ce", - "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", - "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" - ], - "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", - "tabbable": null, - "tooltip": null - } - }, - "6dad7db23e9e4397bfb93655cd8b08b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e794979a2793408791ee570d3af6f371", - "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", - "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" - ], - "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", - "tabbable": null, - "tooltip": null - } - }, - "6eb691aae3a44a25b1e7471929151f47": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "71c1aa3663804753bf3a75a227412072": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "72125343cca3416fbd3f012232e63ae5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "761dbbe1bf4e4804a3649858898b78e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7adbf399ea5e4a7c990cdff60674b593": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", - "max": 3, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", - "tabbable": null, - "tooltip": null, - "value": 3 - } - }, - "7d599e5710f4485a8f7580c7efca3bc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e0ad83f116b4933a35870525656df5d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "81e281800a094e34b2e43021bea6fd11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", - "placeholder": "​", - "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 174.77it/s]" - } - }, - "859b368a8a6d4500960a6e2285f4c016": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "86bfcc40b08440af98f64a732df1ea5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8766872fa61844458d70112fcf44bdb3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8825c219393f4040890a639a17210bc5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "89dc0773756b4b7b93cce8e6cfe47202": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", - "placeholder": "​", - "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 100.83it/s]" - } - }, - "8d829381b5034ed9807b86d514b1fdbb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "8e6984bd5a00425bb9071deba84f4cea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8f2ac8fd36964f11bd556782c96b0f72": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "924315df026a41fb97d7cc8488bb8503": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "95daeef1bd3e4f77b883d3d71fcd1fac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", - "placeholder": "​", - "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", - "tabbable": null, - "tooltip": null, - "value": "Sanity Checking DataLoader 0: 100%" - } - }, - "97b2d3e5a7e847739b237fc9c5cdc3a9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9914744ed44845fd9d00727c7da93d32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "9a20b5d724584e289863cf63a4c13259": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b1dd53c1fdd45dabf3660e9e0be1310": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", - "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", - "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" - ], - "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", - "tabbable": null, - "tooltip": null - } - }, - "9b8b6898ef244336989227f5469a2d11": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b933a5d5aa14741904151b4ea7e3f50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", - "placeholder": "​", - "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 88.28it/s]" - } - }, - "9e33a121da334db899669d702f9d54ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", - "placeholder": "​", - "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", - "tabbable": null, - "tooltip": null, - "value": "Epoch 9: 100%" - } - }, - "9fd5c0e984d04e4aa0e106ec89434720": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "a30948d8cfd6491484d6b63591b65a84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a5f3118f4f9040ebbdb1a7acae012087": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b1dc954934944e92914a1c129d8c7dcd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b23efdc3bb5747af96dd5e539a14b5c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", - "placeholder": "​", - "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "b35ce184b43b48daaa39ccef748eeac6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "b4d7ddbd507e4e1681cc0888680abb5b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b4e804d6e4b44314a8847c2f5be857d4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b6625b52007b4434a7804cfd824452cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", - "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", - "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" - ], - "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", - "tabbable": null, - "tooltip": null - } - }, - "b676b1571a00427587827caac8158c14": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "be1dd700617141cf9517ee7ef1153746": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c198ffce01de4b7294649c1619b5b7e6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c255e442c01446699af3179f14eb8fc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", - "placeholder": "​", - "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "c2906f9d5f47471ca6bf44d8754f8d30": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c325a187e8a54e639300ff5a29640f03": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c60add7b277344feaad65a884c7fbf37": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c7c373a0b1c14b809041651ffcdd4559": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c99d9a52749b40628b8d148c64e75e88": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cb3cebaf14cc445a8055d1aac2f0d05c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", - "placeholder": "​", - "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 180.77it/s]" - } - }, - "cc7d97d8845d46ff9d946020b1b8e4cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "cd4d74958b704246a2cb2462a784d502": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce45f3190357423a9563bfae253f2f16": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce49dfd502074696aefcfa2cff18e4f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ce97bb2d961e4dc9bf44a646cb3d3aff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d04931a3bb0c47329cdd67701a7be0ad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", - "placeholder": "​", - "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 192.16it/s]" - } - }, - "d473da3081af4d4a810014019cd40b29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", - "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", - "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" - ], - "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", - "tabbable": null, - "tooltip": null - } - }, - "d4b49fabdd4543959d64e4e1c60dc360": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d9fc58b33d2645488a8c53af72f21e7a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "da4c6178632b4cfe96d2a9504cc3173b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dc6cccb142db43b7ac9849983a154a20": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dcb0a4350297443aa61691406923fb81": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dcced12e0ae04e32a811f60680db24f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", - "placeholder": "​", - "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "e09f041d857346029cbba27fb36f009e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e12d00f1e1b94e749f22904d3cec2445": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", - "placeholder": "​", - "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 186.36it/s]" - } - }, - "e19ea3de3e554c50a7300a7214c773f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e53d8d156b1c4db6aff2ba8395bf5415": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e6dfb5d14dfe4a1193e551f414ea393e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e7198635809b4f56bd1a30b6cbe661cf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e742e68a86474f0db17ccb64db4264c9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e794979a2793408791ee570d3af6f371": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", - "placeholder": "​", - "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "ed4968eb8435434db1604e34ee657413": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "eeb45b37592a4a599da1857d3444382e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", - "placeholder": "​", - "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f03f6404137144b8b600f8131c78ac63": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f286ebc675c549678f70419f668a7baa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f299c926a6a64a769d3db2e71725f8af": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f60411b259344a9e9a892d9552ecdabf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f609670bc6b840ed9f8698af8c7615a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f69737793cc648bd9aadfc0dd4b16569": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", - "placeholder": "​", - "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f6f12cd135674388b0fc72167a0308eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fb53a4348865461783df6d1e5b16386b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", - "placeholder": "​", - "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.28it/s]" - } - }, - "fb7ccdb37f844e989de3f7a0b12b8924": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fe3a78bc7ec842b08aac1b4e0fe1ed29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", - "placeholder": "​", - "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.93it/s]" - } - }, - "fe40606eebe6464db0b7f86e5abe1997": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", - "placeholder": "​", - "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 177.56it/s]" - } - }, - "fffac86b0934453d88f52df4b9ac6dd6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } From dd1e2c679cd00492271d1b45ca234c575be9295b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 11:45:23 +0200 Subject: [PATCH 136/154] chore: simplify changelog entry --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cc62514913..e68c1cc30f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,8 +13,8 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - 🚀🚀 Added a custom MLflow model flavor for Darts, available under `darts.utils.mlflow`. It provides an MLflow integration for any Darts `ForecastingModel` (statistical, scikit-learn-like, and PyTorch-based). [#3022](https://github.com/unit8co/darts/pull/3022) by [Jakub Chłapek](https://github.com/jakubchlapek), [Zhihao Dai](https://github.com/daidahao) and [Michel Zeller](https://github.com/mizeller). - Added `save_model()`, `load_model()`, and `log_model()` to persist and reload Darts models as MLflow models, including model and covariate metadata. - - Added `autolog()` to automatically log model creation parameters, covariate usage, metrics, and the trained model artifact when `log_models=True` (default `False`) on every `fit()`, `backtest()` and `historical_forecasts()` call within an active MLflow run. - - Metric functions from `darts.metrics` are automatically logged when called inside an active run, with keys reflecting the metric output shape (per-component, per-quantile/interval, per-label, and per-timestep results charted across MLflow steps). Multi-series results log the aggregate over series and write the full per-series breakdown to a JSON artifact. + - Added `autolog()` for model parameters, series/covariate metadata, optional model artifacts, PyTorch epoch metrics, and backtest metrics. Nested historical-forecast fits are suppressed. + - Darts metrics are logged with shape-aware keys; multi-series and window-level backtest details are available in `metrics_per_series.json`. - Added a new notebook for [MLflow quickstart](https://unit8co.github.io/darts/examples/29-MLflow-quickstart.html) with detailed usage examples. - Note: model serving and deployment (MLflow's `pyfunc` flavor, model signatures, and input examples) are not yet supported. - Added support for per-timestep (non-aggregated) encoder and decoder variable importances in `TFTExplainer`, exposed as `TimeSeries` via `TFTExplainabilityResult.get_encoder_importance_over_time()` and `get_decoder_importance_over_time()`. [#3170](https://github.com/unit8co/darts/pull/3170) by [exactml](https://github.com/exactml). From 811e16c0580bcb311aa83a861c462fcc1bc0cc79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 13:27:38 +0200 Subject: [PATCH 137/154] feat: negative x-axis to indicate most recent values --- darts/tests/optional_deps/test_mlflow.py | 40 +- darts/utils/mlflow.py | 38 +- examples/29-MLflow-quickstart.ipynb | 787 ++++++++++++----------- 3 files changed, 453 insertions(+), 412 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index bbd0056466..07c2e6d46e 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1070,7 +1070,7 @@ def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") assert len(history) == len(ref), "Expected one step per timestep" steps = sorted(m.step for m in history) - assert steps == list(range(len(ref))) + assert steps == list(range(-len(ref), 0)) logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, ref, atol=1e-5) @@ -1078,7 +1078,7 @@ def test_autolog_metric_aligns_time_axis_by_end_date( self, mlflow_tracking, autolog_context ): """A shorter series' time axis aligns from the end, not the start, so - its steps overlap the tail of a longer series rather than the head.""" + its negative steps overlap the tail of a longer series.""" ts_long = self.ts_univariate # length 50 ts_short = ts_long[10:] # length 40, same end, starts 10 steps later @@ -1094,17 +1094,17 @@ def test_autolog_metric_aligns_time_axis_by_end_date( history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") by_step = {m.step: m.value for m in history} assert len(by_step) == 50 - for step in range(10): + for step in range(-50, -40): assert by_step[step] == pytest.approx(1.0, abs=1e-4), step - for step in range(10, 50): + for step in range(-40, 0): assert by_step[step] == pytest.approx(1.5, abs=1e-4), step rows = self._read_per_series_table(run.info.run_id) steps_by_series = {0: set(), 1: set()} for r in rows: steps_by_series[r["series_index"]].add(r["step"]) - assert steps_by_series[0] == set(range(50)) - assert steps_by_series[1] == set(range(10, 50)) + assert steps_by_series[0] == set(range(-50, 0)) + assert steps_by_series[1] == set(range(-40, 0)) def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile with matching values.""" @@ -1401,7 +1401,7 @@ def test_autolog_backtest_scalar(self, mlflow_tracking, autolog_context): assert run_data.metrics["backtest_mae"] == pytest.approx(float(ref), abs=1e-5) def test_autolog_backtest_per_window_steps(self, mlflow_tracking, autolog_context): - """reduction=None logs per-window values as consecutive steps of one key.""" + """reduction=None logs per-window values at end-relative steps.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: ref = self._fit_lr().backtest( @@ -1415,7 +1415,7 @@ def test_autolog_backtest_per_window_steps(self, mlflow_tracking, autolog_contex history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") assert len(history) > 1, "Expected multiple per-window steps" steps = sorted(m.step for m in history) - assert steps == list(range(len(history))) + assert steps == list(range(-len(history), 0)) logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, np.asarray(ref, dtype=float), atol=1e-5) @@ -1549,7 +1549,7 @@ def test_autolog_backtest_per_timestep_per_window( assert len(rows) == ref.size for row in rows: assert row["key"] == "backtest_ae" - assert row["window_index"] in range(len(ref)) + assert row["window_index"] in range(-len(ref), 0) def test_autolog_backtest_historical_forecasts_horizon_inferred( self, mlflow_tracking, autolog_context @@ -1771,9 +1771,9 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): """A shorter series' window axis aligns from the end, not the start, - so its windows overlap the tail of a longer series rather than the - head. Calls _log_backtest_metrics directly with a fabricated result - so the window counts per series are exact.""" + so its negative steps overlap the tail of a longer series. Calls + _log_backtest_metrics directly with a fabricated result so the window + counts per series are exact.""" backtest_args = { "metric": dm.mae, "metric_kwargs": {}, @@ -1792,16 +1792,16 @@ def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") logged = {m.step: m.value for m in history} - assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) + assert logged == pytest.approx({-5: 1.0, -4: 2.0, -3: 6.5, -2: 12.0, -1: 17.5}) rows = self._read_per_series_table(run.info.run_id) by_step = {(r["series_index"], r["step"]): r["value"] for r in rows} - assert by_step[(0, 0)] == pytest.approx(1.0) - assert by_step[(0, 4)] == pytest.approx(5.0) - assert by_step[(1, 2)] == pytest.approx(10.0) - assert by_step[(1, 4)] == pytest.approx(30.0) - assert (1, 0) not in by_step - assert (1, 1) not in by_step + assert by_step[(0, -5)] == pytest.approx(1.0) + assert by_step[(0, -1)] == pytest.approx(5.0) + assert by_step[(1, -3)] == pytest.approx(10.0) + assert by_step[(1, -1)] == pytest.approx(30.0) + assert (1, -5) not in by_step + assert (1, -4) not in by_step def test_log_backtest_metrics_aligns_last_points_only_time_axis( self, mlflow_tracking @@ -1827,7 +1827,7 @@ def test_log_backtest_metrics_aligns_last_points_only_time_axis( history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") logged = {m.step: m.value for m in history} - assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) + assert logged == pytest.approx({-5: 1.0, -4: 2.0, -3: 6.5, -2: 12.0, -1: 17.5}) @staticmethod def _read_per_series_table(run_id): diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index be3dd22879..23b314e269 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1145,11 +1145,11 @@ def _log_backtest_metrics( must have the same number of components; names are taken from the first series. - Series of different lengths are assumed to share the same end date, so any - axis mapping to real dates (the window axis, or the per-timestep axis - when ``last_points_only`` stitches windows into one series) is aligned - from the end rather than the start. The per-horizon-step axis is left - as-is, since it means "steps ahead" rather than a real date. + Series can have different lengths and intersect in different ways, + so the time axis is aligned from the end rather than the start: a shorter + series lines up on its last value instead of its first. To represent this, + the time axis is mapped to the MLflow ``step`` as ``t - t_size`` when + ``has_time_axis`` is ``True``. Raises ------ @@ -1303,15 +1303,9 @@ def _log_backtest_metrics( # align the calendar-relative axes from the end max_w_size = max((w_size for _, w_size, _ in series_shapes), default=0) t_axis_is_calendar = has_time_axis and not has_windows and last_points_only - max_t_size = ( - max((t_size for t_size, _, _ in series_shapes), default=0) - if t_axis_is_calendar - else 0 - ) for series_index, (t_size, w_size, canonical) in enumerate(series_shapes): w_offset = max_w_size - w_size if has_windows else 0 - t_offset = max_t_size - t_size if t_axis_is_calendar else 0 for m in range(n_metrics): for c in range(c_size): key = base_keys[m][c] @@ -1322,11 +1316,12 @@ def _log_backtest_metrics( values = canonical[:, t, c, m] agg.setdefault((key, t), []).append(float(np.nanmean(values))) for w, value in enumerate(values): + window_index = w + w_offset rows.append({ "key": key, "series_index": series_index, "step": t, - "window_index": w + w_offset, + "window_index": window_index - max_w_size, "value": float(value), }) continue @@ -1335,8 +1330,11 @@ def _log_backtest_metrics( aligned_w = w + w_offset for t in range(t_size): # MLflow step maps to the axis the UI should chart: - # time when present, otherwise window index - step = t + t_offset if has_time_axis else aligned_w + # horizon when present, otherwise end-relative calendar axis + if has_time_axis: + step = t - t_size if t_axis_is_calendar else t + else: + step = aligned_w - max_w_size value = float(canonical[w, t, c, m]) agg.setdefault((key, step), []).append(value) rows.append({ @@ -1472,7 +1470,9 @@ def _log_metric_result( Series can have different lengths and intersect in different ways, so the time axis is aligned from the end rather than the start: a shorter - series lines up on its last value instead of its first. + series lines up on its last value instead of its first. To represent this, + the time axis is mapped to the MLflow ``step`` as ``t - t_size`` when + ``has_time_axis`` is ``True``. Raises ------ @@ -1571,18 +1571,14 @@ def _log_metric_result( series_shapes.append((t_size, arr.reshape(t_size, c_size))) - # align the time axis from the end (see docstring) - max_t_size = max((t_size for t_size, _ in series_shapes), default=0) - # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] for series_index, (t_size, canonical) in enumerate(series_shapes): - step_offset = max_t_size - t_size if has_time_axis else 0 for c, key in enumerate(keys): for t in range(t_size): - # MLflow step maps to the time axis when present - step = t + step_offset if has_time_axis else 0 + # Time axes are end-relative, with the latest value at step -1. + step = t - t_size if has_time_axis else 0 value = float(canonical[t, c]) agg.setdefault((key, step), []).append(value) rows.append({ diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index 51ea86bbdd..33551375d6 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "aeddb542", "metadata": {}, "source": [ "# MLflow for Darts\n", @@ -12,11 +13,11 @@ "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", "\n", "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ], - "id": "aeddb542" + ] }, { "cell_type": "markdown", + "id": "f72894af", "metadata": {}, "source": [ "## Installing MLflow\n", @@ -26,19 +27,20 @@ "```bash\n", "pip install \"mlflow>=3.0\"\n", "```" - ], - "id": "f72894af" + ] }, { "cell_type": "markdown", + "id": "42e3dcea", "metadata": {}, "source": [ "## Setup and Imports" - ], - "id": "42e3dcea" + ] }, { "cell_type": "code", + "execution_count": 2, + "id": "b346ce8f", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:43.049165Z", @@ -47,6 +49,7 @@ "shell.execute_reply": "2026-06-24T15:18:43.053435Z" } }, + "outputs": [], "source": [ "# fix python path if working locally\n", "from utils import fix_pythonpath_if_working_locally\n", @@ -56,13 +59,12 @@ "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning)" - ], - "execution_count": 2, - "outputs": [], - "id": "b346ce8f" + ] }, { "cell_type": "code", + "execution_count": 3, + "id": "13b13fe4", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:43.054776Z", @@ -71,6 +73,7 @@ "shell.execute_reply": "2026-06-24T15:18:46.599208Z" } }, + "outputs": [], "source": [ "%matplotlib inline\n", "\n", @@ -85,13 +88,12 @@ "from darts.datasets import AirPassengersDataset\n", "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ], - "execution_count": 3, - "outputs": [], - "id": "13b13fe4" + ] }, { "cell_type": "code", + "execution_count": 4, + "id": "4d424e08", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:46.600906Z", @@ -100,28 +102,28 @@ "shell.execute_reply": "2026-06-24T15:18:46.634100Z" } }, + "outputs": [], "source": [ "# use darts plotting style\n", "from darts import set_option\n", "\n", "set_option(\"plotting.use_darts_style\", True)" - ], - "execution_count": 4, - "outputs": [], - "id": "4d424e08" + ] }, { "cell_type": "markdown", + "id": "2f9c40d6", "metadata": {}, "source": [ "## MLflow Setup\n", "\n", "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ], - "id": "2f9c40d6" + ] }, { "cell_type": "code", + "execution_count": 5, + "id": "88320df5", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:46.636640Z", @@ -130,20 +132,9 @@ "shell.execute_reply": "2026-06-24T15:18:47.268081Z" } }, - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ], - "execution_count": 5, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", @@ -152,6 +143,7 @@ ] }, { + "name": "stdout", "output_type": "stream", "text": [ "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", @@ -159,20 +151,32 @@ ] } ], - "id": "88320df5" + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ] }, { "cell_type": "markdown", + "id": "03d5209e", "metadata": {}, "source": [ "## Load Sample Data\n", "\n", "We'll use the classic AirPassengers dataset for this example." - ], - "id": "03d5209e" + ] }, { "cell_type": "code", + "execution_count": 6, + "id": "1596e07e", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.269628Z", @@ -181,22 +185,9 @@ "shell.execute_reply": "2026-06-24T15:18:47.356201Z" } }, - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ], - "execution_count": 6, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Training series: 107 points\n", @@ -204,29 +195,44 @@ ] }, { - "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHECAYAAADmnVpRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfhZJREFUeJztnQe0E9XexQ+9CgLSmwLSRaSI0lQEUQQVaVIsgCAqKmLv8NCHPhWxoYJSBKTYaIqIIL2IIEVBQakC0nsv+dY+1zPfydzcZJJMS7J/a826k8xkZnKSm7PnXzMFAoGAIIQQQgjxmMxeXwAhhBBCCKAoIYQQQogvoCghhBBCiC+gKCGEEEKIL6AoIYQQQogvoCghhBBCiC+gKCGEEEKIL6AoIYQQQogvoCghxAZmz54tFixYwLEkhJA4yMSKroSEZ/ny5WLTpk3iiiuuEOXLlw+5T506dcRFF10kvvvuO0vDOX/+fLFr1y7jcc6cOcXFF18sqlevzo/DA37//Xfx66+/yvVMmTKJHDlyiAIFCogqVaqIggULxnXslStXis2bN4vbbrtN+AG/XQ8hOlmDHhFCgkAXhnbt2klRgh/xr7/+OuQIXX/99SJfvnyWR69///5i3rx54pZbbpGP9+/fL5YsWSIuueQSMW7cOFGjRg1+Ei7yxRdfiBdeeEE0bdpU5M+fX5w5c0aKxlWrVomqVauKxx57THTq1CmmY3/88cdi5MiR4ujRo8IP+O16CNGhKCEkDLNmzZKC5OabbxbTpk0T//zzjyhWrFi6/V577bWoxzF37txyMlRs2LBB1K1bV9x6663izz//FFmyZOFn4zKvv/66qFmzpvH48OHDYuDAgaJz585i0aJF4r333uNnQoiDUJQQEoZhw4aJSpUqiVGjRolSpUrJO8ynn346ZExJ9uzZRcOGDY3n4Mq58MILxVVXXSXFzC+//CKKFy8eNOnpXHrppaJ9+/bynKtXrxZ58uSRf5VLAZYYWFCKFi2a7rW468W+Bw8elC6mihUrytdEu4/a7+effxZHjhwR5cqVE9WqVUvnztqxY4do1aqVOH78uFi4cKE8ztVXXy2vOSP3CIQWLEE4HtbhRsAx4CqJ5/ywMJ07d040a9YsqvdpBYw5RAmO9f7770trGawpYP369RE/H4zNX3/9Ja9PF6AQubly5bJ0DDs/v0jXQ4jnIKaEEJKePXv2BLJnzx4YPHiwfHz33XcHKlSoEDh//ny6fWvXrh1o3rx50HPly5cPtGnTJvDWW28FqlatGmjYsGHgoYcektuuv/76QP78+dMdp2/fvujaHZg/f35gypQp8vVYWrduHahTp04gS5YsgQcffDDoNaNHj5bHuuyyywI333yzPFfdunUDa9eujWofMHDgwECePHkC1apVC9xwww2BggULBq655prArl27jH26d+8eKFSoUGDJkiXyeNivePHigSJFigR++eWXoOOdOHEi0LZt20C2bNkCDRo0CFx55ZWBTp06BV5//XX5Pnfu3Bnz+efOnRuoUqVKoEmTJvK9RPM+zQwYMEBej/n6FRs2bJDbce0KK58P3g++B3he7Ytl3759lo9h5+cX6XoI8RqKEkIy4M033wzkzp07cODAAfl46dKlcmKaPXu2ZVFSrly5wJNPPmk8t379+gxFydmzZwM1atQI5MiRwzinmR9//FFOKJ999pl8fPz4cSmcnnrqqaD9VqxYIa/X6j4A4gvvb8SIEcZzu3fvlhMcrlcXBXnz5pUi7ejRo/K5gwcPSsF23XXXBZ2jT58+UpDMmzfPeA4TMfY1i5Joz3/HHXcEjhw5Yoyr1fcZiygBBQoUCFSqVCnsccyfD4DAgFCwSiyfcTTjF+31EOImdN8QEiYgsGPHjtIFA6688kpRu3Zt6V657rrrLI3bgQMHRL9+/YJcNAoEUyoTOvZDgOuaNWvEm2++aZwTNw6//fabzJY4deqUfFykSBHxww8/yGvbu3evOH36tHxOB5lCCiv7wJz/8ssvi5tuukncc889xvOFCxcWL774oujQoYO8DuUKgIugb9++hrsGwaGIu0AA78mTJ2U2Ec45dOhQ+dpGjRoZx4TbZciQIdKFE8/5+/TpI/LmzWuM67Zt2yK+z3hAFg4CknUifT5WsOMzjnb8CPErFCWEhAA1R9atWyczb3TfO37UJ0yYICcnK6miSPHNyFcPUTJ+/Hi5jrgKxGS88cYbolatWvK5ZcuWyYl+z549cgKCUMmcObOMo0BMBUCcy7XXXiuefPJJmc1z4403yseVK1c2zmNlHwTZYvLDOSZNmiQnRoC/27dvl+uIZ1CTGuJnzOnLZcqUkX///vtvUaFCBRkvgWtFurQZiDs9fTra82Mc1DhF8z7j4cSJE0ExM1Y+n0jY9RlHO36E+BWKEkIysJIgmBB3l1h0LrjgAjF69GjxyCOPRBw73Klazb7RwWSCu1vcHSMgFPsqypYta0w6CHT8/vvvxZgxY8Q333wjLRX333+/nODGjh0r62xY2QcTrgpIxX5m2rRpE3SnjjHA5KkDoQJgKQG4uwehRJn+fkC058fkmy1btqB9rLzPWDl06JDYuXOnEUxr9fMJh52fcbTjR4hvcdVZREgCgPgIxJIMGzYs5PZHHnlE+umtBrqGIqNAV8W2bdtkfMCgQYOCnkesCeINzOfSWbBgQeDCCy8MNG3a1PI++/fvl8d99NFHA5FQgaZmEIyJa16zZo18vHfvXvnYHAuhjqHHlNhxfivvM9aYko8++khuf//996P+fHr37h0yhsPOzzia8cvoegjxAywzT4gJ3H3CfA4zeSjgt4f1ZPHixY6NHSwsWbNmlXEGOq+++mqQhQDpoUj91GnQoIG8e969e7flfVC9FHfTSH1W5n4duBIQtxANhQoVEk2aNJFWpWPHjhnPw82Ami86dpzfyvuMhRUrVsg0cKTqdu/eParPR40Dvk9w1zn1GUczfhldDyF+gO4bQkK4buB7hy8/FNdcc400tWM/xIE4AWJMHnroIVmsC0GjiB9ALRScF3VTFJiAIJJQZwKTJgI/58yZI5YuXSonKKv7gA8//FDuc/nll4v77rtPnmffvn2y5gUE2Nq1a6Mu6IbaHghyrV+/vujZs6ecCFEV96677pKFyvQ6G/Ge3+r7DAeCSxGAe/bsWVnRFTEcU6dOlcdF0K6qqWL18wE33HCDdLlgfwRI4z2ouiB2fcbRjF+46yHEayhKCNHARISCU/jhzghMII8//rjYsmWL9PtjYg1VZh4TCfrZhKJx48aiZMmSYcceWTjI+FHN/lq0aCHuuOMOGfCosnMgnmC1QcAsirMhtgDnRGyByvSxso+628Z5MAnjnAhELVGihCyFj6Jx6u4dgavnz59Pd72Ig8DdOjJxFJhoEWCJCRMVUVUZfUzwQA8cjff8Vt9nKGB1wLWjEBsW1fsGlh5YLkK93srnAyDIEAsyZcoU8eWXX8prx3EhAuz6jKMZv3DXQ4jXsCEfIcR1unTpImbOnBnUlJAQQhhTQghxDNTdMMdDbN26Vd6hs0stIcQMLSWEEMdAkCbcBa1bt5a9WuDyQpwJXF3ow8I0VUKIDkUJIcRRUN8DtTMQaIn4G3RCvvPOO41qrIQQoqAoIYQQQogvYEwJIYQQQnwBRQkhhBBCfAFFCSGEEEJ8QcKJkk2bNoUsnESiA2PIsbQHjqV9cCyTdDyLF09bEhjfjGWSk3CihBBCCCHJCUUJIYQQQnwBRQkhhBBCfAFFCSGEEEJ8AUUJIYQQQnxBVq8vgBBCSJLz7rteXwFJEChKCCGEOEvbthxhYgm6bwghhBDiCyhKCCGEOMvtt6cthESA7htCCCHOsngxR5hYgpYSQgghhPgCihJCCCGE+AK6b3zG66+/Lu6++25RpEgR8dFHH4nrr79eVKhQwdg+e/ZsMW/ePLmeJUsWUbJkSblP2bJlPbxqQgghJH5oKfER//zzj3jhhRdE/vz5xenTp8Wjjz4qcuXKFbQPRMk777wj17HPF198ISpWrCgmTpzo0VUTQggh9kBLiY+YP3++qFu3rsiRI4dYuHChKFq0qLSEmClYsKDo16+f8fjOO+8Uffv2FTfeeKMYNGiQfC5btmyiXLlyolWrViJv3rxBr9+4caOYPn26FEE333yzuOqqq4K2zZgxQ5w6dUrUr19fXHnllUGvXbZsmbTU5MyZUzRu3FhcdtllxrbNmzeLkSNHiqefflp8++238liVKlWS16Bz9uxZKaa2bdsmKleuLOrVqyeGDBkiHn/88aBrtXKuJ598Unz55Zdiy5Yt4q677hJlypSJ+B4IIS5z4YUc8gRl+fLl4ptvvhH33nuvKFGihOPno6XEYzBBQ2Bgef/998XJkyfl+sCBA0X27Nnl+vDhw8Me4+qrrxbbt28XJ06cMJ47evSo+PDDD0XVqlXFzp07jed/+OEHUb16dbFkyRIpSh577DHRv3//oG2LFy8Wf//9t7TUqG3g4YcfFrfddpsUBGvXrhXXXnutIYIAnsf+EAJfffWVvKauXbuK3r17G/ucP39eNGvWTIoJbH/33XfFddddJ1+Ha472XHjvEEBnzpyx9B4IIR6wbl3aQhKK8+fPi1tuuUW89NJLUpS4QiDB2LhxY+DcuXOBZOHMmTOBl156SS558+YN9OjRQ64XK1Ys0LFjR7n+ySefGPs/99xzgfLlywcd46677gqUKFEi5PFbtGgR6Nu3r/G4c+fOgfvuu0+OoRrLlStXBm3TUdsmT54cKFKkSGDPnj3GtmXLlgWyZcsW2L59u3z8448/BvCVGj58uLHP1KlTA5kzZw4cO3ZMPh43blwgd+7cxmtAhw4d5Ot27twZ9bnefvvtoOsN9x6cQh9LwrH0E/xucizj4eDBg/J3Fgt+x3ft2hVwmqR239SpU0daA9ymWLFi4ueff7a0b9asWaU1ZOvWrTLIFfEi586dE6+++qq0DOBYZvbv3y9fg/1Wrlwpvv/+ezFq1Ci5DdaGqVOnyuPBcoJl9erVxmtLlSolpk2bJl0jCKYFl19+ebptcCPp2+Buueiii6T1JRAIGEumTJnEL7/8EmTWa926tbFes2ZNqbbhqoErB26V5s2bB+0Pa8qECROMx9Gcq3379kFjE+49EEI8Yu3atL9Vq/IjSCAOHjxorON3HBbwXr16OXrOpBYlECRwEfgZTLy4zt9++03GikCMYAJHHAW2Zc6cWbz44oshXwv3zq233ipdIBdffLHYsGGDdGdUq1ZN1K5dW+TLl0++/sCBA8Zrnn/+eRkge/vtt0tXEeJQcHwIBrUNbhP8hXhA4C22wQWEa4K7SeeZZ54RpUuXDnpOjwuB6ALKvYLjXHLJJUH7m4VXNOeCeNEJ9x4IIR5x/fVpfzVXMvE/hw4dCnqMhAqKkjgIZWXw63lh8YCQACtWrBC1atXKcF9zoKsCwaJ4HSwnemzGokWLggQDLDBvvPGG+PHHH8XQoUNlSjGEkNqG5Y8//pB+RLUNVhUIi1DnjYbixYuLXbt2BT1ntmbFc65w7wGWFkIIIdFbSsDcuXPl7zeSMBwjkGAkq+8eMSE///yzXK9Vq5aMqwhFqJgSRc+ePQO33HKL8Xjfvn2BokWLBmrXrm08t3jx4sD58+cNX/O3334rfYXHjx83tim+++47Y9uXX34ZyJQpU2Du3LlB51y+fHng5MmTQXEeiJNRIE4Ez61ZsyYopmTHjh3GPoid0WNKYj2X/v5CvQenoN+eY+lXfPPdLFYsbUlgfDOWLoJ5SMWUqGXIkCGOnjOp3TeJwl9//SUOHz4s4y8QE7JmzRrRsGHDqI9zzz33yCyVDh06SIvE119/LfLkyRO0z+TJk0WPHj1Eo0aNpPsGMR49e/aU9VDUNqTfwjUEU53aBncPrC7InGnbtq08PmJVoKRVMTcrIAYEReGQhoxjrlu3TloxAFxNIJ5zhXsPhBBCYnffgM8//1zcf//9wikoSnwAXBVwN6BCK8TJa6+9Jl00oWjSpIkRoGoG8SQQNEiRRTwGvjyIq0BKrQKpxqjngSJscJuMHz9eChR9G9w6eB0m9AYNGhivHTx4sOjevbt8LYJsW7RoIdN5lVsEcS1wlyhxodwpeE5dM7bBvaTqlOD9QDhBgCAGJp5zWXkPhBBCYnPfKBcO5g6nwiMywVwiEohNmzbJkurmyYhEByKpUXDMi7Fcv369rEKrQP77qlWrZMZMIuLlWCYbHMskHc/ixRM+0NU3Y+kiAwYMMBItkMWI32mAmloPPPCAI+ekpYS4DoqZHTlyRGbEIHUarplJkybxkyAkWXnsMa+vgMRpKYEb/MEHH5TrsML7RpTAlI472r1798q4AHNKJsw6P/30k7jggguk2Rx+/Wi2k+Rn9OjR0oXz66+/ShfNDTfckKFLihCSBDz+uNdXQOKMKYGbHxZuWLqdzMKJygaFIEwEEcLfj3r4CEZEkKYCzyHIcsGCBeLjjz+WEw6CKa1uJ6kBTJ+oj4JeN126dKEgIYQQn1tKLrzwQtkrDSDqA7W1PLeUoAEaAjCHDRsmgzJhgtcvGmIFQYYQGwje7Ny5s8yGgBCxsp0QQkgSu2/efNPrKyFxiJLChQsbjzH/O0FUlhJ0Y73jjjtkZgPM78jwUBU2kTWC9E5U0FRdalG0Co3frGwnhBCSpHz2WdpCElKUZM6cWWZS6hmSmNM9tZSgVDmUEaJuEUeCdEukrqIU+qWXXip2794t99N9TFiH7wlE2h4KnAOLDiwsiIIm8aHGkGMZPxxL++BYJud4qlrKgQT+7fbLWHoRU5I/f37pstFbiGBbtGNhJWvJsig5duyY/Ivg1vvuu0+uQ5SgTDkayamL00t5w8Vj/iAz2h6KESNGSFeRTrt27dI1YSOxowqXkfjhWNoHxzK5xrP0uXNp17Fli0h0vB5LN0HzVwAxgnToU6dOGdvwGEs0mPuexSVKEEsCQYGqowrkLQ8fPtzYrt6EyqRAhk6hQoUsbQ8Fusci7kRnx44d0mWUKnniTqE693IsOZZ+gt/L5BzPTFmyyL+o8ZGo+GUs3QKWEeWigXcEn1358uWDjApOfJ6WRUnu3LlFlSpVxMaNG0W9evXkc1hXVd1w0WXKlJGZNSgTDrCOKqNWtocC6cLmlGHEouALkQpfinhQWVH6lygUbo0lmuOh869TP0rm4zt9vlDwe8mx9Ct++W5m8sE1JMtYOs3x48eNTu1w3+A9I9hVgXAOJ8YhquwbFEt5+umnpbUDsR4oePXWW28Z29HS+JVXXpG1SGDWQQt69C6xuj3VQOEw9aGHokCBArLAWKyV+HDsMWPGRP1axP/s27dP1qTBxF6hQoWQ+6FeTYkSJUTJkiUjHvOxxx6Tx0EGlhOYj29+/Pvvv0thDWFMCCEkuswb4KtAVxVPgsDWWbNmyeJniPkoV66csR1FsJAyhKZpmEyfeOKJIGUVaXuq8cwzzxhpVQgkRlGa2rVri6xZ0z4WNOV74403Yjo2LCQQFbGAnjKwUOE6kHGF0v56LBBAueErr7xSZmJZESVuU7lyZVGqVCnjcZ8+fUT16tVjHk9CSBxo/bdIYnAwEUSJ+rHHkhFXXHGFXGLdnkrMnDnTWIfVqXXr1uK7774zquRu2LDB6PUDwYLMo8suu0z6Nbdv325YUyAM4dbS6dSpU9BjHAsiA4FGeD1Mc0r8mPnmm2/EJ598Iid1NAqECG3atGnQPtgOS8Q111wj3XgquwrXjmZ5GR07HPiSw4IGkaM3JERDQfwz4HmcC75dZHyFA0X+YOVRrixEisMyp1LQ8R3MkSNH1NdICImBAgU4bAnGwUQRJcRdSwosKJjw4YqpW7eu+PTTT8XUqVPlXxUsjH2QBdWmTZsM3TfqWHC9IYIax0TAMbrw6t0eYQHBlxFiA9YSxPxAgOiiBK8fO3asrMgKC8qECRNkETwA1xy2jxo1SlrGrPLf//5XLhBYuDaUNEYQNSxycBuikzDq3EBIQFTBSgMhp/+T6OjuG5S1x2sheFSsDboU65YUQoiDHD+e9jd3bg5zApaYz58/v/yLGz3ccGJucUqUJH+0ToKDOi6oDYNJVQkRTNK448fy559/ig8++EBmKiEOJBwLFy6U7jdYHmCBwRdLjwkC06ZNE82aNTMCjNHBF5M/BI0Cj/GFvOeeewzBo65n8+bN4oUXXpCVe0+cOGHpPULIPPfcc9Iig+Z8eAxLz549e4x9ZsyYISsKYxxw7cjC+s9//mPp+P369ZOuRxxTXScFCSEugoD7CEH3xF+EspTgJlTdCFKUxNMyO9TSrdv/7/Pxxxnvt2jR/++HTKFQ+zRpIpwCVW8bN26c7nnEi0AAoLmhCt5csWJF2GPddNNNRuYULA+wRqxZsyadKGnZsqXxGC0A4Br6TKvGCMtJixYtRHHVjlwIKXDgWsH11KhRQwoKBJdaQc99V8CVpccroVeOGgfEJfXt29dIRyeEEOK8KAFOixK6b3xOqJRWxKLAgoFmhoizgFUDEztiJsJh7uiYK1cuGVuigJBARhAsIQqIFwgTCBG0rYYLBBaNr7/+2tgHwbC9e/eWKhpCBSIGOe64HivxQ3iPzz//vLjuuutErVq15F9YNZCCrjBnISGuCdYb/OOkcrA0IYQ47b6hKLGTCBO15N5705ZILF4s3CZUHvidd94pHnnkEZmerbJioF7jLX/87bffSlFgFi8QQOjqvHLlSilYsB2WEoDUcFwPYjd69uwpn4NYQvptNNeDGBhkY8FdNWXKFFmYD0G/Tf61QqmKwgo8RvEeiCZCCCHOWUpUTIluKcHvPH7/zbXE4oUxJQnG0aNHxa5du2TgqRIkiBWxo2Oj2XWjgMsH6bQQJojruPvuu43sGsR2IHYEcSh6/AcsJVbB67E/vuytWrWSrQVwzunTpxv7ICBXFzloCIlMJHPWUUbAKoTsJUIIIfG7b5zqFExRkmCgB0GdOnWklQRuHGS5dOzYMaYUXB1M2JjoQ4kS0L17d/HRRx+JrVu3ynUFSi6jJsqjjz4q3TrYB0XyzHVNwoG4FmTTIINozpw5MnAX8TFw4yiQcYP3CcEzcOBAGfyLAFarQFRhvHCNCHQNFcdCCCHEuihxIq6EMSU+AXU5YB3Q7/wrVqwYMl4CLpSXX35ZLkjrhQXjvffekwGgGRVPC3UsxH+ofVDQDum3GcWAwEUzceJEGcuhV3iFCwVCAZV6+/fvL2NckG777LPPyhoqGRUz01GCBJlB48ePlynKiFNBcKte/Ax9kvA+cc1IQ7711lszPL75MVKE4fLBdSKOhinBhLiIVq6AJEdMiVOiJFMgGju7D1DFxFKh94CTwBWCoFU1lrB0YLKGpcNvXHvttbK6LURYIowl4Vj6BX43OZaxghpVqtgksitxAwoQ+6cqY+NmFlmcdsJfUGJk3iDLhhBCCDn4r/sGFnQlSADdN8QVYmnc5xZVq1aVsSuEkATlnXfS/j78sNdXQqIUJWa3P0UJSXmGDBmS8mNASEIzcGDaX4qShIspudBlUUL3DSGEEEIMkJ2o2oToNUoAU4IJIYQQ4nnmDaClhBBCCCG+ECUIfFXQfUMIIYQQT0rMA1pKCCGEEOJ5NVfA7BtCCCGJjdbHivifgxQlhBBCkpaaNb2+AmJTTAn6rykYU0IIIYQkIWjx0aNHD9l53c8xJWiloYJd2ZCPEEJI4nH55Wl/V63y+kp8yfz582V3dSUCVG8ZP7pvVFzJkSNHaCkhhBCSgOzenbaQkAwYMMBY37p1q+ejZEWUALpvCCGEkCRi6dKlYubMmcbjww6UbrczpkQXJbCWoBO1nbDMPCGEEOIRr7zyStDjwz4QJeFiSsxpwUePHrX13BQlhBBCiAesXLlSTJ06NaFFyWGbr5eihBBCCPGBlcTsOvEKdQ25cuUSOXLkcFWUZLX1aIQQQoiZ2rU5JibWrl0rvvzyS7letGhRkTNnTrFlyxZfWUpCxZMAWkoIIYQkLtOmpS3EYOjQoSIQCMj1J554QhQpUsSx4NFYRUko1w2gKCGEEEKSiM2bNxvrHTp0MARAIBAQx44d8+y6zp07J4URoKWEEEJI8oFgTlNAZ6qzf/9+Y71QoUJB1odDHsaV6O4jL0QJY0oIIYQ4S8+eaX937uRIm0QJgkmxON19167MG0D3DSGEEJKEoqRgwYLpBMBhn4gSum8IIYSQJAdxI2ZR4hdLyaEI1VwBLSWEEEJIknDixAlx6tQpI54E+CWm5CAtJYQQQkhqBrn6zVJykDElhBBCSGqLEsaUpMHsG0IIIc4yZAhHOEEsJfu1aytQoEDIfS644AJjnSnBhBBCEovWrb2+goQSJYc8jCnZs2ePsa6qzJrJli2bTGNGbAwb8hFCCCEJjJ8tJbt37zbWCxcunOF+6nopSgghhCQWt96athDfx5Ts9liUMKaEEEKIs/z0E0c4QSwle/513+B60LnYiihB3ZVMmTLZcv7MthyFEEIIITGLEj149JCHMSXKUhLOSqKLEjTwQ2yJXVCUEEIIIR6LkixZsog8efJ4aik5ffq0OHDgQNggV4VTlh2KEkIIIcRjUaLHlRz2SJTs3bvXWKcoIYQQQlJIlGTPnl3kzp3b8eBRO9OBnbaUMNCVEEKIs2jWABLcIVgPEM3370R/5MgRcf78eZE5c2ZfZt4AihJCCCGJyW+/eX0FvsLcIdg80QcCAXH06NGgid9tUUL3DSGEEJLkoDvwsWPHQoqS/B7XKqEoIYQQkvysXp22ECO7JZylxCtRoseU0H1DCCEkOWnePO3vzp0i1cko88YP/W92R+G+caopH1OCCSGEEJ+JksN03xBCCCHEK1GS3+OYEt19c9FFF4Xdl8XTCCGEkAQnESwlBQsWFFmzhq8YQlFCCCGEJDiJEFNSJEI8iZPXGlXxtK+//lps3LjReJwjRw7Ru3fvoH1Wr14t5s+fL4NgWrZsmW7QI20nhBBC7GLdunVi0KBBon379qJZs2aeD6xfLSUnTpyQtVGsipJChQrJ4m4o8rZjxw5vAl3nzp0rB7R48eJyKVasWND2H374QTz00EPyIiE+7rrrriAFFWk7IYSQJOSpp9IWD+jSpYv4+OOPRefOnWVRMq/xa0zJnihKzAO4d0qWLCnXt23b5l2Z+auuukq0atUq5LYhQ4ZI0dG2bVv54Xfv3l18+eWXolu3bpa2E0IISUL69PHktL/88otYsWKFMenCGqD3mvECv1pKdkdRYl5RunRpKUgwtidPnhQ5c+Z0PyV44cKF4v333xdTp06VbY4V+/btE1u3bhWNGzeWj1HPv1GjRmL58uWWthNCCCF2Mnz48KDH6CnjNX6NKdkdRY0SXZQo/v77b/ctJa1btxbbt28Xx48fF59//rkYPXq0+PTTT6U6gugwDzJSitTzkbaHAqJHFz7gzJkz0v1D4kONIccyfjiW9sGxTM7xzPSvpSQweLBr58Sd+9ixY4OeO3jwoGUrgFNjqURJlixZRN68eYOOlzdv3iBR4ubn9s8//xjrGCMr5y5VqpSxvnnzZlGuXLmw+1tpMBiVKLnmmmuM9XvuuUfccccdYsqUKTKASJ1M99mdO3fOeD7S9lCMGDFCDBs2LOi5du3ayfMRe7DTF5jqcCw5ln7F6+9m6fHj067j0UddO+e0adOCSrqD9evXi+zZs3s6lsoigfgReA90zp07Z6zv3btXbNmyRbjFhg0bgh5bOXeePHmM9ZUrV4ry5cuH3f+SSy6xP6bEeGHWrKJKlSpG1K1Sn7t27TLUEwZfmYEibQ9F165dZXCSDs4Hk5HbLZ2TDahg/HNxLDmWfoLfy+Qcz0xZssi/ZcuWde2cCDEINYnGeg12jaWKFYGnINS15M2bV2bBoHGfm+MFL4SiatWqls5do0YNYx3xOnZcb9ZoTGFQdRUrVpSP4cKBMurRo4eh+ipXriwzbGBFOXv2rJg9e7a47bbbLG0PBRStWdVmy5ZNfiEoSuyBY2kfHEuOpV/xy3czk0vXAPGAucYMuvPGOw7xjCXmPRUrglCGUMfJly+fFCXYz83PTM++QWatlXPrIgQxJXZcb1SWkldffVXWF4HCW7Jkibj44otFixYtjO19+vQRffv2FX/88YeMPcEF6qIj0nZCCCEkXkaNGmWECmCCVfESXlRJNce0KDKq0ZUvXz7pEfB7SrA50NUuF6FlUYJgVsR3LFu2TH7ASAuuWbNm0D516tQR48aNE0uXLhVNmjSR2TV6ilCk7YQQQkg8wM2CeESV5dmrVy/Rr18/X2TfhMu8MdcqOXLkiHwvbllLVKwLAnALFChg6TUIy4A3AwkprosSdbGoUxIOFFO5/fbbY95OCCGExFObRFUeb9q0qahevbqxzWtLiRVRkk9LC4YbR3/shiiBJ8SqEMJ+sJb89ddftokS752MhBBCkpv169MWF9BboVx//fUy5CBRRckhl2qVwNUVTd+bUC4cXKsdliiKEkIIIc4CYaCJA7fqbZQoUSJokk8E900+D6q6qmwfEG0dF7vjSihKCCGEOAvEgEuCQBclCHL1snR7PDElbl5vLNVcnRIlMdcpIYQQQizxbykJsXOn4wO2UzsHRInuvqGlxFlRYi4GFwsUJYQQQpIG3VKCbvaobZVIlpJ8HsSU0FJCCCGEOGgpQdVxTPx6axNaSiLXKGFMCSGEEGKzpURVJUUpC9WjJREsJflTPKaEga6EEEKSAjS0UxMsRIlCxZX4yVJy4YUXhtwnnweBufGIErwPJfooSgghhBDNDYEqqCqexDzR+8VSgokcFhy/xJTsiaHEvAJVc8uUKWOIEt1dFgu0lBBCCHGW9u3TFpczb0JZSuKdNO0QJRm5bvzgvok2pkR34aBTsG4NigVm3xBCCHGWt9/2JPPGbH2AFQUd7pW7wU1w7gMHDkQUJfk8dN+gj00sZe3NcSWFChWK+VpoKSGEEJIUZGQp8UMBNZxXuZb8JEoCgYAxbnDdwB0TLXYGu1KUEEIIcZbBg9MWl6u5KvxQQE13kaDpXUbkzZvX1ZiSb7/91ogpqaiK3EWJnQXUKEoIIYQ4y2uvpS0uWkpCuW+8tJRs377dWC9ZsmSG+2XJksUQUU5fK6wkAwYMMB4//PDDMR2HlhJCCCGegInsp59+Eg8++KAMirz00kuDrABe4mdLyY4dO4IaBYYjn0vZQrNmzRJLly6V6zVq1BCtWrWK6TgUJYQQQlxn9uzZolq1aqJevXpiyJAhYu/eveLPP/8U33zzjS8+DT/HlOiiJJylxE1RoltJnnvuOVlsLhYoSgghhLgOrCPr1q1L9/yuXbt8ZSlBHZCcOXP6ylKiu2+sWkqOHDkiC8I5wbx58+QCKleuLNq0aRPzsZDNVKBAAbnOQFdCCCGOc/bsWbFhwwYjS6Nv377GNr+5b/R4Ej9aSiKJkvxarRKnRNTLL79srD/77LMZFnOziiqgBvGlsoxigYGuhBBCIoLJRt21N2zYUPTq1ctXogST97Fjx9K5bvxiKdFFiVk0mSmopQzDRWY3y5cvFzNnzpTr5cqVEx07doz7mMqFc+bMmbgsZxQlhBBCIrJ582ZjvWzZskGVP/Uy5SGZMSNt8aBwml8sJcp9g8JiumspFMW169ffl50BrgpYvNBROV70OBldgEULK7oSQgiJSpRcfPHF0sWQLVs2eWcc0VJSo4ZnQa5mUeKFpQQZS2qijuS6MV+//r7sYtOmTcZ6nTp1bDmmXntl3759MR+HlhJCCCFRixJU/lTN2/zgvskoHdjsvvHCUoJ+MKdPn7YsSoo7bCnRP8tLLrnElmPqpeUpSgghhDjKli1bgkQJUKIE7puwje6qVUtbPCic5gf3jdXCaW5bSnLnzh1TA75QUJQQQgjxLKYEqAkNLpywJdHROTbO7rF2WUq8cN9Ek3njtKUE4lEJTGXxstt9E09wLt03hBBCLIsS1ABRKavKUuIHF044S4neT8YLS0m0oqSYg5YSiJyTJ0/a6roBtJQQQghxrUaJKoqlXDd+EyXhLCWoVKqEiReWkmjdNwULFjQyYuy2lOhBrvpnGS8UJYQQQly704cwMU9kejyC16JEWRSQEaTX+XC7dLsdlpLMmTMbwspuS4kTQa6A2TeEEEI8ybwJZSmJWKvEYZRFAZN5qDgJFVfitaXEiigBSpRgXO0sNe+UpQQuPVUVljElhBBCPBUlYS0lV16ZtjgErDhKFGVULVXvJxM2U8hBSwksIEWLFrX0muL/vg+UbLdT8OmixE5LCYSgslAxJZgQQoir6cBRiZLJk9MWh8C5ldAwx5OYRQn2U+Xo3RYluDarPWaKORTs6pT7Ro8roSghhBDiajowiKrUvEfVXL0uoAYrjuoFY9V142RasLKUQKQhk8pOVFzJ0aNHxalTp2I6BlOCCSGEOOu++frrtMWDvjdeF1CDIFFdc6MRJcUcsJQgNmXr1q2GlcSuGiV2ZuBQlBBCCLEkShDMqN9d58mTR1YFjShKHnggbfEgHdjrAmp65o2VdGAnLSUIuA2VRWUXFCWEEEIcRb+7DjWRKReOlynB4QqneW0piSXzxilLiVNBrgqKEkIIIZ7UKDG7cGCutzN1NRktJbGKkn9sspQ4GeRqV6l5um8IIYRYyrzRg1zNogRxE+iG6wV+tpTE6r4p5rClhO4bQgghSRPk6qdS8/p59evxg6UkVvdNzpw5jfidRLGUZOS+mTt3rhg+fLilY9BSQgghJGZR4odS82oCRNAtJnO/WkqiESW61ccuUeK0pSQj983o0aNF9+7dLR0jreMPIYQQEqelJMNaJUOHuiJK9Dv1cKLEi5iSHDlyhOzJE8mFs27dOlnsDdesW3viESUYp3iPFY2lRBdDkaAoIYQQ4qz7plUrx0YYFVpVLEs4UeJV8TTlvoGVJNq6IMVNacHxCInTp08b1+KE68YuUUL3DSGEkIiiJKMKoF67byAwVHaQ3ywlJ06cEAcOHIjJdWN3sOu2bduMIm5OuG6AbglS7ht8Nji3VShKCCGEhASTmKpRgsybUHf6liwlLVumLQ6g35H7zVKiC4loMm+cKKDmdJAryJo1qyFc1eeiF2yzdAxHrowQQkjCg0n1zJkzYe+uLcWULF/uzAVGIUq8CHSNNfPGCUuJ00Gu+mdw8OBB43PRxZAVaCkhhBASUzyJH9w3VkUJSuIrS49b7pt4Mm/sLqDmdDVX82cAYQILSTTxJICihBBCSEiU6yajwmkqq0RZIfwsSiBIlAvHLUtJrIXTQrlv4rWUuOG+0T8DBCAjnoaihBBCiC3o7piiRYtmuJ9y4WTovvGBKAFKlLhlKdEDPDOqNOuFpaRsBgLT7lol+GzoviGEEGILusjQ3TQZiRLcGSP11K+iRFl03LKU/Pzzz8Z6lSpVYspmyZYtm2VR8tdff4mnn3466LzKarFhwwZD6OTKlUs4hTktmJYSQgghtqBX5dTvgM3ogiVkIzaIlgzKv9spSsJdoy5Kjh49aqTHOgUChJU4QDxORo0Cw5EpUybjdZHcNxAet99+u3jttdfkXzzW3Ujqc7nsssuEk+iiBOdUlpJIn42CMSWEEEIiWkrCTSoR04JXrUpbfOK+UcLESVatWiXrlICrr7465uMU/9ftg88iXGrtzJkzxerVqw230caNG41tv/zyi7F+xRVXCCfRPwNYd/7++++o4lgoSgghxAedeCtVqiSuvfbaoEnWa3SrhxX3jRdxJbG4b9yIK1m8eLGxHo8oKfavpQSWj3CBxIMGDQp6rLtw3BQlunjFeZXFxmoaMkUJIYR4zEcffSTWr18vu6k+/PDDwm+iBDEIaHYXs6Vk5cq0xUFRkiVLFpE/f/6w+7pZQM0uUVLcQgG1X3/9VcyYMSPouWXLlnluKdGFES0lhBCSIKggRPDZZ5+JSZMmCT+grB7hrCTm7SFFyU03pS0OihIEhUbqLeOFpQSC7vLLL4/5OMUsFFB766230j0XSpSgVsull14q3BIlyp0EaCkhhJAEAVkTOr169fLcjYNAUHUNkYIULZWa97BDsNuWElg0VIBnnTp1jAyaWCgWIS14165dYsyYMXIdliK1/4oVK8S5c+dkETN1LRBHmTM76yDRvyuqGjCgpYQQQhIA+NzNogQTzUMPPSS8BJMZJjUrlhKvYkqQfqwCVq2IEidKzWOMJk6cKObNm2e768ZKAbUhQ4YYadg9e/YU9evXl+sYlz/++EOs1NxmNWvWFE6T0efgqKUEA/DCCy+IYcOGpdsGv9bzzz8v05JC5SdH2k4IIakE7vTVBIlJo0CBAnJ93LhxnrpxrKYDe1lqPpogV7OlxC73zdixY0WHDh3EddddJxYsWOCoKNmu9dIByO6BKFExNRCysMzoLhw340lAzpw5Q8YfOSpKPvnkE2ka0v1F4PPPPxdvvvmm/MdCt8Du3bsHfUEjbSeEkFTjzz//NNavuuoq8e677xqP1YTj53Rg83Y/ixInLCWYC5W766mnnpKWLztFSZkyZUKW/QcIjFbisV27dqJ06dKibt26QYGmbouSUJ8FhBXEiiOiBLnP8+fPF61bt063beTIkaJv376ibdu24rHHHhNVq1aVQsTqdkIISTV010358uVFp06djCwSL63JVtOBAW4y1UQE15NfRYmyQtnpZtKPs2jRIvHVV18ZWSeIowhXnt8KRYoUkf2FQokS/bvTrFkz+bd27dohLSX4jKpXry7cwCxio+lKHJUogQIcOHCgFBZ4gzpQx/gy6iqtXr16Ys2aNZa2E0JIKmIWJcggUc3bYK7XK3P61X0DVIAlfufTXfMzz6QtHouScFaHWDFbhhDXcfLkSVusJACBqbCAqHo2+tiG6uIM4VWhQgW5jniSdevWyXUYAZS4cRrzZxFNA8BgZREB+DfxxYPPCnnROuh5AC688ELjOQyOej7S9oxiV8x9FBDN63R54FRAjSHHkmPpJ1Lxe6m7b/DjjfcOUbJ27VoZM4CJF+mubo+nPtlikol0DMwNv/32m7zmQ4cOBblKRO/e6oKEnehWCswnka6xVKlSQaIkmnHJaCzNFpf9+/cHuePs+C6XLVtWfk8QB4M5U82juiUNgkudC3M09j916pSxHWETbv1fmb+vuH6c20rmj2VRgn+M4cOHixEjRoQ+0L+WE5TBRcANgKBQz0faHgqcyxxMC79Z+/btrV42iaKLJYkPjqV9pNJYQnwokDqKu2H95u2nn36KqZlbvOOplylHhgmuy2oQ6fLly0W5cuWEm1YmTHqRrlFdJyZ3vD8r+0caS5Wmi89OT4FVk3Es5wjndlqyZInxfVD1bTDZ658RLG5m7LoWK2TPnj3oMQQqzm3FYmJZlMyZM0d+6HDfqA8GKWPoSPjqq69KlQyzI1KWlBkJTYBKlCgh1yNtD0XXrl1F586dg57Da2DKcjrXOtnBZ4nPkGPJsfQTqfi9VBkV+I1Ukw1Kzitgro+11Xw846nfZVerVi3iNegTIW489f0z/ZveHNCCeO1Av/OvXLmypXHC/IOwAcxF0YxLqLHEZ6MsIxgjfIbfffedUTStefPmcdUoUeDYX3zxhVyH8FHvU6UIw7KmF0VDfMkrr7widJo0aRLz9yhazOKjVq1als9tWZTAN6b7iWbPni1VaosWLYxKcYjsnTx5snjkkUfEsWPHZIMgZNhY2Z6R2jIrLnzA+EKkyg+W03AsOZZ+JFW+l/gdVHfamNTVe1YxBOpGLN6xiGU89XgNBGtGer2eugrXT9D+X30l/2R6/31hJ7qrBMG4Vt4j3BwQJbDUw/WiX3e0Y4kbc2Udwflxg46yFxArDRo0sC2Go6w2oUMY4fz47ijXEYSW/t4R7IrHumjD/OvW/5Q5Bkn/btsmSmDR0K0aCLCBb6tx48bGc48//rh48MEHZbQvBgsXokSLle2EEJJK6C4S3dKgxz6oLqtuoyY8WLitxLREqjzqBNEGuponeLgUohUlGcXdIEsGFVNHjx4t4y/79esn7KJMiABd3RVjtkLkzZtXWt0Q4wPgSovUF8hO9M9CD9S1PdDVbAqCSUanYsWK8sOACsWgwOSk9yKItJ0QQlI580ahsm9CFcxyO/sGgkTFASaDKDFP8AhGjRU9yFWlTSPkwBx2EC9lNdGhREmozBsdZLoqUeJWfZJQlhJ8l80eD0dECT5Y/cNVwE0T7kOOtJ0QQlJdlPjBUqJEiZV0YK9FCW5yrU58ZktJPOiiRC+1bzeltO+DumYrogS1wbwQJbpAjCYdGCS/05YQQhIgHVgXJbBOqAqYXogSBLmqMuyRCqf5QZRYtZLYXatEd99YHadYyJkzpzG+odw3oURJx44dZbE0fK+QNOImuB4V4Btth+SYLSWEEEKcsZSoAmrY7oX7JtrCaSptVaXFuiFK9MyXaERJKFeIne4bpyhTpowcV2TcIEg3kqUEn4dqBeN2mAS+M+gJtHDhQpmhGw20lBBCiMeiBLUzzJO/Mtkjw0N1wvVj3xs9oFGVVE8nSvA+TZ2Q4wUF2lQX42hECSwOqj5WvO4bc6Crk5T9V0xBjMF6pkQJBEdGgaTY5lXcJmqKDR48OMiCZgWKEkII8QBYFNSkiLLg5slDjyNw21oSTd8bHTUBYbJWgkGCrrEhOse6HeQKELSrxjbRLCUKfG+UKIk2kNTvUJQQQogHYEJUE3eoCpxeZuDEYinRRQnely4aBNqJhGkp4qYo0a0OKGuhYmf8HOhqdjv9/vvvhpXGrYJobkFRQgghPoon8UMGTryWEr3aqKRq1bTFJ6LErmBXJQxgqdDL7DtBGe2a58+fH1MH3kSAooQQQnwoSnRLiZeiJBZLCXA62NUOS0m8cSXKUgLh5nTsRhlNlMybN89YpyghhBDiqqXES/dNrJYSP4sSOywlCDhV4+S068YspPTvA0UJIYSQlHHfJKOlxA5RgqwodL13I8hVpfii+KgZihJCCCG2iRLU9tAFiALptaq8e6IFuqaC+8bNIFcA91CooFaKEkIIIXEB079qxocy3KF6y+A51SzOK0sJKomGujtPdFGi1/WI1VLiVjVXHXNrl3A1ShIVVnQlhBCXQRoqWs+DcJMKLCgQJLt27ZJVPN2qR6GsALCSRBPAqYqnpRMlnTr5SpRAaOG9QXzZYSlxS5SUNVlKIFpz5MghkgmKEkIIcRl9wg5X8VLPwEGKrRs1KWDFUZaSaCdbNMbDggq0QaLkzTcdEyWozpovX76YrA54n3CNITZEVXn1YzXXjCwlyea6AUwJJoQQl9FreIQTJV4Eu+rl26OJJzG/H7fcN2heGEs6rhJ458+fjylmxw+WkospSgghhMSLPmGruBG/iJJ4J1slSpCdcvLkybQn33gjbfG4Q7CdGThuB7oCWkoIISTBwcSIoFK4JRLNUuJFqflY04FDvR/EwhjuGxtdOKdOnTJicrwSJX4IdL2YlhJCCEkcECtQq1YtWQdk2LBhwi8kiqUkXlHilAsnniBXu9KCvXDflCxZUnZjVlCUEEJIAvHHH3+IdevWyfW3335b+AU/x5TE2vfGCVHSu3dvUbVqVfHTTz8FPa9bjby2lCD7xem+NwoE4+rWM4oSQghJIPSJfO3atWL9+vUikSwlJUqUSGj3TTyiBC63999/X4rKxx57LGjbV199ZaxfccUVjltKYHF75ZVXxKhRoww3oJt9b3QqVqxoiKFkq1ECmH1DCElazNaFSZMmCT+gJmtMLBdeeGGG+2G7slYkWqBrvKJEL8O/YMECQ1AiW+azzz4zCsy1b98+puPjvaE4nBVLCcTIiy++KPr37y++/fZbeQ1KvLkV5Kr4z3/+I6677jrx7rvvGtefTFCUEEKSFr+KEuW+wQQe6S5buXB27NghJ8NUsZSYrRcjRoyQfxcuXGiIiGbNmsUsCvRqqDheuEDomTNnGutff/21631vdOrXry9mz54tevToIZIRihJCSMqIksWLFwfFc3jBmTNnjIk/XDyJQsUQYBLUMz7iAZaG3Llziy5duqQTOo4Eus6albbEIUpgrcAYjBkzxngO1x8PSpSg2Nvhw4dD7gOxAkuNApYSI6vIA1GS7FCUEEKSllAujylTpggvgbBQd+VWRIkTwa5DhgwRJ06cEGPHjhUfffSR8TxK2SM4OJ4gUt1yYYiSqlXTljhECcTktGnTxOeffy4fQ1TdeuutIh6sjC2sKHo8DwTJ9OnTjcduu2+SHYoSQkjSEmqigfk9EYJcnRQl+iT7xBNPiE2bNsn1J598Uvz5559GAGm0pddV12NlYbHTfQMeeOABceDAAbl+2223yZL28aCPbUaBxHAXmVGuJEBLib1QlBBCkhY1iaMTr0oBhT8epdT9ng7sVAE1WGn0a0ARsm7dukkLhEqbRuO/oUOHxnwOvdS8tApVqZK2xCBKEAisjqdfd+fOnUW8WBF8uutG8euvvxrrtJTYC0UJISQpQZwAAhJV7ADurFVMB+ICvMJrSwnGBBVRdebMmSM6duxoPB48eLCoU6dOzOdQIgLVdGWsBj6Hfz8LKyB2RBeUd911V9B2WCcQ5BovVsZWWUpQtAxF+MzQUmIvFCWEkKREtypg8lGixGsXTjyWEjtEiX7+SpUqGeuqCV+nTp1Er1694jpHvBk4yDRS14N6Il27dg3a3qFDB+kmclqUQMCtWbNGrtesWVPcfPPN6fahKLEXihJCSFKiTzKYfBo1aiQ7ygIEKpqtBYlgKbHDfaOLEgg1XYBUqVJFBr7GWwwsXlGyefNmYx2ipHLlyuLqq6+21XVjRfAtWbLECEpGKm6TJk3S7UP3jb1QlBBCUkKUIGjzxhtvNFw7qvy83y0lKGGeL18+RywlEEX/+9//ZBbLVVddJS1I8QaPmivRxnLNepCrqrz6wQcfSJcSAnPr1asn7AABuYifyeg69XiSBg0aiOrVq6f7zGgpsZfoQ6sJISQBRQnApKL4/fffpUnebXTLQdGiRS3f0SM2A+8Jd+7xWDL082OCheixu6ic3pNFZfbEK0ouv/xysWzZMmEniBPB2OIaQ4kSPfMGogSxLi1atBDDhw83Ku7aIeLI/0NLCSEkZUSJHkOh1+NwEyUKUANE3aVHQl0/aouo4F27LCVOgODUIFcMXC+a+yUWUeIUamyRaoxMJAUCopcuXWqILOXq0eNK4Lpxs+9NKkBRQghJSvwoSvR0XCuuGycycNwQJeksJWigpzXR08dj/Pjx4uGHHw7qP6OLEqc74WYUs/PLL79IEaisJIqmTZsaPWecFkypCEUJISQpURMMYklUMGKFChWkyd4rUQIXDNJkoxUEdtYqcUOUoLaIajSYkfvmyJEjMmAVqchoLqd3AlaiJE+ePEZwslNkJPj0eJKGDRsa63DXfPLJJ+KGG26QnYOJvVCUEEKSEjXBIOgS3WRVDIByLaDrbLgmbH4IcnXSUoLJ1cl4CGXh2LZtmzg3YYIQX3xhbFu5cqWoXbu2GDdunPHcDz/8IPvw4DNRVhNYIpx2j2Q0tuZ4Eh2kTc+YMUM0btzY0WtLRShKCCFJB6wRqrGcPunoLhxk4KAehp/TgZ0UJU5ZSRRK/CE4NPDQQ0JgEUKsXr1aZvps2LAhZE0Q9AZS1iQ33COhxhbCaNGiRXI9f/78olq1ao5fB0mDooQQknToYiMjUeKFCydWS4ld7pvjx48b3XDdEiVAFUIDH374oVEjBtaSPn36GNvmzZuXrkaJ04SKKcH3RwnIunXrGi4/4jwcaUJISgS5+kGUeG0pcSOeJFSAqi5K9L4x33//vbj77ruDRImbmTcZje3y5cuN5yCciHtQlBBCkg6/ipJYLSVIH0Y8TCKJklCWErhFlCjB54Ig1ssuu0y6SLyylKBWjIo5UmO7YsUKYztFibtQlBBCkg594tZdH36ylEQjShDsqd5HPO4bry0lcIugHoheyA6CQGW3IJ5k5syZrooSnF9VoA1lKalVq5bj10D+H4oSQkhKWUogBlTZdlR1TQT3TbgiX26IorhFydmz6Vw3sJAo9CyWWbNmhTyGk6ixhShCvIsSJUhrLleunCvXQNKgKCGEJB3hRAmsDspagvgFVSDLDZSlAq4Y5bKwih2N+dy0lCDdGL1lwKMQgZ98EiRK9JL/uihRadqoduu0cAo1thAkapxgJWHFVnehKCGEJK0owYQSavJVogQT4J9//unadSlLBa4p2snOjgwcN0WJHlcyZv9+cbpp0wxFCeI2cufOHfTa0qVLu5b1oouSKVOmBF0XcReKEkJI0ooS3Glny5Yt3XYv4kpOnz4t9u7da1xXtNiRgeOVKFEF0ZQogSCrUqWKsR8+o/r16we91s0S7vrYTp482VhnPIn7UJQQQpIKNFJTFgmz68ZLUYJ4hXgEgZ2iBK4Rp8u36zEh0xGfcccd4rfffjPK/efKlStoX3N1VK9EiR5nREuJ+1CUEEKSCky8Ki7BT6Ik1nRgJ9w3OL8bsRLKUnI5hNDvvxvxO7rrxm+iRIFg6PLly7t2DSQNihJCSMoEuSouvfRSY1J2S5TEm/kSr6UEFiRVet8N1405e+bUv6XjzZk3iiuvvFJacLwQJea0cXDFFVewkqsHUJQQQlJOlMB1UKZMGUOU2NWYD31e+vbtKx5++OEgdw2OrwdQxiIKUORLBX7GIkp27doV1/njLaB2VqvqGspSgs8EwsQLURIq8JiuG2+gKCGEpJwoAZUrV5Z/Dx06FCQg4mHSpEnirbfeEu+++66oWbOmmDt3riwcdu+994qPP/5Y7oPJTxULi4asWbMaYsKK+wYCaeLEiWLTpk2eBLmGExahRAno0KGD/It0aVgq3AIWGog+HYoSb6AoIYSkpCjR40rsKqKmp7xCBDRp0kR2xB0+fLghSIYOHRqUeRIN6v3A6oFsnnB07dpVdOzYUbRv314KLy9ESc6cOdOdCwIAga6huP/++2VF15UrV8rCZW5i/q5QlHgDRQkhJKnYtm1b1KLErriSjRs3Bj0+f/68+Pnnn4201wkTJkirSbyxD3AH6SLDzI8//ijGjBkj1/ft2yfGjx8fd6BtPHElOPNOzUIVKk1blXxv2rSpa5VcdfTvCgq/Ie6IuA9FCSEkqVBdZmGVcFuU/PXXX8b6c889Z8SAIF4CMSXt2rWL6/hWqroioPWhhx4Kem7UqFFxlbiPN64EJchqR3DdeI0+tgxy9Y6sHp6bEEJsB0W61MSrZ3OYqVixorG+YcMGWy0lOPfLL78sWrRoIeNMOnXqJGNM4sVKBs77779v1ANRLF26NGgs3BYlOqEyb/yAPrZ03XgHRQkhJGk4efKkkWUSKXsDrhDEPOA1dpSaP378uGGNUE3cUKXUXKnUrtTVUKIE53/ppZeMx126dDHcOPPnz/dElMAVo6wky31sKdGrtyIWiHgD3TeEkKSMJ1EpvxkB14oqjgW3C7Jk7IoncaqzbCT3zdNPPy0OHz4s17t37y4GDRqUzloEt1aRIkWEm5aSqULIRfhYlCCW5ZNPPpFLy5Ytvb6clCUqSwlaZo8YMUKsWbNGFCpUSEZ262Yu/FNjOxT5BRdcIO66666gvPNI2wkhxI54Eqt1LhDMCFcHMllgeYinNobbokQXYEqkIHYEIHNl4MCB8ncak+23335r7AdBgvRit9CDVhFAGkksegXEWrdu3by+jJQnKksJfKQwHz722GOiTp06skCQbvYcNmyYmD59unjggQdEo0aNZBEhlSNvZTshhNgRTwKsTH56amq8cSW6KHGqPDlECTJUQl3v6tWrjXVk+BQuXFiut23bNmg/N1036nNQZckQV+NW51+SmET17XjttddkcRuY3+644w5RrVo1sWLFCiP17fPPPxd9+vQR9erVk/s1aNBAfPXVV5a2E0ISC/w/o6kb3AR2VUR1W5ToaZ/xxpW4YSmBK0Yde/369fJ3NVQGEX6bFbgB1GNR3BYlSP/Nlz+/yJE9u/jf//7n6rlJkosS3eSHFtwwlaoIdgRYoUBPjRo1jH2gitetW2dpOyEksUDlUrh0URgMAiUR3Td2Wkr0dGCnRImeyozAWj2uRBclerozLCtwlXslSkDuXLmkgL366qtdPzdJLKJ2LOIHCP5JFOLp2bOnkeamgqvQWVGBdfV8pO2hgJ/XXLUQOfj63QGJDTWGHMv4SdWx1CdxuHRvvPFGGTPg5VjqlhK4OiIdR3ez4P3E8xkqSwkyehC34dT3AYJj2rRpcn3t2rWGFUSvSgsLEM6vrgHVXd9++20pZGCpdvu7qtw3gQT+H0nV/3M7seK6i1qU3HLLLdLtgn9gfMnxD4Iyyjly5JDbkV6HQkEAbarxDwoibQ8FgmIRh6KD4kMom0zswRwsRziWVsDNBKylCgSJIvPjiSee8PR7qawVEEewzGIJByYY/DadOnVKWm11S0s04DhKlJQuXTpIHNnNRRddZKwvWbLEsFZDoABYJI4cOSIX3coNVzluJuHOifV9xsoF998v/x5x+bxOwN9M+2rW2CJK8A+BBWIE5sIZM2ZIUQKTIL74+LKrRldYxz8oiLQ9FFD3nTt3Dnpux44d8jUMlooP/Ijin4tjGT+pOJbLl6PiRDBoOIfgd70omZtjideqUurI+LCaSQMXDjJwICT0QNJogBtFWXXx2+hkh1vdBbJnzx55LohE1VQQfXXU+fXxdLPrbjqef17+KSgSl1T8P/cCy6Lk6NGj0m3Tpk0b+U8LXzJ6OjRv3lxuh8UDRYLGjh0r/vOf/8h/lu+//1489dRTlrZnFNRlzrFH0BS+EPxS2APH0j5SaSz1oE70UUHMGFyrjz76qPydMLeBd2Ms9SZ1mICtvl6JErwWNz2xTN56FiFcQk5+D/Rmfgh2xbn0IF2IIvP5U+m76TQcS2ex/C2FywU/PM2aNRO33XabaNWqlfzy65aMJ598Uv6TYJ/WrVvLqnh6ZbxI2wkhiYE+CSIrT9XP+O677+TNRiJk3tiZgeNG5o0Cqb6qg64KbtWDXJUl2lfAffOvC4cQWywlsI7ANNurVy9pJsQ/hooT0e+Y0I0Spkz4dM2tpyNtJ4QkBvrkffnll0thom5QUItIWVATQZSYM3Cuv/56X4sSWKFwQ4h+NnjPCF7NKPPGN0yalPb3gw+8vhLic6KOKYE7JVznzUidOSNtJ4QkliiBuwI3HAo9C8TP6cCJaikBSpQAWJ99L0oIsQidjISQqFGTN8QIrJ5IgVWWT69qD9llKYm3RomVDIN40YUHBIkSJUgmcEMUEeIUFCWEkKhA0LvqhqsmdFhAVSwDxMGxY8cSxlICy61yRcdrKSlRooRR8sAtUQLLFKwlAIIEyQCEJCoUJYSQmK0CupXBnBXilaUE8W/RVC01dwu2UhwLlgnVYgMiTaXjumWl0INZZ82aJWs+AbpuSKJDUUIIiQrdmqCLEn2i9CKuRFlKYqk1ouJKUEQNheDCMXnyZNlbBh3Shw4dGpQO7JYowbirFN+FCxcaz1OUkESHooQQYrsocTuuBNVLUTsJxFJnxGpcyeLFi2Uz0nPnzsnHDz30UFDfH7dECdxNKBAHdMuOb0XJ5s1pCyERoCghhCS8pUQv/R1NkGs0GTh4Ty1btpStMhQouDZgwADjsZtBpqEEiC9rlADE7JhKSBASCooSQkhc6cAKPcjSbVESa5CrVUsJytej4eD+/fvlY9QyQXsNM/p4eCFKfGsp2bcvbSEkAhQlhJCYRAl6YOkFEJGOqiwOCHRVLg4/pwNbtZSg0aASPigWh+Z2EyZMEIUKFQraz0tLSYECBYKa9fmK6tXTFkIiQFFCCLEMsjxUIKg+kZvdBwgY3exiDEG8lhI9LTiUpQSxJCB37tyyt0++fPmk+BkzZozR5wf1WooWLSq8EiV4HG/PIUK8hqKEEBJT5VLd5eF1XEm8lpJwacFnz541RA86IKMWiQIunQ8++EAKoZdfftlVURBKlBCS6FCUEOJzYJl48803XbU8RBvk6rUo0S0lsYgS/f2Y04KxrlxRoaq13nffffKzeeSRR4SboBYLrDMKihKSDFCUEOJjkOZar1498fjjj4u7777b96JEL6DmVlpwIBAwRAliPPLkyRPTcXR3lO7CcbuvTbSN+RQUJSQZoCghxMf06dNH7NixQ64vWrRInDlzxteixFz+3CkRsnz5cinUrrnmGhlsq1KCY7WSmN+P/j714mhu9LWJhupa8Ki+TkjKdAkmhLjD1KlTxaeffhoU24AJEnENfhUlF1xwgShZsqTYvn277aLk0KFD4uOPPxYjR44Uv/76a8h96tSpE/PxM7KUeFGx1SpPPfWUvL6GDRt6+r2ISJcuXl8BSRAoSgjxIaiHgViFUD1X/CBKkH5asGDBkPsgrgSiZN++fWLPnj2icOHCtpwbtUFgITFTunRpUbNmTenmevDBB223lOjuG79ZSuAumzt3rvA9r7/u9RWQBIHuG0J8CIImUbBLCQAve8ooEACqslxCWUmcDHbdu3dvkCCpX7++7DsD0YNrmjJlinjuueeC6qbEkhacPXv2sJYSVdqdEOIMFCWE+Aw0WEP9C5A/f34xYsSIIEuJV2ByVqmy4USJHuxqlyjRg2Z79eolx6hHjx62FgtDE79QacHKUoJU4Jw5c9p2vpTi1VfTFkIiQFFCiM/AXb9i4MCB4rrrrvOFKFm7dq2xHs6F5ISlRD+OkwGd5rTgY8eOid27d/vSdZNQvP122kJIBChKCPEZs2fPNtbbtm0rq4eiJoXXomT16tXGeo0aNTLcz4luwboocbLpnLncvF4bxm9BroQkIxQlhPgIZJisWLHCsAioIFGVaosYCtQu8VqUXHbZZRnuBzcHsnCcct/o7iG7MTfm83OQKyHJCEUJIT5i3rx5RiyD7rbRrQNeWUvWrFlj9H8JZzVAUS91vbA0wAUSL0rcQOwoq5EblhI/1yghJBmhKCHER/z444/GepMmTUIWJfNClBw9elQGfyoLDoJCw6EsKSh09ttvv8XdBFC5USB2nOwvY7aU+LlGCSHJCEUJIT4UJZh4Ua3UL6IEwgICI5LrJlTMie72iQWIA3VuJ+NJVM0TlRYMSwndN4S4C4unEeITUGxs5cqVch3FwPT6JG6Ub7fiuokU5KrQhUu8osSteBIACxAsIhhjZRkCECp6d2ASJXPmcMiIJWgpIcQn6JU59XgSULZsWZEjRw7PLCVWg1xD7aMLGj9n3pjjSk6ePGmkQWP8I7msSBggqjVhTUhGUJQQ4sN4ErMowYSo4h3gVjh37pyvRQmyhlRAKl6r3C+JIEr0uBJ13QxyJcQdKEoI8ZkoyZw5s2jUqFG67cqFc/r06aD6GU6DiVlZO+DCsFpFVYkX9PFRJfPjESV6xVUn0TNwFAxyjXtQ0xZCIkBRQogP2LVrl5Glgk63KC9vxqtg1x07dkhhYdVKYmewK9Kj1XuFBUMFoTpJqBL6tJTEydGjaQshEaAoIcQHzNECAc2uG69FidVKrk6IEjTbQ0qwW64bQEsJId5BUUJSmrNnz7oenxFtPInXBdSizbyJN9hV/zzcjicxpwUraCkhxB0oSkjKsnTpUpl2i8nz+PHjnl0HXBTTp0+X61mzZhUNGjQIuZ9XacHRBrnq6bsqY8WqpaRv376y2d+AAQNcTwc2pwXrUJQQ4g4UJSRlefrpp2WlUkx8M2fO9NRKAjcFaNq0qcibN2/I/S688EJRpEgRz9w3EEzRWCuQwqz2xxifOXMm7P7IKnr77bdlYG3//v3FsmXLPLGUmONKEN+j14whhDgHRQlJSdD0To/jsKubbSwMHz7cWO/WrVvYfZW15J9//hGHDx92/NqQ6aOEAc6taqVYRVlWIEgiCakPP/zQWIcw6d27t1EnRJ3fLfS4ElhJnCxtnxIgmyxERhkhZihKSEry1ltvBT3WJz87wWSMUuWIXQkFOv5++eWXcr1gwYLilltuCXs8t4NdcQ5l4YgmniTaYFcEs44YMSLouZ9++kksWLBArhcrVkxairywlDAd2AYmTkxbCIkARQlJObZv3y7Gjx8f9JwTlhK4hjC5obYGutteeeWVomfPnmLVqlXGPriOU6dOyfUuXbpEtEToLox4G90p0MV3yJAhYvHixbYFuYZ6Tbhg188//9xIOw5lEXErniTU+UJl4xBCnIGihKQc7733XjrLBUQJAk7tBO4hFSuCkuWIkRg2bJi4+uqrxZIlS+TzunUgkutG9cRRLF++3JbrHDRokHjwwQdFw4YNxcKFC4O26QIqmiDXUK8JZymBKFK8/PLLol27dkHb3YwnAWiG2KlTJykke/Xq5eq5k5IJE9IWQiJAUUJSClgvVOwC0j7r1q1rWAv+/vtvW8+ld5gtVKiQEZcAV0XLli2l2wZCBVxxxRXi8ssvj3jM2rVrG+vqtfGiBBJEWdeuXY1MpE2bNomhQ4ca+1m5vlDptaoQXEai5JdffpGZUMqyUqtWLfH666+L3LlzeyZKUFV37Nix8rouvvhiV8+dlPTpk7YQEgGKEpJSjBo1Shw8eFCu405Yrwlid1yJLkq+/vpred4mTZoYHYHbtm0blZUEIK5CuRPQURiBqPGybds2Y33Dhg3i+eefly6l9u3bG2OF9VKlSkV9bAgx5cKB6EMMjZkPPvjAWIdVAq+BmHnxxReNY8ByQQhJfihKSMqAolyDBw82Hj/66KNBsQN2x5XoogTBkvny5RNfffVVutgMWGwgkKyirDsQDnbEleiiBGCMEHD7888/y8eIi9EtJtESrojaoUOHpEUCIO6mc+fOxrYnn3xSTJgwQcyYMSMmKw0hJPGgKCEpw7Rp02QtDFUPBOKgatWqjllK/vrrL/kXwauqYy5cGSiUVqZMGWO/1q1by8wbq6A3jl0uHLizlDUEdUhUOu73338v13PmzCmDUEP14rGKLsL0GBVlQVLuojvvvDOoRgssJLDQNGvWLOZzE0ISC4oSkjIgoFOvHGqOVbDTUoKJXVlKUOcCMQoKdNr97rvvZKwCrAPPPPNMVMdWlhI7RIluJUFwKYJwzUHBenBtLCBeJqPgXBVLAiBACCGpDUUJSQngipg3b55ch8umefPmch0uFRUrAUsJxIQdoLgZMm4yqnOBa0ANEKTBRuuawCSvRI5ysdghSiCSRo4cKfLkySMfI+jVaqxLOPD+smXLFlJEqcewiiDAlRCS2lCUkJQrloZYEt1yoeJKEIS5e/du2+NJUKckFIglUS6TaIBoUG4nxGioLrqxoFKWAYJL0XcG1W4nT54sPv74Y1sqmcJ9peJKYI06cuSIEROjMnLwGcBqRJKUkSPTFkIiQFFCkh5YAxAwCS666CJZpEzHibgSFU/iVEVQ5cJB8K45TiNWSwlECYAwQaCrLtzsul5YopACDCBIVLVYPU6GJCGwTP5rnSQkHBQlJOl599135eQNHnjgAZErV66g7U5k4Jgzb+zGrmDXUKLECULFwejXrW8nhKQuFCUkqYGrQKWzwl0CUWLGCUuJ06LErmBXt0RJKBFFUZJC3HBD2kJIBKJ3aBOSQCCdFbUwANw2RYsWTbdPIlpKkGaL4FG4P+IJdlWiBNVTCxQoIJyiWrVq0kKF+Bd1vUqUIK6GdUiSnDB9jwjRoaWEJDUqfkHVwQgF4kywOBFTgu62erl0u0DwqKr/8fvvvxvBo9GA+A4lSmAlsSOoNSMgPFRqMMYG51UCEEGwqIdCCCEUJSSpQdptKDeNGbUNqbyhSqFHA4qB4ThOt73Xg0djac6H96kKl+nF3Nxw4aAxoWqAyHgSQoiCooSkhChBz5jChQtnuJ+dLhw0slO4IUpALC4ct+JJQl0vRImCmTeEEAVFCUlaYAVQdTgqVaoU1j2hW1HiFSVOx5PYlYHjpShRliTz84SQ1IaihCQt6HirgCgJh24piTeuxErhNDuAkFLpzSh4Fm/hNKdBd2NU0NVBLAmCYEmSg6rJMXSZJqkHRQlJWhAAalWU6JaSlStX+rpwmh48qiZ0nFPFh/jVUoJibLVr1w56Dn11VAl6ksTAkhdnnyaSGlCUkJQIco0kStAkr2zZsnJ9/vz5MWWzuO2+AdWrVzeCXaN1O7ktSkK5aui6IYTELEoWLlwoevbsKa6//npx9913i0WLFgVtRw2Cfv36ye233nqrmDJlSlTbCXFKlOjdgEOBeJOWLVvKddT+mDlzZtyiBK4JpAS7IUrAr7/+muF+aA44fvx48dNPP3kqSsxBrQxyTRHQDVrrCE1I3KLk6NGjsn/I/fffL7788kspKp544gnx999/G/sMHjxY/tCNHj1aPPXUU+L11183Gm5Z2U6IE6IEboMKFSpE3F+JEjBt2rSYzok0V5V9c8kll9jaPyYWUQILCsQIRFnHjh1Fo0aNDPeSEiXITMqbN69wA1pKUpTbbktbCImA5V9M/Gi98847sgASfsRuv/12WR1TmYzPnj0rpk+fLkULTOH169cXTZs2FVOnTrW0nRA7wWSsRMnFF18si41F4tprr5UdeME333xj1NGIhp07d0qrhNNBrlZECR7j/wxiZMuWLfK506dPi3Hjxsn3pm4o3KhRooCLTKVmoytwJLcaISS1iPk2bv/+/WLHjh3yblD9GCPQTjeT4wfnzz//tLSdJD6Y5FAvQy16dofb4PsG6x6wOvHB3dKsWTO5vnv37phqf7gZTwIg8HGTANZopbzhgrr55pvFkiVL0r1m4sSJ8v2pDr1uuW6Um+zll18WJUuWlH+dtiQRQlKg9w2sHi+99JK46aabDLP4sWPH5F91p6nuhNTzkbaHAnd1WHTwQxrLHSwJRo2hXWOJiQ535GaGDx8u44/cRg/6rFixouX32aJFCzFp0iS5DiuelZgHfSx1kQ3B7sZ3FdaSBQsWiO3bt4t9+/bJHjZLly41RCEsNrByDhgwQIoUiJfvv//eeH2pUqVc/Z+699575QLM57X7e5nq+GU8VYWgQAJ/rn4Zy0TGyk1I1KIELeBffPFFaR5/9tlnjedVvQRYQ5TwgOBQfT8ibQ/FiBEjgio/gnbt2on27dtHe9kkA/Rgx3jApBeKgQMHimuuucbRviqhWLx4sbGOvjbKfREJ1U8GfP3116Jbt24RX7Nnzx6jJgrcPrrL0+p543WJQJSAWbNmybgNJawABADqsCDAXFlOXnvtNdev04vvJfHHeJY+dy7tOnz2PUvEsUxklGfFNlEChdi/f3+xd+9eOQnp9QVgjoXfHj/OqD0AsK4uItL2UHTt2lV07tw56Dm4jGBuptk3PvBZ4p/LjrE8deqU0fgOAqBDhw5ixowZ0mqAz/jgwYPGZ+4W+I4qrr76aiPdNxLYD9YRuG5+++03WQsE310ziBuZPHmyGDVqlMzUCXX3VK9ePcvnjQe8v7FjxxrvG+fUa620adNGPtejRw/xyiuvpCsQh4Z4blyn299L4p/xzJQli/zrl+9ZIo9lsmNZlMAy8t///leaiN999910XT3x4w1/PCwbuDvGnRdMxG+++aal7aHInj27XHQghPCF4JfCHuwYS6SZquBOxDG899574sMPP5RBzeCzzz4TtWrVEnYCIbRq1So5oSornM769euNdVgJonmPyMJR8SQIzkYavM68efNE69atZVxVRhQpUkRWMHXje4oxUEBswMWJ9H0VxAoXKyxVmBAgYHQrEsDzfvt/4v94ko1nv37yTyaffc8SciyTHMsji14VMAnj7hFZM4jqx4I0YcVjjz0mrSEQH4888oj8Mdd98pG2k8Tkxx9/NNabNGliuNkgRAGyPeD2sxPEqcASgSwwCOaMqrkibql48eJRHTtSavD//ve/IEGCSf2ee+4RzzzzjHRpwr0J64lZuDuFXqYdGTdw0SiReN111wW5zvC5mHEz0JWkKPfdl7YQEomARc6fPx84efJkuuXs2bPp9j137lzYY0XaHo6NGzfG9Xry/5+BXWPZqFEjqAK5bN261Xi+VatWxvOzZs2ybejXrVtnHBfL/Pnzg7afOHEikClTJrmtTp06UR8fY1K8eHH5+ly5cgWOHz9ubMP3PV++fHJboUKFArNnzw6cOXPG8++lut6CBQsGXnrpJWNsRo4cGbQfPh997LDg/zgZv5eE42kn/G66g2VLCe62YOUwL1n+9RXqRDJt0fSVPCBwWQVPIstDv+vu0qWLsa5iHuwAriGdQYMGBT1GLIuynsRSBwPfT7ihVBXiuXPnGttQ7O/w4cOGFQKLH77Pql4JLDiwTClwfTr4fODCUaDWkJUaLoTERY8eaQshEfD+15QkNGg1oOpdmCfAVq1aSfcJ+OKLLwyXQjwgY2vkyJFBz8GtqDfBi6bnTUYg3V3x3XffBcWTKBo3biz8gh5XouJpIBJDFUbTXTh03RBXgBs0xirJJLWgKCG2x5MoEICKmA8A60Kspdt1UDL90KFDcl0VDYNV5O2337ZVlCB9VlkBdVGiW02Q6uwX9MquCrNIVLRt29Z4b3p3ZEII8RqKEmKbKEGZdjN2unAgPoYMGRIkUFSdGxRpO3DggG2iJH/+/DKQWx0P/WxwfmUpgSAKJQQSQZTAOoLPAvVL0CCTEEL8AkUJiZkjR44YXWfRPiBUlgsmRvU8CoupeIxYWLZsmVixYoVcr127tmjevLmsZaPcOkg3R30OvXs10nJj5cYbbzTWUXcFVWJRMRWgsZ0fYkkUoSweGYkSgFoyGC8rxYwIIcQt/POrShIOVBFVqb4ZTYBwE6CmB9DrZ8TCBx98YKyrGihILVcpr0jHRcNIVeodjfjCVQyORpTAhePXeBKAKsl6r52MRCIhhPgZihJii+sm3F257tbRYzKiAVklcNco18odd9xhWEJuueUWua7XQkFGyfPPPy/iAVVoUQRNlW//4YcffCtKzC6ccJ8HIYT4FYoSEgQaIL711luGAIgnnkQBV4dCtzZEAzrKquwdFE7TGzuiWJl6fNVVV8mUYXQJ7t69u4gHuGfgIgLoOIxeOADnsrtCrR3opfzNQceEeAr6xbBnDHGqSzBJXpBu27dvX7kO839GGSbIpFm+fLmRjlq4cOEMj1msWDEZcIqAUcSFoLZJNG4VVBFWDf9QJVVdnwICASnBcA+h462dwIUzevRoua762zRo0MCoVusnevXqJebMmSN79dx2221eXw4h/48P/1+IP6GlhASBSU3v0hyKpUuXyk7NqkDZnXfeGXEUlbvj7NmzRrE1K+AcDz30kOGaQdxIqKZeKAJmtyABaIlg7nDsR9eNEpFwj6HXkB9FE0lhdu1KWwiJAEUJCULvLvvVV1/JiqY6KMyF3jDqeWRxoKdRJPSJPBoXzueff264iRDI+cQTT7j6icECZO7P5FdRQohvgWvR5U7hJDGhKCEGcKvoNT6Q8jt16lTj8e7du6U7Y+/evUYcyahRoyylxuoTudVgV8Rx6IJn8ODBrjW5yygLBwG0devWdf0aCCEkFaCNNwFAfQyk0ip3SbZs2cQNN9wgSpQoYet50NdFxU0oxowZI101AG4UFBFTcSQI/LTaNwXlzpGiu3nzZum+OXXqVNjX4r3CKvL333/Lxy1atAjq3uu2KBkwYIARSOuFMCKEkFSAosTnbNu2TRYKM7tR4MpYu3atrc3Ufvnll3TPTZ8+XRYMW7VqlZg4caJ87qKLLpLPqzLvVoG1BKIEWTQ///yzDBgNBeJHUIcExb1A9uzZpZXEHNvhFvXq1ZNZOHA79enTx5NrIISQVIDuG5+DLBezIAEbN260lLYbqyhRnWQRmIrASVhJFK+++qrM8IgWK3ElSEnu1KmTIUggRFA0LZ7KrPGCAnAonnbw4EFmtRBCiINQlPgcvRYIanX897//NR4PGjTIcOnYKUogBF577TXj+SeffFJaZQDiKVRpd7tFCVxHaOCnLDLIIBk3bpzo1q2b8AOw2BBCCHEOihIfg0laiRJUMX366aflAneCigGZPXu2LedCjY81a9bIdVglGjZsaPRTUUXLIFbef//9mHu+VKhQQdYsUSXqYYXRgTUC/XFUh+EpU6bI7B5CSIJzzz1pCyERoCjxMSgapjJdYGWAGwHCQC8eBmuJHfz+++8y+BSgfwzO07lz56B90FU2nswTHFMVY0NmjZ5+rJreKYYOHSpuuummmM9FCPERAwemLYREgKIkAXvLwMWBbBbw7bffyuwcO+NJIEoAYjsUBQoUCHIdxUq41GDVWwaWGK8ybQghhHgHRUkCihLEWqA7rgKZKfGiWy2UKEEK78CBA2X6L4JdkXUTL3qPHLhnFDt27DDiVq688sqoM3sIIT4GNzQ23NSQ5IeixMfxJMqSULBgQVGjRo2g7Wg2d8EFF8j1Tz/9VOzZs8c2S4ne2A0xLIhd0QuIxUOVKlVkHxwwf/582TgP6B14mzZtasu5CCE+4d130xZCIkBR4lNQF+TAgQOGdcEcXIrAV8R4qEDUsWPHxnwuZPAoSwkKshUpUkQ4BeJK2rVrZ5z3yy+/TCdK0G+GEEJI6kFR4lP0rBrddaNzjxbNvmjRopjPhYJmqMGhu26cRFWIVb1tIE6UKMmTJ4+smkoIIST1oChJsHgSnWrVqslJXHXutTPI1UmqV68uKleubLhwZs2aZbhxkJ3DeiCEEJKaUJT4ENTvUMXF4EpR9ULMIEVYdbDdunWr+OeffxJClJhdOA8//LCxjfEkhBCSulCU+JAVK1bIDr0qniRczxdVSC0ea4nbosTswtFTmhlPQgghqUvKi5Ldu3fLmAq1qAJifnfdhBIlP/30U0yCRFllEDyLNGA3gOtJuXAURYsWlc8TQpKM+fPTFkIikNKiBOmumAgvueQSY0H2yYYNGzy9Lr2oWDSiJFpLybJly0STJk0Mq8zNN9/sWidenEe3lijXjVedgAkhDlKhQtpCSARSVpTs2rUrZIn2/fv3i1deeUV4WZ9k8eLFcr1w4cKiYsWKYfdHt14IKSUy8HoroM/M3XffLQ4fPiwfN2jQQPa1cROzKKHrhhBCUpuUFSWffPKJbEIHECyKxm/58uWTj1G9VGWDuM0ff/xhpOdeffXVliwHyloCgYEeNpFAGu5tt91mNNq74YYbZN8Zt6uowlWDYmqK66+/3tXzE0Jcoly5tIWQCKSkKDl37pz46KOP5DomfUzS48ePFw8++KB8DmLFbauBQllJlCixQjQunI8//ljccccdhiBr06aNLPeuUovd5o033hDlypUTzzzzjChVqpQn10AIcZgTJ9IWQiKQkqIETeyQQgvQiVYFd/bu3Vtky5ZNrn/wwQfi+PHjtp53zpw5sqndvn37bBUl6BVjJdgVAqBHjx6Giwfuk3HjxokcOXIIr2jRooX466+/bGn2RwghJLFJSVECwaF44IEHjHXEZsCKoGJL0FPGLuAOggB67rnnZHDpoUOHwooSvQZJJLCfcvNkZClB074nnnjCeNy3b1/ZbA/nIYQQQvxAyomSjRs3yiBPULZs2XSN5h599FFj/a233rIcOBoJWCRUDAca3N1+++3i9OnTQftAqKhOuZdffrlllwoa86lUWhzbbOFBgbIBAwYYj19++WXxv//9j5kuhBBCfEXKiRLEkmCSBr169UpnKUDxMJWGu379eunqsQNzwzz0tunatWuQ6IGVQ12bVdeNOa4E8TIovmYWYrD8AIgwWGuYeksIIcRvpJQogaVi+PDhch2xI926dQu5H1wbutsjXpARo4QCrDO5cuUysnxQKyWeeJJQcSVmFw5ShRVsdkcIcZ1rr01bCIlASomSr7/+Wuzdu1eut23bVvaVySj4snz58kZ11T179thmJXnkkUdkpk/mzGlD//rrrxtiJB5REq6yqy5K6tatG8M7IISQOBg3Lm0hJBVEya+//iozSRAncSJM2pmykoD77rsvw/0gGJAqC+BemTp1aszXBneMEiU4LgJpb7nlFilGFLCW4DxLliyRjyGWUF02GhBTkjt3brmO4yg3EPj555+NdavBs4QQQojbJIUogcBArZGnnnpKVKpUSYwZMyZdgCr62syaNUuuwwrSuHHjsMds3bp1kIUlVmD92LRpk1EcrHjx4nL9oYceEpdeeqlcR+8ZVJdVGTlWi6bpZM2a1XDNIN35zz//NGJMli9fLtfLlCmToXWIEEIcAzdmprg6QpJSlKDD7KJFi4zH27ZtE3feeaec2Hfs2GE8P2rUKMN6gADTSJM+YjSUgJg5c6Y4evRo3K6bzp07G+uIadHL2euxJdG6bhTNmzc31lWGEeJZjh07JtfpuiGEeMLjj6cthCS7KBkxYoSxjsqgelzFXXfdJYUIrCYjR46Uz0OMoOdLJOBqufXWW+U6OgerST4aUDV1woQJch3Brbr1RcW1KHcKLBqK+vXri1jQ05vV9equG4oSQgghfiahRQkmfVXgDJYHZJ18//33RoM6uGuQAoxKqnDfKGuC1XLm6A+jmDRpUtTXh34yqnor4khUbx0FBNKrr76azg0Ta9zHZZddZlh3EKCLbCM9yJXxJIQQQvxMQosSWAPQ7VdN+hdddJHsNKtbTx5//PEgNwlcN1ZBvZL8+fPL9WnTpqUrdhaJ9957L6TrRgdxJnp33Jo1axopw9ECkaOsJQj4nT9/fpClpHbt2jEdlxBCCHGDhBYlejaNXnMEXW/R4wUgngKFykDBggUNl4wVsmfPLm6++Wa5jiDUuXPnWn4tLBSwlAD01jFXjtWBtUSlCKMUfTzo50GjvZUrV8p1BNW63QWYEEIISQlRAgsJrBcA7hoIEXPzOWSb6MBaEW3zOd2FE00WDkq560GsqtFfKGrVqiVdTSjU9uyzz4p4aNq0qSFwYDFCPAxgPAkhhBC/k7CiBGm/Z8+elesIaEUshg7iNz7++OOg5zKq4BrJ8qCEzOTJky31wlm1apW0UoCSJUuKe+65J+Jrrr32WllYLWfOnCIeYA1ShdRU1g2gKCGEeMbo0WkLIckoSpBRo8eNZBQngliNZ555Rq6jGBriNaIFze5gfQBIMTZXS8XEj+67cMEcOXJEPqfHsDz55JNRW2fiJZSriEGuhBDPwG/ov7+jhCSdKEHl1t9++02uN2zYUFSsWDHDff/73//K0vITJ06M+Xzo6Kt3+zUfH64iiB/EbaAb7xdffCG3oVDZvffeK9zGLErgzkGjQUIIIcTPJJwo+eqrr4LiLmCJiEShQoWMOItYRQmCXgH61ii3Ef7qFhvEubz44otGkTZk/qjS726CLBu8Z70EfZ48eVy/DkIIkTRpkrYQkmyiRK98CpdJq1atHD8nslZatmwp13fv3m2Uq0dNlJ07d8p1XQSo2I5evXoJL8iSJUtQ4C9dN4QQT1m3Lm0hJNlEibJS9O7d25KVxC70OiOqdLyekgyLCeqCNGjQQAbZfvDBBzIexSt0sdaoUSPProMQQgixSnDKSoKAcu1In422aV08tGjRQhZSQ70SuJAQO6IybIoVKybriyADaMGCBcIPdOjQQfa9QRG1Ll26eH05hBBCSPKJErgiRo8eLV0UboJU3Xbt2sk0Y2TcdOrUSZa5zygl2WsQQ9O/f3+vL4MQQghJXvfN0KFDYy7DbqcLR+9MHE3pekIIIYSEJqrbe9ThUBVCYTnImzdvyP1gSUC2SkZVTCNtD4eXpdIbN24sm/n9/fffQR19K1eu7Nk1EUKI77n4Yq+vgCSjpWTQoEHSWoDS6++880667fv37xc9e/aURctQoRQdeqPZ7nfgEunYsWPQc7SSEEJIBBYvTlsIsVOUvPTSS7LJXEZpuK+//rrMOJkzZ44sAz9hwoQgN0ek7YmAHjSKGiTt27f39HoIIYSQZMG2mJLTp0/LLrqwHMA1c8kll4jmzZsbnXIjbU8UatSoIUvWA1RxRfovIYSQMODmM8FuQIk32JYygr4wEB7lypUznsP61KlTLW0PBfbHooOMFytN8Zzks88+k66owoULe34tsaKuO1Gv309wLDmWfsUv381M/97IBbZvF4mKX8YykbFSWd02UXLy5En5V8+MgXtDPR9peyhQkGzYsGFBzyEt1y8uk61bt4pEZ9u2bV5fQtLAseRY+hWvv5ulz51Lu44tW0Si4/VYJjLwkLgmSlQmztGjR41KpsjWUc9H2h4KuHr0NFxlcSldunRcvWxImtrHPxfHMn44lvbBsbQXv4xnpn/rSpUtW1YkKn4Zy2THNlFSvHhxKTDQvfeqq66Sz/3666+iUqVKlraHArEnqhGeAmnE+ELwS2EPHEv74FhyLP2KX76bmXxwDckylslKVKLk+PHjcoHLBapx79690gWDBRVWb7nlFvHee++JAgUKiM2bN8ssG1RABZG2E0IIISS1iUqUTJw4UYwbN854vGTJEhnf0b17d6NJHuqXoFEerCL9+vULKiwWaTshhBBCUpdMgUAgIBKITZs2Sb8kzWfxAUvXli1bOJY2wLG0D45lko6nsojfe69IVHwzlkmOv7rIEUIIST4SWIwQd6HcI4QQQogvoCghhBDiLN26pS2ERIDuG0IIIc4yfTpHmFiClhJCCCGE+AKKEkIIIYT4AooSQgghhPgCihJCCCGE+AKKEkIIIYT4goSr6EoIIYSQ5ISWEkIIIYT4AooSQgghhPgCihJCCCGE+AKKEkIIIYT4AooSQgghhPgCihJCCCGE+AKKEkIIIYT4AooSQgghhPiCrF6c9LnnnhNnzpyR63fffbeoVq1a0PYDBw6IiRMnir///ltUqlRJtG/fXmTPnj3dcf78808xdOhQccstt4iGDRtG/fpk4JNPPhF//PGHXG/UqJFo1apV0PazZ8+KL7/8Uqxbt04UKlRIdOzYUVx00UXG9mHDhokNGzYYj/Plyyeef/55y8dPJubMmSO+/fZbuV6yZEnxyCOPhNxn4cKFIkuWLOLWW28VVapUMbbNmjVLzJgxI2j/J554QhQuXNh4PHfuXLFgwQKRI0cOccMNN4gaNWqIZGTz5s1iyJAhxuMBAwbI96zz+++/i2+++UYcOXJEXHPNNeK6664ztv3111/io48+Ctq/bdu24sorr7S0Pdl45plnxLlz5+R6165dg753YP/+/fI3b/v27XJbu3btRLZs2YztTz75ZND+tWrVEnfccYdc/+2338SoUaPSnfOee+4RVatWFcmG/pvXuHFj0bJly6DtmJvUb2aRIkXkOOG3U4HvHb5/ivz588s5zerriQ8tJU2bNpU/yKtWrRJ79uwJ2nb06FHRpUsXKSjq1q0r5s2bJ1544YV0x0Ah2oEDB8pjbN26NerXJwu1a9eWY4n3vX79+nTbn3rqKTF9+nT5I3Tw4EHRrVs3cfz4cWP7L7/8IooWLSqPgQWTQzTHTyYuvvhi+V7xQ7J06dJ028eOHSu/cxUrVpTC7v7775c/PIpNmzaJY8eOGWOJJXfu3Mb2Dz74QHz33XdShF944YXiwQcfFIsWLRLJCN4f3j9EwuzZs40JVbF69WrRo0cPkTdvXlG9enXxxhtvyB9y/cYCk6U+lqVKlbK8Pdlo1qyZfI/4f927d2/QNog6/Obt3LlT/uZhvF966aWgffAcbtzUWF122WXGNnzf9XHE9xviuVixYiIZqVOnjnyfhw4dkje2ZnAj8f3338vfPox19+7dxYkTJ4zty5cvFyVKlMjwNzPS64kPLSXqjui9995Lt23mzJnyh/w///mPyJQpk7j22mvlB48vT4UKFYz98AOGfx7cscby+mShZs2a8u/ixYvTbYNYw48LJkJMorAo3XXXXWLKlCnGXRLApAChGO3xk1GUYDl9+rRYsWJFuu1jxowRjz32mPw+AQiQ4cOHi9dff93YBxaWjMYSVipM1gr8KOLHq379+iLZwPvEOOzYsSPk9nHjxkmr23333Scf4/sJwde6dWuROXPavVKePHkyHEsr25OJJk2ayL9vv/12um2wzsHC2b9/f+Puv3nz5lIkX3LJJcZ+eF7//ilgydPHcfDgwaJBgwaiYMGCIhm54oor5F9YLM1gzHCjgDEtUKCA/M3s1KmTtOjBEhfpN9Pq60kCxZTs27dPqlAICoB/tgsuuECsXLnS2Afq87PPPhMPPPBATK9PFTAWOXPmDHLXYGxgXdKZNm2aePHFF8WIESPkXRcRIS1zMJFDdIQbyzVr1kjL3DvvvCNdGDrmCeGff/6Rd6mpCL6b+lhiHc/BwqlbQ/r16ydFXyjLVaTtqYL6zdO/ZxBs5t+8t956S7z88svypsRsuVLgeVhWk9lNG2ksc+XKJQWF/t00jyXGEL+ZI0eOlFbkaF9PEkiUwJrx66+/SlcDWLt2rfzxwaLAjxDcEBAbsbw+VcBdP2JKYG4E+OfBJKqPBUzoiI2ASRPWAah6/Z+MpAGRW758eRlPokQK7oj0scSdE0y1uMuEi6xz587SxaAD8zvMuxhnHAPxAakI/k9hfTt//rx8rMZVjSfGGq5HjCV89lhHzIQi0vZUG0uI4cOHD8vH+P3Duv7dfPXVV2VM2KWXXion0meffTbksfCZ4DcD+6Yi+M08efKkISLwWwhXoz6WsO7BAoLfzGXLlsn/c1hNrb6e+NB9Ew7452Dq6tChg3TP7Nq1S5QtW1ZaPJTJDWr05ptvjun1qQTUeu/evUXfvn1lQCXcOfC762OhTJkAYwoXA+6UEChHgsE4QlD8/PPP8kcfwWv6WCr3D7jxxhul6Bg9erScEBTFixeXpnW4NcaPHy/da9g31YAYw4873Ii4s8+aNat020BgqO+ubh4vXbq0dF0gaN3K9lQC7nD85uG9Q3TgN69MmTJB3019rPAbCUvIli1b5G+jztSpU+X3EZ9HKgKrMizwCHJXv5n4buljiVgR/TcTcw3cNbfffrul15PwZPXjHSksIQiq3L17t/Td4UNX/zyTJ0+WPn/cGYGNGzdKNYqIZ2TyRHp9qoEAuOuvv15Gi5crV066FfBPEgrE52CczIF0JA3cGU2aNEkGt2LyxB1puAA2+PN/+OGHoOcQPKgCCOGzR0xKKooSxDFAlMGSiTtzBLxCqEC0ZTSWuNuEe8EcR2ZlezIDMTdo0CCZJYfEAfzm4aZCCWQz+P7BvYP/c/13EUJ7/vz58juZymAeQWAx5hZY5DC2GY0lvmsQgPpvZjSvJwngvgFLliyRVg5Ei+OuHROASvW78847ZbCminzGDzvSfvU7/nCvTzXga8cPPcYCLi2Yydu0aWP8COGuX49xgAvHnG5I0oAZFmmWV111lRxTBGvqAcPIcIB1BEA4I0VYH0ukE+tAKKZqqiBiR3DTgEBqLEg9R5CrShvG9xRmcAX+j/F/rgRHpO2pBn7z8P7xf44YMXyv1B09hB8ycxSwzuEmDhOmDu72McFWrlxZpDIYS8ToYCxhlcdjfDcBfkOVOxxgXOGq0VOnw72e+NRSgrt1/CjhA/v0009lbQiYctU/yVdffSXrj+CHHfu8+eabRkS+ua4D/MgwWerPh3t9soEfIKQ9o+YDfpBhuoVKx6ImPrx/mMhhPYL7Qd2po3YLxh9KHuIOfmm4FpCxZPX4yQQsIAj2hTiDewW1HfCdVBkiuAuH5QmCBOMBC5Q+DngO3238sCPbC+OMmB39+Go7jg8/NMY+GYFgQCCgEg5Yh6BDhg1AADZM3LhhwG8BAn711H1YoGDhhFUP4gUxOkgbtro92YBrCjVIYA1CTAjcLHATqDvwL774QtbfwHhj4sT/vAr2h9B79NFHpQsBMTyo0YG6J+bAa/yvm2t2JCMYO1iE8P+I7yT+F/G7h/9ngPHB/yXGB+uwyquAdIwlxh/jq34zW7RoEVQnK9zrSWQyBdStnYsgOAjpkDpQ9SpiGZcE0zj+wSA2zEWXdKBa8YHrLoloXp/oYPIzZ3nATYNFAb8mFph1Q6UE4hgw++IHzmw+t3L8ZAEmWHOUPL6Tug8ZP/j4bsHsHcoNBtGGMcN3EmLZDMYZ4hCTMe5Ik9V3D5eM2TKEGwOV2grw/4nAawSsw6KkJlEFMsEQKAzXDiyf5gKIkbYnm8XTnBkHd6L6f8ZvHiZI3IjhN888FrCMYKzwueB7qWJ3FBDc+LxgUQ6VQJBM4P9Pr22lgoV1FwvibbZt2xbTb6aV1xOfiRJCCCGEEDPJ6dMghBBCSMJBUUIIIYQQX0BRQgghhBBfQFFCCCGEEF9AUUIIIYQQX0BRQgghhBBfkJxFEgghKQlqcaAYG8qo6wWtCCGJAUUJIcQSKBiFCsEAlTD1Qmiqoi2KRgEnRQEqm6KAHUAVTr0AHao5oz8WittRlBCSeFCUEEIsgV4+KGWuQL+ayy+/XK6jBuOzzz5rVMpEN2qnRAH6M/Xv31+u169fP+krkBKSSlCUEEJiAl1+lShBLxFz6W4z6DECawv6r6BNAXoAZeR6adCggdwXDc9g9VDdbNFcTllJVBNE9NFByX+9KZoSSqGOQQjxLxQlhJCoKVy4sBQEaF6IxoOfffaZ8Tx6guig8WC/fv3Ejz/+KMUI+rLA1QMrx4ABA4w+LMr1gg63EBDYD12s0Zfl/vvvF926dZN9S/BaxYIFC6T7pl69ekGi5OjRo7KRYqhjEEL8C7NvCCFR07ZtWznRo0v3H3/8ISd+CAk0dDPz2muvSUGCpnkQL+hMfcUVV4hFixZJsWIGnb3vvfde8d5774mOHTtKiwdcRbCw3HbbbfLcCnQfRudhPG/1GIQQ/0JRQgiJmjZt2sju25MmTRLDhw+Xz2HyN3f6PX78uJgxY4ZcR2AsrBroFqzaxMPtAwGhA8uJEjfK5XLq1Clx4MABy9dnxzEIIe5DUUIIiRq0Y2/RooU4fPiwDICFCGjZsmW6/Xbv3i0tKgBuGcVFF11krCPmw3xsRZYsWYz1aBqa23EMQoj7UJQQQmIClhHF7bffLgNOzeTLly/IaqLHmYTahxCS2lCUEEJiAkGrXbt2Fc2aNRPt27cPuU/BggWNANTVq1cbz6t1ZOCYs3AigeBVhbLCEEKSA2bfEEJi5sEHH4y4z/PPPy/3Q7bOu+++Ky0q06ZNk/VFXnrppajPWblyZemSgSBB8Gr16tXlUrJkyRjfBSHEL1CUEEIsUb58eWkVCQfEAQJK9ZgRZN18/vnnYvr06TKlF0CkICZF369atWrSxVOkSBHjuRIlShjnVO4hBK4iqwYZPQiSnTNnjjwORInVYxBC/EmmACO/CCGEEOIDGFNCCCGEEF9AUUIIIYQQX0BRQgghhBBfQFFCCCGEEF9AUUIIIYQQX0BRQgghhBBfQFFCCCGEEF9AUUIIIYQQX0BRQgghhBBfQFFCCCGEEF9AUUIIIYQQX0BRQgghhBDhB/4PKTBOvLv8NcsAAAAASUVORK5CYII=", "text/plain": [ "
" ] - } + }, + "metadata": {}, + "output_type": "display_data" } ], - "id": "1596e07e" + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ] }, { "cell_type": "markdown", + "id": "34858645", "metadata": {}, "source": [ "## Basic Model Logging\n", "\n", "Let's train a simple model and log it to MLflow manually." - ], - "id": "34858645" + ] }, { "cell_type": "code", + "execution_count": 7, + "id": "bc8f520d", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.357581Z", @@ -235,6 +241,26 @@ "shell.execute_reply": "2026-06-24T15:18:47.449925Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "model = ExponentialSmoothing()\n", "model.fit(train)\n", @@ -254,30 +280,11 @@ "plt.legend()\n", "plt.title(\"Exponential Smoothing Forecast\")\n", "plt.show()" - ], - "execution_count": 7, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] - }, - { - "output_type": "display_data", - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - } - } - ], - "id": "bc8f520d" + ] }, { "cell_type": "markdown", + "id": "35dc864c", "metadata": {}, "source": [ "Now let's log this model to MLflow.\n", @@ -286,11 +293,12 @@ "\n", "- **Run tags** (`mlflow.set_tags(...)`) – shown on the run page in the UI. This is also where `autolog()` writes its tags (`model_class`, …).\n", "- **LoggedModel tags** (`log_model(..., tags=...)`) – attached to the logged model entity itself (open the model from the run's **Outputs** / Models view)." - ], - "id": "35dc864c" + ] }, { "cell_type": "code", + "execution_count": 8, + "id": "61406cd9", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.451366Z", @@ -299,31 +307,16 @@ "shell.execute_reply": "2026-06-24T15:18:47.906380Z" } }, - "source": [ - "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", - " model_info = log_model(\n", - " model=model,\n", - " name=\"exponential-smoothing-model\",\n", - " # alternatively, use mlflow.set_tag(key, value) in the run\n", - " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", - " )\n", - "\n", - " # log calculated metrics you want\n", - " mlflow.log_metric(\"mape\", mape_score)\n", - " mlflow.log_metric(\"rmse\", rmse_score)\n", - "\n", - " print(f\"Run ID: {run.info.run_id}\")\n", - " print(f\"Model URI: {model_info.model_uri}\")" - ], - "execution_count": 8, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { + "name": "stdout", "output_type": "stream", "text": [ "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", @@ -331,20 +324,37 @@ ] } ], - "id": "61406cd9" + "source": [ + "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", + " model_info = log_model(\n", + " model=model,\n", + " name=\"exponential-smoothing-model\",\n", + " # alternatively, use mlflow.set_tag(key, value) in the run\n", + " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", + " )\n", + "\n", + " # log calculated metrics you want\n", + " mlflow.log_metric(\"mape\", mape_score)\n", + " mlflow.log_metric(\"rmse\", rmse_score)\n", + "\n", + " print(f\"Run ID: {run.info.run_id}\")\n", + " print(f\"Model URI: {model_info.model_uri}\")" + ] }, { "cell_type": "markdown", + "id": "0728690e", "metadata": {}, "source": [ "### Load the Model Back\n", "\n", "We can load the model from MLflow using its URI:" - ], - "id": "0728690e" + ] }, { "cell_type": "code", + "execution_count": 9, + "id": "cae35ffa", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.907880Z", @@ -353,28 +363,28 @@ "shell.execute_reply": "2026-06-24T15:18:47.914326Z" } }, - "source": [ - "loaded_model = load_model(model_info.model_uri)\n", - "\n", - "loaded_predictions = loaded_model.predict(n=len(val))\n", - "\n", - "# verify predictions match\n", - "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", - "print(f\"Loaded model predictions match: {predictions_match}\")" - ], - "execution_count": 9, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Loaded model predictions match: True\n" ] } ], - "id": "cae35ffa" + "source": [ + "loaded_model = load_model(model_info.model_uri)\n", + "\n", + "loaded_predictions = loaded_model.predict(n=len(val))\n", + "\n", + "# verify predictions match\n", + "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", + "print(f\"Loaded model predictions match: {predictions_match}\")" + ] }, { "cell_type": "markdown", + "id": "6bd4597c", "metadata": {}, "source": [ "## Automatic Logging with `autolog()`\n", @@ -386,11 +396,12 @@ "- **`backtest()`** – evaluation metrics under `backtest_*` keys.\n", "- **`historical_forecasts()`** – patched so its internal per-window `fit()` calls don't each spawn their own logging.\n", "- **PyTorch-based models** – per-epoch `train_loss` / `val_loss` via MLflow's PyTorch autologging (see the section below for details)." - ], - "id": "6bd4597c" + ] }, { "cell_type": "code", + "execution_count": 10, + "id": "5ef7f73a", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.915629Z", @@ -399,6 +410,25 @@ "shell.execute_reply": "2026-06-24T15:18:50.019951Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "autolog()\n", "\n", @@ -428,29 +458,11 @@ "ax.legend()\n", "plt.tight_layout()\n", "plt.show()" - ], - "execution_count": 10, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" - ] - }, - { - "output_type": "display_data", - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - } - } - ], - "id": "5ef7f73a" + ] }, { "cell_type": "markdown", + "id": "f484330f", "metadata": {}, "source": [ "## Open the MLflow UI\n", @@ -462,11 +474,12 @@ "- **Inspect** individual run parameters, metrics, and logged artifacts\n", "- **Visualize** metrics across runs with built-in charts\n", "- **Register** models to the Model Registry for versioning" - ], - "id": "f484330f" + ] }, { "cell_type": "code", + "execution_count": 11, + "id": "1a01cd2f", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:50.021527Z", @@ -475,14 +488,9 @@ "shell.execute_reply": "2026-06-24T15:18:50.022824Z" } }, - "source": [ - "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", - "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", - "print(\"Then open: http://localhost:5000\")" - ], - "execution_count": 11, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Launch the MLflow UI with this command in your terminal:\n", @@ -493,20 +501,25 @@ ] } ], - "id": "1a01cd2f" + "source": [ + "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", + "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", + "print(\"Then open: http://localhost:5000\")" + ] }, { "cell_type": "markdown", + "id": "88b0d285", "metadata": {}, "source": [ "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", ">\n", "![Mlflow Overview](./static/images/mlflow_overview.png)" - ], - "id": "88b0d285" + ] }, { "cell_type": "markdown", + "id": "e2b133bc", "metadata": {}, "source": [ "## Per-epoch Metrics with Torch Models\n", @@ -514,11 +527,12 @@ "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", "\n", "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." - ], - "id": "e2b133bc" + ] }, { "cell_type": "code", + "execution_count": 53, + "id": "d01783d1", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:50.024161Z", @@ -527,38 +541,9 @@ "shell.execute_reply": "2026-06-24T15:18:53.370531Z" } }, - "source": [ - "from torchmetrics import MeanAbsoluteError, MeanSquaredError, MetricCollection\n", - "\n", - "# per-epoch train_loss / val_loss are logged via MLflow's PyTorch autologging\n", - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"nbeats-epoch-metrics\"):\n", - " nbeats = NBEATSModel(\n", - " input_chunk_length=24,\n", - " output_chunk_length=12,\n", - " n_epochs=10,\n", - " pl_trainer_kwargs={\"accelerator\": \"cpu\"},\n", - " # these are logged per epoch as train_MAE, val_MAE, train_MSE, val_MSE\n", - " torch_metrics=MetricCollection({\n", - " \"MAE\": MeanAbsoluteError(),\n", - " \"MSE\": MeanSquaredError(),\n", - " }),\n", - " random_state=42,\n", - " )\n", - " nbeats.fit(train, val_series=val)\n", - " nbeats_pred = nbeats.predict(n=len(val))\n", - " # metric calls inside the run are logged automatically (keys: mape, rmse)\n", - " nbeats_mape = metrics.mape(val, nbeats_pred)\n", - " nbeats_rmse = metrics.rmse(val, nbeats_pred)\n", - " print(f\"NBEATS MAPE: {nbeats_mape:.2f}%\")\n", - " print(f\"NBEATS RMSE: {nbeats_rmse:.2f}\")\n", - "\n", - "autolog(disable=True)" - ], - "execution_count": 53, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "INFO: GPU available: True (mps), used: False\n", @@ -587,7 +572,6 @@ ] }, { - "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "33ff56f2bbbb46ddb71bf5ac409bc3c7", @@ -597,9 +581,12 @@ "text/plain": [ "Sanity Checking: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", ">\n", "![Mlflow Charts](./static/images/mlflow_charts.png)" - ], - "id": "6fcc8f13" + ] }, { "cell_type": "markdown", + "id": "3f0828c2", "metadata": {}, "source": [ "## Forecast Metrics\n", @@ -815,11 +846,12 @@ "The metric key is derived from the result: a scalar is logged under `{metric}` (e.g. calling `darts.metrics.mae(val, pred)` logs `mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`.\n", "\n", "Logged metric values are only meaningful to compare across runs when the evaluation settings match. Use the same evaluation time frame, forecast horizon, and evaluation start date for every `backtest()` / metric call you intend to compare against one another." - ], - "id": "3f0828c2" + ] }, { "cell_type": "code", + "execution_count": 13, + "id": "df8e85b6", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.372445Z", @@ -828,6 +860,20 @@ "shell.execute_reply": "2026-06-24T15:18:53.469722Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All logged metrics (5):\n", + " mae: 46.0220\n", + " manual_mape: 10.7420\n", + " mape: 10.7420\n", + " rmse: 51.1820\n", + " smape: 10.1015\n" + ] + } + ], "source": [ "# log_metrics=True (the default) patches every darts metric so that calls made\n", "# inside an active run are logged automatically\n", @@ -855,25 +901,11 @@ "print(f\"All logged metrics ({len(metric_names)}):\")\n", "for name in metric_names:\n", " print(f\" {name}: {run_metrics[name]:.4f}\")" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "stream", - "text": [ - "All logged metrics (5):\n", - " mae: 46.0220\n", - " manual_mape: 10.7420\n", - " mape: 10.7420\n", - " rmse: 51.1820\n", - " smape: 10.1015\n" - ] - } - ], - "id": "df8e85b6" + ] }, { "cell_type": "markdown", + "id": "b08e900a", "metadata": {}, "source": [ "### Metric Shape and Detailed Logging\n", @@ -885,7 +917,7 @@ "- **Per-component** (`component_reduction=None`) adds the component name, e.g. `mae_`.\n", "- **Quantile / interval** (`q`, `q_interval`) adds the quantile, e.g. `mql_q0.500`.\n", "- **Per-label classification** (`label_reduction=None`) adds the class, e.g. `f1_label1`.\n", - "- **Per-timestep** (`time_reduction=None`) is charted across MLflow steps.\n", + "- **Per-timestep** (`time_reduction=None`) is charted across MLflow steps. Calendar-relative steps are negative and end at `-1`, aligning different series lengths on their shared end.\n", "- **`series_reduction`**, when set on the metric call, aggregates across series inside the metric itself, so the mean-over-series logging described below does not apply.\n", "\n", "For `backtest()`, metric keys have a `backtest_` prefix. A time-dependent metric with `reduction=None` keeps its per-window values in the return value, but MLflow charts one value per horizon step: it applies `np.nanmean` over windows for each series, then aggregates across series. The detailed `metrics_per_series.json` table retains every source value with a `window_index`, including for a single-series backtest.\n", @@ -893,53 +925,16 @@ "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is appended to the same run-wide table artifact, `metrics_per_series.json`, which you can read back with `mlflow.load_table()`.\n", "\n", "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `foo_q0.500`)." - ], - "id": "b08e900a" + ] }, { "cell_type": "code", - "metadata": {}, - "source": [ - "# build a small multi-series example from the univariate AirPassengers data\n", - "series_list = [train, train * 1.2]\n", - "val_list = [val, val * 1.2]\n", - "\n", - "multi_model = LinearRegressionModel(lags=12)\n", - "multi_model.fit(series_list)\n", - "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", - "\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", - " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", - " # under a single key, charted across MLflow steps\n", - " single_pred = multi_preds[0] # train == series_list[0]\n", - " metrics.ae(val, single_pred)\n", - "\n", - " # multiple series: the logged value is the MEAN over series, and the full\n", - " # per-series breakdown is appended to the run's table artifact\n", - " per_series_mae = metrics.mae(val_list, multi_preds)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_id = run.info.run_id\n", - "\n", - "# aggregate metrics: mae is the mean over the two series\n", - "logged = client.get_run(run_id).data.metrics\n", - "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", - "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", - "\n", - "# load the per-series table artifact\n", - "per_series_df = mlflow.load_table(\n", - " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", - ")\n", - "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", - "per_series_df" - ], "execution_count": 14, + "id": "ecdbbf29", + "metadata": {}, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Aggregate metrics: {'ae': 44.196, 'mae': 51.316}\n", @@ -947,7 +942,6 @@ ] }, { - "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0305dca7a1b846f19da965d1b74319c5", @@ -957,9 +951,12 @@ "text/plain": [ "Downloading artifacts: 0%| | 0/1 [00:00\n", @@ -1018,23 +1014,65 @@ "0 mae 0 0 47.458874\n", "1 mae 1 0 55.172880" ] - } + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" } ], - "id": "ecdbbf29" + "source": [ + "# build a small multi-series example from the univariate AirPassengers data\n", + "series_list = [train, train * 1.2]\n", + "val_list = [val, val * 1.2]\n", + "\n", + "multi_model = LinearRegressionModel(lags=12)\n", + "multi_model.fit(series_list)\n", + "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", + "\n", + "autolog(log_metrics=True)\n", + "\n", + "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", + " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", + " # under a single key, charted across MLflow steps\n", + " single_pred = multi_preds[0] # train == series_list[0]\n", + " metrics.ae(val, single_pred)\n", + "\n", + " # multiple series: the logged value is the MEAN over series, and the full\n", + " # per-series breakdown is appended to the run's table artifact\n", + " per_series_mae = metrics.mae(val_list, multi_preds)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "client = mlflow.tracking.MlflowClient()\n", + "run_id = run.info.run_id\n", + "\n", + "# aggregate metrics: mae is the mean over the two series\n", + "logged = client.get_run(run_id).data.metrics\n", + "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", + "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", + "\n", + "# load the per-series table artifact\n", + "per_series_df = mlflow.load_table(\n", + " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", + ")\n", + "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", + "per_series_df" + ] }, { "cell_type": "markdown", + "id": "8511fc08", "metadata": {}, "source": [ "## Saving and Loading Models Locally\n", "\n", "You can also save and load models to/from local paths without MLflow runs." - ], - "id": "8511fc08" + ] }, { "cell_type": "code", + "execution_count": 15, + "id": "645ef079", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.471252Z", @@ -1043,24 +1081,16 @@ "shell.execute_reply": "2026-06-24T15:18:53.478330Z" } }, - "source": [ - "# Save model to local directory\n", - "local_model_path = os.path.join(tmpdir, \"my_model\")\n", - "save_model(model, path=local_model_path)\n", - "\n", - "print(\"\\nFiles in model directory:\")\n", - "for file in os.listdir(local_model_path):\n", - " print(f\" - {file}\")" - ], - "execution_count": 15, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "2026/07/23 18:50:10 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { + "name": "stdout", "output_type": "stream", "text": [ "\n", @@ -1073,10 +1103,20 @@ ] } ], - "id": "645ef079" + "source": [ + "# Save model to local directory\n", + "local_model_path = os.path.join(tmpdir, \"my_model\")\n", + "save_model(model, path=local_model_path)\n", + "\n", + "print(\"\\nFiles in model directory:\")\n", + "for file in os.listdir(local_model_path):\n", + " print(f\" - {file}\")" + ] }, { "cell_type": "code", + "execution_count": 16, + "id": "254ba153", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.479679Z", @@ -1085,18 +1125,9 @@ "shell.execute_reply": "2026-06-24T15:18:53.484638Z" } }, - "source": [ - "# Load model from local directory\n", - "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", - "\n", - "# Test it\n", - "local_predictions = local_loaded_model.predict(n=5)\n", - "print(\"Loaded model successfully!\")\n", - "print(f\"Predictions shape: {local_predictions.values().shape}\")" - ], - "execution_count": 16, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Loaded model successfully!\n", @@ -1104,20 +1135,30 @@ ] } ], - "id": "254ba153" + "source": [ + "# Load model from local directory\n", + "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", + "\n", + "# Test it\n", + "local_predictions = local_loaded_model.predict(n=5)\n", + "print(\"Loaded model successfully!\")\n", + "print(f\"Predictions shape: {local_predictions.values().shape}\")" + ] }, { "cell_type": "markdown", + "id": "aab0d1e0", "metadata": {}, "source": [ "## Querying Experiments\n", "\n", "You can programmatically query and compare runs." - ], - "id": "aab0d1e0" + ] }, { "cell_type": "code", + "execution_count": 17, + "id": "109a9812", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.485914Z", @@ -1126,30 +1167,9 @@ "shell.execute_reply": "2026-06-24T15:18:53.496048Z" } }, - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" - ], - "execution_count": 17, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Found 5 runs in experiment 'darts-quickstart':\n", @@ -1177,18 +1197,40 @@ ] } ], - "id": "109a9812" + "source": [ + "from mlflow.tracking import MlflowClient\n", + "\n", + "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", + "\n", + "# get all runs\n", + "client = MlflowClient()\n", + "runs = client.search_runs(\n", + " experiment_ids=[experiment.experiment_id],\n", + " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", + ")\n", + "\n", + "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", + "for i, run in enumerate(runs, 1):\n", + " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", + " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", + " print(f\"{i}. {run_name}\")\n", + " print(f\" Run ID: {run.info.run_id}\")\n", + " print(f\" Validation MAPE: {mape_val}\")\n", + " print()" + ] }, { "cell_type": "markdown", + "id": "22685423", "metadata": {}, "source": [ "### Load the Best Model" - ], - "id": "22685423" + ] }, { "cell_type": "code", + "execution_count": 18, + "id": "7b09db6a", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.497560Z", @@ -1197,6 +1239,26 @@ "shell.execute_reply": "2026-06-24T15:18:53.572133Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading best model from run: exponential-smoothing-baseline\n", + "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", "\n", @@ -1224,40 +1286,22 @@ " plt.legend()\n", " plt.title(\"Best Model Predictions\")\n", " plt.show()" - ], - "execution_count": 18, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Loading best model from run: exponential-smoothing-baseline\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] - }, - { - "output_type": "display_data", - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - } - } - ], - "id": "7b09db6a" + ] }, { "cell_type": "markdown", + "id": "6f1ec89e", "metadata": {}, "source": [ "## Model Registry\n", "\n", "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived)." - ], - "id": "6f1ec89e" + ] }, { "cell_type": "code", + "execution_count": 60, + "id": "7c854bc4", "metadata": { "execution": { "iopub.execute_input": "2026-07-22T08:27:04.144511Z", @@ -1266,23 +1310,16 @@ "shell.execute_reply": "2026-07-22T08:27:04.165897Z" } }, - "source": [ - "# register the best model (from the \"Load the Best Model\" section above)\n", - "result = mlflow.register_model(\n", - " model_uri=best_model_uri,\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")" - ], - "execution_count": 60, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "Registered version: 1\n" ] }, { + "name": "stdout", "output_type": "stream", "text": [ "Successfully registered model 'darts-air-passengers'.\n", @@ -1290,10 +1327,18 @@ ] } ], - "id": "7c854bc4" + "source": [ + "# register the best model (from the \"Load the Best Model\" section above)\n", + "result = mlflow.register_model(\n", + " model_uri=best_model_uri,\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")" + ] }, { "cell_type": "markdown", + "id": "da6cc83a", "metadata": {}, "source": [ "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", @@ -1301,11 +1346,11 @@ "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", ">\n", "![Mlflow Charts](./static/images/mlflow_models.png)" - ], - "id": "da6cc83a" + ] }, { "cell_type": "markdown", + "id": "7af49ea9", "metadata": {}, "source": [ "## Important Note: Custom Flavor\n", @@ -1329,19 +1374,20 @@ "- Darts-specific model parameters\n", "- Covariate handling (past, future, static)\n", "- PyTorch model state preservation" - ], - "id": "7af49ea9" + ] }, { "cell_type": "markdown", + "id": "40621b13", "metadata": {}, "source": [ "## Cleanup" - ], - "id": "40621b13" + ] }, { "cell_type": "code", + "execution_count": 19, + "id": "51fc7c4a", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.573724Z", @@ -1350,40 +1396,39 @@ "shell.execute_reply": "2026-06-24T15:18:53.574817Z" } }, - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ], - "execution_count": 19, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" ] } ], - "id": "51fc7c4a" + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ] }, { "cell_type": "markdown", + "id": "ca40afc1", "metadata": {}, "source": [ "# Final Remarks" - ], - "id": "ca40afc1" + ] }, { "cell_type": "markdown", + "id": "c4c86a23", "metadata": {}, "source": [ "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." - ], - "id": "c4c86a23" + ] } ], "metadata": { From f9eb3f8e6685a62470a960acf1309a319ad28ae3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 13:47:53 +0200 Subject: [PATCH 138/154] fix: use 0-based step for predictions --- darts/tests/optional_deps/test_mlflow.py | 17 +- darts/utils/mlflow.py | 4 +- examples/29-MLflow-quickstart.ipynb | 787 +++++++++++------------ 3 files changed, 381 insertions(+), 427 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 07c2e6d46e..38c6a7b736 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1070,15 +1070,14 @@ def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") assert len(history) == len(ref), "Expected one step per timestep" steps = sorted(m.step for m in history) - assert steps == list(range(-len(ref), 0)) + assert steps == list(range(len(ref))) logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, ref, atol=1e-5) - def test_autolog_metric_aligns_time_axis_by_end_date( + def test_autolog_metric_aligns_time_axis_by_forecast_position( self, mlflow_tracking, autolog_context ): - """A shorter series' time axis aligns from the end, not the start, so - its negative steps overlap the tail of a longer series.""" + """Each series starts at forecast position zero.""" ts_long = self.ts_univariate # length 50 ts_short = ts_long[10:] # length 40, same end, starts 10 steps later @@ -1094,17 +1093,17 @@ def test_autolog_metric_aligns_time_axis_by_end_date( history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") by_step = {m.step: m.value for m in history} assert len(by_step) == 50 - for step in range(-50, -40): - assert by_step[step] == pytest.approx(1.0, abs=1e-4), step - for step in range(-40, 0): + for step in range(40): assert by_step[step] == pytest.approx(1.5, abs=1e-4), step + for step in range(40, 50): + assert by_step[step] == pytest.approx(1.0, abs=1e-4), step rows = self._read_per_series_table(run.info.run_id) steps_by_series = {0: set(), 1: set()} for r in rows: steps_by_series[r["series_index"]].add(r["step"]) - assert steps_by_series[0] == set(range(-50, 0)) - assert steps_by_series[1] == set(range(-40, 0)) + assert steps_by_series[0] == set(range(50)) + assert steps_by_series[1] == set(range(40)) def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile with matching values.""" diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 23b314e269..4ce9e3d98d 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1577,8 +1577,8 @@ def _log_metric_result( for series_index, (t_size, canonical) in enumerate(series_shapes): for c, key in enumerate(keys): for t in range(t_size): - # Time axes are end-relative, with the latest value at step -1. - step = t - t_size if has_time_axis else 0 + # Forecast positions are zero-based: the first prediction is 0. + step = t if has_time_axis else 0 value = float(canonical[t, c]) agg.setdefault((key, step), []).append(value) rows.append({ diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index 33551375d6..fc12c4e824 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "aeddb542", "metadata": {}, "source": [ "# MLflow for Darts\n", @@ -13,11 +12,11 @@ "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", "\n", "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ] + ], + "id": "aeddb542" }, { "cell_type": "markdown", - "id": "f72894af", "metadata": {}, "source": [ "## Installing MLflow\n", @@ -27,20 +26,19 @@ "```bash\n", "pip install \"mlflow>=3.0\"\n", "```" - ] + ], + "id": "f72894af" }, { "cell_type": "markdown", - "id": "42e3dcea", "metadata": {}, "source": [ "## Setup and Imports" - ] + ], + "id": "42e3dcea" }, { "cell_type": "code", - "execution_count": 2, - "id": "b346ce8f", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:43.049165Z", @@ -49,7 +47,6 @@ "shell.execute_reply": "2026-06-24T15:18:43.053435Z" } }, - "outputs": [], "source": [ "# fix python path if working locally\n", "from utils import fix_pythonpath_if_working_locally\n", @@ -59,12 +56,13 @@ "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning)" - ] + ], + "execution_count": 2, + "outputs": [], + "id": "b346ce8f" }, { "cell_type": "code", - "execution_count": 3, - "id": "13b13fe4", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:43.054776Z", @@ -73,7 +71,6 @@ "shell.execute_reply": "2026-06-24T15:18:46.599208Z" } }, - "outputs": [], "source": [ "%matplotlib inline\n", "\n", @@ -88,12 +85,13 @@ "from darts.datasets import AirPassengersDataset\n", "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ] + ], + "execution_count": 3, + "outputs": [], + "id": "13b13fe4" }, { "cell_type": "code", - "execution_count": 4, - "id": "4d424e08", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:46.600906Z", @@ -102,28 +100,28 @@ "shell.execute_reply": "2026-06-24T15:18:46.634100Z" } }, - "outputs": [], "source": [ "# use darts plotting style\n", "from darts import set_option\n", "\n", "set_option(\"plotting.use_darts_style\", True)" - ] + ], + "execution_count": 4, + "outputs": [], + "id": "4d424e08" }, { "cell_type": "markdown", - "id": "2f9c40d6", "metadata": {}, "source": [ "## MLflow Setup\n", "\n", "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ] + ], + "id": "2f9c40d6" }, { "cell_type": "code", - "execution_count": 5, - "id": "88320df5", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:46.636640Z", @@ -132,9 +130,20 @@ "shell.execute_reply": "2026-06-24T15:18:47.268081Z" } }, + "source": [ + "# temporary directory for MLflow tracking\n", + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(\"darts-quickstart\")\n", + "\n", + "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" + ], + "execution_count": 5, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", @@ -143,7 +152,6 @@ ] }, { - "name": "stdout", "output_type": "stream", "text": [ "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", @@ -151,32 +159,20 @@ ] } ], - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ] + "id": "88320df5" }, { "cell_type": "markdown", - "id": "03d5209e", "metadata": {}, "source": [ "## Load Sample Data\n", "\n", "We'll use the classic AirPassengers dataset for this example." - ] + ], + "id": "03d5209e" }, { "cell_type": "code", - "execution_count": 6, - "id": "1596e07e", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.269628Z", @@ -185,9 +181,22 @@ "shell.execute_reply": "2026-06-24T15:18:47.356201Z" } }, + "source": [ + "series = AirPassengersDataset().load()\n", + "train, val = series.split_before(0.75)\n", + "\n", + "print(f\"Training series: {len(train)} points\")\n", + "print(f\"Validation series: {len(val)} points\")\n", + "\n", + "series.plot()\n", + "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", + "plt.legend()\n", + "plt.title(\"AirPassengers Dataset\")\n", + "plt.show()" + ], + "execution_count": 6, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Training series: 107 points\n", @@ -195,44 +204,29 @@ ] }, { + "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] - }, - "metadata": {}, - "output_type": "display_data" + } } ], - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ] + "id": "1596e07e" }, { "cell_type": "markdown", - "id": "34858645", "metadata": {}, "source": [ "## Basic Model Logging\n", "\n", "Let's train a simple model and log it to MLflow manually." - ] + ], + "id": "34858645" }, { "cell_type": "code", - "execution_count": 7, - "id": "bc8f520d", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.357581Z", @@ -241,26 +235,6 @@ "shell.execute_reply": "2026-06-24T15:18:47.449925Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "model = ExponentialSmoothing()\n", "model.fit(train)\n", @@ -280,11 +254,30 @@ "plt.legend()\n", "plt.title(\"Exponential Smoothing Forecast\")\n", "plt.show()" - ] + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Validation MAPE: 7.86%\n", + "Validation RMSE: 34.77\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + } + } + ], + "id": "bc8f520d" }, { "cell_type": "markdown", - "id": "35dc864c", "metadata": {}, "source": [ "Now let's log this model to MLflow.\n", @@ -293,12 +286,11 @@ "\n", "- **Run tags** (`mlflow.set_tags(...)`) – shown on the run page in the UI. This is also where `autolog()` writes its tags (`model_class`, …).\n", "- **LoggedModel tags** (`log_model(..., tags=...)`) – attached to the logged model entity itself (open the model from the run's **Outputs** / Models view)." - ] + ], + "id": "35dc864c" }, { "cell_type": "code", - "execution_count": 8, - "id": "61406cd9", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.451366Z", @@ -307,23 +299,6 @@ "shell.execute_reply": "2026-06-24T15:18:47.906380Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] - } - ], "source": [ "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", " model_info = log_model(\n", @@ -339,22 +314,37 @@ "\n", " print(f\"Run ID: {run.info.run_id}\")\n", " print(f\"Model URI: {model_info.model_uri}\")" - ] + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "output_type": "stream", + "text": [ + "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", + "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" + ] + } + ], + "id": "61406cd9" }, { "cell_type": "markdown", - "id": "0728690e", "metadata": {}, "source": [ "### Load the Model Back\n", "\n", "We can load the model from MLflow using its URI:" - ] + ], + "id": "0728690e" }, { "cell_type": "code", - "execution_count": 9, - "id": "cae35ffa", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.907880Z", @@ -363,15 +353,6 @@ "shell.execute_reply": "2026-06-24T15:18:47.914326Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded model predictions match: True\n" - ] - } - ], "source": [ "loaded_model = load_model(model_info.model_uri)\n", "\n", @@ -380,11 +361,20 @@ "# verify predictions match\n", "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", "print(f\"Loaded model predictions match: {predictions_match}\")" - ] + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Loaded model predictions match: True\n" + ] + } + ], + "id": "cae35ffa" }, { "cell_type": "markdown", - "id": "6bd4597c", "metadata": {}, "source": [ "## Automatic Logging with `autolog()`\n", @@ -396,12 +386,11 @@ "- **`backtest()`** – evaluation metrics under `backtest_*` keys.\n", "- **`historical_forecasts()`** – patched so its internal per-window `fit()` calls don't each spawn their own logging.\n", "- **PyTorch-based models** – per-epoch `train_loss` / `val_loss` via MLflow's PyTorch autologging (see the section below for details)." - ] + ], + "id": "6bd4597c" }, { "cell_type": "code", - "execution_count": 10, - "id": "5ef7f73a", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:47.915629Z", @@ -410,25 +399,6 @@ "shell.execute_reply": "2026-06-24T15:18:50.019951Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "autolog()\n", "\n", @@ -458,11 +428,29 @@ "ax.legend()\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + } + } + ], + "id": "5ef7f73a" }, { "cell_type": "markdown", - "id": "f484330f", "metadata": {}, "source": [ "## Open the MLflow UI\n", @@ -474,12 +462,11 @@ "- **Inspect** individual run parameters, metrics, and logged artifacts\n", "- **Visualize** metrics across runs with built-in charts\n", "- **Register** models to the Model Registry for versioning" - ] + ], + "id": "f484330f" }, { "cell_type": "code", - "execution_count": 11, - "id": "1a01cd2f", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:50.021527Z", @@ -488,9 +475,14 @@ "shell.execute_reply": "2026-06-24T15:18:50.022824Z" } }, + "source": [ + "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", + "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", + "print(\"Then open: http://localhost:5000\")" + ], + "execution_count": 11, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Launch the MLflow UI with this command in your terminal:\n", @@ -501,25 +493,20 @@ ] } ], - "source": [ - "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", - "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", - "print(\"Then open: http://localhost:5000\")" - ] + "id": "1a01cd2f" }, { "cell_type": "markdown", - "id": "88b0d285", "metadata": {}, "source": [ "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", ">\n", "![Mlflow Overview](./static/images/mlflow_overview.png)" - ] + ], + "id": "88b0d285" }, { "cell_type": "markdown", - "id": "e2b133bc", "metadata": {}, "source": [ "## Per-epoch Metrics with Torch Models\n", @@ -527,12 +514,11 @@ "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", "\n", "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." - ] + ], + "id": "e2b133bc" }, { "cell_type": "code", - "execution_count": 53, - "id": "d01783d1", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:50.024161Z", @@ -541,9 +527,38 @@ "shell.execute_reply": "2026-06-24T15:18:53.370531Z" } }, + "source": [ + "from torchmetrics import MeanAbsoluteError, MeanSquaredError, MetricCollection\n", + "\n", + "# per-epoch train_loss / val_loss are logged via MLflow's PyTorch autologging\n", + "autolog()\n", + "\n", + "with mlflow.start_run(run_name=\"nbeats-epoch-metrics\"):\n", + " nbeats = NBEATSModel(\n", + " input_chunk_length=24,\n", + " output_chunk_length=12,\n", + " n_epochs=10,\n", + " pl_trainer_kwargs={\"accelerator\": \"cpu\"},\n", + " # these are logged per epoch as train_MAE, val_MAE, train_MSE, val_MSE\n", + " torch_metrics=MetricCollection({\n", + " \"MAE\": MeanAbsoluteError(),\n", + " \"MSE\": MeanSquaredError(),\n", + " }),\n", + " random_state=42,\n", + " )\n", + " nbeats.fit(train, val_series=val)\n", + " nbeats_pred = nbeats.predict(n=len(val))\n", + " # metric calls inside the run are logged automatically (keys: mape, rmse)\n", + " nbeats_mape = metrics.mape(val, nbeats_pred)\n", + " nbeats_rmse = metrics.rmse(val, nbeats_pred)\n", + " print(f\"NBEATS MAPE: {nbeats_mape:.2f}%\")\n", + " print(f\"NBEATS RMSE: {nbeats_rmse:.2f}\")\n", + "\n", + "autolog(disable=True)" + ], + "execution_count": 53, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "INFO: GPU available: True (mps), used: False\n", @@ -572,6 +587,7 @@ ] }, { + "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "33ff56f2bbbb46ddb71bf5ac409bc3c7", @@ -581,12 +597,9 @@ "text/plain": [ "Sanity Checking: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", ">\n", "![Mlflow Charts](./static/images/mlflow_charts.png)" - ] + ], + "id": "6fcc8f13" }, { "cell_type": "markdown", - "id": "3f0828c2", "metadata": {}, "source": [ "## Forecast Metrics\n", @@ -846,12 +815,11 @@ "The metric key is derived from the result: a scalar is logged under `{metric}` (e.g. calling `darts.metrics.mae(val, pred)` logs `mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`.\n", "\n", "Logged metric values are only meaningful to compare across runs when the evaluation settings match. Use the same evaluation time frame, forecast horizon, and evaluation start date for every `backtest()` / metric call you intend to compare against one another." - ] + ], + "id": "3f0828c2" }, { "cell_type": "code", - "execution_count": 13, - "id": "df8e85b6", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.372445Z", @@ -860,20 +828,6 @@ "shell.execute_reply": "2026-06-24T15:18:53.469722Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All logged metrics (5):\n", - " mae: 46.0220\n", - " manual_mape: 10.7420\n", - " mape: 10.7420\n", - " rmse: 51.1820\n", - " smape: 10.1015\n" - ] - } - ], "source": [ "# log_metrics=True (the default) patches every darts metric so that calls made\n", "# inside an active run are logged automatically\n", @@ -901,11 +855,25 @@ "print(f\"All logged metrics ({len(metric_names)}):\")\n", "for name in metric_names:\n", " print(f\" {name}: {run_metrics[name]:.4f}\")" - ] + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "All logged metrics (5):\n", + " mae: 46.0220\n", + " manual_mape: 10.7420\n", + " mape: 10.7420\n", + " rmse: 51.1820\n", + " smape: 10.1015\n" + ] + } + ], + "id": "df8e85b6" }, { "cell_type": "markdown", - "id": "b08e900a", "metadata": {}, "source": [ "### Metric Shape and Detailed Logging\n", @@ -917,7 +885,7 @@ "- **Per-component** (`component_reduction=None`) adds the component name, e.g. `mae_`.\n", "- **Quantile / interval** (`q`, `q_interval`) adds the quantile, e.g. `mql_q0.500`.\n", "- **Per-label classification** (`label_reduction=None`) adds the class, e.g. `f1_label1`.\n", - "- **Per-timestep** (`time_reduction=None`) is charted across MLflow steps. Calendar-relative steps are negative and end at `-1`, aligning different series lengths on their shared end.\n", + "- **Per-timestep forecast metrics** (`time_reduction=None`) use zero-based steps, so the first predicted value is `0`. Backtest calendar-relative steps are negative and end at `-1`, aligning different series lengths on their shared end.\n", "- **`series_reduction`**, when set on the metric call, aggregates across series inside the metric itself, so the mean-over-series logging described below does not apply.\n", "\n", "For `backtest()`, metric keys have a `backtest_` prefix. A time-dependent metric with `reduction=None` keeps its per-window values in the return value, but MLflow charts one value per horizon step: it applies `np.nanmean` over windows for each series, then aggregates across series. The detailed `metrics_per_series.json` table retains every source value with a `window_index`, including for a single-series backtest.\n", @@ -925,16 +893,53 @@ "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is appended to the same run-wide table artifact, `metrics_per_series.json`, which you can read back with `mlflow.load_table()`.\n", "\n", "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `foo_q0.500`)." - ] + ], + "id": "b08e900a" }, { "cell_type": "code", - "execution_count": 14, - "id": "ecdbbf29", "metadata": {}, + "source": [ + "# build a small multi-series example from the univariate AirPassengers data\n", + "series_list = [train, train * 1.2]\n", + "val_list = [val, val * 1.2]\n", + "\n", + "multi_model = LinearRegressionModel(lags=12)\n", + "multi_model.fit(series_list)\n", + "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", + "\n", + "autolog(log_metrics=True)\n", + "\n", + "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", + " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", + " # under a single key, charted across MLflow steps\n", + " single_pred = multi_preds[0] # train == series_list[0]\n", + " metrics.ae(val, single_pred)\n", + "\n", + " # multiple series: the logged value is the MEAN over series, and the full\n", + " # per-series breakdown is appended to the run's table artifact\n", + " per_series_mae = metrics.mae(val_list, multi_preds)\n", + "\n", + "autolog(disable=True)\n", + "\n", + "client = mlflow.tracking.MlflowClient()\n", + "run_id = run.info.run_id\n", + "\n", + "# aggregate metrics: mae is the mean over the two series\n", + "logged = client.get_run(run_id).data.metrics\n", + "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", + "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", + "\n", + "# load the per-series table artifact\n", + "per_series_df = mlflow.load_table(\n", + " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", + ")\n", + "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", + "per_series_df" + ], + "execution_count": 14, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Aggregate metrics: {'ae': 44.196, 'mae': 51.316}\n", @@ -942,6 +947,7 @@ ] }, { + "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0305dca7a1b846f19da965d1b74319c5", @@ -951,12 +957,9 @@ "text/plain": [ "Downloading artifacts: 0%| | 0/1 [00:00\n", @@ -1014,65 +1018,23 @@ "0 mae 0 0 47.458874\n", "1 mae 1 0 55.172880" ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" + } } ], - "source": [ - "# build a small multi-series example from the univariate AirPassengers data\n", - "series_list = [train, train * 1.2]\n", - "val_list = [val, val * 1.2]\n", - "\n", - "multi_model = LinearRegressionModel(lags=12)\n", - "multi_model.fit(series_list)\n", - "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", - "\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", - " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", - " # under a single key, charted across MLflow steps\n", - " single_pred = multi_preds[0] # train == series_list[0]\n", - " metrics.ae(val, single_pred)\n", - "\n", - " # multiple series: the logged value is the MEAN over series, and the full\n", - " # per-series breakdown is appended to the run's table artifact\n", - " per_series_mae = metrics.mae(val_list, multi_preds)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_id = run.info.run_id\n", - "\n", - "# aggregate metrics: mae is the mean over the two series\n", - "logged = client.get_run(run_id).data.metrics\n", - "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", - "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", - "\n", - "# load the per-series table artifact\n", - "per_series_df = mlflow.load_table(\n", - " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", - ")\n", - "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", - "per_series_df" - ] + "id": "ecdbbf29" }, { "cell_type": "markdown", - "id": "8511fc08", "metadata": {}, "source": [ "## Saving and Loading Models Locally\n", "\n", "You can also save and load models to/from local paths without MLflow runs." - ] + ], + "id": "8511fc08" }, { "cell_type": "code", - "execution_count": 15, - "id": "645ef079", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.471252Z", @@ -1081,16 +1043,24 @@ "shell.execute_reply": "2026-06-24T15:18:53.478330Z" } }, + "source": [ + "# Save model to local directory\n", + "local_model_path = os.path.join(tmpdir, \"my_model\")\n", + "save_model(model, path=local_model_path)\n", + "\n", + "print(\"\\nFiles in model directory:\")\n", + "for file in os.listdir(local_model_path):\n", + " print(f\" - {file}\")" + ], + "execution_count": 15, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "2026/07/23 18:50:10 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { - "name": "stdout", "output_type": "stream", "text": [ "\n", @@ -1103,20 +1073,10 @@ ] } ], - "source": [ - "# Save model to local directory\n", - "local_model_path = os.path.join(tmpdir, \"my_model\")\n", - "save_model(model, path=local_model_path)\n", - "\n", - "print(\"\\nFiles in model directory:\")\n", - "for file in os.listdir(local_model_path):\n", - " print(f\" - {file}\")" - ] + "id": "645ef079" }, { "cell_type": "code", - "execution_count": 16, - "id": "254ba153", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.479679Z", @@ -1125,9 +1085,18 @@ "shell.execute_reply": "2026-06-24T15:18:53.484638Z" } }, + "source": [ + "# Load model from local directory\n", + "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", + "\n", + "# Test it\n", + "local_predictions = local_loaded_model.predict(n=5)\n", + "print(\"Loaded model successfully!\")\n", + "print(f\"Predictions shape: {local_predictions.values().shape}\")" + ], + "execution_count": 16, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Loaded model successfully!\n", @@ -1135,30 +1104,20 @@ ] } ], - "source": [ - "# Load model from local directory\n", - "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", - "\n", - "# Test it\n", - "local_predictions = local_loaded_model.predict(n=5)\n", - "print(\"Loaded model successfully!\")\n", - "print(f\"Predictions shape: {local_predictions.values().shape}\")" - ] + "id": "254ba153" }, { "cell_type": "markdown", - "id": "aab0d1e0", "metadata": {}, "source": [ "## Querying Experiments\n", "\n", "You can programmatically query and compare runs." - ] + ], + "id": "aab0d1e0" }, { "cell_type": "code", - "execution_count": 17, - "id": "109a9812", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.485914Z", @@ -1167,9 +1126,30 @@ "shell.execute_reply": "2026-06-24T15:18:53.496048Z" } }, + "source": [ + "from mlflow.tracking import MlflowClient\n", + "\n", + "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", + "\n", + "# get all runs\n", + "client = MlflowClient()\n", + "runs = client.search_runs(\n", + " experiment_ids=[experiment.experiment_id],\n", + " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", + ")\n", + "\n", + "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", + "for i, run in enumerate(runs, 1):\n", + " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", + " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", + " print(f\"{i}. {run_name}\")\n", + " print(f\" Run ID: {run.info.run_id}\")\n", + " print(f\" Validation MAPE: {mape_val}\")\n", + " print()" + ], + "execution_count": 17, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Found 5 runs in experiment 'darts-quickstart':\n", @@ -1197,40 +1177,18 @@ ] } ], - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" - ] + "id": "109a9812" }, { "cell_type": "markdown", - "id": "22685423", "metadata": {}, "source": [ "### Load the Best Model" - ] + ], + "id": "22685423" }, { "cell_type": "code", - "execution_count": 18, - "id": "7b09db6a", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.497560Z", @@ -1239,26 +1197,6 @@ "shell.execute_reply": "2026-06-24T15:18:53.572133Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading best model from run: exponential-smoothing-baseline\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", "\n", @@ -1286,22 +1224,40 @@ " plt.legend()\n", " plt.title(\"Best Model Predictions\")\n", " plt.show()" - ] + ], + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Loading best model from run: exponential-smoothing-baseline\n", + "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHECAYAAADmnVpRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoK1JREFUeJztnQd4U2UXx0+6001bSmmBsvcWZIkoiKLi+FRw4MC99544PgXX50IUEffeuFFQFAeisvcus3Tv3eZ7/u/te3OTJm2SZtybnt/z5OlNbpLee3OT93/P+Z/zmiwWi4UYhmEYhmECTEigN4BhGIZhGAawKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYxiOWL19OP/30k0ev/eGHH2jFihW6P/J79uyhTz75hMrLy9XHNm3aJB7zZt9JX7wnwxgRE3d0ZRhbfv75Z8rPz1fvh4WFUXp6OvXv359iY2N9eri+++47SkpKolGjRrm1rcnJyXTsscc2WY9B7vPPP6eGhgbq06cPDRo0yGvbetxxx1FRURH9888/br+2b9++NHDgQDEQu/NZREVFUY8ePahfv37kD1599VW6/PLLafv27dSzZ0/x2IMPPkgPPfQQ1dbWinPDVTZs2EBbtmyhs846q8k6T9+TYYINPvsZxo67776b1q1bRyeddJK4j4ECV7K5ubl077330u233+6zY3b11VfT6NGj6YMPPnB5W//66y8xWGdnZ1NCQoLN+l9++YXOPPNMsXzrrbfSU089RUb+LPLy8ujPP/8UAvH9998X4sbf4H/jmIaEuBdofuedd+jxxx93GA3x9D0ZJthgUcIwDkC0QnsVj4HkuuuuozvuuINGjhxJxxxzjG6OW1paGhUWFgohc+WVV9qse/3116lr164iDREsnwUiDogknXHGGUIs+pvp06eLm97fk2GMCMtyhnEBk8lE5557rlh2lq44cOCASL/ghqiFIw4ePCh8GEuXLqVDhw7ZrMPAW1FRQfv37xfLuC1ZsqTFbUN05NRTT6U33njD5vHS0lL69NNP6aKLLmr29RjYv/rqK5EqwWscUV9fLyIU3377rdN9c/dYeArSPqeddhpt3rxZpFUgyHCs8D8BIitffPGFTdoHx/XXX3+lL7/8ktavX+/0vXfs2EFff/01rV271iP/R2VlJf3+++/0zTffiPeSIJq1detWsSw/W9zk8W7uPRGhgwcHxz4rK6vJemwrUnSgqqpKnFs//vij088SxwJ+HmwjjiFSewyjG+ApYRjGyqhRoywZGRlNDsnChQsxYlg+/fRTm8eLioos06ZNs0RGRlrGjh1rOeqooyxRUVGWW2+91dLQ0CCeg7+XX365ePzoo4+2nHDCCZbOnTtbZsyYYamurhbPOfPMMy3R0dGWTp06iWXcbrvttha3tU+fPpZvvvlGbNuWLVvUda+++qolIiLCsnXrVrEO26MlKyvLMmbMGEtsbKxl4sSJlr59+4rl559/3uZ527dvF+sSExMtxx13nFieP3++ZdKkSZYjjjjC7WMBsM3YP08/iyuuuELs0+rVqy1///23WH7jjTcsp5xyimX06NGWHj16WJYvXy6e++yzz1ri4uLEduO4p6SkiP3ev3+/+n61tbWWmTNnWkJDQ8X/xO2MM86wzJ07V7w3joFk1qxZ4jG8RsszzzxjSUhIsHTr1k38n169eom/+fn5Yh32Ga+Tny1uBw4ccPqedXV1lptvvtkSHh5uGT58uDiW+DzPOussS0lJifq8G2+8URxvHIshQ4ZYJk+eLM6hpKQky59//mmzjZ988ol4vH///papU6daBg4caBk2bJhlzZo1LX4WDOMPWJQwjB0YkPDD/fHHH4vbe++9Z7n//vst7dq1s5x77rlisNCCgTo1NdWyceNG9bHff/9dDCYYjMCiRYvEoCMHSoBBGu+tHWAyMzMtZ599tsufiRQl2KaOHTta7rrrLnXduHHjxACWm5vbRJTU19dbBg8eLP7fnj171Mexn3juZ599Ju7jfTGAYUDPzs5WX3vVVVeJ19qLEleORWtFCUQcBvyYmBhLRUWFKkoGDBhg+e2338RzKisrLfv27RPCDOsgLiQFBQViu/HeEoiCkJAQy3fffac+huXevXu7JEpefvll8diTTz5ps62LFy+27N27Vyzfeeed4jmOcPSejzzyiHjsgw8+UB/766+/xH5Pnz7dRpTg+F544YWW4uJi8VhZWZkQHCNHjlSfh88S4uzaa6+1+d8bNmxQjxvDBBoWJQxjBwYrs9msXs3+5z//EVequPp84YUXbJ6LH3MMHC+++GKT43jBBReIgRvMmzdPPA9Ri+bwVJSA22+/XQzgEA3btm0T/w8RFEeiBIMlHluwYIHN+2FQ7NKlixA02ue9//77Ns/DwI5jpBUlrh4Ld0WJViBi8EcEBgIC0RogRQkiHfYgGjV+/Pgmj8vI0ooVK8TxSk5Otpx22mlNnnf66ae3KEogLtPT09Vj5gx3RAneE9uEaJQ9iJ6YTCYR6ZKiBK+F+NMCgYTH8/Ly1M8M9x966KFmt5NhAgkbXRnGBXMlwP1p06aJnDwMrwA+C5nLh4+hUeirPgx4AJDbP/nkk6ldu3aisubss88W5bu4tW/f3mvH/+KLL6Ynn3xS+AlQddOxY0c64YQThOfCntWrV4u/9qXHKEc94ogj6Pvvvxf3V61aJf6OGDHC5nnYl169etk85uqxiIuLc2u/4NOQ1UioMpo4cSK9/PLLTcqbYUDWAm/Ovn37xP7I7QH4e/jwYdV/0qFDB+E/sd9HcOSRR4rXNgf+D7xCF154IXmLvXv3im1yVBqOcwj7sGbNGurSpYvqeRo+fLjN8+Q6HAOUjOMzw3mI0uOVK1fSiSeeKAzbAwYM8Np2M0xrYVHCMC6C/hLdu3enF198URUlGDABzIV//PFHk9egzBMDMgYImBkXLlwonvvWW2+J155zzjn02muvicG2taB3BwZRvB/MlhdccAGFhoY6fG5NTY34GxMT02QdHpPr5d/o6Ogmz8NjKJeWuHosvCEQHWEv8OT27Ny5U5TjOtoe9J9paR9bAiLM2bH0lJY+H1BdXa0+FhER0eQcwmPa7QOLFi2i9957T5h5Z8+eLSrKIEpwfIYOHeq17WcYT2FRwjBugOZp27ZtU++jkZfsAYIr+JZKd9HnBDcMOvPmzaObb75ZXA3feOON6hVva5g5cyZdc8016rIzUCYMUL0CoaUFj8n13bp1Uwd2DOASXKnv2rWLOnfu7NGx8AX2x65Tp04UGRkpIguvvPKK09ch8oUIEfbRHm0FjTNwDPB/UMnizvY1R0ZGhtgmfBb2yMfkZ+MOEKkQq7iBv//+m6ZOnSr648hIF8MEEi4JZhgXQRgcZZ3aMDlKcVNTU0VTLEellQjDyxC/dj2uYmW4PycnR30cYfbi4mKPPxOULSOic8MNNzTb9RRhfFxxv/DCCzZlqBiYUL6KCA5A0zJECyCgtHz00UdUUlJi85irx8JfmM1mmjFjhkj9QEDZg+OOaAP2D8cDzdi0qS4sf/bZZy3+H0QozjvvPBHNsRcmEDyyNBefLXDl88U2QSx8/PHHNqXjiHogdYXUmX26piWwHejAa5/yGjJkiM05yDCBhCMlDOMAhP5lygADLPwQL730EsXHx9Pzzz9vEzlBj4jTTz9dDBLnn3++8Cjg+egtgSgE+ocgbD537lzR8Kt3795icHnzzTdFyuGSSy5R3+/444+nZ599lp555hlxBZ6YmCjaubsKno+BzJWUCFJJuGLGgIztgi/i6aefpqOOOkpEc+RAinQVthHRHTwX0QOIs3HjxtkMcq4eC3+CYwlBAl8JGsuhcyrEBrwy6FsCbw2iHHge9mfMmDEi0gShhuOIaNNjjz3W4v/B54UW8oh6XXvttaLTLP7vhx9+KPqLwEeDzxEdW2+66Sbh9UEkBH+deWwgGCdMmCC2CWkWCBWk5iAg4Plxt/sr+p3AQ4L/iVQNzmWk2ZBusxedDBMoWJQwjB1IPSD0L82V+PFH6gU+Egzi9nn+sWPHipA6rrTRWA3mSYTW58yZI9YBDFRTpkwRAx2alOHqGlfxuEFISGbNmiXSJAirY8BAGqU5UYJt1U4W5wgMuvBPDB482OZxGG4xOMFPgG3CfkF4obOodv4VDMwYzN9++21atmyZ8K1gOxERsf/frhwLgIFRGjGbA/unbYLmTGBh//CZ2YMBH83qIAzQiA6DOQzAEH9I6eDYABxnNCHD/iNSBEGI44KUDgSYds4jRy3h0cAOExQisiKb40GYYFmmvXCsFy9eLJ6DG8Qujgm20dF7Yn+wTfAfwZgKPw6iYDA0Q+xJ8L4QlY5SQHhPGaGBKEQkB1Guf//9l8rKysRngGZy+P8Mowd4Qj6GYRiGYXQBe0oYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFbU6UoGHR7t27HbbBbqvwMeFjwucKf3/4N4V/Z/VAmxMlDMMwDMPoExYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlQcoXX3xBn332mc9fwzAMwzDeIsxr78S4zZw5c6iqqsrp+t69e9N5553n0ZGFwKirq6MzzjjD5dcsWrSI6uvr3XoNwzAMw3gLFiU6YcuWLfThhx/S7bffTtHR0a1+v9NPP93tmZBPO+20Vv9fhmEYhvEUFiUB5K677rKJbECU3HHHHZSSkiIe++ijj+jrr7+mXr160XfffUdms5muvPJKWrJkCf3222/iOe3ataMRI0bQuHHjmv1feC+InX79+tFPP/0kIjQnnngi9ezZs9Wv2bNnj9j+qKgomjBhAu3evZvKyspo+vTprTxCDMMwjDepqrbQS4uIMlKIpk80kd5gUaJjIArWrl1LISEhdNJJJ1GfPn2aPGf79u306KOP0owZM+iZZ55xmr7Be61bt47Cw8PphBNOEMLhzjvvpN9//52GDBniMH3T3GuGDRsmnrNixQqaNGkSjR8/nvr27UtPPvkkhYaG0uDBg1mUMAzD6Iw3vye6Za5FLLeLI5o8Ul/ChEWJzsnLy6MdO3ZQcnKy+thxxx0nbpKbb75ZCJbrrruOevTo4fS9EL1Amig+Pl7cnzJlCs2bN4/mz5/v9msWLFgg7t922230n//8h9555x1x/9ZbbxVeGIgShmEYRl9s2K0IEvDo2xYWJf4EaY3s7OwmjyMagKt5X5GWlkb//POPV94LUQitIJGsX79eRCxycnKEdwSpkw0bNjQrSiZOnKiKCzB06FD6999/m/3/zb2mvLxcbMPDDz+sru/cubONYGIYhmH0Q06hdfmXNUR/rLfQ2EH6iZYEdaQEguTAgQNkZKS/RAtEwP/+9z869dRTqVOnThQRESFSPIWFmrPNAbGxsTb3w8LCqLa21uPXHDp0SPzt0KFDE1HW0rYwDMMw/ienyPb+7Hct9NUcFiV+AYOjI/wRKfEV2PbZs2cLv8cpp5wiHoN35LHHHiN/07FjR/H38OHDNGDAABsxGBkZ6fftYRiGYZrncIHt/a//IFq300KDe+hDmAR1pMRRCgWpjqysLMrMzBTRBaOBKEVNTY1I10gWLlzYYsTDF8TExIiqnzfeeEOkeQAiU0uXLhXGXIZhGEbfkRIw510LvfcAixLGAyBGLrzwQnFDY7WDBw/SsmXLmqRZ/MVTTz0lfC8w5MLg+tVXX1FGRoYhBR/DMEwwU1dnofxiZXlQd6LsAqLcIqIPfyJ65FIL9cgIvDAJ6kiJkUA57axZs2wap6HPh6NGaq+99hp9+eWXtGnTJurfvz+9+OKLIloBE6qz5mmO3gvRDW3PEfvmaa68ZvTo0bRx40b6/PPPhWBCH5UHHnhA9E9hGIZh9EOuJkrSNY3o7Ikmuu9VC2GoePJ9C718W+BFiclisVjrg9oARk/f6O2YwD8C4SIrdHAfAuu5556jiy66iIwKnyd8XPhc4e9PsP2mrN1hoaGXKEP+ZVOJnrzaRF2mWai0giginGj3hyZKTwmsMOFRmWkVKAseM2YMXXXVVXTttdeKpmqInng6Zw/DMAzj+3Lg1HZEiXEmuuZ05X5NLdEzHwU+RsGihGkV6IsCY+uoUaNEWuett96i77//XnSBZRiGYfTDYa0oSVQiIjdNM1FkhPLYy4uICkoCK0zYU8J4pQT64osv5iPJMAxjkEhJhyTlb1qyiS49yULzviAqqySa+xnRAzMDtokcKWEYhmGYtkBOoTUKkppoffz2c00kW3e98KmF6ustxknf/Pjjj3TuuefS5MmTxeRr6JkhqayspAcffFCUiKKSAxUiWlpazzAMwzCMH9I3mgLJrh1NNGm4spxXTJRfQsZI3/zxxx+iL8X9999PAwcOFF4CNCgbO3asWP/ss8/Svn376O233xbT2WNG2a5du6qTs7W0nmEYhmEY/xhdtaRrZjSBMLFfr0tR8vLLL9M111xDRx11lLh/5plnquvQ6vy7774Tc7Kkp6eLGyZmQzMtiI6W1jMMwzAM4/turqhITrbOsyrQ3s9z0PVVd+kbpGkwhT2mssecKyeffLIQGDJ9g8nZKioqRI8KSZ8+fWjHjh0urWcYhmEYxvfz3qQkEIWG2vYjSUkw2URKAoXLkZKcnBzR/AUpm5deeknMtYL0C9qbX3HFFaJfhZwPRRIXF6c+3tJ6R0DwaD0rYoPDwsSsuJ4iu5xqu522dVo6JuvWraPU1FSfTjSoN/g84ePC5wp/f4LpN8VisaZvYHK1344kTaQktxhdXr1vdnWlaZzLokTO+oo5Vzp16iSWYXhFe3GIErPZLB5DNEQKDwgO2aa8pfWOeP3112nBggU2j02bNk20P28t8LboDQz+ODbo/eEumzdvppSUFGrfvr3Xj8nZZ58tjvkll1xCbQ09nid6gI8LHxM+T4z13SmtNFF1bRexHG+upKysHJv1lhqM0alieceeQsrK8r7btVu3bt4TJRjwEhISbJQOlmWXekzCBuGyfft2dQ4WLMuNaGm9I9D7YsaMGV6PlOCk6Ny5s67azG/YsEHMV4M5Y/bv328zC7ArnHjiiaKjKm7ePiZohJaUlCTaI7cV9HqeBBo+LnxM+Dwx5ndn+37rcpeO5ia/5/00KZv6kHaUmRkYp6vLosRkMgkfybvvvqsaVz/66CMaP3688kZhYaJMGJGN2bNnix7/P/zwAz399NMurXcExEdrBEhz4KTQ02CDqBCOD6IlX3zxhdM27fDmYEZe+HHkscHEfFVVVeKYrly5UjyGVu9///236LKqnRwP4gcCA0ZjGWEpLCykw4cPC4GJaihHxwWfv56Ol7/Q23miF/i48DHh88RY3528YgQQlCBCh3ZNUyntE63rMZNwoH733PqvqLzp0KGDECdIowwYMMCmk+ett94qoiEYXG+88UaR1hkxYoTL69sq8M2gTBrHd+bMmfTqq682ec7BgwfVGXrPOecc6tKlixAvAJPfQVR8+umndNNNN4lbfX09HXvssfTLL7/YvA/eH63gJfAH3XLLLfTQQw+JqiqInVWrVvlhrxmGYZjAdHM1NVmfommmZgijK0BK4eGHHxYDGK6c7YFxFRU5CFM5UlktrW+rwJeDqMfUqVNp0KBBoindzp07VW8JIhhI7cBUfODAAUpMTBTRDdl8bv78+UJ8XHfddeLmDs8//7w6eyXCivfdd58QmmvXrvXJvjIMwzCBnveGmtAuFhFxxRBrGFEicSRItLQkOPwlSEZc3kDZjSVQKhai+voMpaWuyTcu6LQkon8WuL6PCxcuFEIAKS4IEUREXnvtNXr00UfFejSoQyoGqR0IEoCUzEUXXeSV7a2urqZdu3ZRdnY2jRw5kh5//HEherRpH4ZhGCZIGqdF1FJDTRiFRFjHqbAwE7WLs1BBiYE6uhoNCJIDufrebUQoUGYNUbJixQrVDwJRgqhUaGioMATjb//+/b3+/+fNm0f33HOPiMJ07NhRLRODd4VFCcMwTHDNe9OnoohCL/qXlphDqM99vajLRZ3J1NizBP1LIEoMFykxCohYNEFESuooNDSMyOTH/+sEiA+U8cIXoqW0tFR0wEVKB2XT8Ihg7iCIB3ciWrI6SoL+MlpBhHTPt99+K7wkcGNDAKHBHfdxYRiGCb70zcSiQ0Q1DVRX00Abb99M+987QAOf6k8JQxPUrq7FZUS1dRYKD/PRINlWRYmjFIrinzggBuBA+1qwLai6eeyxx5r0ALn++uuF4RWiZMyYMaIsF8bW888/X30OKm5k6TD6wGgFB4ApGeXFEqRktB10d+/eLYQL0kXwqoDvv//eZ/vLMAzDBDZ906Oq1Obx4tUl9PvkFZR5SRdKj+qOJhBqBU5asv+3M6hFid5ZvHixEANo228PjK1TpkwRPg90UoUBFdU5uI8+Lyj9xaSGr7zying+JkiEaBk+fLiocEIKCO8B0yx6xEDUYBkRF8mQIUNE7xn0NjnmmGPok08+EQKJYRiGCT5REmJpoO7ViiiJSI2giKQIKttSRtRAlPXqXjovOpv2pfSnlXHtRQonEKKES2ACCMyrMKs66sI6YcIEUaK7fPlycf+BBx6gN954g/7880+aM2eOSOU888wz6vPxWL9+/WjWrFlqSTCMspdffrko+/3ggw+EsEEXXogUAM8I/CxIFSF9tHHjRlq0aBGNGjXKptMuxAv8JgzDMIxx0zedqisostE3mDSmHR21bAz1mdWbQqNR+UEUVVFDd+5bR2ENDQEzu5os9qaDIEeWv+ohfaMX+JjwMeFzhb8//JsSvL+zNbUWipxkoWOLDtFtBzaIx/rc34t63IR0DVHl/kr69/zVVLJeiaJc2msczZ0TQ2ce439PCY/KDMMwDBPE5DVW0/SosoY/4odYZ+AzdzJT8gRrrqZ9bVXAKnBYlDAMwzBMEHO4sV9Xj0qryTV+kGZaYAiTDOt8ayxKGIZhGIbxCTlFwquhVt5EpUdRZIrtvHJRTURJYJwdHClhGIZhmCCvvEmrqaSYhjpxP35wXJPnIIUjSeX0DcMwDMMwvkrfaPuTJGj8JBJzJ9tICfqUBAKOlDAMwzBMEJNTZLE1uQ5uKkrCk8IpxKxIAvaUMAzDMAzjs/RNcyZXgO7e5gyzVZQUsaeEYRiGYRgvc7jAQj0bIyVhSeEUlR7p8HkyhWNuqKfKAsV/4m84fcMwDMMwQUzVwWpKqFfmRkscEi+iIo6I0vhKoourRNM1f8OihPE7Dz30EJ111lluveaOO+6gGTNm+GybGIZhgpXoAyXNmlwdmV1T6gJjdmVREmAwP01iYqJ6Qwvik08+mVasWOHV/3PLLbeIeXaaA5PxYRvOOOOMJuswYzHWjR07ttXbgnl7ysrK3HpNRUUFlZeXu3wc5e2zzz4jo4OZpDHRIsMwjLtgJpnkXI2fpDlR0ugpAe1rAtPVlWcJDjAYoJOSkmjVqlXifkFBgRAHkydPpl27djmcrM8TWhrU5bZghuFvvvmG9u/fT506dVLXvfzyyxQTE0MlJQGapcnN4yjBNhud6upq3R53hmH0TXEZUbeKkmZNro4aqAWqVwlHSnQAJmeSV/bdu3enu+66S0QSNmxQJk6SfPHFFzRu3DhKS0ujkSNH0iuvvCJUsGT9+vU0depU6ty5Mw0dOpSeeOIJdbZgXG1/+eWX6v/55ZdfHG4LRNAJJ5wgZiSWrF27lrZt2+YwgjJv3jwaPHgwdejQQcxq/MMPPzR5zuzZs6lHjx7Uu3dvuvLKK8WsxPa0tG/uHkd5Cw8PF+t2795N06ZNo/T0dOrWrRvdcMMNNtGavXv3iue///77Yj+wHRBncjbnk046ScyUPGjQILr//vuFUNCC5+DY4/0R1XjzzTfVdYsXL1a3B+snTpxIy5Yts3l9dnY2XXjhhWLb+vTpI2Z6xnHCZ4YoF7ZfvsfcuXPdOi4Mw7Ttbq49GitvaiLCKLqrNRrSfK+SShYlDFFdXR29++67FBcXJwZAyQcffCAG9Ntuu01EA+bMmUOPPPIIvfTSS+pzTj31VDH4//777/Tee+9RcXExff/993TrrbcKP8aJJ55Ie/bsETcIAGdceumlQsRIUYDUzTnnnNMk6oDHIaDuu+8+WrlypUg7YfCGiJFg+5588kn63//+JwRLu3bthJDR4sq+tYaamho67rjjhED7+eef6cMPP6SlS5fSzJkzbWbwxPG65557hOdl06ZNdPzxx9OaNWto0qRJdMopp4h9hNjAflx//fXqa//9918aP3489evXT4iN1157TfwfzAgK8Hp53PEe//nPf8RnsXPnTvU9rrrqKsrPzxefF249e/YUxxfPg6hEWk++x+WXX+6V48IwTPBzaGc1pdQpF1Fl6XFOTa6y/bwkUL1Kgjp989vEP6kmx/aKFsMsBqddoVnkq0mZI1Ij6aifxrj8fHkVDHD1HhsbKwbOlJQU9Tm4OsdAjQEN4Iobjz3//PN0zTXXUFVVlRiwzjvvPOrSpYt4DgYzdZsiIkTUQP6f5oC4wCCJAXbMmDFCJH333Xf0+eef2zwP7w/BM336dHH/7rvvFoMxRAUiDuDxxx8XJtXTTjtN3Me6b7/91uZ9Wto3T44jQPRm69atYlvy8vKEoIDYAwsWLBDCbMuWLdS3b1+bfYKIgEhBpAL3zz//fLr66qvFekShXnjhBeGtwV+ku/773//ShAkThPiSaCNNYWFh6nbhLwQNIiCffPIJ3XnnneJxbCeiI4iSgOuuu059vdlsVqNADMMw7lCwupRkAXB9V+epGxBqDiVLQgSZimuEKNnHosS7QJBUHbIVJZI6CkwNtiNwFSy9EBgIIQIw0C9fvlykYXAFvWPHDjG440oeEQzcEAGAwAJRUVHiNWeeeaYwtB577LF09NFHCzHiLhhEkUrAFf/BgweFSBg1apSNKIF4chRxQcTgo48+Up+DaAGEjRbcl1EEV/bNk+MIMJDLtBaiTlKQgNGjRwuRtnHjRhtRMmTIEJv3RGSjsLBQ7JPcNmwXbth/iAg8B+kgZ0Awwie0aNEicTxra2uFx6dXr17qc3C8cQywrYjqQBhpt5dhGMYTKjaVqKIkvG/zogSEpUVRfXENJdVV05qCer/HLoI6UoKIhT0yUhIaGurTSIk7aK+C8RcpkXfeeUd4BxDCxyAGkFKB2NCiDcUhDfLjjz8KD8ONN95IRUVFYiAcMWKE2/twySWX0LBhw8QVPJYdpZmkgNGC+3Kd/Itjbf8ciav75grOognYDvvtxHvj+XIbJYh8aMH2QSw4Eh3x8coXHFEV6V1xBMQWUj6IrMBXgzQY0mkQXhJEmWBu/uqrr4QX6IILLqCFCxeqUSiGYRhPsOzQlAM7mIjPUa+S8q0lhF/t8oO4qGdR4jUcpVAwgOAqHVfV8kpaj2BwxNW0TEOkpqaqfgRnYKCFDwK3p59+WqRh8BfpCwzK2HdXQQQAhk38T2n41ILBH9sEP8UxxxyjPv7PP/+oKQg8B8ZZ+DJgHpWsXr1aHdBd3bfWgO1B9AnmVCk6YCLGfbmtzkCE5c8//6QHHnigxec4Aymtyy67TBVd+Bw2b94sjLNaIB5xg6cFQmbWrFlClLj72TEM0zw//Wuht3+w0A1nmmhYb19dnuqDyL2KybXKFEKdBrRcjRiXGUWyTrM2uwo1jORP9Dsqt1Ew+CDigYEbplEpNjBIPffcc0Jg4AobqRFcVcN7AVDCCx8IqmSQYsjJybEp64UXAuvsq0aaY8mSJSK94qwsGVUhTz31lBAiiD7BB4PIzM0336w+B/4J+ErWrVsnohIwr2oHcFf2rbXAEwIBevvtt4vSYRwbbBfEFNJjzQHPB6Ic8JagpBrb98cff9iYTfG+SG1h35CqQbrnwQcfFMcfoKIGPhrsF4Qmng//ixZERlDBg2OE/4PPSvvZoTonNzfXK8eDYdoyW/daaOpdFnrjO6LrnwvM/C7+ora4lmKKKsXy7qg46pDSsgBL7KapzsmFKPEvLEp0gLbcMzo6WoTyn3nmGTGYSpCOQdTj3nvvFeF/DFjwfKAqBuCqG+kWVODgPVCFgwEXV9sAPhO8LiEhodmSYC3wqTTna4DJFYMp/A94Lu7Pnz9fmD61gzpKjBEBQOUNBm/7zqwt7VtrwT58/fXXQgwhQoP3x2OoUGoJlO9CIH366afitcnJyWKfzj33XPU5SLtAkEFYwaSM6AtSVjISAuGGPiPYf7weVTfwjWjBvsLcis8HIhACBmZcgOOL6BfECZcEM4zn1NVZ6MJHLVTZeG2262BwH82S9db2CzvM8ZTaruXXaMuCwwv8L0pMFnebQRgcvaVvcGWNmwSCoiVzKp6PNIQzz4U2TWEPPBK4EsfgKX0W8pgglYKIhzMhgv+L19uvxymECAS23RmIAGB7MVjjffB/HDU2c7ZveH9sp7NmaM62zdGxwTbYe0zw3hAOEB44LxydJ4iS4LX2Hhn77YBAc/a/8X/xekRMxKycZtueAdgHPMfRZysrgvD+zj7ftvb90QN8TIxzTB5500IPLLQOeeFhRNVLTW7714xyTHbN20Nb7t8qlud37U+L/u3c4muK/i2iP47/Syz/0L4TPbtlAPmToDa6GgEMMM4GseZe0xzNDVjNlQXjfZv7sjjbVnyhmxMkQCsCmtt+Z+vsB29Xt83VY+NKya0rlUzNbYP2fzs7Xs0ZZrGNiKQwDOM+/2610MNv2F6D19YRlZQTJcQG5xEtWWs1uRanuVbNZ+5k/a1NrKyiqmoLRUX6z3ejHwnLMAzDMD6gstpC5z9iobrGLgORmuuLQDQI8xfFjaKk1mSi+k6uKa+I9hFUH6KIEPQqyffzDBcsShiGYZig5u75FtqyV1ke3pvo4hODX5TUlddR+U6ljiYrMpZSUlwb7k0hJqqMjwpYV1cWJQzDMExQUp1TTT/ctIP+eD0X5jcRIXn7PhN1TDYFvSgp3VRG1NhJYEdUPKW60RC6LkkRJbENdZR7UOkl5S/YU8IwDMMEJevu3Up1nx2iB9FDKTaZku/oR/27xlBKgtVbkldEQUnFHqXPFdgXGUODktx4cXsz0a5CsVi0q4roaPc7g3sKixKGYRgmKNm3tJCk9XxEWT6FPPoHba/oRimDuqqJgtwgFSWV+6xVnTkRUZSa6LpZNbyj1bBfuhfv03J7em/BooRhGIYJOmoKaiiq2LbPRkN1A22fs5PiMg7R0LC+tCY2mfKKETUJvq6ulQeUpmkgJzzKpR4ljnqVVB7wb68S9pQwDMMwQUfJOmvjsGXt06nbdV3JFKqID8uBCno0axVNy90dtJ6SKk2kJDfcTB3cSN8kdLWKknrRat5/sChhGIZhgo7itVa1kZ3Rjvo91IfGLRtD7UZZHZ/HFx0IWlFSuV+JlFSbQqg4NNwto2tyT2uvElMeixKGYRiGaRV5q6yRktouSuOw+P5xNPrrIymmV4xa8ppbGHxNzS3osr1fERO54VHocOlW+qZDb2ujx4hCaxrIH3CkhGEYhgk6iteVqJGCyO4xNn04orsqkYBwi4Wqc2so2KgtrKX68nrVTxIWStTOtYaugqTUMCoJVbpLx5RypIRhGIZhPB+US+qobq9SErsnKpY6ptpef5szNOmJAMyE62sqG6MkMlLSPhHTVLhu5sXUIYWNU2bEV1aTpd5/0SSOlDAMwzBBRelGzey4UfE2zdJAlKa6BBU6mD04mKjcp628MbuVupGUxSrHKBTRpMON0yr7ARYlDMMwTFCmbsDOqDhKT3Fe8ppSU0UFVg0TFFRpIyURUdTBA1FSlWA9RoW7/OcrYVHCMAzDBO3suDvNcdQx2flMuIGY38VflTee9CiR1De2mgd5O/yX4mJRwjAMwwRlpKSOTGIyuvQmosQ64KZClBQFr6ckB+kbN8qBJaYO1mNUvIdFCcMwDMO4TX1lPZVvU2bH3RsVQ7UhoU0iJZFpkWRptJm0r60MvkjJPiVSgvn48sMiKT3F/Y61kelWUVImWs37B46UMAzDMEFD6aZStVoEJleUwkZF2g7KIeEh1NAu0tqrJNgiJQcUEVEQFkl1ISGUmeb+e0R3tqa4qjUt630NixKGYRgmaCjWtJd3ZHKVmFKVQTexvpbyc5WeHsFAfVU91eTUWBunEVFmB/ffJ7FzpEh/gYbDHClhGIZhGLcp0VbemFEO3HJ6olxjDA0uP0mU+NvFA1GS0s5E+eFKNCkkn0UJwzAMw7hNcWPlDfwUux2YXCUxna2ipPpgVXCWA4ebKSqCPKq+SUmwRlrCK2qprryO/AGnbxiGYZigoKG2gco2K+mbAxExVBUa5jRSktjNKkr8mZ7wazlwRJSIkqBDq7ukJFpFCahq9Kn4GhYlDMMwTFBQtrWMGmoaTa5mZbIXZ5UnST2sA64/0xP+Tt9kepC6Acnx1vSPeF8WJQzDMAzjOsVrrSbXXVGKKHEWKdFWl0QVVQVpi/kojypvQHwMUUEkR0oYhmEYptUmV5QDA2fVN9r5b2LLgtVTEkVdOrifugFI+VQnaiIlmvf1JZy+YRiGYYJOlOwyNx8pCU8Mp5qwULGcVF1FldWWoPKUlIWEUUVouMfpG9CQbHboVfElLEoYhmEYw4OGaSWNswMXxpipLDS8WVGCSEB5XJS1gVqh8UWJpcGiej+kH8TT9A0ITdOUTWexKGEYhmEYlyjfWU715UoTtD0xSpQkMZbIbNfNVUtNY3oi0tJAuXtrDX+kqw9Xk6XW0urGaZK4lDARcQHlfmo1z5EShmEYJmgm4QObQ2XlTfOvsbS3RgLy/TgTrl8qbyLMFBJClNHe8/dDr5LsCCWFU3uoSpRc+xoWJQzDMIzhKdG0l98S3rzJVRKmnQk3KxhESaW6jEhJRgpReJhnRld7UUL1Fr+YXVmUMAzDMEHWXr55k6skKsMqSio0pbRGpXKfbY8ST9rLa0lJMNGhiGj1fsWeCvI1LEoYhmEYQ2OxWKzpm+RIKgpT5mxx1mJeEpdprS5BesLoVNlFSlrjJ5FdXQ+FW49RxW4WJQzDMAzTLJV7K6muWJmbpaaLEiUBHZObT120626NlFBuVfB1c01r3fshfWMbKfF9NIkjJQzDMEEUMWjLk/CBog6Kn8QVT0lqL6soCS8IBlFSKf7WmkxUGBZJmR42TtO2mj8kPSWcvmEYhmFcZcdTO+nHbj/R2mvXU3VudZs6cGVbytTlg/Gx6nJLnpIOqSFUEBYhls0lweMpyQuLIovJ5JVISX54lBA5gD0lDMMwTIs01DXQjmd3UV1pHR344CD9Muo3ynp9n2go1hbQGjz3hkS7HCmJjiLKi1CiJdGVNdRQ4/uSV19RW1JLdSV1XutRIj0lDSYT5TT6SpC+8XU0jtM3DMMwBqd8ezk1VFoHVPgrNt62if6Y8pdNaiNY0U5Ct6M2yuVICbq6lsZEqYNhlYHNrpU2PUqUfWpt9U2smSgywprCQXO6mtwa8iUsShiGYQyOVnhEd7dGCopXFdNvx/1JC6Zuopxs5So6GJGt1cPiwmhPabhL3VzV18YHR1lwpc3swGZKTiCKMbfOUwLR1ivDzuzq43bzbomSO++8k8aPH6/eTjrpJJv1VVVV9Mgjj9Dxxx9PZ5xxBn399ddurWcYhmFa16NjwBP9aPRXIym2T4y4b2ogyvhzH316za6gPLSY70WWwmLm34N5rqVuJPVJVlFSuKsqaGYHzmxllETSrytRth/LgpWm9i5SXV1NN910E5144omqitLy3HPP0e7du2nhwoW0Z88euueee6hr1640cOBAl9YzDMMw7lOs6WaaMDieIpIjaNyyMXT3CXvomHU7lN/rPdbnBBNIJzTUKD6H8I5RVHnYtdSNSqpVlBTsrAqSSEkUdfOSKOmfSbTYjxU4bqdvIiIiKDo6WtzMZuuG1tXV0bfffkvXXHMNde7cWURSJk6cSIsWLXJpPcMwDONZpKB0fYnaoRSCBHz7dwg9VddVrZyIKjbugOvqYFyniXq4GimBkJGUGbjVfGVjCstbPUok/TLturru1lH6BsydO5cmT55Ml156Ka1YsUJ9PDs7m8rLy6lv377qY/3796edO3e6tJ5hGIZxH4TT68rq1SgJqK+30F3zLaIsFOWhILbMuAOuqwbPigTrhXLHJNdeH93J+pqqA0b2lFSpy3kifdM6P4lN+saPkRK30jePP/441dfXU0VFBS1ZsoRuueUWevPNN6lXr15UVqbUicfEKHlMEBsbqz7e0npH1NTUiJvNBoeFiWiNpzQ0NNj8ZfiY8HnC35/WEOjflKI1xepy3OBYsR2vf0e0aY/VX9CxtpKi6+qoprhGmEGD6ZhU7LMOkoVRSnt5mb5x5f8nZIRTjSmEIiwNVHe4ymfb7OtjUtnoqykMjaCakFDqlGqhhobWl+/2TCeqDQsV/VyS6mqEKPF0H0IwbXELuHV2RkYqHzhSN+ecc46IlPz8889ClMhUDgSLFB6IjMjHW1rviNdff50WLFhg89i0adNo+vTp1Fr27dvX6vcINviY8DHhc8V435+c33LV5aq0KtqybS/dvyBd/XkXA3XjuL1z5S6K6mkduIPhmORssu7/riprhVFYQy5lZblwVV8brcyoW1NBptxK4Xe090vq/ZhYai1UnV1tUw4c0XCIsrK8U77buX06HdoZLURJdU4N7d6ym0LM7hfvduvWrcXntEoyh4eHi8gJSE9PF6Jlx44dNGTIEPEYlrt37+7SekdcfPHFNGPGDK9HSnBSwNfiimprC/Ax4WPC54pxvz85WXnWq9pJPei5n6Iou1C5P3UsUeQKM1GBcj+yMokyM100WxjkmOSXFFoNv/Ht1eXBfdtTZmbLr+9bQPRX+F4hSsJqGiijXQaFJyhlxUY5JhVZlbTFst2mcdrooR1F8zNvMKgH0aF/zTSAisT9lIYUisu0zjHkTVwWJcXFxaJq5sILL6TExET69ddf6ffff6cLLrhAFSiTJk0Sz3nsscdo7969tHjxYnrqqadcWu8IiI/WCJDmwEnBooSPCZ8n/P0x8m8KumuWrFeqaiLaR1BFTBQ9/r7cHqI5V5rogx22Ja/d/biN/jgm0lNiCjNRVrU1CpTR3kQhIS1HPFITLcIYKqk+WEOR7SINdUyqD1inFcC+oFNt+3Ymr0V8BnRtoL0aX0llVhUlDEyggIqS+Ph46tSpE1100UVUUFAgIh8PPPAADR48WH3ObbfdRvfff78QH1FRUcIMO3LkSJfXMwzDMK5TdaCKagtqVZPr7HeIihttejOnEA3oZqLQNOuAW7on+Myuao+SjCg6WGgdhF0tCcb8LjK6IL0Z8QN8EwXwRwVSbrhZ9CjxZgoKFTh/+amBmsuiBDsILwduSNmEhoY6FC7oRYLyX6y3PygtrWcYhmE86+Rq6R5Hcz9XlqMiiB66RPl9jczQdCzVVKoEA5jrp7ZI8ZGY0Tgtn9RurtFRro0vSHGgWsVREzKjlgN38VKPEkm/TLsKHB82UPMohuRIkNj7PpoTHC2tZxiGYdzr5LooO45qlKAJ3TSNqFOq8hsb29k6mNRmG2/AdXUwhig5lO9m4zRYC8JMVK5pNa8tMTZq47RMb4uSrnat5n1YFsxOT4ZhmCDo5Pr+nng1SnDnedaLvqTUMCoJbTRu5hpvwHV1MDalmqmiyr3GaZKGZI0oMWCvkir7FvNp3r3oj4s2UVxaOFWEhPq8gRqLEoZhGINHSkLjw2h3vTKwjupPlBhnHZQwMVteuGLcDC2sIku9b6ee9yfaqEZVouuzA9sTomk1r21CFihqS+po25wddPDTQ8LM7Ko4qwwJpdLQcK9HSkC/riY1hYOJC311HrEoYRiGMSDVh6vV3hSmHnEw/onlHmhR4sTIGVJvoeoca6VGMEVKis2aFvNuipJ2KaFU3BhNKteBKMl6JYt2PLmT1lyxjrY9uqNZYVJ1qEoVZ+JzNpm81mK+ia8kvDGFU2exSZ15ExYlDMMwBqS4cb4bUJqupG5Ajwzb0H1yvDKVvZE9E81VH0lyIzUt5pPdS19ohVsturrWBbbjd9Fqa5fenc/som2PORYm5bvK6c+TV1JDtbK9O6OUqiFfREr6d8UcOL43u7IoYRiGMSAlmsqbgwkaUWIXKUm2K3nVDuTBFCk5aHJ/Mj6tKFF7lTQoUahAUrHLdsDf+b9dtH22rTAp2VAiBEllY3luQXQUvZXak1CH4m76ytVIiY0o8ZHZlUUJwzCMASnWVN5sibD21ehuJ0riookKIm37cAQLMuoTkRJBB0qsw5m7g3JKgsmuV0nghJul3qIO+KHR1krXHU/vou1zFGFSsKKQVpzyN9XkKG3kY/vG0gN9R1JOhJk6tUeFq/erW5tW4PjmPGJRwjAMY0BkJ1cMXOsqop2KErRfqGmnjwHXmzTUNgg/hX05sKeREptoUgCPUdWhKmqoUSIiKROSqf+cvuq6HU/torVXraeVZ/1DdSVKf5bEEQk08KORtLs6ymepG9A+0UQ1yRwpYRiGYeyoLapVw/bxA+NoxyHlyjgtiSjG3PQq2ZKijwHXm1QdqhapFhCFxmnWKYDcjpS0T1Q6oeohmlSuSd1Ed4+mrpdnUv/ZVmFy8JND1FCp7HjKscl05Gcj6FCNda4eX5hcJe17RVE9KedX6U5O3zAMwzB2qRtz/zjKLnAcJZGEt49UB5PyIEnfyPbywNzZrEZKEtzo5mobKYnURVlwhcZAGt1NiYB1vSKT+j1mFSag4+lpNOK94RQWE0ZZ2dbHfRUpAX26hajeG6RvXClXdhdO3zAMwxi4k2tVZ23ljePnJyWa1F4lwZK+0QoHMe9NvmflwLLV/GGtiTPLdx1L3RElMY2iBHS7MpMGPTuAYnvHUI+bu9PQVwZTSIQyhGcdtr7e243TnFXgWMrrqLawsYVwIOa+YRiGYfTlJwGHk7SVNyangy48Ex1qq6i+sJbqK+ptTJRGxCbFkhqldnP1pPIEkZKi0AjRfMzcUO8zE6crlO+0Td9o6XxBJ3GzJyvbGrHokuq7bUMFzpcQJeVWARWRFOHV/8GREoZhGINOxBcSYaKdYTHq487SN+hVYlNdEgRlwdqIT2m02WOTq2zNHxpmouxGX0nlXt91LG2J8sZICT5bs2YyxeawjZT4astkWbD7FThl28pExZArsChhGIYxEHVldVS+Q7lUje0XR7sOm5z2KJEkx9uXvBrfV6Ldh/woz1vMg5AQkxBuamrChx1Lm8PSYC0HNmdGkynUtVSM1lPi7RmCtXRKJSqKdb+B2t639tOKk1e69FwWJQzDMAaiZGMpUeNFfMKQeNp5kFr0lARjAzXpKQkxh9hUn6S72c1Vm8LJ1kYBfNSxtDmqs6vVypoYu9RNc+zNUf6mtiMyR/rOU4Ly8uiu1u0qcbECR9voryVYlDAMwxgI7Q98/OB42nlAWY4xK4OSK304jG52RdWHFFbmTmY6WGAdiD3tZopj5I+Opa6kbrSVNy2xda9FLYf2ZeWNJLWf9RgVbK90KfqjNWa3BIsShmEYg5pcYwfG0Z7G0H33jsqVrCOU+W+CJ31TW6CYdYG5cxTtPGBptadCESW+71jqbjlwc9TVWejCRy0kK3MnjySf07t3OBU1Tl5Y5UKVEvqu1JUpn5UrsChhGIYxEJiETVKSHEO1dc2nboIxfaON9CBSsn2/dV3vzp69JxqoSaNrwCIlOzXlwC6kb2a/S7Rys3W/773Ad6kbR2bXkIJqqq+s91rqRrxnq7aOYRhGB6H8HTt20Pz58+m8886jq6++msrLrQN3sCG9FBHJ4bS70NrVAZESZyBSUhEaTuUhYUFRfaOdiA8t5rftU5ZRHZ0U77mnJCfC2rE0EKKkYrfrouTfrRZ6+A0lRIJJ+N6+1+R20zhPRUm2TU+XSpcqxVyF+5QwDGM4SktL6euvv6YlS5bQ0qVLKSsry2b9qFGjaObMmRRsNNRZ53uJ6mSmLYes63pkOB+Q2sUhtaNES2Kqy0SreYg5Z+kevaMVVSEdomh/buuiJHJSvnpTiDhGabWVVLG70u/HqLxRlJjCTKJ1vjMqqy10/iMWqmsMUtxzPtGR/f2znd06EuWYo4mKrY3m4vrGOn1+8drGJ7oIixKGYQxFTU0NDRs2jHbu3On0OVu3bqVgpFoz3wsiBFovRXPpm9BQE7WLs4gBt2t1GTVUN1BNXg1Ftre2VjdqpCRfMwNyr6Z9xVwGDeYAzK4QJXWlSsdSbzcHcwYEUEWjKDFnmikkzHki455XLLRlr7J8RB+i+y/yn3DCDMSmNDNRo5epbGcFdWjO5LpW8UBFdXTtXOP0DcMwhmL16tU2giQyMpImTZpEN998s/qYfeQkWLD1UkTZlAM3l76xNlCLDIoKHO2kgvss1lRC706eD87wlACb1IQfy4Jrcmqovry+SXt5e37610LPfqwsR0YoaZvwMP9GvOK6W4/RwdXOU6VIgUHcgfgh1s7DzcGihGEYQ7Fu3Tp1+c4776TCwkKRxnn00UfVx/fubbyMDDJsvBSdzbSrUZSEhLRcdaKYXc1BMVuwehxCiLZVRnonUpKg/A1UBY4r5cBFpRaaOdsaHZtzhYn6dfV/Ci71iHiqbUxrFf/ZOBtkC34S9NRxBRYlDMMYivXr16vLU6ZMIbNZGWjxt3379m0mUoJJ6GSPEsx3EhHe/ODUtNV8peGPQ1RaFG07ZPKKKJGdUA8FKFJiU3nTzbEouXeBhfY1Nko7dhjRDWdRQOjTO4y2mBUVF3Kogir2VrbcU4dFCcMwwS5KBg0aZLMuMzNT/D148CDV1np/BtNAo+0vUpsURUVlzc9506S6JAgaqKEEFX4Y2aNEWw7cq1VGVyJ0UM8Oj3a5ssRnPUp6OBYlX/6u/DVHEr1xj0m0xw8EMBSvibF2qcv/tXGKZjuK12gjJY2hqBbgSAnDMIYBZkApSjp27EjJyckORUlDQwPt368ZrYIEbcolO9TsksnVWaTEqOkbm2hRJ6soSUsiiov2fJBGlQ2OY6C6utqUA3drKkoKSixqldHIvojsBK5yqnMq0ZrYJPV+3rJ8h9/V4sZOrpEdIikqjY2uDMMEGdnZ2ZSfn+8wSqIVJcGawpFeCsz3srvcOt9Lj/SWB6jkBBPlh0fK4h3D9irRRotCO5jpcEHrUzfaCQ0rQ8OouLFjqV/TN7IcONQk/EL2rNMUmw3uQQEF/WCyEuLVvjeIlKDSRgv8OHXFisk1YahrfhLAkRKGYQxpcm1JlASb2RVXnlJImDPMtFPjpXA1UoI+HAVhyhVrlUE9JdoIT3GMNfLTmh4lEpkGk2bXqkMtdyz1WjnwrsZy4M5RFBIR0oIoCWx/GUSV0lNDaF2MMtlSTX4tlWKiSA3a+W5c9ZMAFiUMwwSFnyTYIyXomSFLRlEOvOugxeVyYG11iUzhVB+uofpqGTcxZqQkO1Tbo6T1A7VsQGeTwvGDrwSDuiydjXZicl2306KbSAnISIGvRJPC+SXfuZ9kMIsShmGCXJQMHjy4yfouXboErSix6VHS2bZHiUuRkkZRojW7Vh2sMmybfbC73ioevJW+AbZt1H2fwqnQzGcU7VSUKH9RiTuwGwWcjPbwlSQ79ZV4Ug4MOFLCMIzhREloaCj169evTUVKtD1K0GJelgNDbCTEuuApaRwX8mzMrsZL4WhLmTdXRPokfWNTgeOHXiWYSVcS46Dypr7eQht2K8s9M4hizIGfHqBTe6L9EdGU15gOLFhRSPVV9Wo6qqSxvXxEagRFutjNFbAoYRjGENTV1dGmTZvEcq9evSgqquncIO3ataPY2NigFCVaL0V4mnW+F1dSN9pIiU2vkv3GjZSEJ4bRpsNhbkWLXOlVgsnt/N2rxKYcuFtTUbLjAOa70U/qBmSkmETYZnVjtKShsoGK/i4Sy5V7K6m2qNHkOiTerfmDWJQwDGMIMBNwdXW1Uz8JwI+fjJbA6IrS4GBB66Uoio4ii8W9wVhGSmwbqOlDlFjqLS4/T6acEC2S5cAQE+bI1kcP0K49s4P/y4LLWygHXqcjk6s2fQNsfSUFrUrdABYlDMMEReWNRIoSCJjc3MZwQhCg9VIcNEU18UG0RGSESTQHy9FZ+mbfu/vph65LafXla9XwvzOqD1eTpVYRMKFpUVRY6j0/ifZ4okKp2hTit/SNrLwhEybji9a9yVWmb8BarShZltekk6urTdMkLEoYhgmKyptg95WokRIT0c4aq7Do7kKPEtv5b/SVvtnzchbVV9TToc+yadWFa5wKE0RJtj9tDRlUxnlndmCHvhKTSTW7IhVh34PD26izA3eKotDI5suBh+hElKD6BhSGR1JBUqxacVNbVGsTKYkfEufW+7IoYRgmKCpvgr0CxzrfSyTtynGvR4k2hVMaGk5VjVGAqgCnbzDYa1MXuUvzaNXMNU1KlRtqGmjNleto3xvWLr2HB1pnIOzd2XspDVkWLEVJQ3UDVR2qavV+brx9M+2cvocKfredwK6moEb1X0Q7qbxZ2yhK4qJbnnjRX6QlKxNBgq1JjdESC1Her/mqKIlIiaCo9Kber+ZgUcIwjKFESUxMDHXt2rVNRUrEfC+5NU0qb9xJ36i+EpNJnS0YnhJUSgSK6uxqYZDUkvtjHq26aLUqTOrK6+ifGavo0OfZ4r4pzERD5g+iTTGJ6mu8nb4Bh7QVOLtbl8LZMz9LCKqaXTW0+tJ1Ig2lvre28qZ7TJPXFpdZKEvZdRrUHUJAH54S+G86KL3TaGWUNYWz/70DVFtQ65HJFbAoYRhG95SVldGuXbvE8sCBAylEXqK1EVGiNaRqe5RERhClN4bRXSGlcRyXvhI0Y0O4PVBooyRJY9tRaEyoVZjMXCMG75Vn/kt5P+Wr7fWPeGcYZZyVbjsRn7fTN00aqHludi3dUkZbH9mu3q/Nr6V1129QxaD2GER3bxopWa+c9rryk9ibXX9raEemxlmq8dl50slVwqKEYRjds2HDBpf8JMEqSrTlwFEZ6OaqLHdLc+/K2VEFTiAn5tNGCdJOS6ORHwyn0OhGYfJDLv08/Fe1zDQsPoyO/GQEpU5WRkIpSlDC283FsmhXkOkwmwZqHkZKkHZae/U6kQISmKxpqqwFe12aiG+d1k/SUx9REnuza4UpjKKHWCNXnlbeABYlDMMEjclVzh4cHh4eVPPfaMuBa9tFUVWNZ705rA3UInVhdrVvGpY0NolGaIRJQ1WD2oBr9NdHUtJoJV+AKMO2RlHSNY0oovEq3RtgpuH2idb5b1pTFrz9yZ1Usk4pEYrpHUOdnrTm2rY8uI1KN5faHIPo7i1U3nQnXSHNrqBhiDWFI3FnIj4JixKGYYJKlCC106lTp6CKlGiFQ36kuUmqwVUwUzDI0UQBUF0SKBxFCZLHJdGI963CxJxppjHfjqL4AdYqjux8ovJK76dutMf1cLhZnVHZkwZqhX8X0c5nd6k+mMHzBlLcMbGUeYVixEb0BObdsq1l6muiM81OTa5goN5ESXurGCzqYW05DyKSw0VUz11YlDAME1SiRJvCKSoqopISa3liMLSYPxCi7VHiXoRATsqX3Wh09VdzMGdIPwUG7ahO1v1KPiqJjlo2hgY+3Z/GLRndJK2h9ZP09oEogdm1LiREbcnv7qR8dWV1tPaa9SRVTa87eqipjN7396TYfkoJbenGMjWSgiqVULMixCQNDRbVU4IUVXyMPtM3YF9iPIXFWTvsxg923+QKWJQwDKNrEKqXogSpmZSUlp2dweYr0fo+dtZYUy+epm+0Js5yPzQHc/a5qv05Ms0UEmY7HMX0iKEuMztTRFJEk9fK1I23Zge2Rx5XeZwwQ3NtseuG4M2ztqp+mcQRCdT9RusMeqFRoTT0lcEUYtePJLp70yjJ7kPWiJDeTK726Zv9BSYhJlvjJwEsShiG0TWHDh2i/Px8l6MkwShKpKcEZs/thYpfxrP0jfK3MCyS6htFQGWAIiU1OTWi+seZwbM5tu+z+ix6eWEiPntkQzqbiJKLKZycH3PVfipIQQ15aVATwRXfP476PNDL5jFH5cDrbEyupDtk9Q04kEvU/nirSmk3prFe2E2ssRaGYZggSN0EmyhB4y1ZEoxy4L2HreswT4snkRKLyUQl8WZqV1AuUhP4HyY/97+wKYV1V5T4IX0DbM2ulZQwtOWW6Vsf2aYu9324j0OxAbpekSnKZ/OW5TudHXjtDq3JVV+pmyaRklyiTvdkiDLu0Ogwaj/JunLbPgsVlRId2b/lfeBICcMwQS1KjF6Bo53vxdzJTAca20Akxro/hb30lICCaG3HUmszL39h0zTMTVEi0zcR4cpkfL5O37jqvaktqRM+ERA3IJa6zHSumCACB784SPRnQZVKp/Oa5uJsJ+Ij3REbbaIExR4jzktEhHrd3pO6X9vVxk/y0hcWGnWVa036OFLCMEzQiZJgajWvrbyBGfTAqqahc1eJMSsDeU2tEgXooRlwzR5USrQGm1JYB1ECZ8D8ueOANaIRGur9CELHZKKoCPQqca8suHSD1VTdbmS7Fo2emDJg9FdHOl2/rtHkGh3lfqrOn2bX4jIlfQOfkKN91oqrluBICcMwhhAlKPXt37+/S6/p3LlzEIkSqxHVkhJF1TVNQ+euggFDpnD2hWijAP43u7bUNMwZ+3JIPQa+KAeWxwkiwN0GatqJ6Dzp0aGlrMKiTieA9vK+EF/eQJ6H6J1T4KDQDUJFW9bcEixKGIbRLXV1dbRp0yax3Lt3b4qKcu1qHs9LS0sLDlGyzxopKY+3DpKeREqAFCW7GgJbFqyWA4eayNy5aeWJM3zVXt4eRGHKQsOpNFRJKJS7cIwwS662JLY1bNit79SNQ7OrtcO8yqF8ovxi19+PRQnDMLpl+/btVF1d7Vbqxt5Xguod+R5GpEoTKSmItIoyTyIl2gqcrJDWdyxtVTlwY/oG5t2QiBDPTK5enB3Yqa+kcWI+zKhsP3uxs0hJSISJ4hp7kXjK2h2ka5Oro14lSOG0JnUDWJQwDBNUfhJHZtf9+zUjmYE9JdlhUQ67aXpidkXHUjkXiycdS1tDTX4t1ZXWeVR5g0oOf0RKZFmwana12Daxswf7U76jXCzH9otzS2g5Yp22vbyeIyUpJpsKHHtYlDAMEzR4S5QYOYUjPSWYhXWfpnGax5GSxqwCOpaGpHrWsbS1VHipHNjX6Rtg4ytpJqJUsqFUCBdv+Em0JlfdixKbSImlWXHlChwpYRgmKEVJsFTgSE8JqmMOFJDX0jfA0qGxY2lBLdWWuN6x1KvlwA4moXNFlKAiJd3DY+BO+mZ/pLXPSPEq5+aI4rXFre5mqk1vyQgDSp4T44yRvmkuUhJm20HfKSxKGIbRLRs2bBB/Y2JiqFs3a6vuthIpgVCoK6mzlgNrfvQ9N7paB7jqlGi3qku8RfkuJc3hbqSkrs5Cuw4qyz0zUJHlu8Easw+junV9tLUzad4vSqOzlkyurRUlWdlEJeX6j5K0ZHStrrHQ5savXj/r17FZWJQwDKNL6uvrVTHRs2dPURLc1kSJ1k+ibZwWHkbUPtGz99Q2UCtPDEwFjrabqzuRkj3ZRHX1vk/dgMgIk4gC5EaY6VCUso1F/xSrXhh7StaVqGk2eEpawzqdN02zP5/Q+8aR0XXLXuvn5ep+sChhGEaXHD58WJQE2/cdaUuiRDsRn1kTKUFzL0+jBNr0TUG0NlJS4f/0jQmT8bkuSv7caF3ua83O+TyF869ZmWjOUmehgj8LmzyvrryOyrYroQ1U3YTaTbbnLmt3GqPyRvZ0kalE+/SNrbhybT9YlDAMo0v27dunLnsiShISEsTNyK3mtdUe4R2jKK+4dX4SrdEV5Gj6vvjT7KrODtwpyq0B/PNfrabJE470/WAtza5rYpPVx/KW5Tk2uTY0n7p5/Tui215Jpv05Lf/f5Wut+zm8N+kemcIpLCWqrLY4NLm6OqEgixKGYYJSlGijJXivhobme0zoPX1TFtv6xmn2kZL9Yf6PlNQU1lBtkfvlwBVVFvp+pbKM1NXYgeRzZFnwuph2ZGkcLfN+0biNGynRNk0b0nTSvsUrLXTZ40Sf/R5Lt7zY/P+srLbQr+uU5c6pRD19nKbyZa8S214rrr0XixKGYYJWlMgKnJqaGsrOziYjt5gvMLe+cZq9pyS7JpzCE8P86inRVt5Eu+En+eFvDNjK8mlH+aftuoyUlIeGU2Vn5cCVbSmjquxq5+3l7SIl5ZUWuuopa8Tg+78UA6gzfltnbaN//EglPaJ37GcLti9rxjmXZg02NQuLEobRMSgN/O9//0t33XUXlZQ4mFgiiPFmpMSovhKtpyQ7pPWN0+TswtIzjHSQ9HRUHqiihpoG/5pc3YiUaFM3/xnvn4FaekrAvgzFVwLyf813KEpMYSaK62/byfWhNyzCoCspryL6da3z//njP9b9nDxC/4LE/nyUkZLDBRY6XGA1uboqrliUMIyO+eabb+j++++nxx9/nE455RSqqPD/HCWBgkWJ1VMS0T6CDpSEeiVSAoNsu8biEMxJogqDhuY7lvokUuKiKKmts9BXfyjLcdFEk44gv6CdmXdNTJLD0mBhct1WJpZj+8ZSaJT1c1q9zUL/+6jp+367wtJsRAhgDPfXfvqiV8l6TfM3V/0kgEUJw+iY33//XV3+9ddf6cwzzzT0PC6eipKMDM0laxuJlCBqIdMEonGapltmazwlWrNrfglRdFf/lgWXaxun9bA2JmsORBZgogQnjVbKdf1BUrxJRJbAH3WJFBqtCI68ZfkiiglKN5U5NLnW11voiqcsVN9YEnvLdKLQEOU13/zp+P8dLrCoPgwYXFMSDRIp0YjkA3mWpn4SFytvAIsShtExq1atsrn//fff04wZM9RS2bYgSjp06ECRkdb26p6KEqNV4FQdqlLblmMWXW1jqtZESrSiBA26IrtYRUm5Hxqo2bSYz3RtduAvlvs/dWOfwtmVF0KJo5TmMNXZ1VS+TSkBLl7juJPr3M+I/tmiLPfvSvTo5URH9KpWu9Ju18zhI1n6r3V58ggyDLat5h3M3eOiyRWwKGEYnYIrMSlKYmNjyWxWfsA//fRTuvTSSw1ZTeIqtbW1Ynbf1vhJ9BgpQSfTvW/uo5qCRiejC+3l1W6uWlHSykiJ1uxaq+3q6odIiRQlUelRFGoOdel78MVyZRlNuk4cTX5FpnDwdTMNS26SwnFkct172EL3vmodlBfcbhLbfuwQq+hzFC354W/ra44faYwoieybIy0jMn0jTa6hoYoocxUWJQyjUzCzbV6eMhKNGzeOPv/8cwoPV1onvvXWW3T99derIeRg4+DBg+q+tUaUpKamUkREhC5ECfbn73NW0YZbNtEfx68QxtLmKN2i+BTUSEnjjz38IObI1g1Y2rLgiiRrtKJyj28jJbXFtWKGYBDd3ayWwKJktqTc8bmMaIMc6CYNJ4qP8XOkROMrKejRVJSUSJNrqIniBsSJz/ma/1movPFQXn060dhByjZrRYm9rwSv+/Ef67w+/ih59hYR4SZKbezGD/EMD9CmPcr9Pp2Jotw4X1mUMIwBUjfDhw+nE044gT744AMKxaUHEc2bN4/uvfdeCka8YXIFaE0vy4IhSgIp4qoP11DFzgp1npm/TltJVQcdC5PD3+bQlge2qvdje8fQwXzvpG7sG6gVRURRSKNHo9xLkZKyrWVUuamq2dSNNNje8ZKFptxmocEXWyi3qOnn87k2dXO0/6MHPTOs/3NbSCxFpCgit+C3AtFyvmyrksaJ7RsjIj+fLLNGQRBBmH2F9fW9MmrFBHvgl7VEZRXWfcMcMQcbo2EThvjPN+Mt5HmZXUBCkNTUetYm3yNRgqu3k046ie644w6bx6uqquixxx6jE088kaZPny7y3+6sZxjGyurVq21ECTjjjDPo9ddfVx+fPXs27dyp6eUcJHhLlGhTOKWlpVRUVESBwr45GYTJitP+biJM9r9/gFbNXEMN1Up6LvWE9mQamqT2rmht6gYkJ1gHvIJyE5m7NJYFZ1W2Wrjl/ZpPvx+zgvZcuJf2v3PAaTmwrLxB3w45Cd0F/7VQQ4Pt///8V+Uv0gOnjiO/o009bMwiSp6gVOHUldXTvnf2k6Ve2d74wYrSe/gN6/bPvclECbHWY419gFEXYNBeovGQ/NDYGA5MNlDqxr4CB8beHxsriNw1uXosSp588klKS0ujykrbUN8LL7xAW7dupZdeeomuueYa0V9h48aNLq9nGMZ5pERywQUX0K233urwecGCL0QJ2LOnMaYcALRVJ/KXF+WxK063CpNd8/bQuus2qANd+lkdafibQ+lggfWH3RuREu1kfofyrRU49RX1IqLTmvTMums3iDliwOZ7t1DZjnKn5cAQIPs0zbYWryR67G3r/S1ZFjGpGxg3iKhDkimwomQPUcoEawpn97wsGz8JGqXhObIM9j9HN30/KUrAN39anPQnIcOhFcva1NQQX0dKli9fLkoSjz7a9mijGuDrr7+ma6+9lrp27UrHHHMMTZw4kRYtWuTSeoZhbJFiA/O3dOvWzWbd6NHWX7Zt27YF3aHzpijp3t1q/d+9ezfpIVIy8Mn+qhBASgfCZNM9m2nL/daUTeblXWjIS4MoJDzEpnW3NyIl2hl2N2dZKLqrxuya5XkKZ+Mdm20iP/UVDbTminVqUzabcuDu0ZRbZO1eKpn1uoV++lcZ1D5vNLgGoupGgkgH2r2DjbuJko+29ivR7mvC0ASRtpCBJpT0OmoYduwwoiglA0TfrlC8JOjwumyN8hhSPgNsv+6GoJOmgdpv662P+zR9g8jIs88+S7fddluTdWjhXF5eTv3791cfw/KOHTtcWs8wjO0MuQcOKKHvYcOGNflx693bOksXoo/Bhq9Eya5dmo5OARQlSUcl0ahFI8mcaRUme+ZbS5Z73dWD+s/uS6bGmYBty4FbPzgP0F7970bUwtzqOXAOLcqmg58oFVNh8WEU0SVcNYJuf3xH03LgbtEiZSNJirdWuZz3iIUO5VnsurhSwJAioaiMqDDKTNE97Jq+hRDFD4izaRg2yMnsvjCxQpgAeEjQzwOzH1dUWaMkRmgtb482gldbZzVluyuilUkPXARplylTplCnTk1nCCorU5ziMTHWZjhxcXHq4y2tdwTmq8DNZoPDwlQ3vSfIMspgLqd0Fz4m+jsm//5rTTZDlNhvR48ePcQPF66yIEr8tZ3+Oi5SlMCoij4lrfl/iMxK4L/x9ra7ekxQDiwIQYlvJIVEhNCRXxxBK0//V3g5BCaifrP7UualncVnK/0d2pllOyY39V24CwQAqiVyCpWUhPmEKBvfh7vHCE3eNty6Sb3fd3ZvKksoo6yL95Gl1kI7n9tNyccmq5GSyA4RFGIOoT3Z1v1AczGYP+FHQHvyU++20D9brSmAzLTW77en9M+0el/W77JQxtFJqmkZxPaJJVOUyaY3x8ButturPU9OGh1C3zW+39d/WKhC0w/xuBHGHJ8Q4bEH/Um05zG+z14TJfjh++OPP+i9995zuF72UEAbbCk8EBmRj7e03hEw9C1YsMDmsWnTpgmTrDevxBg+Jno7T37++WebSIGjctb09HQRTdm8ebPwSvjz6srXx0XuLwSJjBh5iiyjBps2bfJZaXBzxwQ/ymU7FVES3jGc9h3SdKudm0b77zxItQfrqMNt7YmOa2iyjVt3I2Wg9IY31R6irCzPfR+SHh1TKafQLITJnhprr43cjbkUkeX69Sr2bd+NB6i2UCm3iJsUS3VH1pLZFEUpVyZT7tw80QRu1eVrqC5XuYQOSQ8V+7h2K/ZJSYfEhOXSYxdW0fodHSm7MEwVJOCYQUWUlWVtUuZvOsRhzFJCAb+tKqBp/RvbtDYS2iNE7M/KTcjzKGNaYsQ+yspqcHieDO6M46t0Zfvilyqqqcd3V2kQ2KeD49fpnZBa6z5JuqWWUFZWofW+XRraES6feevXrxc/Dscff7za3Ag+EZQpLl68WPxAousirkQGDx4snoNluREtrXfExRdfLLpXejtSgpMCP/SuqLa2AB8T/R0TrfcB3zmtWVOb/sR3ElUlEPcYwIPhuKBKLz8/X41yONp3d0BJMJrPISqLhmytfT9PjklNXg1tKd8uluN7xdtuQyZRj2U9hLk1JMzx64s1V9IjBnWkDlZbg8cc0Zfoz8bgRnkqfoeVc86UG+LWMdr7xj4q/8MaARk57wgKSwwTx2ToPYPp39WrqeD3QqrLsXYhTurbTvyPUo22OmJAexo+iOjDh4gm3kRUrxmXL5qaSJmZGneunzkaxtOFyvKh4iTqe0UcHbjzkNpevuOYjpSZ2YV2HFTuIwp1xKDOTs+TzMwQ6peplAGv3hWl+lAG9yAaMbh16cpAkeQgTTN2KM5121mTvSZKTjvtNCFAJIiYrF27lp544gn1agTG1YULF9KcOXNES2eIFUwk5sp6R0B8tEaANAd+PFiU8DHR63kiy4Gjo6Opb9++DrcBj//4449iefv27dSxY8egOC5onCbxlviBr2TdunUiooQre9nrxV/HRNuUDAZPh89rZpMO5imjX3iYUoGCSfVaC9ILso/9luww6psWKdqnI5Xk6jEv31lOW2cpYgsMen4gRaVEqemH0PBQYdZdPv4Pqiu2ipKY7jHif+zLsSqPrmnKfh09lGjOlRa6/SVl27p1JBrayxRQn4X2WG3KIopMihTG1uJVSvQmcVgC5RaZ1D4rg7o7T1XI8+TkMQ1ClGgzNcePdC3FoUcSYjFZYgOVaixJQ3u6f666vPcQFfCAyBuiHvhi4wpEgjLF+vp6UVlz2WWX0cyZM2nUqFEur2cYhkQvDWnIHDJkiNMBtE+fPkFpdvWmydXe7IoIb2vTQZ5gX3XiLrL6Bnl7bwgSoK3w2LgHFThK2qEmt0Y0BWsJiLt1128QZcSgy8zOlHpc08tlc4aZBv1vgM1j8hjsPazcxymu9STceg7R9Wcqjz15dWAFCYiNNlFmmtUYjH3vMlPxVsb0jBGixNbk2vJ7njym6T5NHmE8g6uz2YKhrTypInLL6KrlvPPOo7PPPtvmscTERJo7d64wpyLNYq/4WlrPMAzRmjVrHPYnaU6UBFNZsC9FCYDgk11e/YV91Yk7oFw0r9h7PUocihJU4HSNpsIVRWpZcPzA+Bb3qfAv5fmo3un7sLUizJ6Op6dRzg+5dODDg2QKN1HCMOW9sw5bB7OwMG2TMRM9fyNupBsGdlMavCESsC+HqMuMTpRydDJFpCqmZRhgW6q80YK+K/ExyqSIIDKCaPwQMjSotEH0R5adR0e5L7I8VgVIqzgzqWJdc4KjpfUM05Zx1jTNnmAtC/aHKPE35Q7aq7uKbD3urR4lknZxJjU6gQocGSmR3WZbQjsRXcbZ6RQW0/w17qDnBtDAp/vTiPeHU3RmtGg0lt8otro09gHRM/Zl1HJOotBIZSzTihJXenOEh5lEukYyfnDr5zQKNFrR7G5/EgkrA4bRsShBObAzUJovLwxYlLguSgLRll/tZGoitTeJq9j2KPH+1T+AOKht714DNTkRHUgYopnhzwloAocUT/tjlZ1AtEEi54PRMwO6mZqIEi3rGk8rZJpcnRX3lLHW95xypLEFiX36ZrAL0SJHsChhGJ2KEvi4BgywzcVrQbRRRktw9Q+/RDDgi0gJ+roEMlIi0zdRGVEUGuWeyda2m6t3By5tCudAmJuRkjVWUSLnfXEHmboB0q+hZ+w9OFrq6y2qUOmZ4Xra4rzjiK46jWjGZOWv0Tmij3W/j3F+PeUbTwnDMN4HvXu2bNkilgcNGtRi9Rl8JaiCQ3k+Blutz8ToogSiLDXVO3F9lJ/KZnP+FiU1hTVUW1TnucnVh5ES5epfGWC31kaTjCdVtDBbMI5j8TpFlER2iKSoNKXHhjtIkyvokqr/KAFKeBEFQfmufaRk50GiqhrXTa4S+GheulX/++4qpx1F9OodJoo1Ex01mCMlDGN4ULYqux825ycJ5gocKUqQnvKW9wzVgrITtb9FibbzZ7RHlTcWn3hK7H0S63PDKCw21CVRUrGnUi3xTRjqfpQE7D1sMVT6BtEPlCfLsmBtt9b1moygO6Ik2AgJMdGlU0109iTPhRanbxjGgH6SYBUlaHCGkmhvpm7sfSV5eXlUUmJNPejZ5OrrSInNDLhZJrUyqHJfFTXUNbjkJ4kf4pkoMVr6RiviyiuVShyJu5U3jHNYlDCMAStvgrUs2Bd+kkDPFtyacuAmoqS992fAleZEpCSkCRfdZZvzlWgrbxI8FCXa9I2chVfvDNREQVCxJNH2KPG06oRRYFHCMDoUJUhbyOkYmiPYyoL9JUr8mcLxVuM0zLjqi5JR7Qy4pp5WgVHwR4FfRAn2Ky7aGNGFAV0dV+BIUWKOJOqeHoANCyJYlDCMTqiurqYNGzaI5X79+okW8y0RHx9PaWlK7JtFiT5FiU2kJNM9UQJ/0cF836Ru7MuCQW5Xa1vVvGX5TrepZK3SYCQiNYIiPTC5olpFlgQbJXXjrAIH/VZ2HLCuDw01hsDSKyxKGEYnbNy4UVTRuJq6sU/h5OTkqH4MoxKMkRK1HDg9ikKj3SsHRv+Q6hrfpG4c9d/YFB5PYQlKUWb+8gKRxrGncm+lWk2EKIknLeCzC4jq6o3TOE3St4vSPl0bKdm0R6nIaesmV2/BooRhDGpyDUaza7CJktriWqrJV/rHRHd3r2mar02uDjuVZhElj1emIK4trKWS9SU+95MYofJGEhVpoh6N6Rm0U0fEx3bOG46StBYWJQxjUJOrhEWJa7Rv355iYmL82tXVxk/iicnVpnEa+QSbCpw9RCkTNCmcX/KbbZrmSifXFitvOhhrIJcpnMpqot2H7CtvArddwQKLEobRoSgZOnRomxYlaJ+flKRcsXsLpBlktGTPnj1ixnJDVd6kmHw+Ay5SEclHJzXrKylpbJrWmnJgo0ZK7D04SOG4Ozsw0zwsShhGB8BLgsZpoGfPnpSQ4PoVaLBU4MBAKUUJUje+mK5eihK05D9woNGd6I85bzwVJT5snOYohYMZawtio8ncOUrcxyzA9ZX1tp1cG9M3Ee0jKCrdfZMryMo2VuM0p3Pg7LGKktR2RB2SjBX10SMsShhGB8DjUFmp9IUYMsS9+cu7desmWrIbvVcJTLpos+8LP0mgfCU2jdN01mLe6dX/HhMlN6ZwGqobhDCRVO2votoCxSOTMNgzkyvYq5mML9NookST7vp5tYVyCpVljpJ4BxYlDKMDtAOkNvLhCmFhYeqEc9u3b6eGBuedONuqyTVQE/O1On3jB0+JoxlwbXwly/IcT8LnYepGm74JD0N0gQxF784o+1WWf7JmXFmUeAkWJQyjA7TGS+3VvLu+kqqqKtq7dy8ZEX+IkkBFSjBpXVhMmMeREgzeKZ55Sj3qvyErcEDerwVerbzRGl3RyRXzpRiJyAgT9cpQlrX6nytvvAOLEobRmSjRXs23JbNrsImSutI6qsmp8XgiPq0oSU/x7eAtZ8CVkZLI9pEUPyhONbbW5Nc0Mbl6OhFfcZmFisuMmbpxJOIknL7xDixKGEYHaAdIFiW+EyWZmZmqD8LXoqS1E/FVVVtE8zRf+0mczYArfSVkIcr/rcDW5JocTlEZihnWXWQnVyOaXJ2JEpxSjoQK4z4sShhGR5GSiIgIyshojA27AUdKXCMqKko9vr4WJa31k8j28r72kziaAReeD1tfST5VHayimrwa1U/iqclV26PEqKJkoMaDA3pmKMKOaT0sShhdlcV+/PHH9Pfff1NbAlegcoDs2rUrhUoXnRsEQ1nw/v37fR4p0aZwcnNzqbS0tFXvVZVdTWsuX0eHn8ulhroGn0zE549Iif0MuBt2EyWNbkchESa1iZpN07TBrTe5GrFxmsQ+KsKpG+/BooTRDQsWLKDp06fTUUcdRZs2baK2wuHDh6miosLj1A1ISUmhdu3aGbosWHpKMMkgbr7CW74SzAuz+rK1lP3FYSp4u5B2PbvbeaSk1eXAJr/PgIt5etodqZxTlVmVlP3lYS9V3hi3R4mkVyfFfCxhUeI9WJQwumHZsmXib01NDf3vf/+jtkJrTa4AoXSZwsHgLvt9GClaJCMlvoySeFOU7J63hwr/LLR+jk/tpsK/ixyLkq6KKJn9joV6nNNAny5rOtGdPf9s8U/jtOZmwFV9JUR06PNsdTlhqOelQMGQvgkPM4nSYAlX3ngPFiWMbtCmHd555x0RQWgLtLYc2JGvBP1KjEReXp4oZzaKKCnZWErbHtveJHKy9qp1oupGm75B59Pw+DCqrLbQAwsttOsg0WVPWKigxLkwySm00MtfKssR4UQTXJ91wKsz4KZMsJYGyxmDw9uFqx1fnbF6O9Hf2yKDrsW8lmG9NMvutRZimoFFCaML0PBLK0qqq6tp3rx51BZobeVNMJhd/VEO7C1RUl/dQGuvXkcNNcognXllFzIPVgbpij2VtPHuzVRXXkfV2dU2lTeb9xDVNXZsLypToibOePJ9izCcgitOQUmwye8z4KICBxGRsATb/ioJLZhc12y30NhriM5+NI0+UYKfDkVJ+0Qic6QxPSXgnvNNdNwIov9eZqLu6cbdD73BooTRBWj4Ja+UJRAlsvV6MOON9A1gUeIfUbJ9zg4q3ag02ojtF0u97+tJ6Q+nUWiMYlA+8P5B2vX87iaVNzCPannhM1t/heRwgYVe/FxZjowguvt8U8BmwDWFmmwaqbniJ3n9WwvVKJ3o6fH3lNScpLbOonpljBwlAf26mujH/4XQvReyIPEmLEoYXaC9spdXYQjpI43TlkQJ5rEJFlGCmXiXL19uMyjpIVKSmppK0dHRHomSghWFtOsFRV2Ywk009OVBFBoVShGdIqj/nL7q83Y8tauJyXXDbtvjUF1DIp1jz+PvWYQoAFed6p8oiaS/Zl6XLY2NgbWlwS11ckV05dNfrfdXbSP6S+NZP5hn7YJq1MZpjG9hUcLogi1btqjLV199tboMw6tR53JxFTkwduzYUR0sPQFRFinoAi1KCgoKaNiwYXT00UfT5Zdf3uJn6E9RgmMkoyUQTvX11llwmwNekbXXrBfNxEDvu3tS/EDrAJ1+dkfqeHpak9fJcmDtFPcxZuXvW4uJ1u20CpNDeRZ66Qtl2RxJdNcM/16F9+ls/X9bPRAlKzbaljKDuZ9Zgs5PwvgOFiWMLtAOoueff74YzKRY+f777ylYKSsrUw29rUndyMZg6HMij6crEQpf8ddff4lZf8HChQvplltucbo9+Izfe+89v4kS7bFGpdfBgwddes2m+7aI0ljQbnQidb+uWxOxM/Dp/hSVbmsCVdM3jaIkMZbowZnK4I9DctfL1uMy510LVSn9yejq04jSkv0rSmB2lWzZa1EjPdFdzapp15zZqKgc8MkvTT/jj35WUlJNK2847cE0hUUJo7tICdIQGMQkwVwerE0ftKbyRtK3b19V7Bw6dIj0kJICzz33HD3wwANNnvfPP//Q+PHj1XLgI444gnr10pQ16MRXcvi7HNr/zgGxDO/IkBcHCb+FPeGJ4TRk3kAizSoYXYtKLbQ/19qk7LozrJGC7/4i+nmVhQ7kWmj+V8pj0VFEd5zn/0G7j1aUZGnE1jMDqP3kFBr07ACnJlekbqSxFT08zj1WaUxXW0e04CtHjdN8tReMkWFRwuhKlLRv356SkpJo6tSp1LNnT/HY0qVLac2aNRSMeKvyRm++EntRAv773//SE088od7/+eef6dhjjxXeITBkyBD65ptvPG5f7ktRUr6jXP217P9YX7XviCOSxydT31m9yRRmooyz04VQ2bjHun5gN6XS5ZFLrft5x8sWeuxti/CZgGv/Q9Qhyf+iJCHWRGmNvtat1owapRydTCM/OII6TEl1+tq/t1jntZl0BNHVJxerJcYvf2kRJtdgaJzG+BYWJUzAKSkpUa/q5ZU+Wq3fdNNN6nOeeeYZCka8VXkjkcfPPvrkb3bs2KEu33nnnTbLqKr6/PPPacqUKSKiAxAtQfO8Dh38M1K5K0q6X9+NxnxzJGVe3oU6zchw6fnH75lEQ+YNskndaOdNmTGZaHDjR/7PFqJ5X1j9JrefG7jURt9M5W9OITXbS8Wej3+2PvesY4g6ta+nqWOU+/CZLPotOBqnMb6FRQkTcLRX9Nor/ZkzZ6qt099//32Xc/9tsXGa3kSJ3C/4XB577DF69NFH1XXXXnstnXXWWcLPARAVW7x4MSUmJvpt+7TH2lFUxxFouT5gTj+XIzmhZuscRtrKGznHTGioieZc2fS9rj8DPTwCKEo0KRxpdm0J+IU++UVZDgslOm2cNeKjNbzK9E1UhNKnhGHsYVHCBBzt4KkdVGNiYuiqq64Sy7W1tfTiiy9SsBGM6RtU2sj9wuAfEhJC99xzD9111102zwEXXHABffbZZ2Q2OzdP+gJpCPbHbMH2PUqQvpFMGUV07DDr/Vgz0W3nBNYAalOBo0nhNAciPVnZ1tRNUrx1WfpUflljfT9ESfyRpmOMB4sSRreREnDddddReHi4WJ4/f77L5ZtGQV6lx8bGCj9Na0H6IyEhIaCRkgMHDoiOvPZCCxETREkkSM+98cYb6ufrTxDBycjIcCtS4imIIshy4I7JRMkJ1sEYA/MTV5tEdAEgbaNdH8j0DdiS5Vr65hPNXD5nHaPdP6Lr/mO9L7++nLphnMGihNFtpASkp6fTiSeeKJbz8/MDmpLwNnV1daJPhowoeOPKEe8hj2FWVpY6+7A/0Q7y0qwst+3555+nr776ipYsWSKqqhBFCRRSAMNo68t5lg4XEOUXN42SSEb0NdHyuSZ6f5aJ7ruQAo5tWbB7qZvQUKLTj7Jdf+EUJQKkhStvGGewKGECjhQaERERNmF1ydixY236XwQLKIOFMPFW6kYvE/M1Z96FCIGHZNKkSQEP3w8ePFhdXrdunX9SN05sQ6MHmOicSSYKCQl8SgNRDHg+XPWUrN5GYpJBgFRUip0fJj7GRBdNsf8fgd9PRp+wKGECCtIxcuDEVXVYmO3kX2D06NHq8ooVKyhY8HbljV7MrtrKG2/ul7dBCbJfRImDyhs9A2HUu7F/3Y4Dynw1zaFtmHbWBMf7d60mhQM4fcM4g0UJE1CQvpBVGPapGwkaaskwfzBFSnwlSgJtdnWWvtEb3oqUoNy1tNK52LCpvPF8aiO/Is2pmNUYE/M1l7r5+GdlGV/R/yiNmB1OXjdxuPV+16bd+BlGwKKECSjaQdOZKIEJdNCgxn4PGzaovS2MjrfLgfUSKZH7hV4zmZka16TO6N+/vyp2PRElm/ZY6Ix7G6jLNKKJt2eIvh4tpW+0E97pmb4OOrs6Yt1OJZoCJgwhSm3nXJyh/DklgWjMAKJxyteZYZrAooTRVXt5Z4waNUotJUVr8mDA2+XA2veCIAiEKMGVs0zfdOnSJSCVNe5U4MhzbtOmTaLs3BX2HLLQzMcaaNBMC32+XHksvzSU3lviuPX6xkZR0j2dKDZa/+kb0LeLySWzq7Zh2rRjm9+3kf1MlPOliX6fZ6LwMGMcB8b/sChhdFt5E+y+Em1EAQO4t4iMjKRu3bqpkSh/zrKMCil06NW7n8TeV4IUYkupLkwqd8NzDdR7hoXe/B6Cw3b9B0ubvgbNwsoqjZW6sZ8DZ2vjxHwOUzeNc93As/yf8S2/L8zNgTY4M/qGRQmj2x4ljiIlweIrwQ+6FCW+iChIgYeSYPQN8RdG8ZO46yuZ97mFepxroRc+VSaYA+3ilJSEbBWPuV92HrAdwGV/kuYqb/RIH81Ezc4iJdv2KTcwfrD/ZzRmghMWJYwuIiVpaWlq0y9ng2x8fLwaKcGgbmQKCgp8GlHQRp38aXY1SuWNu6IELdHLK60z+N5zAdGuD0x05wwTnXec9Xkf/tRcJ1fjDNpIM3Vq37wo+V5zbXDKWOPsG6NvWJQwAaOwsJBycnJaTN0AGBKPPPJIsZydnU379rnY/7qNVd44ijr501fi6/3ypShZu3at0+edOUExaF5/JtHO90306OUhlBinDMTTjrE+74OltmJ5wy7jVd7Yp3AKSojyippeBHy/0mLTLp9hvAGLEkb3qZtg9JX4qvIm0BU4RkvfdOrUSZ30sblICXp3oOvq8zeGNElTdO1INLxnlZqu2agpAZaRErSR1/o0jEBznV0rqy20bLWynNGeaIDBBBejX1iUMLo3uQajr8RXlTeB7lWiTd/4Qmx5G5guZbQEs1Cj5bwzMKuvM6aOqmgSLUHTMTmYQ5BEhBsrxaGtwLHv7PrrWqIqpb0QTTmSJ9djvAeLEkbXPUqciZJgipT4QpSkpKRQUlJSwCIl8AhhlmcjoE3hrF+/3qP3OPnIctE8TFbhiNLo/UQ1tcZM3QBtZGeLXQXO939pUzfGEluMvmFRwui+R4kEs+jKq+9Vq1apnWCNiK/TN9qJ+TDHjj8azuF/yIntjJC68WZn1/aJDXTMUGUZzcRWbTOuydWV9I00uaIdznFH+He7mOCGRQkTcFGCJlau9umQvpKqqiqfzlfir/QNIhqyqsjbaIXetm3byNcYzeTqaA6c5syuLTF9onX5/SUWWq81ueo/k9UEeEVQaWSfvsnKtqalRvcn1fDLMN6ARQkTENA9Uw5ivXv3VjuQtgVfCQSV7B3iy8Hb32ZXo4qSAQMGqA29WiN0zxivGFplaTBasEuMmL6BuVf2K9l1iKi6RhFZi1danzPlSBYkjHdhUcIEhN27d6ttvV1J3QRTBQ72XfZZ8aUZ1N+9SoxWeSOJjo6mXr16ieWNGzdSXV1jdzQ3SU4gOkGpWqf9uUTfNWpmcyRRt45kSPo2Tl1UX0+086AjP0mANowJWliUMIaovNGG2iMiIgwdKfF15U2gepUYrXGaI18Jolja/XCXcyZZIwfS5Ipy2eYqd/RMn862FTioKFryr3Ifk+sN7x24bWOCExYljCF6lGjndRk+XJkDffv27WKuFaPhrzQHojBhYWFimdM3/vGVnDqOKErRzIZO3Tgzu/65gai0sfr5+JFKiodhvAmLEsZQkRJ7X8nKlZoEt0HwdeWNBPPpyDQKjK6+nphP7hemC5DlyG2pAgfEx5jo5DG2jxmx8sY+fSMn5rPt4mrc/WL0C4sSxhDlwMHkK/FX+kZ7bJGW2Lu3mTnoWwnKs+X7QwgZbSZYb4kScK4mhWPUyhtJr062kRLtfDeIlDCMt2FRwgQ0fZORkUGxsbFuvVZvFTjV1dV000030Y033mgjOOypr6+nZ599lpYsWaKWQnfs6FsHpL/Mrnv27FEjMUbzk4DMzEyKi4vziig5aQxRrDk40jfRUSbKTFOW1+4gWr1dWYaXpEOSsYQnYwxYlDB+B628pRfE3dQN6Nq1K6WmpqqixNdpiZZ477336LnnnqPnn39e7M+1115Lhw4dahIZOvroo+nmm28WUQtw3HHHiYkGfYm3za6IhkCEBUs5sKN289hHTBbpKeZIE115qrI8si9RegoZGukrkW3lAVfdML6CRQmj+/byjgYQGS0pKioShtdAok0hocx53rx5YmC+++67KTc3lx5//HEaOnQo/fHHH+rzrrvuOnr//fd9vm3e6lWCEmZEg7p160bnnXeeWs4t0VasGKkc2JnZ1dN285LHrzLR36+Y6JcXTIZLZdkje5Vo4f4kjK9gUcL4nU2bNnnsJ9Gjr2T16sbpUonU+V4qKytpzpw5Yg6Yu+66S40uYMD+9ddf6YUXXnA7bRXIifkQCcJN7u/ChQuDKlLibV8JSoBH9DWJqInR6Ztpuw/xMUSjBwRsc5ggh0UJ43fQoErbTdMT9OIrQaMteVWNBlzwlMBbInupyNQSrpZvueUWUW46fvx4v20fqmAwZ1BrIiXffPMN3XrrrTaPPfzwwzbz6bAoCV7sIyWY6yY8zPhii9EnLEoYv6MVJQMHDvToPUaOHKmGxQNZFozog/SIIEUDrwvMrCjBveSSS0SfEOwjUjdPP/206B7qb2QKBz6XkpISt14LwXXOOeeo4kp6eTDx3jPPPNMkfQPzbnp6OhkR7bnYml4lwYa2LBhwKTDjS1iUMH5nw4YN6mR0cpBzF0xiJ1MTCLU7Ml/6gzVr1qjLw4YNs6nmQIqjtLRUbJ823eRvPK3AgfCYOnWqGhGZNm0a/fzzz+o8RU888QTl5OQIwYLW+bLviq/Nu74C1Tcy9YRzFNVSDFHHZKI4jZaWrfQZxhcY89eDMSwFBQWUnZ3dqtSN5IgjlDnTYbqUQieQfhKtKJEgchBoo6MnFTiI/px++ulq75ERI0bQG2+8IQTO2WefLR6DWPnvf/8rJheUotCofhJ7X0lFRUWz5d1tCZy/UohMGErUpQOnbhjfwaKEMZyfxF6UgH//bZyQI4CREqRv9Ii7kRJU2iD1JA3EnTp1oi+//FJNPcEzIw29L7/8Mi1evFh9bbCIEm+YXYOJN+8x0XdPmuiLR1mQML6FRQnjV4JJlGDwlpESVNngpndRsnnz5haf/8EHH6jlyhAfX331lU2TNxhnYdqVUarbbrvN8OXAjkQJ+0psm6jBS5IYx6KE0ZEo2bdvH91777106qmn0sUXX0xLly61WY8QLnoyIA997rnn0g8//ODWeib48aYoQbpEpkYCIUr2798v0lF6jpLIZnMyyrFq1SqXqm0kr732msN9QzWOrOopLi4OmkiJtlcJR0oYRueiBKHaY489lubPn08zZsygWbNm2Qwyc+fOFfdRfXDppZeKskHtlVlL69sSuML8888/Re66LeFNUQJjYu/evdUqEcy/oic/iV6AMRWeENkOHgbW5pBpG/hh/vOf/zg99g888ECTx40uStAcTqam/DGzMsMwrRAlMLWhNTZCufjbv39/1WAIpzryzmixjRAu1kPALFq0yKX1bQ1EnMaOHSvKEKXxsy0gz5cOHTqI6pvWIlM4ECT+NrtqRYmeIyVAW/3TXF8XTAEge44MHz5czDTsjCuuuMJGhED8oOrIyKBy6LPPPhPiOVDmaYZpy7glSrRVBLjiQhmgzMGiB0J5ebkQKtorYfRrcGV9W+PDDz8Uf3EMUeWADqDBDlqu4+aNKIlERgACkcJxVg6sR7TN5prrgKsVLC2VMaNB3GOPPabe79Kli9o0zsgcf/zx4ncKPWYYhvEvbn/r0B4bVxIoB7zhhhuoX79+4nHZy0DbOhshXvl4S+sdgatf+5A8fiha88Mnm0AFchI3XI1qp5HHQACPzrvvvhuQ8lF/HRPtfCL40ffG/9OKgX/++UekBf11TGSkBOc0wv6BnhiwOY480tpcorlJDLWCBQ3q7J9nf1zOOOMMmjx5Mv3444+ij4mej4Gv0MNvit7gY8LHxBGu9DByW5RcdtllwqSKSdDgCZGpHOSfAa74pakOfgmzWZnDu6X1jnj99ddpwYIFNo/hh2/69OnUWmDaDRSY+8RR5ATVGyi3DBS+PibLly9Xl7GvWVlZrX7P5ORkIeRQCQOPjjfe05VjAnOn/F/oAxLI88lV8F1FxBKiBD04ZBM0LcuWLVOXUQrs7Hhq9xdeMbxv586dvX78jYQRzgF/w8eEj4kWXLx5XZRAROAGPwCukH777TchSjIyMkQEA/noQYMGiediWW5ES+sdgegBDLXejpTgi4If0EB1nkTVhgQtvCFIMKhiwjNcnUL0+RN/HROtdwbzv3jLfwCzK/pv4IaB1xsphJaOCTqbatMcRvBSwMP06aefijQqLgjsW/xjn2U0C6JxzJgxTSJ3zo6L0UuBW4MeflP0Bh8TPiae4rIowZwZSC9AJKDFNzwluPKV3R1hiINxFSWEs2fPFgMvmiph2ZX1jsDg4qscNX48AvUDoi3LRAUDfBGy1wPSDzAPBqItua+PiXZ2YAhTb/0vmF0hSJDqw/+AQdPXx0RbLooUkhEGI5xTECVyviBtTw6AYyjLe/FcR5EUPXx/9AofEz4mfJ60Hpd/VZA3hxhB+gRXuRg8J06caJNKuf3220V76mOOOYZmzpwpBIx2cG1pfVsB3geA0kNc5aMRFdJispfLaaedFnRhcESCZDkwJmxr166d1947EE3UjFIO7E4FjvYxrTGWYRhGd5ESXAVAROAGYSE9IloSExPppZdeEuuRZrF3r7e0vi2gNbliMJNXoy+++KJIZyEtgEnObrrpJvr8888pWEBvjPz8fK9W3jirwLn88svJX5U3OIe9vT++AhEknG8oz3dUgaN9rC1eLDAME3g8ir86EiT265sTHC2tD2a0V/LawRRpqk8++UTt3YFuucE0S6k3m6YFurMrRLVMRaGKKDIykowADOayYyk+D8xg7ChSggsQ7bnJMAzjLzgp7Ge0g6Y27QCSkpJowoQJYhkDhtaDYXR8KUq0nV3h9fB1Z1fttPZ6b5pmj0zLIJ32999/q4/D/Cp9MjDAakv3GYZh/AWLEh2JEoCKBwlKXIMFX4oS+86u2v/V1pumueorwXkpe0uwn4RhmEDBoiRAokSaXJsTJX/88QcFC/4SJf5I4RjR5NpSZ1f2kzAMowdYlPgRGD1lVY3W5KpFO99IsERKtJU36OWAKi5fihJZ3eSPSIl2Vlkj0KtXL7XyCZESfDZyWcKREoZhAgWLEh2lbqQJWPbZwLxAsmLFyKDbZ1FRkVj2VaWKNmLhjUgJOps++uijTaavh5dk7dq1YhmN/1BRZiRgYpUt51ERJUWyjJRAMMqpIxiGYfwNixKdiRL7FE5zk6cZBe1sq74SJRhM0e69tWZX+CowfQK6FC9cuJCOOuoo+uGHH9T1KNuGKdSIJldnvhI0Mjx48KC4j47C3BSNYZhAwaJEh6IE7cAlwZDC8bWfxFtmV3QzxYzNs2bNUtMaECBTp06ljz76yPB+Eme+Eq3w5dQNwzCBhEVJgEyu8qreEcFWgeNvUeJJCgfbiCjBV199Je6j74mcG6a2tlbMUTR//nwbP4lRIyX2MwZr/STcNI1hmEDCosRPwBuC+YLkYNbcvCKYnRU3OUeJ0ZuoaUUJmo3pTZR8/PHHIkKAma8BjKDffPMNffbZZ3TJJZeIxxA5ueqqq+iVV14xfKQEMyvD8CrnYdLOWs2REoZhAgmLEp2lbuyjJWVlZTaeDKOBwVw2gevatatPm3J5YnZ9//33xfxNWp8IXnvCCSeIrsMQIXfccYf6/IKCAnVgx8zXRkVGRDDXEoSvNO6mpqYGeMsYhmnLsCjRuSgxegoHJkrMMA18PUcMzK7azq5Iu7TE888/ry6ff/759Pvvv4vBWYI0zuOPPy5uzlrbGxFHERGOkjAME2hYlAR4zhtnBEsTNX/5SewFHyIALZldkRZbv369GsV56623xPwwjkC05NVXX1UrU6ZMmUJGxpF3hP0kDMMEGhYlOjO5aq/EMUmf0SMl/igH1qIVfC01UdOW97oS+bj00kuFB+PDDz+k66+/nozM4MGDm0ysyZEShmECDYsSnZlcJZh5Vl7179ixg3Jzc8mIBCpS4oookU3Q3OnMiufBgyIFo1FB12DtscL+GNW4yzBM8MCixA/g6todP0kwNVGTogRRCH90CkU3XBnx8IUoCSa0kRGIZQhhhmGYQBIW0P/eRnDX5OrM7HrKKaeQXkEaBPuJlMiuXbvEbffu3aog6969u1O/hjeJi4ujvn370ubNm4XZFd4SZ4NtMPQcaQ1aDwmnbhiG0QMsSgwkSvQEKlv+/vtvWrp0KS1ZskRsX3PVLv5MDcBXAlGC7YEwQVO05iIlCQkJlJmZSW0NiNxx48bRvn376Nprrw305jAMw7Ao8acoQaQAV/Gugj4YXbp0ob1794peEnV1daJ3RqBLfG+++WZavHgxlZaWtvj89PR0GjRoED300EPkLyBC3n77bTWF40iUwOeDfZGpGyOX93oKjK6//fab6CXTFvefYRj9wZESH4NmW0hjuGNytY+WQJRUVFSI8tVAmxEfeeQR+uSTT5o83qNHD5o4caKo6kCqBjdEH8xms9+3UVuBg2jO1Vdf3eQ5bd1PooUFCcMweoFFiU5NrlpRghJUgBRJoEXJL7/8Iv5CXKEKZdKkSeKGPh96QYo/9CFxZnZlUcIwDKM/uPrGx2gHRU9FiV6aqCHqs3XrVnVf3nvvPdG7Q0+CBCA6IyfTQ/UPokzNiZK2aHJlGIbRIyxKfExrJzvDgCmbXAXa7KotS9aKJT0iUzgNDQ20evVqp5U3iKj4o38KwzAM0zIsSnwIqj+WL18ultPS0lzq5GoPmlrJCAvKbHNycihQaEXR2LFjSc9oza32KZyamhp1kkB8JvadTRmGYZjAwKLEx1U3mOUXHHPMMR4bCvVSGqz930aJlEizq5YtW7ao5cucumEYhtEPLEp8yM8//6wuH3vssR6/jx58JTCN/vXXX2qpcufOnUnPoAxZtoK3j5Rom6a19cobhmEYPcGixIcsW7bMK6LkqKOOcvie/gSGURn10XuUBECQSMEBc25xcbG6jitvGIZh9AmLEh8B3wIaU8nIQs+ePT1+r9TUVOrfv7+aEiopKSF/Y6TUjSNfibY0mytvGIZh9AmLEh8BH4MsRW2Nn8Q+0oI0ijTP+hNt2sgoosSRrwTdS2X6pkOHDuLGMAzD6AMWJTr3kzh6j0CkcGSkBGkRzMRrBBxV4Bw8eFC0mAdscmUYhtEXLEp07ieRTJgwwaHg8Qd5eXm0fft2sYzyZKNMcY95huTMxDJSwn4ShmEY/cKixAdUV1fT77//LpYxoV63bt1a/Z4pKSmiogSgGVhRURH5CyM1TdOCyQtlVGfPnj1CXHHlDcMwjH5hUeIDUDpbVVXlNT+JfcQFXUq1nWJ9jRFNro58JUjhsMmVYRhGv7AoMYCfJNC+EiOLEntfiRQlSEH17t07gFvGMAzD2MOixECi5Oijj1ajLv7yldTV1dHKlSvFMhqmobzZqJESzHC8bds2sYwJ+5DeYRiGYfQDixIvg7SN9GDAS5KZmem1905KSlIbguGKH7P2+poNGzZQeXm5IaMkAP1hEhISxPLSpUtFSTDgyhuGYRj9waLEB6kOGF2ln8TbyMgLBldc+fsaI/Yn0RISEqJOaCgFCeD28gzDMPqDRYlBUjeO3tNbKZxXXnmF7r77btq3b5+hZwZ2xVciYVHCMAyjPzipbjBRMn78eHH1jwocb5hdFy9eTFdffbVYRrksREi7du2aiJKoqCjDpjy0vhIJixKGYRj9wZESL4K28nImXXgZOnXqRN4mMTGRhg0bJpbXr19Pubm5Hr9XbW0t3XTTTep9TFw3ffp08TjIycmhnTt3imWkQOSsu0aPlHTt2lX1mTAMwzD6gUWJl/0XckD3hZ/EUQSmNb6SuXPn0pYtW2weW7JkCV1//fXCf2HUpmn2oIEdms9JjBrxYRiGCXZYlBgodeNNX8nhw4fpwQcfFMsoM541a5YaCZk/fz49//zzhu5PogX7p03hcOqGYRhGn7AoaYaysjL66quvqLi4WFei5KijjqLQ0FCx7Kmv5N5776WSkhKxfPHFF9NFF10kDK+SW265hd56662gECVg9OjR6rKsxmEYhmH0BYuSZrjyyivp1FNPFXPOZGVltShg5KRvffr0oY4dO5KviI+PVwfWTZs2iaiHO6Cz6Wuvvaa+16OPPiqWL7jgAiFWAIy0mFEXoNeKL/fHH1x77bU0ZcoUIb5OOumkQG8OwzAM4wAWJU6Ap+Lbb78VyyiVnTRpEh06dMjhc2tqaujSSy8V3U997Sdpbct5iI0bbrhB7dmBFE5qaqq6/uGHH6azzjrL5jVGLQXWAk/Jd999R2+88YYaZWIYhmH0BYsSJyD6oJ2JF1UokydPpvz8/CYRklNOOYU++ugjcR+tyyFQfI2nvpJ3331X9Yr069ePrrvuOpv1KDd+8803bVIcwSBKGIZhGP3DosQJmzdvbvLYxo0bRQpAejHQ5h1C5YcffhD3zWYzLVq0yGGzLm8zbtw4de4WVyMlpaWldOedd6r3n332WQoPD2/yvOjoaPryyy9FmuPkk08WnhOGYRiG8TUsSpwAr4bk9ttvVz0V8GNMnTqVtm/fLibIk2Wz6HsBceIvv0JsbKwqftBfRPo/muOxxx5TU1CnnXYaHX/88U6fm56eTt988w19/fXXFBMT48UtZxiGYRjHsChxIVKC9Az6dyQnJ4v7y5cvF6kPRE5AWloa/frrr6Iqxp9oUzjYvuaA7+XFF18Uyyj9ffrpp32+fQzDMAzjDixKXBAlECD9+/cXLdlRrQLq6+vF3+7du9Nvv/1GgwcPJn+jjXRIU64zsI1I34Bp06ZRjx49fL59DMMwDOMOLEpaSN+gakN2A4X5EykNeEcASoUx2AdqgIcBVbZLh2CS1T+OwHZLkH5iGIZhGL3BosQBqLrJzs4Wy4iQaEGKBmkbVLGgrXwg+3fApHrCCSeo26ztwOpMlKC6Rr6GYRiGYfQEixIXUjf2dOvWjc477zxhNg00qI5xFA3RgnJmmGFldEU7CzDDMAzD6AUWJS1U3jgSJXoCJcqY26U5X4n2ca2IYRiGYRg9waKkhUiJffpGb6AbqywNXr9+Pe3du7fJc7QRFBYlDMMwjF5hUeJB+kZvaIWGfbSkvLxcba7WqVMnGjhwoN+3j2EYhmFcgUVJM+mbuLg4ysjIICOLkp9++omqq6vV58lUD8MwDMPoDRYldlRUVKgzAiNKYoRBfNiwYdShQwexvHTpUqqqqlLXceqGYRiGMQosSuxAlYqcQdcIqRtZ5ivb20NUyXQN9kOKksjISJo4cWJAt5NhGIZhmoNFiYErb1pK4WzYsIH2798vlo855hiew4ZhGIbRNYYTJd9//71P399IlTdajjvuOHXWYERHtFESwFU3DMMwjN4xnCg566yzqLa21mfvb7TKGwnazY8fP14s79q1S6ShWJQwDMMwRsJwogQlrqtWrfJ5+gYeDHRuNRLaaIhsgw/69OkjJg5kGIZhGD1jOFECfvnlF5+8LyIwO3bsUAfy0NBQMqooeeqpp6ihoaHJ4wzDMAyjVwwpSn799VefvC8EiZxp10ipGwmElIzuaMuCWZQwDMMwRsCQomT58uVUX1/v9fc1qp9Egp4q9gIEDeAwszHDMAzDBJUoQYnp7bffTmeeeSbdeOONtG7duibpj2effZbOOOMMuuiii9R+Ga6ud5WSkhJau3atW6+pqamhjz/+WGz7rbfeSmVlZc2WAxup8kaLvSiZPHkyRUREBGx7GIZhGMbrogSD+NNPPy2adOHvkCFD6LrrrqPDhw+rz3nxxRdp5cqV9N///pfOPvtsuu+++0QViKvrfZHC2bZtmxBSmPdl+vTp9MUXX9Dnn39Ojz76aNBFSmQ/ErPZrN7n1A3DMAwTdKIkJiaGXnvtNTr22GOpa9eudMkll1BycrIaLUE6ZdGiRXTDDTeIKAPEy4QJE4QIcGW9t82uP/zwgxig4bOA6TM3N9dm/UsvvURFRUUORQk6pPbq1YuMSFRUFE2ZMkUso2/JiSeeGOhNYhiGYRjvihL4FbTzwJSWloooCSIQ4NChQ+KxAQMGqM8ZNGiQGglpab2rtGvXTo2UyOoSe9DFdOrUqTbCJTw8XERnZOQA24LIjQTvtWXLFrHco0cPURJsVBDJuvjii+ntt9+mjh07BnpzGIZhGMYllBagboJuoUh/jBs3Tk1zSI9GbGysjclSPt7Semc+ENy04H9+/fXXVFBQIDwuAwcObPI69OiQDdYQ8bjiiivoggsuoPbt29P27dvpu+++EyIE/hZ4Y6Kjo2n37t1UWVkpXoN9ciZ4jEBmZia9+uqrYtmV/ZDPMfI+exs+Jnxc+Fzh7w//pngXZCF8Ikoef/xxESWZN2+eTdoAYGDHIC8nh5OPt7TeEa+//jotWLDA5rG0tDR1Gd4QCBt7wYQ0k+SVV14Rg7Sc/RemT0RLvvrqK8rLy6Mnn3ySZs6caRNVSU9PV2cKbkvs27cv0JugO/iY8HHhc4W/P/yb4h1caUjqtiiBPwMRCngytIZKDORIkaDFuYxeYBmCwJX1jkAKYsaMGTaPwcMi26djO+xfj6ocmFvBmDFj6Oijj25yBXzVVVcJUSKFz9133035+fnqc0aNGtXsdgUbOCYYfDt37uySkm0L8DHh48LnCn9/+DfF/7glSp5//nn6999/6eWXX24SoUAEAsbVN998k2bPnk0HDx4UZtOHHnrIpfWOwGvsy1mPPPJI8b/hCUG/Enuvy3vvvacuI2XjaJBFegbREogbDMYffPCB6icBEE1tcXDGPrfF/W4OPiZ8XPhc4e8P/6b4D5dHoOzsbHrrrbcoJyeHzj33XFE9g5u2egalt4g4QHzgOehHom3c1dJ6V0BFiXwNUkgyKiIrfKQowfNQAuyMu+66S12eM2eOiLpI+vbt69Y2MQzDMAzjx0gJTKLaWWcl2ogJSoTh5yguLhbVK/Z+kZbWuwpEDcyqAF4QlP2Cn3/+WURgAAQT/p8zxo4dK1I7qOLRVgAhhaE14zIMwzAMo7NICSan69ChQ5ObNK1qSUhIaFZwtLS+JbQ+EW0TNZTAalM3LXHPPfc0ecyonVwZhmEYxugY0kAwYsQIVQwhUoKKm/Lycvrss89U0YM+JS1x/PHH07Bhw2weM2onV4ZhGIYxOoYUJajiQfpFNkrbs2eP6BYre55MmzbNpUgMDLKovNHCooRhGIZhAoMhRYl9CgfRknfeeUe9f/7557v8PjDb9u7dW73PooRhGIZhAoNhRQnMrhLM/ovyYtClSxcaP348ueOVeeaZZ0S1zvDhw2n06NE+2V6GYRiGYXzQ0VUPoF8JKniqq6vp22+/VR9HszV3e22gUgd9T5AWgkhhGIZhGMb/GDZSAs8IOq/a407qxv79WJAwDMMwTOAwrCixT+EApF+4pJdhGIZhjElQiRJXepMwDMMwDKNPDC1KYEqFQRXAR3LOOecEepMYhmEYhmmLoiQmJkaNjlxyySWUlpYW6E1iGIZhGKYtihKwcOFC2rt3L73yyiuB3hSGYRiGYdpiSbC2Kysm0WMYhmEYxtgYPlLCMAzDMExwwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdYLJYLJZAbwTDMAzDMAxHShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QVhZFDee+89WrNmjVgeMWIETZ8+3WZ9fX09LVq0iNavX08JCQl09tlnU8eOHdX177zzDq1bt069Hx4eTo8++miT/1NXV0ePPfYYdejQga688krSM7/++it9/fXXYjktLY1uueUWh89Zvnw5hYSE0KmnnkoDBgxQ1y1btoy+/fZbm+fjPfBerqzXIzt37qT58+er9/FZhoXZnvabN28W+1VaWkrHHHOMuEl27NhBr7zyis3zca7hnJM0NDTQd999R3///TdlZGTQ+eefT2azmfQKzul77rlHvY/zukePHjbPycnJoY8//piys7Np0KBBdMYZZ6jHrbq6mu6//36b548ePVo8B6xevZref//9Jv/3iiuuoJ49e5Je+d///if2F0ydOpWOPvpom/WVlZX00UcfiXOqU6dOdN5551FsbKy6/qmnnhLHTYLn3HDDDer9iooK+vTTT8U5lZiYSKeffjp169aN9Mwnn3xCK1euFMuDBw8W57YW9N7Eb86qVasoLi6Opk2bRp07d1bX43j9888/Nq+ZM2eO+P1x5fV6ZMWKFfTZZ5+J5aSkJLrrrruaPOfPP/8Uv5f4bTj55JNp6NChNuvxHfr8889p06ZN1L9/f7HfoaGh6vqtW7fSF198QVVVVXTcccfRuHHjqK1g2EgJviDHH3881dbWig/Wnocfflh8oXAy1NTU0MUXX0xFRUXqeggSiBW8B2744B3x9ttvi5Pw33//Jb2TmZkp9gUCCttszwcffCCEV69evSg1NZWuvfZa2rBhg7p+z549VFZWph4T3LQ/ui2t1yP40cB2HnHEEfTTTz8JsaoFAygGy/j4eBo4cCA9/vjj4sdAkp+fT1u2bLHZZwgP+3Pt3XffFQIP4nb27NmkZzAgyH3566+/qLCw0GZ9QUEBzZgxQ3xfRo4cKQYNDCQSHEMcy4kTJ6rvgx9WCcS/9nh17dqVfv/9d12LVzB27Fixvfv376esrCybddjnq666SgywOCbbt2+nq6++2uZ8wkDUu3dvdb/HjBlj8x433XSTuCjA6zEYX3jhheJ/6Rmc09gXnDPaizjJE088QW+++SYNGTKETCYTXXLJJTbCDL/NEOja8wHPc/X1egRiE/vRpUsXcV7b8+WXX9J9990nzns89+abb7YZP3DO4NzBuTB8+HCxvwsWLFDX79q1iy677DKKiYkRFwu4gIDAaSsYNlKCAQQ3DKpasQHwI/vNN98IUYITQw6ouI8PW9KnTx+nYgTgBwNXwLgy/uOPP8gIogQ3nPQYbOxBdAg/jCeeeKJ65ffaa6+JK0TtgNLcMWlpvd5o166d2N59+/Y5jbjhivXyyy9Xn//000/Taaedpv54Qng522dE4vDDhKhcdHS0eKykpIT0DAYYuT+OBBRECH5M7733XnF/1KhRInKA745WWBx77LEUGRnZ5PV4jvZ5uNLGc/UuYBHtAfgs7YF4xW/I4sWLKSoqSnyHcI5gYMG+SRBBs78qBsXFxSIaAMGLYwvw24WLh7POOov0Sr9+/cQN0SHctOD3A5EfiAo8Bxw4cEBc/GgjRIiOOfr+uPp6vYHPDzec+zgfHP3OXnPNNXTmmWeqkclXX31VXBgBRGVxobxw4UL1N0b7m/H++++LaO11112nPobnaiO4wYxhIyXNgatboL2ixbJM90iWLFkiwtBQqfZXiwBXh/hyREREUDCAK2DtMUlPT6e1a9faPGfjxo3imDz//PO0e/fuJu/R0nojniv25wmuXA4ePKg+lpeXRw8++KAIzyNFowURA4T5MZA/8MAD4gfW6OeL/TFBVA2pG/vvD6JKiLzhR9bZFFoIU//4449C1BgZnAPJyclCkAAcD0Qk7Y8JImY4VyB2EXqX4KoXkdnDhw+L+4jw4jjjO2jk3xOkJ+x/U+yPyS+//CJ+M5BGxXF09/XB8JuCKBP2FcgoI4TKQw89JFJBWsG+bt06cSGgFctI5+C71BYISlECFYsfDxlaw48Dwmda4XHBBReIKxR8+PjAzznnHPElkSBCgvc46qijKFjAFYs8JhhEEG7GFZwMQUOJ42oY+UtcxSB/jEiApKX1RgSpLBwHOajK4yPPFay/4447xD4j533bbbeJqzsJruxwtQyxhrA8Imp6vspzBewzIgPwQAAIMQyiMiKJK0QIdqQ7unfvTi+//LJIYTkCAxIiSEceeSQZ/bsDoYpoCYBwRQpH+5ty++230wknnCAiJRBi+K7gKlmKGIjaRx55RJwfiL6ecsop4hgaFYgyfCfkdwbnCM4VbeQa+4nfVvzO4tjhvvTtuPJ6o//OAixDUMjvE34zPvzwQ3EfaStEhrQRy6KiIuE5kiB6C0GD3+q2gGHTN80BMYHBA1euMOnhJMAXQGskwuO4AVzFIZeJ0Cr+IpT20ksv2RgkgwHkNnFcEEYuLy8XJzsUujwuSHXJdNeUKVNEaPGtt96iJ5980qX1RgSfN7wC5557rvCVYPDAfuGqVnpStKFnXPXg3JChWQg6HEdc8UjhNnnyZDFgYXA3IvhsIcphvoPowNUt0nY4PgDni/aYwDsBgY+Qdfv27W3eCxGkk046STU2GnmgwTkCbxp+N/bu3StMqvI80aZ/5DGEkRwD0oQJE4Q4gWEa74NzBL9JMDpiWc/m3+bAdwWCHQPqV199JcQGfmdxwSKB10j6jfA7i3MEoh5+Nldeb0RuvPFGccOFCtI0OEfgNZPpXfxmwBOJ54C+ffsKf9Gtt94qxi58v6SYlWIN2Bv0g5Wg3Uv4BPBjCac7DEkYPJv7UDHYytAirnxxUjzzzDOqtwRXRvgCwZhlVIYNG6Y6vjHAwMAJ46ozMCChMsXT9UYAP4K4UsExwY8FfhRQjaKt1NKCgQgRNURWIF4Qbtb+gODKDzdt1M1o4Hsyd+5ccX5gP2B2hH8CfiVH4PuF1+D7oxUluA9vE35sgwEMIvhdgT8JAwl+D5wdE5xHOIfkbwouBLZt20Y//PCDehGAMD/OPZgijQq8NYgQYt/wXUAqorkreilyPX29EYAIk7+zECIYP3Jzc1VhjgsbbdoO54mMhEQ1njeHDh1S12MZj2ujJ8GMsS9fmgFhQPxAIuwOpYkfA1z5AajX3377TX0uQrAwnElFD0MSSl2lWxyGWFnFYWRgrMMPIq7o8KVA/huhVQlynTKNgWOEELQ0oLmy3ohggMGPJAQbwu4w/mrLX3Glq/UGIIKAAUka1OAn0Zqt8UMEoWdfYmskILKQ7sRni+8PyjoxmMjycaTs8CMrwXcLPhr7ARpmc7zG2cBtNPAbgX1BSheCDRU6iIgARD7wmASRMlwQye8HPCWIAGjFKl6jd/NvS6AaCYMl0lD4ziDigfYLkqVLl6rLiECjHYH2N6Ol1xsR/AZAZCBliYtdXBBr92n8+PHC/C0jIPiNwfgC7xbAdw6/M/JiB8ZrPGb0aGPQR0pwssP5jC8+PlxcteDDRp4WIP8LIx6ECa7mUYKFH1aADxcf9AsvvCBOBAwq+NARZgZQqtorZURJ8AOi96oTeGPg0sb2wlCHY4Ire+w7QCQAXhrsG35AUTWAHLj2h/S5554TP7xw2uPYaXuztLRejyBNhdSKFBa4KsUAKnvSwB+BiiT8MEKg4Nho9wmvxw8KeifgmCI3DG+ABFd5kyZNEs9BOSjOJXgGUlJSSM8g4gcxhrw20goQHjgOEKv4fsCwi/QlBBaeI6OGAKFohN9xzPDDiRJGGBlleForSow0wMjeR7hqh+iC+EJaSvphEPXBbwauWuGPgKFVigqUvc6aNUuIdTyG1yIkLy90IM5wnuAiAFWD+H3C7xZeo2dw8YYSV5ja8V3AbwqOh6wYQrQHPhFUW2Ewvuiii2zKw3/++WfhOcL3CukMiH/Zz8aV1+sRfPbz5s0T244LWhwTRD9kOgbfH6SFEYXFbyb8NIg0ShBtQ4kvLpLxfcP4hPNAXuicc845Yj2OC84lnIvakuFgx2RxZpvXOTgxIEjsw8gYGCT44uMHE1e2jgYJvAeeg9fJMj1HYLDCQC9LuvQKviQwKGrBwKFt9IUregyc2Gfc7JEGPggOeCK0PQVcWa838MMPs6UWRIu0ZZwQLBiMkPvVRkEkaKqGH1T8QOD8clRdg3MROXH4A/TejwPAkCuNdxJE0OQgiys9VAHI/DeEiBaIMxwT/HzgmCBl5ei44wrYXqzoFXwvpAlTggFSG2rH54xBAr4S+ygHjhkuDBCGx3ng7DcH4XykT/HeevcJ4LcP+6QFA7A22oFjhuOC80Be7WuB/wbvg99YR1Gzll6vN/Abat8QDue/tmIGUSEIU5w7jhrk4XuD8w2iH7858KVpqaurE5WR+J5ByOm5GaO3MawoYRiGYRgmuGgbSSqGYRiGYXQPixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXSBvovkGYZh3AC9U9AHBB1Ug2kyTYZpK7AoYRjGJdDgCp18AZqpYfp1LbL1OvClKEB3ZTSeAuiSqm1AhrlT0K1ZtoNnGMZYsChhGMblqR207a4xpQGmXgfowXjPPfeI7p0A3Tt9JQowuZ2clRkdY+27yTIMY1xYlDAM4xGY4VaKEky0JgWJMzClA6ItaMeOeajspznQpl4wFxWeixlSEfWQ7ckxP4qMkshJIjEXDeYmsp8zBULJ0XswDKNfWJQwDOM2mPsIggDzlmCuH0xmJx/XziAMMJEbJq/D5GwQI5g7CKkeRDkeeeQRMeeQNvWSnJwsBASehzlGMP8OJpXEJGeYLE87Gy8mjEP6BvOOaEUJ5hTBxIqO3oNhGP3C1TcMw7gNZonFQI/ZhTFhGwZ+CAk5o64WzNYNQYIJ1yBeMJU7JhnDpIAQK44mlrzsssto7ty5dO6554qIB1JFiLBghlU5Qy144IEHaPbs2eJxV9+DYRj9wqKEYRi3OfPMMykyMpK++OILeu2118RjGPztZ1jGTMSLFy8WyzDGIqqBqd1hUJVpHwgILYicSHEjUy6YLRXTxLuKN96DYRj/w6KEYRi3SUxMpJNOOklM0Q4DLETA1KlTmzwvJydHRFQA0jKSlJQUdRmeD/v3loSGhqrL7kxo7o33YBjG/7AoYRjGIxAZkZxxxhnCcGpPfHy8TdRE6zNx9ByGYdo2LEoYhvEImFYvvvhimjx5Mk2fPt3hc5KSklQD6rp169TH5TIqcOyrcFoC5lWJjMIwDBMccPUNwzAec+2117b4nPvuu088D9U6L7zwgoiofP3116K/yKxZs9z+n3379hUpGQgSmFcHDhwobhkZGR7uBcMweoFFCcMwLtGjRw8RFWkOiAMYSrWeEVTdfPzxx/Tdd9+Jkl4AkQJPivZ5AwYMECme1NRU9bH09HT1f8r0EIyrqKpBRQ9MssuWLRPvA1Hi6nswDKNPTBZ2fjEMwzAMowPYU8IwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwDOmB/wO4yGlRd4tdywAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + } + } + ], + "id": "7b09db6a" }, { "cell_type": "markdown", - "id": "6f1ec89e", "metadata": {}, "source": [ "## Model Registry\n", "\n", "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived)." - ] + ], + "id": "6f1ec89e" }, { "cell_type": "code", - "execution_count": 60, - "id": "7c854bc4", "metadata": { "execution": { "iopub.execute_input": "2026-07-22T08:27:04.144511Z", @@ -1310,16 +1266,23 @@ "shell.execute_reply": "2026-07-22T08:27:04.165897Z" } }, + "source": [ + "# register the best model (from the \"Load the Best Model\" section above)\n", + "result = mlflow.register_model(\n", + " model_uri=best_model_uri,\n", + " name=\"darts-air-passengers\",\n", + ")\n", + "print(f\"Registered version: {result.version}\")" + ], + "execution_count": 60, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Registered version: 1\n" ] }, { - "name": "stdout", "output_type": "stream", "text": [ "Successfully registered model 'darts-air-passengers'.\n", @@ -1327,18 +1290,10 @@ ] } ], - "source": [ - "# register the best model (from the \"Load the Best Model\" section above)\n", - "result = mlflow.register_model(\n", - " model_uri=best_model_uri,\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")" - ] + "id": "7c854bc4" }, { "cell_type": "markdown", - "id": "da6cc83a", "metadata": {}, "source": [ "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", @@ -1346,11 +1301,11 @@ "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", ">\n", "![Mlflow Charts](./static/images/mlflow_models.png)" - ] + ], + "id": "da6cc83a" }, { "cell_type": "markdown", - "id": "7af49ea9", "metadata": {}, "source": [ "## Important Note: Custom Flavor\n", @@ -1374,20 +1329,19 @@ "- Darts-specific model parameters\n", "- Covariate handling (past, future, static)\n", "- PyTorch model state preservation" - ] + ], + "id": "7af49ea9" }, { "cell_type": "markdown", - "id": "40621b13", "metadata": {}, "source": [ "## Cleanup" - ] + ], + "id": "40621b13" }, { "cell_type": "code", - "execution_count": 19, - "id": "51fc7c4a", "metadata": { "execution": { "iopub.execute_input": "2026-06-24T15:18:53.573724Z", @@ -1396,39 +1350,40 @@ "shell.execute_reply": "2026-06-24T15:18:53.574817Z" } }, + "source": [ + "# Uncomment to cleanup\n", + "# import shutil\n", + "# shutil.rmtree(tmpdir)\n", + "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", + "\n", + "print(f\"To cleanup manually, delete: {tmpdir}\")" + ], + "execution_count": 19, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" ] } ], - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ] + "id": "51fc7c4a" }, { "cell_type": "markdown", - "id": "ca40afc1", "metadata": {}, "source": [ "# Final Remarks" - ] + ], + "id": "ca40afc1" }, { "cell_type": "markdown", - "id": "c4c86a23", "metadata": {}, "source": [ "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." - ] + ], + "id": "c4c86a23" } ], "metadata": { From 6f73130ae3265541dcc8fed50862108083d216fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ch=C5=82apek?= Date: Wed, 5 Aug 2026 14:41:34 +0200 Subject: [PATCH 139/154] fix: docs fix for CI --- darts/utils/mlflow.py | 7 ++- examples/29-MLflow-quickstart.ipynb | 95 +++++++++++++++++++++-------- 2 files changed, 76 insertions(+), 26 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 4ce9e3d98d..d59aecd524 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -349,6 +349,7 @@ def autolog( - Calling ``ForecastingModel.fit()`` inside an active MLflow run (e.g. within ``with mlflow.start_run():``); does nothing if no run is active: + - Logs model creation parameters (``model.model_params``), both as MLflow params and as a ``model_params.json`` artifact. - Logs target series info and covariate usage information (past, future, @@ -359,16 +360,19 @@ def autolog( - Calling ``ForecastingModel.historical_forecasts(retrain=True)`` inside an active MLflow run; does nothing if no run is active or ``retrain`` is not ``True``: + - Logs the same model creation parameters and ``series_info.json`` as ``fit()`` (overwriting any prior ``fit()`` artifacts in the same run). - Does not log the trained model artifact; call ``log_model()`` manually if needed. - Calling any Darts metric inside an active MLflow run; does nothing if no run is active: + - Logs the result of that metric call as an MLflow metric. More information in the notes below. - Calling ``ForecastingModel.backtest()`` inside an active MLflow run; does nothing if no run is active: + - Logs all evaluation metrics under ``backtest_*`` keys. More information in the notes below. @@ -382,7 +386,8 @@ def autolog( keyword argument when provided. - ``component`` – the component name when ``component_reduction=None``. - ``quantile_or_label``, e.g.: - – ``_q0.500`` for quantile metrics with keyword argument ``q=[0.5]`` + + - ``_q0.500`` for quantile metrics with keyword argument ``q=[0.5]`` - ``_qi_80.000`` for quantile interval metrics with keyword argument ``q_interval=[(0.1, 0.9)]`` (80% interval between quantiles 0.1 and 0.9). diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb index fc12c4e824..b5a76dbb92 100644 --- a/examples/29-MLflow-quickstart.ipynb +++ b/examples/29-MLflow-quickstart.ipynb @@ -144,7 +144,8 @@ "execution_count": 5, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Updating database tables\n", @@ -152,7 +153,8 @@ ] }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", "Experiment: darts-quickstart\n" @@ -197,13 +199,15 @@ "execution_count": 6, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Training series: 107 points\n", "Validation series: 37 points\n" ] }, { + "metadata": {}, "output_type": "display_data", "data": { "image/png": "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", @@ -258,13 +262,15 @@ "execution_count": 7, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Validation MAPE: 7.86%\n", "Validation RMSE: 34.77\n" ] }, { + "metadata": {}, "output_type": "display_data", "data": { "image/png": "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", @@ -318,13 +324,15 @@ "execution_count": 8, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" @@ -365,7 +373,8 @@ "execution_count": 9, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Loaded model predictions match: True\n" ] @@ -432,12 +441,14 @@ "execution_count": 10, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" ] }, { + "metadata": {}, "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0sBJREFUeJzsnQV0G1cTha/MHHPsOMzMzMxJ06ZJmqZNMSn/hZSZmdu0SSHlhtOk4TYNMzOzY2Zm73/mrVZa2bIt2ZItyfOd4+Nn7Wq12l3Je9/M3NFIkiSBYRiGYRiGYRiGYRiL42T5TTIMwzAMwzAMwzAMw6KbYRiGYRiGYRiGYawIR7oZhmEYhmEYhmEYxkqw6GYYhmEYhmEYhmEYK8Gim2EYhmEYhmEYhmGsBItuhmEYhmEYhmEYhrESLLoZhmEYhmEYhmEYxkqw6GYYhmEYhmEYhmEYK8Gim2EYhmEYhmEYhmGsBItuhmGYWoyHhweefvrpmt4NpookJiZCo9Hg888/52NpZfhYMwzDMObCopthGMZBCQsLQ//+/eHo75HEpvLj5eWFzp07C/FZXFxc07vH2Bg3btwQ18nXX39d07vCMAzD1CJcanoHGIZhmJojNzfX7g9/v379sHPnTjGOi4vDxx9/jCeffFKM33vvPdQGgoODIUlSTe8GwzAMwzBG4Eg3wzAM4zDUrVsXH374IVq1aoW5c+dytJthGIZhmBqHRTfDMEwtpmRNN0W+Kf329ddfx+bNm9G1a1exTsuWLfHnn3+Wej5FV7/99lt06dIFnp6eqFOnDsaPH4+TJ08arNe4cWNdCriLiwsaNGiABx54AElJSUZfe+PGjejWrRvc3d0xb948s94TbaNZs2bIyMhAWlqawbJNmzZh+PDhYj9pf3v06IFVq1aVek8k3Js0aSLW6dWrF3bv3o37779fRJTV9O7dG4MHD8alS5cwZswY+Pr64rbbbhPLCgoKRKS9bdu24hgGBgZi2rRpuHr1qsE2vvjiC3To0AE+Pj6oV68eJk2ahCNHjpi1Tll1xqmpqXj88cfRsGFDuLm5ieP+2GOPiccVLl68KJ77ww8/YPny5WjTpo047h07dhTnoSaha0W5bmj/mzZtimeeeQZZWVm6dbZu3SqWb9iwwejzleubsiHo/RN0DJTtPvroo2Ydr7Iw9bmxsbG4/fbb4e/vL35mzpyJ9PR0cY088cQT5b6G+lwtXLgQ7dq1g6urK9asWWPycbD1c84wDOOIsOhmGIZhSnHs2DH8/PPPWLZsmaiDJWF5xx134PTp0wbrzZ49W4ighx9+WKxHYpvEZd++fXH+/HndeiQ0SczSDwmM33//Hdu2bRMCtWRa9OHDh/HTTz9h8eLF4vVIaJkDbe/ChQtCAJOoUfjtt98wcuRIISxOnDiB6OhoIX4mT54sBIzCK6+8gpdeeglPPfUUoqKi8Ouvv+KDDz7AtWvXjL5eZmamEG40WXD58mXcdNNNIsJ+880349NPP8Vrr70mhNb+/fvFRAAdm/j4ePHc+fPni+P38ssvIyYmRuwXiXtKkVcwZR1j5OXlYejQoVi6dKkQVyTM6Zz+9ddfGDRoEHJycgzW/+eff7B9+3b8+++/4nzRpAO9B0rTrykKCwt11w1N0FD2wh9//IFHHnnE7G2Rv0FkZKQYf/XVV7rtKvXd5h4vNaY+l37TenQtrF27FtevX8fUqVPNfj/03B07dmD9+vU4cOAAgoKCUBls8ZwzDMM4JBLDMAzjkNStW1fq169fueu4u7tLc+bM0f2dk5NDClhq1KiRlJ+fr3s8IyND8vLykp588kndY7t27RLrfvbZZwbbpOc1bdpUmjFjRrmvvXLlSvH8ixcvGrx2WFiYlJubW6n3GBsbKz311FNiO2+99Zbu8czMTCkgIEC66aabSm3jjjvukOrXry8VFxdLiYmJ4pjMmjXLYJ2kpCTJ29tbCgoKMni8V69e4rWOHj1q8PjixYvF40uXLjV4PDU1VfL395eee+458fdtt90mtWnTptz3aMo6CQkJpc7Fd999Jx77+++/DdZdv369ePyrr74Sf1+4cEH83bNnT4P1rl27Jh7/5JNPJFvi66+/lpycnKTs7Gzx95YtW8R+0vsqibOzs8H1HRkZafDe1Zh6vKpyrL/99lvx97Zt2wzW++GHH8Tjjz/+eLnvXTlXHTp0KLXMnONgb+ecYRjG3uFIN8MwDFMKighT2qoCpTU3atRIRHIVVq9eLX5PmTLF4Ln0vIEDB4pItgJF9iZOnIjQ0FA4OzuL1FZKkVZSXdWMGjVKpLqayq5du3SpwuRmTtHlN998U0SGFSi1OCUlpdS+EpRuTlF6em+URk5RywkTJhisQ9F7MmwzBh2XTp06GTxGx4ZSjOk9q6G09u7du+uODT3vzJkzIq340KFDKCoqKrV9U9Yxxn///Sf2Ydy4cQaPjx49WpxPWq6m5HqUJk3ZAupzXt1QJJauRYrkOjk56dLBKZPA0vtl7vGqzHO3bNkCPz8/8flQU/I6qQhz1y8LWzznDMMwjgiLboZhGKYU4eHhpR4jsaCuT6WUaUV0Us0oiWkSRvRDqbVKvfbZs2dFii2tQ6KD0rEprZfqq5XaZzURERFmnRESw7Q9EqOUVk5CgtLBSeiX3Feqny25r3fffbdYRvur7DNNDpTE2GNl7S+9Xn5+vmhhpn49Eo30vpXXmTNnjkhLp7pyEuMkLm+99VaRYq9gyjrGoNegfabXNWY4RynQ5p5zYzRv3tygbZs5P2+//XaZ26W0Z6qTJz+AvXv3itRsOs90bRm7boxhjqO7ucerMs9V1isJeQUYe25ZmPsZKes4VPacMwzDMObBopthGIYpBQmiiiChQOuRoKDaWxK9FIGkH7rJz87OFustWbJEmKR9//33wviJzMmIK1euGN2uOsJu1j80JychAKkWnIQp1aCT8FX2lVixYoXRfaWfnj176mpjlZprNcYeK2t/6fVIvNDrq19PeS2l3p2eSzXfdCzo57PPPhN18RQJpei7qesYg6LztM/GBBfV7JY0hTPlnBuDMhWU92XujzoboSRU90/XChnptWjRQpf9UPK6oewBgurlS058mNOr3dzjVZnn0vVl7Dqiz5A5+2rsmqvMcajsOWcYhmHMg0U3wzAMUykoBZtEBonqiqCb+5Ip42RQZg28vb1FBJWi3orzOQlUEsEkyMuDTM5oP8moSg2lplPquTnHhgzjjDlJlwVFdO+55x5hkEbu3MYi2aasozBs2DAh+tetW1cqZZuyDWi5rUMp22phSJMXJV30yfyLJlxKOuaTo7exa4OgEgJLHi9TnztkyBBxXSh95cvbV3Mx5zgwDMMw1QuLboZhGKZSkJCdNWuWSH8mN2iKupIQJHftd955B88995xYj9K9SQw8+eSTIr2WHJvJrZnSbq3FjBkzRKsu2g8SPVSnSi7VJLr/97//iUgzpStTlJac0pUabopEUmulBQsW4JtvvhFim9a97777RHswUyFXdmqdRqnrNLlA0UaKQJJIfv7553XO43fddZc4dufOnRNCkBzSKX2a6oApldzUdYxBqfRUD06t2SilnV6f0vvJ+bx9+/a49957YctQ3TIdf3KTp9ZvdK6mT59eqn6eHOop3Z7OFzl60/ukjAZy9aa0fjUBAQGi5Rq1wyvZTq4qx8vU59K5pPZc9PeePXvEeiTUaV1zfAyMYc5xYBiGYaoXFt0MwzAOjNpkTP1Tnlgzh++++04IQmq5RWKCjMzuvPNOUW9LYpygftuLFi0Sdbn169cX0T5KF6aextaCRD6ZqVEqr9K7mvaLDMyoNRJFtEmA0YQARbDff/993XPfeustESmnXt1U80pp6iTE6b2ZKozo9VeuXClaj1GPbeobrvQmp1RjmqwgqFab0qXJVI5EE+0XPZdEE4lDU9cxBvV9JjFHzyPxTynQ9F5oMoCOA9Wb2zK0n9Qujdpw0bEnEU6TI9TirSTUSoyuq7FjxwozMOo1XbJnuQJNqNDED9VWq/t0V+V4mfpcSpcnUzX6TJDJGn0e6LND1wiVIVRVeJtzHBiGYZjqQ0MW5tX4egzDMAxjlyipweQgzjCWhPrBkwAn533KCGEYhmEcC450MwzDMEwFREdHi3RgcmFnGEuzfPly8ZuvL4ZhGMeEI90MwzAMo4LStiktl9KDKSX81KlTeOyxx4Qx27Fjx8RjDFNZqOyhZcuWInOCaq2pppuuL/qbShIYhmEYx4Mj3QzDMAyjolevXsKkbOrUqQgJCRG9oqkvMtXHs+Bmqgp5C5CjOLWoo+vqjTfeEMaC5HvAMAzDOCYc6WYYhmEYhmEYhmEYK8GRboZhGIZhGIZhGIaxEiy6GYZhGIZhGIZhGMZKsOhmGIZhGIZhGIZhmJoW3UVFRejbt2+pn88++0y3Tk5ODl5//XUMGzYMN910E/7++2+DbVS03BoUFxfjypUr4jfD8PXGOBL8/cbw9cY4Kvz9xvD1xjgSLqauSG0ttmzZovs7NzcXEyZMwIABA3SPff7554iMjMRvv/2Gq1ev4rnnnkPjxo3RsWNHk5YzDMMwDMMwDMMwTK1NL3d3d9f97Ny5E/7+/ujWrZtYVlhYiPXr1+Ohhx5CvXr1RBR8+PDhWL16tUnLGYZhGIZhGIZhGMbRqHRN99q1azFu3DhoNBrxd0xMDLKzs9G6dWvdOq1atcLFixdNWs4wDMMwDMMwDMMwtTa9XE1sbCwOHTqEF198UfdYVlaW+O3t7a17zNfXV/d4RcuNkZ+fL34MdtjFBW5ubibvq1LLzTXdTHXA1xtTnfD1xvD1xjgq/P3G8PXG2AtOTk7WEd0U5e7UqRPq16+ve8zT01P8pmi2IqxJUHt5eZm03Bg//fQTvv/+e4PHpkyZgqlTp5q9z1RLzjDVBV9vTHXC1xvD1xvjqPD3G8PXG2PrNGnSxHqi+6677jJ4LCIiQtR6X7hwAZ07dxaP0VjZiYqWG+Oee+7BjBkzqhzppi/sBg0amDQLwTBVga83pjrh643h641xVPj7jeHrjXEkzBbdx44dQ3x8vDBBM9iQiwtGjBghItPvvfcerl27hn/++QeffPKJScuNQeLaHIFdHiS4WXQz1QVfb0x1wtcbw9cb46jw9xvD1xvjCJgd+l2zZg2GDh1qUJutMGfOHBHNJnH9+OOPY/bs2ejevbvJyxmGYRiGYRiGYRimVke6n3322TIjxmSM9umnn4qUIGPrVLScYRiGYRiGYRiGYWq16HZ1da1wnYoENQtuhmEYhmEYhmEYpjbA4WaGYRiGYRiGYRiGsRIsuh2UqKgo3Lhxo6Z3g2EYhmEYhmEYplZTqZZhjGU4c+YMioqKylzu5+eHhg0bVmrbL730EgoLC/H7779XYQ8ZhmEYhmEYhmGqRub5TFz74TqilsbALdAVvVf3hEc9j1pzWFl01yD33Xcf0tPTxTgjIwPXr19H69at4ezsLB4bNGgQ5s6dW6lt169fv1xBzzAMwzAMwzAMYy2kIgnx/ybg2vfXkbg1Sfd4YXohrn53Da1fb1VrDj6L7hpk9+7duvHKlStx8803Y8eOHQgODhaPRUZGIjo6GvXq1ROp4nl5eWjWrBni4uKQkJAg1gkICEBERESpbT/00EOQJEn3N22LxDxtKzk5WWwrPDy8Wt4nwzAMwzAMwzC1g4LUAkT+EYVrP15HzrUco+tELYlGy5dbwMmldlQ7s+i2YZ588kkRASeRHBsbi169emHZsmVYuHAhfvjhB7FOYmKicIOnv8eOHVtmejltKzMzU0TWScCnpKSgffv2WLt2LQIDA2vsPTIMwzAMwzAMY/9knMnA1e+vI3ppDIqyDTNuvZp4otF9DUXEO2FTIvLi8pG4JQmhI0JQG2DRbeNs2rRJCOPRo0frHnviiSfEj8KCBQtwxx134PLly/D39y9zW5s3b8bGjRsxZMgQpKWloWfPnvjss8/w1ltvWf19MAzDMAzDMAzjWBQXFiN+fQKu/nANyTtTSi0PHhqExrMaIWR4MDROGng19hKim7ixMIpFtyPQvXt3ESGm2malTro6CAsLw8GDBy2yLRLIasGthqLc8fHxQjxTVPvQoUMYNmxYmdui7dD2iDp16ojI+NGjRy2ynwzDMAzDMAzD1J56barLvjLvGnJv5Bosc/FxRsT0CBHZ9mnhbbCMxLdbsBvyE/MRvz4e+Sn5cAtwg6Pj0JFuEtzUOsueadKkSanHqO571qxZot6bBL6bmxtycnIqfK9Uz63G29tbpK8zDMMwDMMwDMOYSszKWJx5+ZyhtmjujUb3N0DEtAi4+hmXmU6uTqg3JRxXv72G4nwJMStihTh3dBxadJMgJWoi0m0pjO339OnTce+99+LVV1+Fi4uLLnJdXFxssddlGIZhGIZhGIYxRsyqWIPodeMHGyF4UJBIIa+I+tMjhOgmbiyKZtFt71CKNwnRa9euoVGjRsJwzN4hMzSKaE+cOFEnuA8cOKBrPcYwDMMwDMMwDGMtinKKhAkaQani3f/sCo1zxWJbwa+dL/w6+CL9RAbSDqch42wmfFv7wJGxfxVay/Dx8UHHjh3x2muvYc+ePVi+fDmmTZtWrZF8hmEYhmEYhmFqJ0k7knXu5KGjQswS3ApU860Qtci+y4FNgUW3jeDn54d27drpotdEw4YNjfbgpp7e1Obr0UcfFa3CPvnkEwwePFj07FaoX78+GjRoUO626tata7RmnGEYhmEYhmEYxhhx6+P1emJMaKUOUr3J4dC4yGI9akmMcEF3ZDSSJElwYBwtvZyxbfh6Y/h6YxwV/n5j+HpjHBX+fjMdqVjC5vZbRZ9tJ08njDg/FM5elcu4PXTnEcStkwV898VdETrccXt2swplGIZhGIZhGIZhKoRqsElwE2ScVlnBrRiqKUQtioYjw6KbYRiGYRiGYRiGMS+1fGzlUssVQkbIPbsJingXpBbAUWHRzTAMwzAMwzAMw5guujVA6IiqpYM7Uc/uyXKr5eK8YkT/pW9D5miw6GYYhmEYhmEYhmHKJetyFjLPZYlxQA9/uIe6V/mI1VenmC90XBdzFt0MwzAMwzAMwzBMucRtSNCNQyvpWl4Svw5+8G3vK8aph9KQeS4TjgiLboZhGIZhGIZhGKZc4tX13KMt5zRef3o93fiGgxqqsehmGIZhGIZhGIZhyiQ/OR/Je1PE2LuZF3xa+ljsaNUz6NkdDanI8Tpas+hmGIZhGIZhGIZhyiT+nwSg2DKu5SVxD3HXmbLlxeYhcVsSHA0W3QzDMAzDMAzDMIxJrcJCR1tWdBMR6hRzBzRUY9HNVMjw4cPx448/8pFiGIZhGIZhmFpGUW4RErfI0Wfqq03O5ZYmdEQIXANdxThubTwK0hyrZzeLbhshOTkZjRs3xoABAyr1/MGDB+Pnn3+GNYiNjUVGRoZVts0wDMMwDMMwjO2StCMZRVlFYhw6MgQaZ7n+2pI4uTkh4tZwXc/uGAfr2c2i20b47bff4OTkhP3792P37t2VEsaZmY5psc8wDMMwDMMwjC2kllvOtbwkEaqe3Y6WYs6i20ag9O3HHnsMkyZNMprKLUkSvvnmG/Tr1w+tWrXC3XffLYQ2ccstt+DSpUt45ZVXUL9+ffFTVFQk1tu4caPBdsaNGye2ozB9+nSxfoMGDdC9e3c899xzLN4ZhmEYhmEYhoFULCFe25/bycMJwYODrHZU/Dr4wred7IqeejANmReyHOYMsOi2ASi6ff78ecycOROzZ8/G4sWLS6VzP/7443jjjTfwyCOPYOXKlRg6dCjefvttsWz+/Plo1KgR5syZg71794ofZ2dnREVFIScnx2A7cXFxSE9P1/391VdfifUpuv75559jx44deOCBB6rpnTMMwzAMwzAMY6ukHUlDXlyeGJPgdvF2sdpraTQa1FdFu6MWOU6023pHzQboPqsYsUlAUVEEnJ3pTGp97q1MWCBw8HvT5zN++OEHEa0OCgoSYjo8PByLFi3CrFmzxPLr169j7ty5WLFiBW666SbxWJs2bXDHHXeIcUhICFxcXODv7y+i1uYQHBysG1O0e968eejcuTMWLFgAd3d3s7bFMAzDMAzDMIzjELdejnITda3gWl6SereG4+zr5yEVSohaHI2WL7awSg15dePQojs2GYhKtO23mZWVJQT2qlWrdDM8999/v0gxV0Q3RcIpvXzkyJEGz6Ua8Kpy6tQpvP/++zh27BhSUlJEWjq9Fgn9Fi1aVHn7DMMwDMMwDMPYJ3EbtPXcGiB0lPXqudU9u0OGB4uU9tyYPCRuT0LIEH2Q0F6xXTVqoYgzJIp0F8LZ2UVcLNX2uiayZMkSkUpOUWsS3ER+fj4SEhJw8uRJtG/fHoWFhUJgu7rKNvqWgtLMKbI+efJkEdmmiDnViffu3Rt5eXIaCcMwDMMwDMMwtY/sq9nIPCMbNft394d7aPVkwda/LUJXR06Gaiy6bRxK8S4uLsa1a1Gi5tkSkWFLQxHtF154AQ8//LDB4/Q3Lfvss8/Qtm1bEYE+fPgwevbsaXQ7VMNNEWo1fn5+BrXhtDwyMlL399GjR5GYmIgvv/xSpKcTJ06csPA7ZBiGYRiGYRjGnl3L61rRtbwkFFGnnt0FyQVyz+70Arj6WTb4WN3YngqtRZw9exa7du3C7bffrnMdV36mTJki2ohR1Ltjx44YNmyYEOJXrlwRzyXjtU8//VS3rYiICJw7d85g++RGTtugqDWJ9jfffBPx8fEGzyEhrjic07bJvZxhGIZhGIZhmNqNgegeY/16bnXP7nqTtT27c4sRs9L+e3az6K5ByECtWbNmIoW8JOPHj0daWhr++usv8ffSpUvRsmVLtG7dWhimkaGaOur99NNPC9dzShFXWoZ9/PHHwq08ICAAoaGhiI6OFlFzBXrtDz74QAj8wMBAdO3aVbwuwzAMwzAMwzC1l/zkfKTsTRVjr2Ze8G7pXa2vX1/tYr4wGvaORiqZk+xgyOnl12wyvZzqtmmfyLXcGFRf7enpiTp16ugeo6g1tQEj4V0SOpVJSUnIzc01cDEn8e7r6yteiyLdtE36W4EEOj2P9oPqykmch4WF6VLOSbh7e3vDx0fum8fY5/XGOB58vTF8vTGOCn+/MXy91SzkHH7sYbnstMkjjdHmzVbV+vqSJGHnwN3IOC3XlA/c1x8+zatX+FsSVgU1CEWlyxLcBAlfteAmqI2XMcFNkGCmFmAl24bRNhQBSBFvteBW6sHpcfpN69HzFcFN1K1blwU3wzAMwzAMw9QSaiq1XK1rIgx6dtt3tJtFN8MwDMMwDMMwDCMoyi1CwmbRd1kYmgX0NB7wszYRt4brenRT5F0qst8EbRbdDMMwDMMwDMMwjCBpZzKKsorEOHRkiE74VjfuoXLPbiI3OhdJu5Lt9gyx6GYYhmEYhmEYhmFsIrVcjeJiTiTtYNHNMAzDMAzDMAzD2DFSsYT4DQli7OTuhOAhZftPVQcBvQN049T9spu6PcKRboZhGIZhGIZhGAZpR9ORF5snjkTQoCC4eOvNldUkpErocl8xut1fjP2nrVdr7RnhAY/6HmKcejgNxYXFdnmWWHQzDMMwDMMwDMMwJVLLQ8o8Ij+sAY5eAA6fB/o/KuHLZZJo82UNArRGbkXZRcg4JbcQszdYdDMMwzAMwzAMwzCI36AS3aPKrufefkwvsAsKgce/lDDlVQlpmZYX3gHd9e7pKQfsM8WcRTfDMAzDMAzDMEwtJ/taNjJOy5Fk/2514F7X3eh6hYUSdh6Xx26u+seXbwO63i/h8DnLCm9/VcuyVBbdDFN5FixYgHXr1vEhZOyGLVu24Ouvv67p3WAYhmEYhrF4anloOa7lRy8CmTny+OYBwN/vaRDgK/99ORro87CEeassl27u194XTp5yrDjFTs3UjFfGM9XGypUrsWbNmlKPP/DAA+jRo4ddn4lt27Zh48aNePfdd8td7/Lly3jmmWdw+vRp8fehQ4fw7bffIiwsDG+//bbBujExMXjllVfE+LvvvoOTk2Gyxuuvv474+Hh89dVXcHZ2NlimbJfQaDSoW7cu+vXrhzFjxpRaXpIPPvgAQUHG3RuLi4uxfv16rF69Gp07d8aoUaNKrVNUVIQ//vgDBw4cQEBAAO644w60bNmyzGOydOlSceyMoX7ftM3Dhw+L1xw5cqTBer/99pt4rfHjx8NUSh6j0NBQ9O7dGxMmTDC6njnnKDk5WezvpUuXxLEcOnSoOP7GXtvU4x8ZGYk33nij1OPPP/88mjdvbvQcde3aFbNnz67wWJw7dw6rVq1CdHS02Nadd96JOnXq6JZ36dIFU6dOxaBBg9ChQ4cKt8cwDMMwDGPLxK+XXcsrahW2/Zh+PLCTBhP6aXDkR2DqaxL2nwHyC4CHPpGw7Sjw3TOAr1fV+nw7uTrBv2sdJO9KQc71HOTG5MIjXDZXsxc4vbyGOXjwIP7++28hbNQ/ZQk8e+LMmTNYsmRJheu9//77uOWWW4QIJq5cuYIff/wRn3zyidhGyYg4CTdaTkJKDYm5t956C7/88gvWrl1b6nWU7ZJY6tWrFwoLC4VoUgSYennJ8+Hubjy95saNG2jRooWIeG7fvl1EP41B7++1115DvXr1xOt06tQJu3fvLvOYNGrUqNQ+bN26VQhsRcR+9tlnYkKDhC8JQrVIP3/+vBC+alFrCiWPEQlv2vbdd99tdD1Tz9HJkyfRtGlTkc1A741mPl966SWxbWOvberxT0pKEs9p3769wfq+vr5lnqPNmzdXeBw++ugjTJ48WWy/SZMmWL58uZgkoX1U8Pf3x+23317hpBLDMAzDMIytk5+Sj+Q9KWLs1cQTPq28y1x321F9BHtgJ/l3ozANdnytwRNT9Ost+g/oPkvC8UtVj3gH9LDzum7JwSkqKpIuX74sftsiL730ktSsWbMyl9N+L1q0SHrsscekp59+Wtq6davB8sTEROm+++6Trl69Kn322WfSQw89JO3Zs0csy8nJkX788Ufp0UcflV5//XXp0KFDpbafm5sr/fTTT2L777zzjhQZGalbduzYMbFt+qHlc+fOlTIzMw2eX1xcLK1atUrs24svviht375dPH7w4EGpX79+kp+fn24bGzduLPX6WVlZkpeXl7RlyxbdY0uXLqVPpjR9+nSxXfVrNW3aVLr99tvF8oKCAoNtvfDCC9KQIUPEMZg4cWKp11K2m5GRoXts/vz54rEbN24YXV4Rqamp0pUrV8R43Lhx0tSpU0tdb2vWrJE0Go109uxZ3WO0Xo8ePUx+nejoaMnZ2Vn69ttvdY916NBBWrdunRh/9NFHYpvKcRo0aJC0ePFiyVyMHYMFCxaIx9TXhrnnaMaMGVLfvn1Lvd65c+fKfe2KOHLkiHhOQkKCyedo2rRpFW73/PnzBuewsLBQatu2rfTAAw8YrEefNVdXVyk5OVmqCWz9+41xLPh6Y/h6YxwV/n6TpBuLo6S1gRvEz+mXz5RzrIqlgLFFEgYUSUHji8TfJVm2pVjyGy2vQz8ew4qkH1YXi/vEyhK7Ic6k/bNVONJt41Ak7amnnhJRYIo6UhrxF198oVuekZEhIn0DBw4U6bCU3hwSEoL09HQR8fvzzz9FhDEvLw/Dhw8XKccKqamp6Nmzp4jqUbQ0OzsbY8eORWJiolhOqclK5JC2sWzZMhGFzMnRFnEAIpr68MMPi6gf/VA0l/aHIvUUIaQIpbKN8PDwUu9v165dyM/PF1HVktx777349ddfRUSaoAgl7aOSDl4yfZsi3BS1ptR8iqhSmnNFUIRUSVOuDJRu3Lhx43LXoZRmOm6tWrUyOK+Uah4XF2fS6/z888/iWNLzFBISEhARESHGDRo0EGn1xA8//AA/Pz8RxbcEyn5fv3690ueIril1arZCeSn25kAp7k888YRIT6fPhLnnqCQUGVeXLlCpQrNmzUqdr27dusHFxaXMDAeGYRiGYRh7IE7tWl5OavmpK0CK9lZrQEfAyal06vjkwRoc/kGDrtrbvNx84P4PJdz1roSsHKnqDuZ2WNfNNd02AImn+++/30AkUNoupRNTbe+JEyfQtm1bnUh58sknMWPGDAQHB+ueQ89X6mgJqpGm5f/++68Q6wSlNJNApnpieozqn0mgUOqvl5eXWGfOnDlwc3PTCTn1fj322GPo2LGjEO5KSjal3VJN7X333ad7XUrnrV+/vkht3rNnj8E2SnL27FkxoeDp6VlqGdXKUpow1bxPmjRJiPm77rpLiJySUDo5TSzcfPPNQpySyCWh+sILL5R77Ckl29XVVRxX2m/i0UcfNXgN5XxUlosXL5YSfTQhoSxT0urLg1K2p02bJsS0eht0bdA5OXbsmBCFsbGxQoDSZAZNklAK+5AhQ0rVZJsDCWk6psYEsqnnaPr06SJFfcqUKZg4caKYZClLcJt7/Ol90z74+PiICQd6/zt27BATRZaC0so3bdokasvV0LVDn5OSKfYMwzAMwzD2QlFeMRI2yUE31wBXA7fwklCdtrqeuyyaRWiway4wZ66Eb1bKj/22ETh0TsLSN4G2jc2r83YLcoN3c29kXcxC2rF0FOUWwdnD0L/JoUR3WlqauMGmyNWwYcN0kUJ1jTLd8NJN8E033SSiruYstyQ7h+5BXnyeiIJedr6GqpXwm45bqDv6b+5j8vpKNFhBEcAkuklQKYKbILE9a9YsYTqlNuwqGVmkc0QC7aGHHhL1s/RD0W8ys6KIJdXVUjSYtqe8nhLdVkNijmrOyUyqoKBARLnVAoP2jYQOCZ++ffsKwU6C21RI9JNYMgZNDFAklYQcibu//vpL7A/VNZdEEXtK7S9Fu6lWnAy1lEmHkqKODNxIlFJtdGBgoG45Gdipa4jVx6cy0DEreUyUmmN11kB5hnQkzimirOa5554TExp0XOhaoWgrvbdnn30W//zzD9577z1xHGiihc4d1ZWbinKMrl69iiNHjghDNPUkj7nniM4NZTrQejQxQxFjmjT49NNPhVhXY87xVyYelEkbmjSizxJlh5BJoSWgzw1N5pAB24MPPlhqOV2/tA7DMAzDMIw9krwrGUVZRWIcOjIETi5lJ0NvP66PVA/S1nOXhYe7BnOf0mBAJwmzPpSE4/npq0DvByWc/AVoWNc8dRbQ01+IbqlAQvrxdAT0NNQtDiO66UaZbrDJqZfENjlEP/LII0IYEhs2bBA3+pQCS6ZWM2fOxMKFC0XasSnLLU1+fB7yYvLEuBBy+qstQuLYWDSY0oVLCh0SF97e3qXSXEseQ5oUoVTz7t27GzxOKeZKtDQlJaXcKCuZYVFEmyKUrVu3Fq979OhRg/RdElEU/aPrgATa6NGjRbq6qVFGSkOn/SgLeu0333wTH374oRBjFB0tKegouksTCPTelONIKc4kVEmwDh482GB92o6Hh4eIuP7+++/C3KykQCxrIqAy0PEu+R5p8kNZVhF0jNu1a4c+fQwncmjSio4HiU6aOKDjQpMjNNEyYMAAYfBFkWUS+LQNc0Q3HSOK4tJxUhzXq3KOCHJXVxzWL1y4ILIQKAX+1KlTIp27Mse/ZMo6TRSQARodD0uQmZkpSi4ovZzKBOiYlITKNBzB+JBhGIZhmNpJwmY5yk2Eji47IEpBPMW53NcL6KRvFFMutw3ToEsLYMqrEk5cBjKygYWbgOdmmLef/j3q4MafUboUc4cV3fPmzRPRLIqkKSmjFPlWmD9/vkh9ViJXJIAoxVURQhUtt0bEmeZiKNJNN83VGem2BJS2SimtashNOSsrCw0bNiz3uVTrS4KkvGNL0Vea/CgLqo+lc0112goU1S4p9mkihX5I8NGkDP1Q5LVkhNkYlPJOkws0SWAskkqCmMQ0CfuffvrJ6DYojZwi7iS21FD0kcRmSdFtaVFdETRBVTLqSkKTrkmazCgP+nzRZ4SOrzHatGkjfui90meLMhyoFpmOqVLvTedZqfc2FfUxoudTSQJ5BlDtf2XOUUlIZH/zzTeiPGH//v0GoruqUPaAJfpCkuCmDBL6vP33339GJx5o2bVr10QUnGEYhmHsDalIQvbVbLgFu8G1TumJZaZ2kLRDDgaRWAoaoM/+LMn5SCBOu2r/DuR5Y7q6atVQg4WvAe3vku/R9p2m3+ZGugPstq7bZNFNN7GUskq1lSSeqRUQ1YoqooFEE5lRqVsU9e/fX0TJTFluDSjFm/aTboopnbpkT2dbhyYnqE6bhJTSa/njjz8WIsiY8ZgaEkmvvvqqSC1WMhFo8oH6DisRT6XdEdVqK5FpilBS/TGlW9M5V0e1qbaXBJK6pIAEIW2Pji2JL4rG0mMEbYOigLSdsgQ4ReKpFzSJ9FtvvdXoOiTm6FhQ1LasemdKoy45wUDvg6LZlJFhrWwKU7jtttvEeaNMD8oEoFRvmsAaN26cLtJN1yi1OyvZX5qM8OgaVrfWMgalmtM6SimCknZNKf9KvbciSOl808QILTMFStmmyRaafKHPfmXO0YoVK4TZn3pihcpMqmqmRmKYPgvKBAFlPdD1YMxsrzxKHn8S0xThVgS3uvxADb0Hem1zW7MxDMMwTHUjFUvIvpKNtKPpSDuahtQj6SJFl9KKXeq4iPtmr8ZVK6lj7I+8xHxknJTv9/06+sEtQPZ2qqg/96DO5ocz2zQC/LyB9Cxg72lZX5oSpFPwaekNFz8XFKYXirZh5j7fLkQ3RVjJqIpqMIcOHSqEA6UeU0op1VAq6bLqaBClXNLziIqWG4NcrenHYIddXHRGX6ag9Aku2dPZVlAicsb2j1yjyRSKUnCpfp6imSSKFy9eLGpe6Tnq96fexuOPPy5qr0mQUKSX0oRJfFFtqpJpQOtQvS6lodM6lJJNIoPEIW2L6mKp5vv06dNCVO/bt08IJNpn5bXIiIyEChmX0XN37twpBBotpxRnEvoUBSUBTIJMSS9WoO3SdUTO48pkQMn3pERzS75P+k0TAZSqTOK65DEkkUfvm1LIafKhrGOloDxGqfIljcCefvppA/dxNUrN9PHjx0X6MR0PmoBQzL/o2JBpHU0q0GeHsgtyc3NF+r7ymlQuQFF5KrlQp+YraeE0aVDWNUzHnMQf+SUo65BQpnNHRnpU601Gc7SMJr+UbZZ3DNTHiCLylD5O0W9yCKfjYM45oh8SwzTBQhNGNAFGzvJUT//iiy8KB3D1c8w5/rQdOr50XdL3Ar1Xuubp2KvfX8lzRMZ/lAlCkyHGjj9lDdAxpc8K1aAr0HVM/cUVyFSQ0uuVz2N1Y+vfb4xjwdcbw9eb/UD3ajmRuUgXAjsd6cfk3yRWjFGYVoirP15H6zcs01XE3qjN32+J2/Wp5UEDAso9BmoTtf4dSQ+Yn1nYoxXw32EgJgm4HiehQah52/DvXgeJm5OQH5+PrCtZNjFRZEpgV0N9w0zZWFRUlKghpZtfitwRFK2jaNrcuXNF/Sw9TjfSiiimlNolS5aIaF1Fy41BUbXvv//e4DESbpZqhWQL0PGjDACKqpUFGZ+ROKbjRhMc6okLEroUCafnK+ZcJSN4JLapFpxq8Y2lB1PaMAl0WkbCSC146LWpjptEBYkZWo+WU+2u+tqg16D9ozRbdVSQJlsoOk5p0pRKbiydmiYTlHZmJKzIRZzct+k8G5u9on0iV3RaTs7rJGJLmnEpUASd9peyKpTtUhq6MQd0ZbkxKKuDIvLGoMg+TS6oIbFPnxc1tJ90vim6TZFRtVkYHScSyCTKFXNBmnAiYzJq66a4nRuD9plq89URcsVxm9LYaVJFMXKjdO5FixYJV3xjlHWM6GuCotUkbuk6MuccKctp0o7ePz2XBC9lTKiNFCt7/JXJKJo0ooi+MXFe0TkqefxpPxQ3ezV0bY8YMUKM6XNLk1jr16+3qiEkwzAMw5iCVCgheVEqsvZnIfd0HopSDf/vGcM13AUF8YVAEeAc6IwW65pC42IfkUPGMsS8E4fUv+Ry4QZfRcCnj7fR9Ugx9n8qAjHJLvBwK8bRbyPhVok+WB8v88c3q2VPnq8fTcDYHtlmPT/hhyQkzpODtvXeDEOdsRX7I1mb8u7TzRbdJAAockk9ohWnbYqIUionCWe68aUbVhLSyg0+iWZqCUWmRhUtt2akm26OqT7a3tLLaxN79+4VEVW1mLdHbP16IyFMKd6WrKGurdBEE00mUUZFTWHr1xvjWPD1xvD1Zttc/zkSp585W+Zy9zB31OnsJ3786HcnP1HLfeSeY4hbI3u/dP29M0JH1b6J5Nr8/ba9x05kX82BxlWDYReGwMXbeBuuqzFAs+nyeFhX4J9PK/d6q3cDk16Ux09NBT562LznJ21PwoHJsmFvg3vqo92HcqZlTWLKNWPy/AQJXYqCUsRVEd00VlJhKXpH9aQkxKm2lsQy1UIqdboVLS/rNc0R2BUdjNr2IbInTK0vthds9Xrj2mPLQWnttoKtXm+MY8LXG8PXm20SvShGN3YLckWdLnVkkU2/O/nBI9zD6PMazKivE91Ri6IRNqbszjaOTm37fsuJzBGCmwjo4Q8337LN9HaIVmFyrHZgZw2cnCqXEdGnnX47+8+aJljVBHQLAOgpxUDqgTS7OV9mJQVQPSf1qT1//ryoj6RaWrWxEtUAK7XE5GRdMsW2ouUMwzAMwzAMw5hH1pVspB6SU4R92/ui/9Y+JhtMBQ8NgntdN+TF5SN+YwLyk/LhFmSZoBdj2yRuT9bXcw8s27Wc2H5M1Z+7c+VfMzRAg8ZhEq7GAofOAQWFElzNKGlw8XWBXztfpJ/IQMbpDBRmFIrHbB2z9pBSUqkmlFKBqR6VIt/qOmKqHaVaUarhpccpeqnua1vRcoZhGIZhGIZhzCN6uT7KHXFruFmOzk4uToiYWg+Xv7oKqUBC9LIYNH6gEZ+CWgClaisEDQgqd13FudzNFehZxYzu3u0gRHdOHnDiEtDVuFdxmfj38BeiW0S7D6cheFD5+24LmB2PJxdlantExkbGjLvI7IjaW1E/b2OCuqLlDMMwDMMwDMOYBtkzRS/Vim4NEH5LadPcioi4LUI3vrEwig99LbluknbIotvZ2xn+XWVzM2NEJ0q4qL0sSHB7ulfNbK9XG/3z950x//kBPfWtgKl1mD1gH0nwDMMwDMMwDMOUIv14BrIuZolxYN8AeEZ4mn2UfFv7oI5WdFEEMf1EOh9pByfrfJYoKSAC+wTAyc3JtP7cnar+2r3b6cf7TpvfdozqzxVS97PoZhiGYRiGYRimmlLL600Or/R26k+vpxtztNvxSVSnlg+sKLVcL4wHdqp6S7nOzQFXbZHz3tPmP9+zkSfcQt10kW6pEv3CqxuOdDMMwzAMwzCMHSIVSTrRTS2fwiZW3nm83i3hcHKXpQHVdRfnF1tsPxnbI0llohZcgYnatqPyb2dnoE/7qr+2h7tGCG/i3HUgJcM80UyeBUq0uzC9EJnn5UwPW4ZFN8MwDMMwDMPYIcm7k5EXmyfGIcOC4RZQeddxV39X1B0bKsb5SQWI/zfBYvvJ2N5kTdIuWXS7BrrCt11pny6FhFQJp6/K424tAV+vqke6S6aYH6hqXff+FNg6LLoZhmEYhmEYxg6JWqZKLb+18qnlRlPM/2RDNUcl7Vg6CtMKxTiofyA05fTc3nlcPx5ogXpuY2ZqlUkxNxTdtl/XzaKbYRiGYRiGYeyMorxixP4dp3OfrjtKjlJXheDBwXAPcxfjhH8TkRcvR9EZx0JxLTelnnvbUcvWcyv0als1MzW/jn5wctPYjZkai26GYRiGYRiGsTMS/k0Q9axE2Li6cPZyrvI2Nc4aREyrp0tBVkfSmdpZz604l1Pr9/4dLbcPzSKAoDr6tmHUwswcnD2c4ddJ3kDWpWzkJ8lO7LYKi26GYRiGYRiGsWfX8ilVTy1XqD9d1bP7zyizxRBj+xkSyfvkGmiPeh7waupV5rppmRKOXpTHHZsBAb6Wi3RrNBr0aiOPk9KAS1FVTDE/aNvRbhbdDMMwDMMwDGNHFKQXIn6jbHTmFuKGoAqilebg08Ib/lpn6MwzmaIPOOM4pB5IRXGO7ExP1w2J37LYeYIi0Jav51bo1Vb/2vsqU9dtR/26WXQzDMMwDMMwjB0RtyYOxXmycAqfFAYnF8ve0te/nQ3VakM9d3BF/blV9dyDLFjPrdBbXdd9xvyMCmVySOnXbcuw6GYYhmEYhmEYe00tn2y51HIFIeQ9tD27l8eIlGTG8eq5K8qQ2K5yLh9ghUh3T216ObH3lPnP9whzh2dDTzFOPZyG4gLbvU5ZdDMMwzAMwzCMnZAXl4fE7XK00quxJ/y7a92oLIirnyvCxtcV44KUAsRvjLf4azDVT2FGoRCnhHcLb3iEe5S5blaOhINn5XHrhkBogOUj3f6+GrRqKI+pdjw3T6p0XTelzKeftN1SCBbdDMMwDMMwDGMnRK+MBYr1Ue7yanItZqi2MNoqr8FUL8l7UiAVysI2aED5Ue49p4DCInk8qLP19qm3NsW8oBA4cgFVSjG35bpuFt0MwzAMwzAMYydEL422amq5Aokyjwg5EpqwKQG5sdyz295RMiRMquc+Zp3+3BY3U+tpH3XdLLoZhmEYhmEYxg7IupSFtCPpYuzX0Rc+rXys9lrUs7v+bVpDtWJDsc/YJ0k7tPXcGiCwf0C56247qh9bw7ncUmZqvm194Owt96hP4Ug3wzAMwzAMwzC2bKBWkghFdIsUc+7Zbc/kJeYjQ1vz7NfRD24BbmWuS7XV+87I46b1gPqh1ot0d2gKeLpX3kyNnPv9u8q+BrlRuciJyoUtwpFuhmEYhmEYhrFxJElC9DKt6NYA4TdbX3R7N/VGQB85Ipp5LgtpWhMuxv5I3ql3LQ+uwLX8wFkgL9/6UW7CxUWDbq3EEFdjgfiUypupEakHbTPFnEU3wzAMwzAMw9g4aUfTkXUpW4wD+wXAU1tvXVVOXJJwObpsoVN/ujrazSnmjlDPHVRBPbdharn1otxGU8wrUdftr67rttEUcxbdDMMwDMMwDFPLUst3n5Aw9PFidLxHQqsZEs5HGhfe4RPD4Owl18xGr4hBUa7W0pqxK5K0olvjqkFAL71IrchEzZrO5cbM1PaerkSkuzuLboZhGIZhGIZhqoBUJCFmRaxONJEQrixHzksY92wx+j0iYcsR+TFqDbV6l/H1XXxdEDZB7tldmFaIuPXcs9veyInMQfaVHDEO6OEPF2+XMtctKJSwW1tbHRECNLF+FQN6talapNvV3xU+Lb3FOP14OopybG9iiCPdDMMwDMMwDGPDJO1MRl6c3LIrdHiIEBnmcuaqhCmvFqPr/RLW7S29fM8p01LMozjF3O5I3K6v5w6qoJ778HkgK0dfz22tPvBq6ocC9YLl8f4zQFGRVOkUc+pDTqUYtgaLboZhGIZhGIaxYXQGapRaPsW80CPVa9/1TjHa3y1h2Vb94w1Cge+e0cBPDhBibzkRxsB+gfBs6CnGCVsSkRttmw7RTPmp5abUc28/ph8PqoZ6boKEvRLtzsgGzl5H1fp170+BrcGim2EYhmEYhmFsFKqhjl0dJ8YuPs4IHRli0vOiEiQ89EmxqNf+dSNQXCw/XjcQ+OJ/Glz4U4NZEzToqRU7UQlAZJzxCKPGSaNvH1YMRC1hQzV7cr1P2iGLbupn7d9Fbq9lSj23tZ3Ly6rrrkyKOaXN27KZGotuhmEYhmEYhrFREv5NRGFGoRjXHV8Xzp7O5a+fKuGpr4vRbLqEeavkem0iwBd4/wENLi3U4H+3auDupinlHF1etLu+umf3n9yz217IOp+FvDi5/1dgnwA4uZUt/yite8dxeRziD7RuVF17CfRupx/vq4SZmndzb7gGyGUXqQdSxWSDLcGim2EYhmEYhmFslKhl+qhyvVvLTi0vLJTw+oJiNJkm4bMl+j7LPp7Aq3cDVxZr8NwMDbw9DVOG+7TTmFTX7dXIC4H95Z7d1Los9SD37Ha0VmEnLgNpmdVbz63QrSXg5FTx5E9ZUDaGvzbanZ9UgOwrcns9W4FFN8MwDMMwDMPYIAVpBSLSTbiFuCFoQNkmWD9vAN74WW+C5eEGPH2bLLbfuNcJdXyMC6he6ki31rW6LOpPj9CNbyyMMu/NMDVCkspELbgCE7Xq7s+txsdLgw5N5fHJK0BmtuRQKeYsuhmGYRiGYRjGBoldE4fiPLkYu97NYXByKfvW/e+depEyewJwaZEGHz3shGD/8sVTUB0NWjaQx4fOU4S8bLFDrcOoLpigFmZF2bbXmokxbDWXtEsW3a6BrvBt52tT/blLopipkf8AXYtVMlM7wKKbYRiGYRiGYRhzXMsnl51anl8gYfMRvVHat3M0qBdseqRSqevOLwCOXix7PervHD5J7hFOdebxmxL4HNowacfSRW91Iqh/oEjBLguqgVacy/19gPZNUO30UpmpVZR1YYw6XfygcZa3kcqRboZhGIZhGIZhyiM3JhdJO+QopVcTT9TpVrbr9K4T+rTyUT2oNta81OA+7VV13SfLXzdsYl3dWNk/xjZRXMtNqec+cw1I1Jbp9+8IOGvFa3XSu4pmajQp5NtejuZnnMlEQXoBbAVOL2cYhmEYhmEYGyNmZSwg6aPc5ZlabdyvFyijepovlgwdzMsXO4G9AnTRxOSdLLodpZ67Jvpzl6R1Qxj0ja+MA7murlsCUg/Zjtkfi26GYRiGYRiGsTGilpqWWk5s2C//Jl0+oof5r0WpxN6e8nhPBWm9Lr4uIo2XyDyfhdzYPPNfkLE6RXnFSN6XIsYeER7wauplk/251VCGRo/W8jgmCbgRj6rVddtQijmLboZhGIZhGIaxITIvZCH9WLoY+3Xyg09LnzLXjU2ScExbh92tFfVXNj9K6eKiFzvX44DoxPIjjEED9KnKyVqjLsa2oF7VxTmyCR+53peXKUERZcW5nCZfurREjdFblXWx70zVRLct1XWz6GYYhmEYhmEYGyJ2VazJUe5/DujHVM9dWfqo6mkrMrEiUy6FJE4xt/l67uAK6rkvR9NEizzu1x5wdamZ9PKSZmqVqev2qO8B9zB3MU49mCoc3G0BFt0MwzAMwzAMY0PE/5Ng0KarPDZUsZ5bobfaOboCsUPRRI2rppS4Y2yznjuognruzYdrrj93uX3jT8NsKKKvRLsLM4uQcS4TtgCLboZhGIZhGIaxEfIS85F6WDaA8mnjA6+G2mJrIxQVSbpINxlQqd2fzUX93Irqup29nHWGVdlXcpBzQ2udztgE1M5NuYa8W3jDI9yj3PWXbdVPsozojholNECDJtrkjkPngIJCqUop5knbbWNSiEU3wzAMwzAMw9gICdT7WqszQkeElLvu4fNAktageVjXqqUFk9hpWk8eHzxbsdgJVKeYc+swmyJ5Twok7fmryLU8MVXCf9pId+MwoEcb1Di9tNHunDzg5GXznx88JFg3jltXCTc2K+BS0zvAMAzDMAzjyEjFEgrSClCQUoCC5ALkp2p/pyiP5evG+ckFKEwrgH93f3T8qj2c3Dg+UptTy0NHlS+6N2pdy6uaWq6u66b63tx8CHO27lpztbLqui9+eElX111/ekSVX5+xDImq6K7a9M4Yf+2gjAl5PHWInJ5d0/Rqo8Gi/yRdirm5xm4+rbzh3dwbWRezxAQEZY+4B7uhJmHRzTAMwzAMYwWyrmTj0B1HkHk+E5BNhE0m+2oOggcHsZCpZRQXFCNxsyyYXP1d4N+9Trnrbzygrueu+utTXfcf/2rFzqnyRTdNDDl5OKE4t1iIbnLAtgXBxqgyDzSUkRBQ7iFZskV/DU0dahvnr7eq1IHM1B6aZN5+0XVYd1woLn9xRXz3xm+IR4M76qMm4elThmEYhmEYK3Dhg4vIPGum4FbdW0YtibbGbjE2TMreFFGPS4QMD4GTS9m36mmZkq72ulVDoHG4BSLd7fXjPafKTy93dnfS1c7m3sgVE0VMzUNR3YyTGWLs19EPbgFlR3gTUiWdiRqVFnStwVZhajo3p1IJebyvEmZqRNi4UN04dm3Np5hzpJthGIZhGMbC5CfnI/bvODF29nZGQC9/uAW6wdXfFa6BrnALcIVrgCvcAl21j7mJx1z8XLCt105kX84W0aqcqBx4RpRtpMU4FvH/avs2kegeoa9LNcZ/h/RpwVVpFaamYzPA012upTXFOZpSlxWX7OSdyfBu4mWZHWEqTeJ/+muoonruFduA4mLbSi0nPNw16NJCwv4zwNnrQEqGhABf8/atTpc68Ah3R25MHpK2JqIgvRCufjUnfTnSzTAMwzAMY2FuLIpGcZ58N9vwrvroubQ7Os/viHYftEHL55qj8exGiJhSDyHDQuDfzV+IFRLfGicNIqZp3awkIHppDJ+bWkT8Rm09txMQMqx80b1R1SpsdC/LiCUyYuveSh5TbXd8SvnR7qAB3K/b1vwjLn2hdx4LHRliemr5ENsQ3MZahx04A7Oh79K64+R2e8X5EhL+03sl1AQsuhmGYRiGYSwI1bZe/zlS93eDmQ3Men7ElHB9ivniaLE9xvHJupwljJ8IStsuLy2YrokNWhM1dzdgUGfr1NNSXXd51OnsJzI5lH7dfK3WLDGrYpF5Tn8NBfQpu547LlnC1qPyuHkE0LkFbIpebfSTAPsqIboJqutWiKvhFHMW3QzDMAzDMBaE0sKzL2XrHJ59Wnib9XyvRl66m+XM81lIO5rO56eWpZZX1Crs3HXguly9gAEdAS8Py0Up+7TTmFzX7eTqhEDttZoXl4+sC7LgY6ofqUjSuckTLZ5rXm66+HJ1avlQ20ktNz75U7mJx8C+AaKMR+kKUJSrrceoAVh0MwzDMAzDWBB1lLvhPeZFuRXqKynm2mg34/gkmNEqbMM+/Xi0BVqFqemtSus1qa5b3a97p9Y1m6mZKPd5bZS7lz+CBgXabWq5YuwWXEcf6a5MFgUZESqfpaKsIp3/QE3AopthGIZhGMZC5MXl6dIY3ULcUHesPr3RHMJuqgsnd/k2LWZFjGglxTgu5FietEsWBB71PeDT2qdaW4WpCQ/WoFGYPCYjq8LC8sVOoFp0K62qmGqPcl8wI8odkyhh+zG98z0Z6NkaGo0GPdvI46Q02WOgMoSNl+u6idi12vSQGoBFN8MwDMMwjIWI/DMKklakNJgRASe3yt1qufq56gR7flIBElSOxIzjkbgtCVKBpDO/Kk8w5eRJ2KatxY0IAdo1sfz+KNHu7Fzg5JXy163T0U+47hPJu5KFmRdTvUT/FaNL7afSlKAKXMsptVwJHNuSa3lJeqtKHSryFyiL4MFBOt+B+A0JYoKiJmDRzTAMwzAMYwHoZi7y1xvyHxoyUKtfpe3pXMw5xdzhif83wWTH6R3H5JZeSqswawgmw7ru8tfVOGtE7awyQZRBvemZ6q3l/kjvWN7i2WYVXhO2nlqu0Esb6Sb2namcWHb2dEbIULkTQH5iPlL2paAmYNHNMAzDMAxjARK2JCLneo4Y000eGaJVheAhQSJFnYjfEI+C1AI+Tw4IRYYTtKLbydPJoEa6olZhoyxcz11ZEyuD1mGcYl6tRK+I0bne0+SH+lwYIypBws4T8rhNI+tkSliKnmrRbYK/QFnUHa8v84ldUzMp5iy6GYZhGIZhLMD1n1QGandXzkCtpAlQvcnhuj6zMStjq7xNxvZIP54unL+J4IFBIjJXHhsPyL+dnIDh3a2zT11ayK3ITIl0E0EDgnTjZBbd1UZxYTEufnTJrCi3vaSWE/6+GrRuKIY4cgHIzatctFuUbLjK7zN2bXyNtLZj0c0wDMMwDFNFcqJyREsawiPcHSEj5XTGqsIp5o6Pct2YkloeGSfh1BV9FDDQzzqCyc1Vg67avs0XbpCRVfkixbeND1wD5dZMSbuTa6xutrYRsyIWWdr2hIH9AgwmP0xJLZ9iw6nlCr20/gIFhbLwrqxHhpIBkHsjF+nHM2DTojsyMhKnT5/W/Zw7d67UOsXFxbhy5QoSEvRfIOYsZxiGYRiGsTcif4sCtAbjVMtNUerKkp4l6SI6fh184dNGdrJO2Z+KrCvyDTbjmKI7ZET5kzX/aKPcSj23NemjTjGvILVX46RBUD9Z1BSmFSL9BPeWr44o94WP1VHu5hU+50a8hF3a1HJKK2/XxPZFdx+Vv8Ci/yo/mRM2rm6Nppib9R/hk08+wfPPP4/33ntP/Hz66acGy6OionDrrbfikUcewS233IK33nrLIHxf0XKGYRiGYRh7vPmN/O2GzlSqwR2VM1Ajof3id8UIGi+h2XQJyemSSP006Nm9hHt2O1qLubQjskD1be8LzwjPctffoKrnHt1LU43O0WbWdXO/bqsTvSwG2UqUu39AhV4AxLKtsAsDNTW3DgY83eXxj+uAlIzKace6Y0KFwSURVwOtw8yehp01axZ+++038TN//nyDZR999BE6deqEdevWYeXKldi1axf+++8/k5czDMMwDMPYG/EbE5AXK9tJh44KgUc9D7O3se+0hK73S3jvd6CwCIhOBNbslpfVuzVcd8cWtTiaAxYORPwmfSu40BHlp5ZTv+xNB+VxgC/Qo3X1RbpNqutW9+tm0W39Wu5PLpsV5S6VWj4YdkFQHQ3uGSOPs3KA+asqtx33uu4I6OkvxpnnspCpNZ+zWdGdkZGBy5cvIzc31+Bx+nvPnj2YPn26+DsoKAgjR47UieqKljMMwzAMw9gj139WG6iZF+WmnsvPfFOMvg9LOHPNcNmBs/INske4B4IHybWaOddykLIv1RK7zdgA8f/E68Y0YVMeB84CqdpuXGSg5uxs3Uhl/VCN6ANO7D8DFFVQp+3d0hvudWX3teTdKSgu0NZbMBYnemkMsi9n6yY7lNT+8rgeJ+kmTzo0Bdo0to9IN/HkVA0Uv7evVkjI1/a0N5e6qhTz6o52y53sTaRBgwZYv349li9fjtjYWMycORMPPPCAWBYTE4OioiI0bNhQ/4+nYUMcOXLEpOXGyM/PFz8GO+ziAjc3rZ2iCVANufo3w1gTvt6Y6oSvN4avt5on+2o2EjcnibFnQw8EDgo0+Z6Daivv/xA4H2noGq2YBZHQUbZVb0o4ErfIr3NjURT8e9aBI1Mbvt+K84t159Q1yBV+nX3Lfb/r9+nHI3tUz7Hp3VZ2u87IBk5ekdChafliJ7BfoDD3KsoqQuqRVPh3lyOLto49XW8iyq2q5W72bFOT9nvJZhhEue3hvSo0rQdM7Aes2ilnAf25ScLMUeYL79AxwTj76jldXXeTxxrDEjhRKwFLiu45c+boxmSiNnv2bLRv3x79+vXTiWO1IPb09ERenpxuVdFyY/z000/4/vvvDR6bMmUKpk6dCnMhEziGqS74emOqE77eGL7eao74r/UmWD4TfXA98nqFz8nO0+CTZf74+V9fSJIcvnFzkfD4zamYNSYdo1+qh8sxrjh6QcKFS9fh5gIUdyiGxlMDKUdC9F8x8H7QE07ujt+ExpG/37L2ZQlxSnj18sD1G+VfO6t3hlGSrBi3Db+Ba9fk51qTVuG+JKXFeN2OJPg5a0PtZSC10Qu5S2uuIDik4gisLWEP11vq6jRkX80RY6+eXsiol46MaxUb1/2+UX/99G0ZhWvXCmFPzBjkjlXiMwC8/1s+BraK0UW/TUYDuLd0R975PKQdTsfFAxfhGiq77leFJk2aWFZ0q2nVqpUQ24cPHxa//fz8xOPp6enw95dntdLS0lCnjjwTW9FyY9xzzz2YMWNGlSPd9AGiKL0psxAMUxX4emOqE77eGL7eaj5SeWmt3L+JesC2f6gt3EO1jj9lsO0oMOtD4JLKD61XG+CH5zRo2ziAqnXRtwNwOQbIL9QgraARujeT18uYmIXoxTEoziyG5xkvhN2kT5V0NGrD99uZ7/VdgBpPaozwRrKgMEZSGnBc2yqsXWOgd5fKmfWZy+h+wLuL5PH52CA0alR+S6rgiSGIfUdOmS8+WYxGjRrBHrCX641S9q/+op8Y6PBKWwQ0ou+N8rkaAxzTloB3agYM6R0Be6NhQ6DXCmDfGeDcDTdcSGyEEZXoU18wqRAXP5QPhutxdzS6rwGqA5NFN6WGk9M4iV6FxMREtGzZUozDwsIQEBCAY8eOYdCgQeIxSh1v06aNScuNQeLaHIFdHvQBsuUPEeNY8PXG8PXGOCr8/aYndn0c8hMLxDhsfF14hpXtPJ2ZLeH5+RLm/qV/zMMNeOs+DZ6calif26uNhN//kVMnD57ToGdbeVn92yKE6FZqOuvdHA5Hx5Gvt4R/E3WO96HDQ8p9n5sPSygulq+J0b1MS2e1BN1bS3B1kUSP5L2nKn5dn2be8IjwQG5UrmhxJxUAznaUkWHr11vUsmjkaKPcQYOCENS34r7cxPLtdO3I18+0YRo4OdlPPbeap6dLmPKq/D4+WwKM6mn+uQobH6YT3fHr4tFkVvVMDJm8p9nZ2SKdfMOGDTh48CA+/PBDnD9/HqNGjRLLqaXFtGnT8Nlnn2HHjh3C3ZyM0yZPnmzScoZhGIZhGPs1UCs7WvLfIQkd7jYU3P06AMd+0uDp6ZpShlg9VPGI/Wf0dYtkmESChkjYlIi8hLJL9BjbhpyTFSOsgN7+cK1TforrxgP662BUz+oTTJ7uGnTWGmOfvV5xuya631dczItzipF2OK06drNWQFFuA8fy57QpMA7qWm6MmwcATbRzjRv3AycumV/X7dvWB16N5QnS5F0pyE829A+rcdHt6+srenTv3r0b3333HQoLC/HLL78gPFw/y3rvvfeK/tu//vqrSDv/6quvDNJKKlrOMAzDMAxjD2Sez0TyzhQx9m7ujcB+AUZbPD30STGGPynhaqz8GPWb/fwxDbZ9qUHLBsbFE6V/urrozdQUNE4aREyR77ukIgnRK7QbZeyOhH8TTG4VRpmmJDCU62dAR1Qr6tZh+06b2Tpsh2wUx1QdahdI3QuI4MFBCOxVcVo5cTlawsGz8rhrS6B5ffuMchM0QfnEFP3+f7rEfNFNE0N1x9fVfY9Sy8fqwKyabkolf/PNN8tcTukY5GhOP5VZzjAMwzAMYw9c/+WGQZswupEryWdLgXmqnrIDOwE/Pqep8KbXw12DTs3lG2WKLqZnSfDzlp8TMbUeLn1+RXcT3uQBDl7YI+ob/dCR5Yvuk5dlx2ZicGf5+qhOerfT4MvlsrjZe0rC6F7lv37QAMN+3S2etfouOjxViXIv3aIfTx1iv4Jb4d6xwGsL5PZ5f/wLvDtLQniwee8rbFwornx9VYzj1saj/nTr17jbbtECwzAMwzCMDVKUU4QbC6PEmBzEI26rZzQ6+d3fslAhPf71Exps+aJiwa3Qs7WyHeCQ3m8LPq18UKez1pz2WDoyzpbvJs3YHgXphUjeI2dJeDbyFP2ty0OJcld3armxSLfS57k8PBt46tJ3Uw+kis8LUzWiFkUj57o2yj0kCAE9TYtyl0otH2L/Z8LHS4MHb5LH5DVAfbvNhVrZKT3lE7YkojDL+k7uLLoZhmEYhmHMIGZlLArT5Ju08ElhcAtwM9qD+6KsyzG0K/DILeaZF/Voo19XnWJOREzTi3yKdjP2ReLWREiFki7KbSxLQs2G/ep6blQ7ZKpeVxu8JudoxdCtPAKVuu58SRiqMVXrknDxE31f7hbPaYvsTeDiDQmHz8vj7q2p37X9R7qJxyZrdCU4lE2UlWOe8KZSndAxoWJcnFuMhP+0qSRWhEU3wzAMwzBMZVPL7zFuoPbTOv1N4N1jzL/R7akyUztw1vCGMvyWcGhc5G1GL40WdYmM/RD/j+mp5SQmdhzXi99WDVHt0KSAEu1Oy5RLHiqiZIo5U3luLIpCTmSuGAcPDUJAD7n1siks3epYqeUK9YI1uH24PE7JoO9bmA11nFCgFHNrw6KbYRiGYRjGRNJPpouUWcK3nQ/8u9cxKpSWaOso/byBWwaaf3hbNQB8vYxHut2D3RAyPFiMc2PykLSDRY29IBVLwnmecPZ2RmDfgAr7uufLXekwqocsgGuC3tq2dQS1DquIoP76VlbJLLorTVFuES59qq/lbmlGlNuRXMuN8dQ0/TX52VIJRWZOPgb1C4SLn4tuIowyCqwJi26GYRiGYRgTuf6zKsp9VwOjImjZViBTLr/EtKGAl4emUi693VrJ48h4ICbR8IaSU8ztk7QjachPkFsUBQ8MgrOHsxmp5TUXqTSs665Y3HiEucO7hVyrnno4DYWZ1q+ZdTQStydh5+A9uig3TbRRLbKpnI+UcPSCPnOmcbjjRLqJjs00GNlDDHE5Gli5A2bh5OakyzQpTC+0ekYGi26GYRiGYRgTKMwoRNSSaF2Ust6U0gZqxE/r9aLknkqklpc0UyMOaFv+KNDNoksdOUoTuyaORY09ppaPKj+1XG2i5uwMDOuGGoMmgGgfTI10q1uHUf16yj7ZOI6pmNzYPByZfQz7bz6IrAtZ4jEnDye0fLGFWYfP0VzLjTFHFe3+eLH5ZTZ1x8l13UTs2jhYExbdDMMwDMMwJhC9IgZFWbITc73J4XDVpiaW7IlLKcEE1d/2VkUIzaWnykytZF03RUjDbw4T46LsomqpSWSqTvy/esMmpUSgLK5ESzgfqY801/GpOeHk7akR/eOJU1eptlsyr66bSyAqpLiwGFfmXcX2XjsQszxW9ziVsPTd0At1OsldC0xl8Wb9ObrVwVLLFUb0ADo01U8G7T5hnvAOGRYsJjSI+PXxovzDWrDoZhiGYRiGqQBqAXb950hVanl9o+v9ssEwyl2VGtweKjO1knXdRH2Vi/kNdjG3eXJjckWbN8Kvkx88wj3KXX/jAf14VI+aj1T2bqtvY1cy88IYgf1YdJtK8r4U7Bq6B2deOofCTHlizzXQFR2+aIc+63vBr4N5gvvMVQkntKXgNPHXKKzmrx9rQN+v6mj3J2ZGu128XRAyRJ78yovLR+pB6znts+hmGIZhGIapgLQj6Ug/niHGdbr4oU7n0gZq1Erplw3aGywn4M5RVTusDUL1rZpI5JDwV+Pfwx9eTeR+yEnbk5ATJdd+MraJYqBGhI4oP8pNbFTVc4/uhRqnT3uNWf26yfDPt62PGKcdT0dButYRjtGRl5iP44+dxN6x+5FxKlP3eIOZ9TFoX380uKO+aG9lLmrX8mkOmlquMH04EK717ftrh9wmrdIp5muslzHEopthGIZhGKYC1P2wG95tvE3YliPAtVi90zS1talqFEep66a2OJeiSi/XGapJQPQy7tlty8RvNL1VWEGhhP8OyePgOkDXlrCZSDex1wQzNXVdN4qB5N1c161Abf4oc4ZSyW/8qf9g+3X0RZ8NvdDhs3ZwC3Sr9LlSu5Y7amq5gpurBv+bLH/X0rzk50vNE92ho0OgcZafH7c2rtTkZlnkJ+WL/wtH7jtm0vosuhmGYRiGYcqB6vzoZkzcOLlpEDZRrqUurzf3PWMtE13qoarrNpZiHqEyc6MbQFNvGJnqpSivWLhRE24hbqjTpXSmhJo9J4GMbH3dqlMlop2WplmEPAFA7D1dOvPCGEED9K3DuK5bJu1oGnaP2ouTc06jIFV2dafWVW3fb41+m/qY1Ye7JHRO/vhHwqkr8t/9OgD1Q2v+2rE2D9xEvgPy+Kf1QFKa6d+DbgFuCOwnt+7LvpqDjNP6jIOSxzb9dAYufnYZe8bsw6bWW3Ds4ROIWamvvy8PFt0MwzAMwzDlkHY4TfTDJoIGBxs1UCNjqeXb5HGgHzCxn2UOKbX6Udh/pvSNpFdjLwT0lm/SM89lIf2EnALP2BbJu5N1JnxkoFZRyrDaBMsW6rmVzArFGDA5Hbig755XJqIPuXb3rd2SyR4mXk49dwa7hu8V5SoKEVPriVTyxrMa6SKu5kKCcP1eCd1nSbjjbcnhXctLEuCrwb1j5XF2LjBvFcyi7ri6urEywar0SY/flICTz5zGls7bsXPAbpx/+wJS9qeK7A1zYNHNMAzDMAxTDtSSSyFsvL7+T83izUCu3H4Ztw8H3N0sFOkup22YQr1b9dHu+A3sYm7vqeWZ2RJ++0cee3kAkwbAZujTTlXXfbLi9V39XeHXUTYByziZgfxk7YeklkGi+MT/TuLaD9dFKQjh09oHvVf3QKdvO8A91L3S2952VMLAxySMfVbC4fP6x0d0B2ZPQK3hiSka4aVBfL1CQl6+6dHusLH673WKXF//NRIHZxzGphZbcHDaYVxfEIncG4aeGT6tvNH0scbiHJpC6alahmEYhqlFiJSx9HTExsYiJiZG/C75k5CQgIEDB+KTTz6Bk/Jfnak110es0o7LCag7OtSqvblLEuinQbMISdRz0w011fq6uhhuv+6oEJx6Wh7HbUhAi2ebW+z1GctcQ0p/bo2LBsGDyzdRW/ifPrWcJnBqslVYuXXdpyXcZcK1Tq3DFNd2inaHl1Ge4chceO8iopfF6Htuv9AcjR9oBCfXyv8/2X9awss/SPj3oOHjnVsAb9+vwdjecnZCbaFpPQ1uGShh2VYgNhn4cxOV+Zj2XI96HvDvVgeph9JExtDJJ0+XWodKi8iRnybN6IeyjMyBRTfDMAxTa8jKysK7776L06dPG4jq3NyKXZ8PHz6M4cOHY9y4cdWyr4xtQPV92ZdlBRTUNxBuQaXNjc5ek0SPWIJ6xnaxsOkVpZiT6KZI+snLpbdPN4xkwETu6iRuqDVVRe2omOoj63wWcq7liHFgnwCj5Qlqgf7tSv0EzoM32ZZoojZ2NO9YXGyag7lipnbl66tinFwLRXfkH1G4+Im2f5cG6PJ9J9RVRVbN5fglCa/+KGHVTsPH2zQC3ryPhKdteADUBHOmabBsq6RrH3b3GNMnHuqOrytEtxq3UDeEjpBFdvCgILj4Vl46s+hmGIZhag0vvvgivvzyy0o/f8mSJSy6a3Fqed0J+ro/NT+ro9xjq9ab2xg9W2uwcJOkM1MzJurpplBpaUatqRrcabyPOFP9XP3+um4cUkFq+YEzwJEL+tKCbq1sSzz5emnQvomE45cg+kBTKryPV/n7GNg7QNQqk2N3bTNTS9yahJNP6Wcn2rzTutKC+3ykhNcWSKKURe1h1yQceP0eDWaMAJwrWRPuKPRup0G/DhJ2nYAwk9u43/R2e43ua4DUA6nIS8hH8OAg8Z1ap7NfpVq2GYNFN8MwDFMroNTx+fPnGzwWHByMsLAwg5/w8HCDvwMDA9GqVSuRgr5y5Urk5eXB3b3y9XeMfRGnruc2crNcWCjh143y2MUZuGOk5fdBbaZ24KyEB4xEP+kG8eLHl3X1wyy6bQNyLL/+U6QYO3s5I/ym8qO88/623Si3Qp92FG2Vo93kYj68e/nrU3SQetunHkxD5vks5MXlwb2u43+HZpzNxOG7j0IqlM9p49kN0eSBRmZv51qshDd/lvDLRqBI9uIT1AsGXrlLNhCjtlmMPtq964R8zD9eJGF0L9OOjYu3C7r91gXWgkU3wzAMUyv46KOPhGAmnnjiCXz44YdwdXU16bmTJk3Cr7/+KoT3P//8gwkTapE7TS0m61KWrn2Mf/c6Io27JP8cAGLkTlAY3xcI8bf8zS/VaDo7yzfcxtqGEdSCilIh8+PzkbgtSbjuOns4W3xfGNMpzCzEicf1Uc5Wr7aAZ0TZaf8pGRIW/SeP6/gA04ba5tEe3EWD+drJAcrAGN7dhLru/oFCdBPkBt1ghmNnYtDEwoFph1CYUajrBd3mbZUrookcuyih/yMSMuXqBAG1bXvhDg0emgR4urPYLgl1jmgeAVyMguh1T8ewU/OaP07sBsMwDMM4PHFxcZg3b54Ye3p64vnnnzdZcBNTp07VjRcvXmyVfWRsD52BmnAtr1utBmpqvDw0olacOHUVyMop7cpLKZBUe0gUZRcheVftSuO1Rc69eR4517W13H0D0Oi+huWu/+sGIEeeF8Rdo6jvcM0LhbJEjZ+3PF6yxfj1WJK6Y0IN+sk7MoVZhTgw/bDO7dqvkx86f9exUu3Anv1WL7hpIuat+zS4vFiDp6ZpWHCXAaXYk5O5wpItpruYWxMW3QzDMIzDQ67jOTnyncuDDz6IunWNC6iyGDFiBOrUqSPGq1at0m2LqT2p5XXHlU4tT0qT8PcueRwaAIzpbb196akNklFKr7otkBp1KypyMWdqDnLpvvajnFbu5OmEDl+2L7c2lAzU5q3SiwNjJQS2Ak0CKVF4EoTkFl0RdbrVgXdzWakn70pB9jWtPbuDQXXrR2cf17m1e9T3QPc/u4rUZXPZfUISmTRK3faVxRq8fJdG1NUz5XPrYP14tfY7uqZh0c0wDMM4NNTua+7cuWJMtdjPPPOM2dtwc3PDzTffLMaZmZnYuFFbxMs4LDlRuTonW992PvBuqg3tqaCWNPkF8viOESjVysuS9Gij33ZZKebkrkttbQhqUUVCjqmZSOfx/+mbWLd+pSW8m5TfXmj7MeCs1m9tYCegbWPbFlbqrA51tkdZkLlgxG36fvJRSxwz2n3m5bOI1054US17j8Xd4BFWufr1137SH9eXZ2oQ4Gvb14QtUTdQo/PCIMM/qouvaVh0MwzDMA7Np59+iuxsOaoye/ZsYZRWGdQp5uRizjg2ceviKkwtL+labk3UZmr7zxi/gaSbfOojS1Bqa8YZuR6dqV7OvXlB1yIsoE8AGs0qP62cUEe5bdVATU3vdkAr7dvadhS4HF2xqImYWk+0zFJSzB1tUujq/Gu4+t11XT/2rj93hm9rn0pta8cxCZu0/bebRQB3jrLkntYOJvTVf47W7EaNw6KbYRiGcViSkpLw9ddf66LVzz77bKW3NWzYMAQEBIjx33//zSnmDk7cmniD/q3GeuUqad7dWwPtm1pXKLVtRGm95Ue6S6aYk4s5U70k7UrGtR+u69LKO37ZrsKWQ3HJEpZvk8ch/hB9lm0dilyro92/bKhYQJOJXNDAIDHOvpKDlH2pcBTi1sXj9EtndX+3/7StaDtVWag1mMIrMzVWzaJxVMb31Y/X7Kn5CR4W3QzDMIzD8vnnn4t0cOL+++9H/fqVd8xVp5hnZWVh/fr1FttPxrbIT8pH0m7ZiMyrqRd825SOVv20zvoGampcKHKm7c99NRZISDV+Exk6Si+6E/5h0V3daeUnVGnlrSit3EhZQkl+WgcUyCbXov2Tu7ZEwNah6KuTVkn8soH8BioWNvVVKeY3FkbBEUg9koajDxwHtG+/2VNNq+TOvu2ohC1H5HGL+hD9txnz6dQcqK/9Otx8WO4pX5Ow6GYYhmEckpSUFHz55ZdiTE7lzz33XJW3ySnmtYO4DfFAsTwOGxcqonpq8gsk/P6PPHZzBaYPr579UszUiANlRLu9GnnBR5vSmnIgVUwgMNXD+bcvIPuqNq28tz8am5BWTkJVab9Fl9nsifYhuIl6wRqM6iGPr8VCJxTLgwwJnb3lVnaxK2OF0749kxOZg4O3H9a9j/DJYWj5YvMqbdMgyn2XRky4MeZD39tKtJu8NzYdQo3CopthGIZxSEhwU19t4p577kHDhhXfAFfE0KFDERgo18yuXr1aVyvOOBaxq1X13BNKp5av3QMkyh5rmNQf1WZw1NPATE2qOMVcAuL/5Wh3dZC8O1lXzyunlZfvVq6wcb+cuUCM6gk0rWdfAkvtZaDO/igLcvEOnxQmxoWZRYhVeSfYGwVpBThw22Hkx+fr6vc7ftWh1CSdOWw5LIkaeaJlA2D6MEvtbe1kvEFdN0e6GYZhGMaipKWlidRywsXFBS+88IJFtksR81tuuUWMSXCvW7fOIttlbIeC9AIkbUsSY496HqjTRW4VV2ZquZUN1NT0UJmpHdCXj5abYk4u5kz1upW3erkFvJtVnFZeykDNjqLc6p7dgX7ymOrS0zLNSzGPWmR/LuZSsYTUg6k4NPMIMs/K5UtezbzQ7dfOcHavfDyTjOXUUe5XOcpdZYZ2BTzd9ZOlppRAWAuOdDMMwzAOB5mnpabKJj0zZ85E48aNLbZtTjF3bBL+TURxvqRLhS0ZrYxNkrBunzyOCAFGdK++faNevUF19GZqZbk/+3evA9cAVzFO3JyE4nxtrjxjFc6/c0EYgxEBvSitvJFJz4uMk7Bmj/5aGtfH/k4Q1Z/fri2vyM0HFm+u+DkBvQPg2chTjBO3JSE3Ohe2TkF6IWL+jsWxR07gvzZbsXvUPiTvTBHL3IJc0WNRV7gFulXpNajueMdxedy6IXAbR7mrjKe7BsO7yePYZODQOdQYLLoZhmEYhyIjI0O0CSOcnZ3x4osvWnT7Q4YMQXBwsBivWbNGmKoxjkPsmvJbhf3xL1CkLUOdOYquseqLTlLaqlLXTentV2OMr+fk4oSQYfI1WphRiOS9sjhgLE/ynhR9WrmHEzpQWrmJ18QPayUUa+dDZo2339pds3t2O2kQMU0b7S4GopbaZrQ763IWrsy7in03H8Cmlptx5J5jIjKfn6j3SXDxc0G337uYZJhnVpT7bk21frfUmhTzPRzpZhiGYRiLMHfuXCQny87TM2bMQLNmzSx6ZCldffLkyWKck5ODtWvXWnT7TM1RlFOEhE2JuugVmWGVvDFWi4q7q8G1vCScYm47kHmWSCuX9GnlPs1NE18FhRK+Xy2PnZ2B+8fDbunSEuio/Zrdewo4e82EFPNpahdz2+jZLRVKouXbmVfPYVuvndjWYyfOvHQOSduTIRXo94+M4CgLpsMX7TDowAAE9JRbSVaFfw8Au07I4zaNgKlDqrxJRos6g2T1LtQYHOlmGIZhHAZqD/bJJ5+IsZOTE1566SWrvI46xXzx4sVWeQ2m+knckqRzIQ4dEyoixmoOngVOXZHH/TqQ0VH1i25TzdQo0q1EXLmu2zqco7Tyy7KZYkBPfzSebVpauXLzHyNbB2BiX0ovt9+oJmVgqCegfjYh2u3V2EsYjxFZF7KQdljrTFgDkMP/if+dwvnhl3Bg0iFcmXsVWRcNM5g8G3qi0ayG6LGsG4ZfGIpuv3ZBgzvqwz24ainluij3T/pj9hpHuS0KfbaUdotHLgBRCTUzwcOim2EYhnEY5s2bh8REOVI5ffp0tGyp/U9rYQYOHIjQ0FAxJjM1SmlnHD+1vKaj3EQPVdswqusuC9c6rgjoI0fqsy9lI/MCl0FYEkrZvzr/WqXSyksZqN1kv4Jb4Y6RgIvcCQy/bgQKC83s2V1DhmrpJ9Oxa/heRC2MRnGmyvvASXYjb/VaSwzY1Q+DDw9Au/fbIGRIcJXM0spysKcMAaJdE2AKR7ktzgRt6zDFUK0mYNHNMAzDOATkJv7RRx/pIi/WinKXTDHPzc0Vtd2MfVNcUCz356bz6+OMoIFBBstz8yQs3CSPyQ23ptI/QwM0aCx3XMKh8+WLm9CR8sQQwdFu66WVt3yxBXxamF7TeyFSwr8H5XGzCGB4NZrxWYsQf31PZIrg/3Og4ueETQwT7dXEc1bEoCiveg3/ov+Kwe7R+5BzXTbBc/J2QvgtYeg0vwOGnxuCPmt6otn/msC3tU+V2oCZU8v9+j0aOJnQao6pfF336hpqHcaim2EYhnEIvvvuO8THx+vSv9u0UfVXsgLsYu5YJO1MRmFaoRiHjAopFc1atRNIlbsD4dbBgJ93zd0YK3Xd2bnAGTnYWn6/biG65c8GU3XOv3dBZA8Q/j380eRB09PKie9W62/6H5joOCLLXEM1Vz8XhI2TM0oKUgsRv7F6rlGpSMLZN8/j6P3HUZwjC/06Xf3QdGkjIbgjbq1XZSdyU1m/V5+xQnXxtwyslpetdXRtCYQFyuNNB+m7s/qFN4tuhmEYxu4hQ7MPPvhA9/fLL79s9dccMGAA6taVbxjXr1+P9PR0q78mYz3i1sSXm1r+1w79Tdpdo2tWJPVsra7rLns97+Ze8GrqJcYpe1JRkFZQHbvnkOQn5yPyjxs4cNshXPlWm1bu7oSOX5mXVk4ZEz+tl8durlSmAIdhTG/KxJDHf+8CktIqFjYR6p7di62fYk6fgYO3H8blL67o92F6PfRc1R2uoXKbverCWC23o0zA2BpOTvpMDGptt+WI5c7hgx+blqHBopthGIaxe3788UfExsaKMaV9t2/f3uqvSe3Ibr31VjHOy8vD6tVaK2LG7qDIV+y6OF19rtJuS+00vWG/PPb3AQZ1Qo3SU5XEUZ6ZGqXEKtFueo8Jm2W/A8Y0cmPzcG3BddEy6r/WW4XZFvVx16eVNzcrrZxYvo3EqDy+dZCclu0ouLpocOdIeZxfAPypLccoj+CBQfAIdxdjOrZ58XlW27+Ms5nYNWKvrkMBTZa0fbe1mDhx9tAWpFcjVFtM5oxEp+bApAHVvgu1ivF9VCnmuySLZSrM/9u0dVl0MwzDMHYNCd73339f9/crr7xSba/NKeaOQcqBVOTHy713Q4YGw8XbxWD57pNAmja1fHQvqunX1HiqpJP2Du6A9qa9LEJHqVLMNyZYec/sn5zIHFz59ir2jN2Hze234tQzZ+SWUUX6m3QSiSS4mzzU2Oztf6syUHtokuMIbgVzXcxJ+NabKke76RhHLy+j+XwViVsXjz2j9urKAlwDXdFzeTc0fqCR1eq1y4Nruasf8k5w11YNrNkjnwNLZipUBItuhmEYxq5ZsGABoqKixHjSpEno1Kn6wpD9+vVDeHi4GG/YsAFpaTXX9oaxnmv52j36G6txqmhJTeHjpUFbbRnx8ctATl7ZN36BvQPg4itPIlCEr7iwes2q7IGsS1m49Pll7Bq2B1s6b8eZl88hZV+qLqJNeDX2RNPHGqPvxl4YcnwQms9pZlZaOXHikqTrxUwu1dR2ztFo31SD7lqH/cPngeOXatbFXCqWcOGjizh05xEUZsrtAH3b+6Lff30QNMDQLLE6+XunfHyILi2Am/rX2K7UGrw9NRjaRR5HJQBHL1guU8EUWHQzDMMwdkt+fj7ee++9Golyl0wxp335+28T88wYm4GiFXFa0a1x0RhEhhXW7JZ/U0BsdE/YBEqKeVERcER7824MJzcnBA+VxUVBSgFSD/LEkEJOVC72jNmHbT134txbF5B21NCXwaeVN5o/3RT9t/bBoIMD0Pr1VvDv7g9NJetu5/+tahM2UVMjEdZqN1RbV7Ho9mnpgzpd64hxxskM0cbLEhRmFOLw3Udx4f1LusfCbw5Dn3U94dXQEzX5nfP6z4aO5Y56Ldiyi/maPZbLVDAFFt0MwzCM3fLLL78gMjJSjMePH4+uXbtW+z5wirl9k348AzmRuWIcNCAQrv6GZkpXoiWdQ3ifdkCwjdTg9mhjmplaKRdzTjHXRUCPP3wCKftTDY6VX0dfkTo+cE8/DNzdHy1faAG/Dn5VFkWZ2ZLoX014eQB3joLDMn24Po3393+ovtuEaPd0y0a7sy5niXZgcWu1BokaoNWrLdD5+46lykeqm5U79FHWbq2ACf1qdHdqFeNV/brXVKF1WMlMBVNg0c0wDMPYJQUFBXj33XdrLMqt0LdvX0RERIjxxo0bkZpqeBPP2HtqOWwqtVyhpzaFlzhwtvybx5DhIUJ0ENyvW+b6LzdEmzjCva47Wr/REoMPDUD/LX1F6jhFXy3Jwv+ADLmcGLcPB+r42M61ZGkCfDWYpE2XTkwz/AyVBUWgndzkYxK9LAbFBZUvgyDDwF3D9yLzrGzE4OLngu6LuqLZ401rPKJcXCzhdVUdMEe5q5eGdTWiNZsyWRmbJFU5U+GNe027plh0MwzDMHbJwoULcfXqVTEePXo0evasmbxfJycnTJkyRTcRsGrVqhrZD6ZyKKnlJErrjgkttXyNQT237RzlDs300cSKIt3uwW4iLZogIZJ9Tav+arFZ2tnXzun+7vRNBzR9tAm8Gsvt1SwN3aR/u1KVWn6T4wpuhXvGmpdi7hbghtDR8ucvPyG/Uk77dJwvf3UFB6YdQmFaoXjMp6U3+m3qjVCaeLIB/tpOde7yuEdr2/pOqY3R7nV7q5apQP4F6u2VB4tuhmEYxi75448/dOOXXnqpRvdFnWK+ePHiGt0XxnQyz2Ui83yWGAf08hcRTzVZORK2HpXH9UOgi5DYSnsmJa3xYhSQnC6Z7mL+T+11MSdhdvzxUyjKkk21Gsysj+DB1jXU2nkcOKK6Se/WyvFF9/BuQIT2klu3z7SIokHP7oXmpZgXZRfh6OzjOPv6eUAbJA8dHYI+G3vDu5l5bd2qK8pNEdKajrzXRiao67rNTDGvSqYCi26GYRjG7qAU7s2bN4txo0aNhIt4TdKrVy80aNBAjP/9918kJ8tpq4xtE6vUe5aRWv7fISBP7iQmIlK2doOsTjGvyEWXW4fJRP52A0nbksTYI8IDrd9oZcUzBFyLlTDtdUMDtdqAs7MGM0fpzf7++Lfi51C7PrcQOX0jfmM88lO0H74KyL6eI1q8xayI1T3W/Jlm6PZbF7j6mVa/TZ/znDzrnpsf1gAnr8jjXm3l9oNM9UMZBiFy4g/+OQjkltP9obxMBTKzHNvb9Ndl0c0wDMPYHWvXrkVhoZw+ePPNN9e4GFKnmNN+rVy5skb3hzG/nrvuuLoVpJbbnljqaYaZmm8bH3jU9xDj5F3Jwtm5tpFzIwdnX9GnlXf4vJ3JoqwypGRIGPOMhBhZ46N3O8c2UCuvZ/dP66UK+yI7uTqh3q1yC8bifMlARJdF4vYk0eot/USG+NvZ2xldf+2Mls83N8llPj1LwnPfFiNgHDD4mXpVbiNVFscuSnj8S/37f+s+jnLX5ISQktaflQNsO1Y99fgsuhmGYRi746+//tKNSXTbAuxibl9QdCz9mNyayK+TX6kWQiQQlHo/DzdgWDfYHD20bcOI/WfKFzR0c6i4mJOgSdRGe2sLdD5PPHlK16u5/owIEVm1FhQ9m/Si3vm+RX1g9XsauLna3uSNtWjZQKPrRX7qimk9jU3t2U3n88r8azhw6yEUJBeIx7yaeqHvP70RZmQCrSSFhRLmr5LQfLqEDxcCeQVAQpoLbn4ZiE+pvKt1WcJ+yqsScrWB+4cnASN61J7rwBYZr5pEXb3LtPO9fFvVMhVYdDMMU6OkpKTg8ccfx6uvvorz58tpNsswWnJycrB+/XoxDgkJqfHUcgUycmvYsKEYb9q0CUlJtUvU2Btxa8t3LT92EYjSlj4P6UJtnmzvJrl5BOCvNdnef1YWIuVRm+u6b/wZjcTN8mfSPcwdbd6yXlo5RcTuelfCdm0ELTQA2PCxxmbazdVYz+71FYsbv/Z+8OvgK8Zph9OQeV52IFdTlFOE44+cxJkXz0IqkrcZMjxYGKb5tq7Ydf7fAxK63CfhwU8kJJRoNnE9Drj1FcmkNmemQJ/JWR9KuHBD3yLs00dr33Vga4zoQb4Y+n7dFX13FhVVvR6fRTfDMDXKfffdhy+//BJvvfUWWrVqhf79++OHH35AerocgWKYklDNdHa27L48ceJEODs728RBon/ASrS7qKjIIBrP2HqrMCOu5bth06nlhJOTRtQnEnHJwA19ibpRgvoHwtlL/rzE/5sgelXXBnKjc3HmZX2YtcNn7eBax7AfuyV59lsJS7boe3KveV+DpvVs8xqyNlOHyseAWLjJtPrZiHKi3TlROdg7fj+iFusfb/ZEE3T/s2uF5/TsNQnjnyvGyDmSLmIp9nEIsONrINRfLrnYcRwGqeBV4duV0F0LdXyAJW9o4K5tjcbUHH7eGgzuLI+vxcqZGOWxdCtwWm6Wgr7tgZE9zH9NFt0Mw9QYu3btKiVM6LFZs2YhLCwMM2fOFGZZxcWV79fJOB62mFquwCnm9kFeXB5S9qXqWgoZ68m8dq9ttgorP8W8/HWdPZwRPEh26s6Pz0fa0fTakVY+5zQK02VBFTGtni7N3hp8sVTCJ9oGBk5Ossjqoaq9r234emlw6yB5nJoJrNxZ8XPqTQ6HxkU+ZiSulWh28p4U7Bq2V3fd0gRSlx87odUrLaFxLvsYJ6VJ+N8Xxehwt2TQM5wmrHbO1WDxG05CSM37XwLctbp93ir6qZrwPnhWwpNf67fx0/O1d/LFFhmvcjFfrZpkNRblfsMCrvMsuhmGqbEboWeffVb39+2334727dsbpBD/9ttvGDZsGJo1a4bXX38dV65UMBXJODxkUrZ69Wox9vHxEdeHLdG9e3c0btxYjGnCKCGhdqXw2st3z6UvLgPae6i6RlLLE1Il7Dstj9s1ARqH2+6Ncs/WajO1ikWCoYt5BaFxB4BEW4I2lZ5awrV9V2X5bmGWbzUUWd8+RYZNtnvt2GrPbvcQd5EuTuTF5gmztGsLrmPfpAOihzfh2cgTfTb0QviksDK3Qyniny+R0OJ2CV8tBwrlcn7Ryuy3lzXYO49qzvX71rlZPuY9rX/+Y59L2H5UqrSJHtVx58vl5nhyKnDzQL4WbAl1f+3yWoct3gycvS6P+3esvL8Hi26GYWqEVatWYfdueWqxdevW+OWXX3D8+HEcOHAAjzzyCAICAnTrXr16FW+88QaaNm2KIUOG4Ndff0VWltxbl6ld7NixQ1crPXbsWHh4aPMWbQROMbd9wX3urQu4Ol97B6WRo2olWb+X1pXH48xoCVMTUNsahQMmGFUpYqY21HXnxubh9Iv6g9L+k7Zw9Xc1uB7+OyRh14mKnbUrgrYx423ajvz3yzOB2bWkPVhFDOwENNZq438PApFxJqSYT9OnmB978AROPXMGUqH8vKCBgaJ+26+dXPtdEjqXZI7V/i55EiRFNjYXae4UpTz/hwZ3jNSI8oySUJszEsgEifTJr0ii7Zs50Ovf856Eq7F60633H+BrwdagrIO28hw59pwCElMlo1HuN39RRbnNdCyvsujOyMjA3XffjXfffbfEjhWJWsy77roLjz76KPbv32/WcoZhagcUrXzhhRd0f7///vtwcXERX2QUKfz6668RHR2NxYsXY8yYMaIdk8LWrVvFdwiln3/wwQdVvlFi7AtbTi1X4BRz2xbcl7/QZ8y0+7CNUeOltapWYeoURFskPFiD+trg9cFz8k1ieXiEewi3diL9eIaod3bU831yzikUpslp5dSKqu6Y0FJuxMOflND/EQk9ZksiUl3R8SurVnjiC5KupzsJtzfvs+3rpjohcau0D6N/2V+tMCUjIxSu/rLTVX6ivl93k0cao8fSbnALlPt5lyQjW8LYZ+XzoZiXKeeExPard2sqNEX88EENRnSXx4lpwKSXJGTlmH5dfL4UWKVNow/0k0sMapNrvT0xXls6RNel0q1CzcL/gHPX9ZNHQ7pW/rUqJbrJ9IhMbGJiYgwe//7774Wj7MMPP4wBAwbgqaeeMkgHrWg5wzC1gwULFuDsWTn6QM7TZIZVEopgknhZt24drl+/jvfee08YrSlkZmbi+eefFym8TO2AbqKV/tdubm4i0m2LdO3aVZREEFu2bEFcnN6wi7Ehwf1RGzS6V3abV1NQKGHjAXkc4Av0aQebRzFTy8iGrkWVySnm/zpmtDt6eQziN8jvzS3UDW3fK51W/uNavZA6dA649VUJ7e6SsGCt6e7VsUlyL+5kbXk8ibXvn+UezCWZPQFwd9Obi1H6dXk4uzsh/BZ9FoqThxM6zeuANm+2gpNL2fKFam837NP/TenAB77T4JeXnBARYprwdXGhOm+N6A5AUO/ue943LRtiz0lJGOkp/PqSBg3rsuC2VSb005+bNarJVqWtnCVquSstuo8ePSqEMkWf1JDR0dKlS/HEE0+gV69emDZtmriZXrFihUnLGYapHVBa+Guvvab7+8MPP6zwSywiIkII7DNnzoiUdKr/VqCoOFM7OHToECIjI8WYarn9/ORona2hTjGn/30LFy6s6V2q1ZgjuIldJ4A0bZeiUT3lG3BbR12X+sMaE6KIKiMxR0wxJ6O808+r0so/alsqMkqib9NBeaz+F0RRrfs+kNDsNrkeuLwIZ2a2hHHP6dOIOzUHlr3FUc2yMjLuHq09bjnANyY0d2j2eBPRe9u3rQ/6rOuFiCn6lHNjUH/tb1fJYxL4S9/UYPtXGnRX+R6YSoCvBqve08DXS/576Rbgvd/Lfw4Ztk17XdLVjj93u+12PmBkereVsxEImqxRT7b98S9wMUoeD+5CP1U7l07mpoRSOudzzz1X6iY5NjYWaWlp6Nixo+6xzp07i5tkU5YzDFM7+Oyzz8T3gZIe3LevysmiAuh7p0+fPvj555+FECf+/vtvXLtmQmiHsXvsIbVc4c4779SNya+AsQ/BXSq13E5umGeOBjzd5fH3a4zXJqqp08lPmIoRiduSRN9jh0orf+Y0ClJkB6vwm8OM9mGn9F9FHD0xBdj4sUbcWCvcSICoB244RY52JadLpTIiprwm4fB5+e8GocC6DzWiFRFjnGemUx21PP5imYTs3PKvU8/6nhi0vz/6b+8rrtmK+HQxbVMfWb91cNUik20ba/DHK7QN+e+Xf5BrxcvqzT7zHQmRWm/CAR2Bt+/na8HWcXHRYEwvfaYQtYtTotxv/WpYy13l1zJnZbrRpXrLFi1aiLY+apSeuurIA42Vxytaboz8/HzxY7DDLi4irdBUlFZD3HKIqQ74eisfcnKmyDZBvZXfeeedSn026bkPPPAAXn31VfH8b775RqSf1zZq2/WmiG66iRo/frxNv28qhejRo4cwBqQMMfpRTzrbI/Z2vZH4Ov/2RVz58qr+JvrD1mhwd/1y34PSUojEwcgekriZtnWC/ID7x0M4NJPo+HK5hNfvKX+/Q0YE48bvUSjOKUbs+rhyXaDt6XqL+SsWcWtl5eMW7Io277Yyug2ldzIxeRCVEUgY3h3Yewp4/09gtfY2l9LGX/9JwkcLyRhNwpNTgHrBwIMfy5Exwt8HWPsBEBZoH9dLTdEkHJgyWHaDTkgFflwj4ZFbTDteFaV2J6YCX2uTZ91cgaenmXftlHW9UbvAN+8FXvlRrvud8ZaE3d9IOgMuhQ/+0NcEh/gDf7xC3yF8PdgD4/rIUW2CJlWGdJHwy0bgkjbKPawrlSmUfy7V3kNVFt2U0kdtWv7880+jy93d5RnT3NxceHp66lr+KM6yFS03xk8//STqwNVMmTLFwKTGnP1nmOqCrzfjkAM5GTES9Dmmz39lo9SjRo3C22+/LSbmvvvuO2HuaGtO1tVFbbjeLl++rMuM6tatm/hfYusZDuPGjROiWymDeOmll+AI2MP1RjfoCd8kIemnZN1jYc+HQhpaXO51cz3eBWeuyVk0XZrmIjM1DplyO2+bZ2o/Z3y7MgKFRRp8uawIU/tGwdujnJtEMojTpsue//oC8rvkwd6vt8LkQlx+Vn9+Q54ORkxWDFCi2UV6lgabDjQQ9vXhgYUI84qCclmE+wBfzAYeHuuK+Wv9sHqvN4qKNcjKBT5bAsxdIaFzszzsPyf/v3FzkfDtY3HwccrTbYMpm5lDXLF4s5wm/sGfhRjVKQquZoUAjfPJMn9k5dYR46kDM1CUk1yp82Hsert9ALDneDDWHfAW0dDxzxbgr9di4e8jC/T9Z93x8g+UTUFRcQkfz4pHYTb9j6r6+2KsT9swDZydGojP+crtBXh4TDTeWEDXqNzp4IExsbh2rfzvxyZNmlT4OiZf5vv27RM3y/fcc4/4m1LFSTTfcccd+P333xEeHi6i0PTPjNr/EDRu0IC+1FDhcmPQa82YMaPKkW76ANHrmDILwTBVga+3srl06ZJu0s7LywsfffSR+F6oLI0aNRKTcH/88QdSU1NFrbfy/VRbqE3X26JFi3Rj8gSh82/rkGkoZXMUFBRgzZo1IiOD/ofZK/ZyvZHgvvDORQPBTRHuhveUfb+hsPqQfnzLEA+7uM4UaFdvHw78uhFIy3LGxmMNda2PjCE1lJD8ZQoyz2Yh51gu/FP8UaezLFps8Xqj80oto4rzilGcr/3Jk8RvSfv35S+uoihVzhmvOyEUHe5rb3TbdIwKtKnlU4e6oEmTRkaP58h+wJUYSlsGFqwDcvOB/EKNTnATP7+owdShtpUlYMvQcR3dS84SiEp0wZ5LjXDnyKptk1qC/fqfPCYB/9ZsXzSsa7ydWGW/3xa9CQx8DDh6EbgW74pnf2qAte8DyRnAk98BShD05Zka3DGudDkDY9tQOcDWo/K5/e6fRojUWl1Q9svkEZb5fJv833/kyJGiBlvdY/f06dO6mXuKMFFtJt0Av/nmmyKN9J9//hH136YsNwaJa3MEdnnQB8iWbxIYx4Kvt9K88sorQnwQc+bM0dVkV4XHHntMfKcQc+fOxb333lul+i17pTZcb4prOXHLLbfYxfsNCQnBhAkThGEoOZj/+++/Ivpt79jy9aYIbhJf6rZgje4ru4Zbzbq9xQatwoz18bVlnpsh4deN8t3/p0uAR2/RwN2t7PfQeHYjnHzqtBhf+y4SnecFwBZIO5qG0y+fRfq5DFwovKwV2MWAiZnbroGuwjytrOt0+Tb9eZ4ypPzz3CwCmPsU8OrdkqhDnvsXRcrlZR8/rMH04fZ1jdgCL95BDuPyyaS0/TvL6JltKl8tLxYRaOKeMUDjcCeLf7/5egMr35Vby1FqPJnwPTsPOHUViEmS1xnaFXjtbvv73mCACf0kbD0qX5OfLNYfkTfvtdz5NPmqpPrr5s2b636CgoJEtKpp06a6dZ599lmcP38eI0aMECY3Q4cOFT+mLmcYxjGhFFvqua0IkWeeecYi26VOCFQ3Sxw5cgR79miLMRmHIioqCvv37xdjqotW/9+xdajsQYEN1aqjhvsCLn1+pVKCm5yotxyRx9T3uoP9XGYGxk+TBsjj6ETg93/KX5/coF0D5BTKmJWxyI2t+RTzyN9vYM/Y/UjZk4qi5CIUpheiONd0wU20e78N3EO0znIlSMuU8I+2JVxEiOkt4eoGavDubCdcX6oRLcFWvqPBU9NM3yfGsI1XX20SwqkrwJrdlT86qRkSPl8mj12cgRfusJ7gbRSmwbI3NeJ1iC+WyeKbCAsE/nxVA2dnFtz2yHgjnr7UvaJPe8udz0rnuU2aNEnUVKoJCwsTKYB0g+Tj4wN/f3+zljMM45g3wjThpkDmZ76+5qV9lcejjz6Ku+66S4y/+uors9zQGfuLctu6a3lJRo8eLSaaKLuLMsSSk5MRGBhY07vlcFRVcBP/HaJ2MfobMHvNmnl+hgYrd8gK9cOFEu4eQ+aTxt+Ls5czGsysL9zdpQIJ13+ORMvnm6MmKMotwunnzyDytyj9/gU6wyPIA07uTnBy1ci/3ZzK/e3frQ7CJ5adDvr3Lv15njyQIpvmnec6PhphWsdUHvpsvXAHMOF5+Tp97w8JE/pV7jP31Qp9i7+ZoyjKbd3P7cDOGnz1BPDQJ/pZIAqML3pdIyZmGPukZQMNWjaQcF5V0k99uS1JpUU3CWZjopk+MPXr1y/zeRUtZxjGsVi/fj22bt0qxs2aNcPs2bMtun0yZHv66aeFqFm2bBk+/fTTKtWKM7aHPbUKK4mrq6vwJvn888+F6R9lfDz00EM1vVs2S86NHBx7+ATyYvPg7O0sRKHux9NZPOZi5LH0Y+m49mNkpQU3sXav/ibannvr9mqrEe67FLWnG8i/dlDrpLLXb3RfA1z5+iqkIll0N3uyKZzdq7d8ICcyB4fvPoq0o/qONg3vbQCvWR5o3LyxRcsZlm6RDFLLmZphbG+gfRPg5BXZMX77MWCQvorVJNKzJHy2RD6fzs7Ai3dWz/l88CYNjl2UME/bE/yt+zQY1JmvJXtnfB/gU+2/EWojRt+llsQ2i7IYhnEIioqKDHwb3n33XYv5NCiQX8SsWbPEuLCwEPPnz7fo9pmahSLDyqQNuYPaY9stJROD4BTz8jnzyjkk70pB1qVspB/PQMreVCRuTkLcmnhEL41B5M83cOWba7j48WWce/MCTr9wFif+d6rKgpsi5UqrMA83uTbTnqFot8L7f0jltlvyjPBE2ATZ+Ck/IR8xK2JQnSRsScTOoXt0gtvJ0wmdvumAth+0hsbVsje9JNI2alPLw4P0Kc5M9UMZBiWvU3Oh+noyUSPuGEH199UnfL98XCN+qNTgeUPPZ8ZOeeAmDXy9gEA/4P0HLX8tsehmGMZq/Pbbbzh58qQYU+01uY1bgwcffFD07iZIdFNEkXEMyPWbJm+UKLc9pvySCakyWUCdQM6dO1fTu2STZJzJQOzfcfIfTqiU4KqM4CaOXpBroAkS3F4e9nedqRnRA+jaUh4fOqevOy2Lxg/oj9nV+dcq7IlsCaRiCRc/vYwDUw6hIFnO9/Zq7Im+G3ohYprcUsrSrFanlg8yP7WcsSzThgKNtZUA5GZ+5Lzp1x15MHyyWF6fEiGqK8qt4OqiwWOTqdSAjdMcKcU8eoUGlxZq0LGZ5a8n++1dwjCMTUMtBcmxXOHDDz+0mmCiFh/kM7F8+XLExsaK39OnT7fKazHViz2nlpeMdpNrvxLtpqwPxhASYAqt32iFpg83RnFBMYqyi1CUVYRC+k0/OdrfWdrf2sf82vsiaEBQpQ6rEuW299RyBfqupejb1NckXRRxRI+y35d/D2oX5ieizeknMpCyJwWBfa3nPVCQViDKCOI3aPvyAAgdFSIi3K7+srGbNVi6VZVaPtj+z7O94+KiwTPTgUc+k8/LB39KojbaFL5dBSSlyePpw2TBxDBVxcfLetcRR7oZhrEKZGp248YNMR47diwGDy6nqNACUPswha+//tqqr8VUD9nZ2di4caMYh4aGok+fPnZ76KmuW8nGoAwQJXrPyGSez0TMX7Fi7BbshoZ3yd4vTq5OcK3jCo96HvBp7o06Hf0Q2CsAIUOCETa+LiKm1kPDuxugyUONKy24iTV71PXcjnFWbhkItNBa6Gw+DOw/LZUr0hs/qO9VfWX+NavtV/rpDOwavlcvuDVAixeao9vvXawquCm1fMN+vdN0vw5WeynGDO4ZC4RqO9Ut3QpcvFFxtDs7V8JHC+X1aC7/pWqOcjNMZWDRzTCMVepw33vvPd3N3Pvvv2/1ozxw4EC0by8X6O3evRuHDx+2+msy1oUEN2VMEDfddJNOtNojdevWxZgxY8SYJqO2bNlS07tkU1z67IquJVSThxvBxbv6EvESUiXsPyOPydiJ2gI5AuRY/uztptfMht8UBve6cputuHXxyL4uf/YsSfTyGOwZtQ/Zl+Wmyq7+LuixuCtaPN0MGiunelM2Q16+fkKCWzvZBp7uGjwxRT73xcXUt7ti0T3/b/rcyuOpQ4A2jR3jM8s4Niy6GYaxOJQ6m5qaqkur7dDB+iEFEvcc7XYsHCW13Jih2s8//1yj+2JLZF3OEmKMoJ7Rje41vya7KqzfS0ZqjhXlVrhzJFAvWB6Ti/mZq2ULGmq5RY7hgmLg2o/XLbYfxfnFOP3CGRydfVyUAxB+HX3Rb3MfhAwLQXXAruW2y0M3QRhYET9vIH+Fsq/TnDwJH/6pX/7yTBbcjH3AopthGIty7do1kVquOIu/+eab1ZrCW6dOHTH+888/kZiodUZi7I6CggJhokZQX/ehQ4fC3pkwYQICAuQ8yhUrViA9Xd8eqTZDvbWpXRXR5MFGcPGtXrsZdWr5+L6OdQPv7qbBU1P174n6dpcHpfU7ucnrR/56A4WZhVXeh/yUfOybdABXv9OL+Pq3R6DPul7waqRVWlaGTLfW75PHdQOBAfbXBMGh8ffV4OFJ8piM7j5fWvZ1+v1qIDZZb4bXvqljfWYZx4VFN8MwFoXM0xT38Mcff1yYnFUX3t7euPfee8U4Ly8PP/74Y7W9NmNZtm/fjpSUFDEeN24c3N3ltFd7ht7DbbfdJsaUNk995Ws7lMIctThajF38XNBodvVGuQsKJWzU1vkG+AK928LhmD1Rfm/E7/8A1+PKFjTuIe4InxwuxoXphbpzU1mKC4tx5N5jSNknZz6RoG//aVt0+LKd6LFeXazZA+RyarlNQynm7tqOot+upFZgpa/T3DxJmK0pvHIXC27GfmDRzTCMxTh27Bh+//13MQ4MDMTzzz9f7Uf34Ycf1rmkf/PNN6J3N2N/OFpquQL37Dbk0heXIRXKN9Fk5OXqZz0jLWPsOkEGW/J4dC/ZTdnR8PXS4NFb5HFhEfCpts1SWTR5QG+oRtFpau1VWc6+cg5J25N1Bnm91/REw7saVHvrv2Uq1/JbBzneOXYEwoI0uEe2vUBmDvCN/l+AjgXr9K39Jg0AOjXnc8nYDyy6GYaxGNQWTOnv+tJLL8Hf37/aj27z5s11hlXXr1/XpSgz9kNxcTFWrlwpxm5ubhg9ejQchZ49e6JVq1a6aP6VK1dQW8mJysGNP6LE2MXH2UDsVRdrdqtSyx2gVVhZ/G+yBp7aZJHv1wCJqWULab8OfgjsJ5dBZF3MQuKWypXpRP5xQ5dSTj3Xu/7aGf7dqv9/QlaOhHV75XGIPzCwU7XvAmMiT99GPa/lMaWYk0u5Ql6+hPd+V0W5uZabsTNYdDMMYxHIOI3qVJUoN0Wcawq1oZpSX87YDwcPHkRUlCzGhg8fDj8/PzgKFOFTR7t//fVX1FYuf3EFUoF8E91oViOrtouqqD833ehTpNtRCfbXYNZ4eZydC3y1ovzodePZqmj3fPMN1VIOpOLU06d1f7f/qK1o9VYT0DnOydO7ljtiNoOj0CxCg2la+47ENGDBWv2yXzYAN7Rd5sb3Bbq24vPI2BcsuhmGsQiLFy9Gbm6uztCMTNRqipEjR6JFixZivHnzZpw+rb/5Y2wfR00tV7jzzjt16bW//PKLiOzXNnJjchH5uzyx4uztjCYPVX+U+3K0hLNaPdmnHRDo59g38XNu08BFW0b91XIgI7ts4V13TCg8G3qKccJ/iaKPuqnkROXi0MwjKM7XTqjc3xAN7tQ2DK8BlqpSy6cMcexz7Ag8p2pz99EiSfgu0M+7HOVm7BwW3QzDWISffvpJN7777rtr9Kg6OTnhkUce0f399ddf1+j+MJUT3XQeJ06c6HCHr379+iKCT1B6+c6dO1HbuPz1VRTnyZMNje5tALcgrYNSDUS5HT21XKFhXQ1mjJDHKRmyC3RZaJw1QiwrqJ3Hy6MopwiHZx5BfrzsWhbUPxBt3pbLKWoCdWp5cB1gEKeW2zxUpz22tzy+Hgcs+g/4bSNwLVZ+jDJSerZ1/M8r43iw6GYYpsqcOXMG+/bJ/Vg6duyILl261PhRJeFPbuZKCm9aWlpN7xJj4rV07tw5Me7Xrx9CQ0Md8rjVZkO1vPg8XP85UoydPJ3Q5OHGNbIf6npuR+vPbUoU8ZPFkqiTLYsGd0SILASCXMwLUgvK3Tb5eZx44hTSjsqt8ChS3mVBJzi51tytJrUJo3R64mZOLbcbnp+hv07f/0PCO7/pr9NX2bGcsVNYdDOloDY9L774IrezYSoV5b7nnnuq3ZnWGNSve+bMmWKclZWFn3/+uaZ3iTEBR08tV7836j9OLF26FNnZ2agtXPnmKopz5Sg3OVm7h1Z/Ozjq27z1qDxuEEq9flEraNNYI1yfCXKBphZiZeFaxxX1b6snxkXZRYj8/Ua5274y9yqil8WIMYn1bn90qZEMBjVLt6hSywfX/P8lxjQGdNKgXwd5fPoqlYLI4xHdgT7t+Twy9gmLbsaoCdV7772HKVOmYPbs2aLfMcOUBbXk+u2338TYxcVF1HPbCuoU87lz59bK2ll7o7aIbi8vL/EdS2RkZBi8b0cmPykf1xZoo9zuTmj6aONS0dJ/D0g4drHybapM4ce1QH6B3pTJFiYKayKKSD2Pi4rKPtZkcKdw7Yfrou+2MRL+S8DZN87r/u40twP82mqbg9cQ5HxN/bmJoDrA4JpPwGIqeZ0qvHp37fmcMo4Hi27GAHIMJkMshe+//x5DhgxBdLR2mpFhSrBx40bExsrFVhMmTEBISIjNHKN27dph6FDZCvXChQv4559ywjpMjRMZGSmcy4nOnTujceOaSTuuLmpjivmVb6+hKKtIjMlcyyPc0HCR6oxHzpHQ+V4JD39aXK7ZV2VIz5Iw851iPPGVfrsT+tauG/lebTUYohWgF24AK7aXva5PC2+EDA8W45zIXMStiy+1TubFLBy5/zig1ePNn22GsAl1q7yfGdlyX/HKskGVWj6pP+DKruV2BdV1t2+i/5uu2f4da9dnlXEsWHQzBnz77bcicqlmz5496N69u/jNMBWlltsajz76qG7Mhmq2jdKb29Gj3Ar9+/dH06ZyXvOmTZtw40b56bv2Tn5KPq59f03Xt7np/wwnVai++M1f9GL425VAh7vlyLcl2HVCQqd7JGHKpHDPWMduFVYWL9xhWDNLGQZl0VjVP72koVpBegEOzTiCwnT5vqHuuFC0eKZZlffvr+0SGtwK9HmiPjbJ83Bmw67l9o2TkwZv3S9fp64u0I0Zxl5h0c3ooHZP8+fP16UJr169Gg0byu6lMTExGDRoEH744Qc+YoyOxMRE/P3332Jct25djB492uaODkXflet43bp1uHTpUk3vElPLU8sVyJ1d8R0g0fP777/DkaF+z4WZcuiy/owIeEbILakUft0IRGn78CqQYzFFvmd9WIy0zMqJb2o39MoPxRj4mISrWgdkP2/g95c1WPC8U61KLVcY3h3o2lIeHz4PbD5c9rrBQ4Lg01I2pUzZk4K047JRmlQk4egDJ5B1MUv87dPGR6SVa5yqdjw3H5Jw2xuSiHQnpTtj7LOUAWHeuc/Jk7B6tzwO8AWGdq3SLjE1xKQBGuybp8HB76nGu/Z9ThnHgkU3o2PhwoVCRBFUazh+/HiR6jl48GDxWEFBAWbNmoWHHnoI+flyOxCmdvPnn3+K64K444474OrqCluDJpDomlWEzTfffFPTu2RXZGZm4sknn8QLL7yAU6dOWe11kpKSsH27nOfarFkztG/fHrUBRXQTZPZXXsTRnqGI6NX52ii3iwbNHjd0LisslETEVWHRaxoDofTDGqD9XRLW7zXv+Fy8IaH/IxLe/hVQLB36dwSOLdBgxsjaexNPEw1qJ/MvlkrlrttotirarT2P5965gIR/5FkS1wBXdP+9C1x8Xaq0XwfPSrjpRUlXb08UFQOzP5LwzDfF5dafl0wtz8qRx2Qcx6nl9gu1B+vYrPZ+VhnHgUU3I6AbvS+++EJ3NP73v/+J31SfS3Wwjz/+uG7ZvHnzRJ2sUsfL1F5sPbVc4f7774e7u+yQ/OOPPwo3c8Y0nn32WXz++ed4//33hRDu2bOnmLigLgeWICEhQXhHTJo0CUVFRbood22JPjZp0gQDBw4UY2qVtn//ftgqeXF5KNJGqs3l2nfXdSnIEdPqwauhYZR78WZDh+JpwzTY9JkG8+Zo4KNd9UYCMPZZCfe8V4yUDKnC/2k/rpHQ+T4J+8/Ij7k4A2/fr8HWLzRoHF47rq/yoBZa9bUWHGQ4dimq7GMaMTUcLnVkQR2zIgZX5l/D5S+u6Hp6U2swr8ZeVdqfs9ckjHlGQqZWLE/oB9w7So6qEx8vAia/Ione22allrNrOcMwNgCLbkawY8cOHDt2TIzpprp37966I0PRS7rpJqMfRbjs2rVL1Hnb8g0iY12OHj0qfogePXoI0zJbJTg4GNOnTxdj6tetuK0z5UNtrP744w+Dxw4cOCBc4cPCwjBt2jRs2LBBJ5ZNJT4+XkzeDR8+HOHh4aJLws6dO3XLJ0+eXKtOja0bqpFjNUU1t3TcjvPDL+HI3ccQuzYOxfmmdQMozCjElXnaKLezBs2eNIxyFxdLePd3vUh6aaYsiGni5YGbNDj1qwYje+jX/3k90G6mhNW7jIuvpDQJt74i4f4PSaDJj7WoD+z+RiO27ezMgpug6O8jN8vHghIsvl5Rtph18XZBw5n15fOVL+HMi2d1y9q83QrBA4NQFSLjJFFGkJgm/z2wE7DwVeDl21Mw90nAWW4XjlU7IcoEohLK3tdcSi3fJY/9fYBh3aq0awzDMBaBRTcjUEe51VHtkmmQdGNcv359ndP5gAEDDKKdTO1B3ffalqPc6lZ4Cl9++aXDpvFakuXLlyM9XY400URcly76njtUYrJkyRKMGTNG1MxT+jlFasuCMmMoQk7dEEhoU8r/f//9ZyDYya38448/Npj0qw3ceuut8PSUw7mLFi2yqTaNubF52H/LQVz69LLsTl0IxK2Nx+GZR7G5/Vacev4M0o6mlft5urbgOgpS5HzhepPD4d3EMCK6cofci5eg3rwkuNQ0rKvBho81+PE5jajFJmKSgIkvSLjjrWIhshU2HZTQ8R7JwJF71gTg8A8a9GjDYrskdGw8tK20F6wjx/By2ofd17DUXSPV5jeaJXtmVJbEVFlwR2qN0Tu3AP5+TwNPbfv2B28C1n2gP/dUg97zAQlHzhvf1437oYuWU2q5myufd4Zhah4W3QyuXr2qcw2mm2G6ASwLim5TnTeJbeXG+9577xUO0UptL+P40HlXIqCU/XDbbbfB1unatatwiybOnDkj3KKZ8qFUfAUSw4cPHxbZDU888YTIHlCgloKUft66dWv07dtXpIuTWKfHv/rqK2HCWK9ePREh37p1q0G/dHLvfu6558T3yuXLlzFnzpxad1r8/Pxwyy23iDGl7ZOJpS2QuD0JOwfvRvKuFF2U2jnIWdVzuwDXvr+OXcP2Ykf/3bj05RXkxmh7NGkpzCrElblaRa0Bmj1lGOUmsf7Ob6oo950ao6UF9Ni94zQ49YtGtBJS+ONfoN1dEpZsljDn62KMeEpCdKK+N/OKtzX47hkn+Hix8DJGUB0N7hgpj9Oz5CyCsvBs4Imw8fpWYP49/NHuo7ZVKgUhkU8lA2e1pujNI4ANH2lQx8dwmyN7arDnWw0ah8l/0znu/6iEv3dK5aaW38qp5QzD2AgsuhkRfVJugin65OamnfYuA3KppgiVuhXT3LlzMWzYMMTFxfERrQWsWbNGZ7pH9bcBAQGwB9RZHOrsDqY0Fy9exLZt28S4VatWQkwTnTp1wmeffSYyXchtfOLEiXBWcj+1LQYpXTw0NFRkxZA/BBmkqSOhzZs3F5FxEvH0OiTYu3XrVmvquI1x991320yKOblSX/jooohw5yfIppke4e7ouao7Wqxtim6LuiD8ljA4eehvITLPZuLcG+exueM27J9yENHLY1CUXYTrP98Q4pyg51Df55JRSYpcEuSmXVH7rvqhGqz5QINfXtSI1GEiLhmY9rqET5fo16N09OM/aXDzwNp7TZnK/ybrj9FXyyWR7l8WLV9qAa8mnvDvVgfdfukMZ/fK30ZSi7hbXpZwQJupXi8Y+PdTDeoGGj9nbRtrsG++Bn20lUzUg3vSSxI+XaxveUap5X9rU8vr+Mj+AAzDMLaARnLwHEsSk9euXUOjRo1EexbGEDKUohvj1NRUIbYjIyPFzbKpUGr5gw8+qHMzp6jVkSNHROSmNlJbrjdqw0XCm9i4cSNGjtSGSmwc6kFP1yhd58T58+fRokUL2CvWvN5eeuklvPvuu2L84Ycf4plnnilzXZpso8wH+j44efKk0XVIuFNXBMqk6dixY60W2MagNHtKr6de3TSJQdcoZR5VN3kJeaINVNK2JN1jwUOD0OnbjnANdDG43siRPHZVHG4sikLK3tRS21KcrKmmmxiwqx98W/sYRLkHPCph1wn57+VvaXDLINOvi+hECQ99ohdZhLsb8P5sDf53q9znlzGNYU8U69qGrf1Ag7F9rHvsyIWc2oIt26pv67X9Kw3aN9VU+P1GwvreDyQsVCUrPTAR+OoJjXAtp7IDYuYo4JeXHPf/MGNZasv9G1Nz8FVVyyFDKRLcBBlNmSO4lVpeimJR6ihB6aGvv/66VfaVsQ2oNnf9ejkHkSZsKMPBXqD2YZTirPD111/X6P7Y8uSEUrNPAvDOO++sMPvlqaeewvHjx0WaOB1jqvMmt/NXX31VPE4p/W+99ZaIlLPgLg0dZ6V9GAnwjz76CNVN8u5k7By0Ry+4neTIZo/F3eAeXDoDytXPFQ3urI8+a3th0MEBaP5MM3iqXMlJbCuCO2xiXQPBTWw/Bp3gbttYrr81h3rBGqx8V4M/XtGgaT25HvzAfA2emKphwV2FaPcXy6wbi6HJloc/1QtuLw9Z6KsFd3l4uMvn/DV9cgjm/w2Me1bCgnUq1/IhPOnCMIztwJHuWgz94yPHaboZJijVU22UZA6XLl0SN9i5ubni5pGi3R06dEBtozbMlJIYoDZSxIsvvoh33nkH9kRycrKYLMjJyYGvr6+ILNprZoa1rrd169Zh3LhxYnzTTTfpPB8Y609oUSYGXZseHh5iErM6ot1SsYRLX1zB+XcvyGZpFDGu64bO33VCUP9As6432lbynhRELY5G7KpYFGYWwcnTCX3/6Q2/tr4G6458qhj/HpTHv71MtcUskmoKijy3uF3ClRj579O/atCmsXXOx0vfF+Pd3/Rt3Fa/r8HoXqVfy5Tr7Y9/5Ki3uq83QaZr8as0cHfja4oxjdpw/8bULHxV1WLISEoR3GSMVlnBTTRr1kwIMCVK8/DDD7M7tINO1Khdy9V1qPZCYGCgLnKbkZFh8H6Y0gZq9913Hx+WaoLasJGvBkETmFTrbm3yk/NxcPphnH9bL7iDBgSi/9a+BoLbVDROGgT1C0THL9tj2Jkh6L64K/pt6lNKcO8/LekEN0WpbxtqkbfDVBJqo/aYura7nPZhVYHqrxXBTRUmv75kXHCbyoyRGmz+XIPgOoaPT+xHpQYsuBmGsR1YdNdi1EZSZHZUVajmkwySCGotxr2QHQ/q0Xz69GkxJidwe62HVrcPI3dttZt2bSchIQF///23TgRSSzCm+qAsEqV92Pz584VhnbVI2Z8i0skTNmntvjVA82eboefy7nAPdUd8ioSN+yV88IeE6W8Uo9M9wGNzg5GRbdr2nb2cETo8pFRaOaF2LH9+hgYuLiyQapp7xwLe2uqAXzYAKRmWFd6/rJcwZ65+m18/ocH04VU/7/06yAZrrVWdy6YP4+uJYRjbgkV3LeXChQtYu3atGFPt5aRJk6q8TUqHVNfIkghX6sUZx0Ddk90eenOXBZVCKLXo5J5N6dSMDE2WUU03cdddd4k6eKb6oPp4xXeA+nVbI9pNGSuX517F3gkHkBstt/hyDnBFzsvd8EtgU4x/QUK9m4tR9yYJo5+W8Px8CYv+A05eAdbu98bEF8g5uvKC7MQlvflZRIhseMXUPNSm6+7RemfwBfItgkVYvUvCfR/qr5k37tXg4ZstJ4yb1pNbir14J/D5YxqMUbWVYxiGsQVYdNdS1OKYbvAsdWM9atQoTJ48WYzj4+Px8ssvW2S7TM1DdaYLFy4UYy8vL+FEbc+o24d9+eWXNbovtgKJMXVquT1PrNgzNGFJnzHiu+++E74DloJqrrfdehRnXz0HqVAWQad9/HF7SG/cuiJQpP6u2wvE6M3LS0EGaJNelISLdGV493f98565jetubQl1ivnXKyRR611V9p6SMPU12pbyGsArd8Hi+Ptq8M4sJzw+xXivd4ZhmJqERXctJD09XRexpDTG+++/36Lbpx6+3t5yL9Zvv/1WGLQx9g+ZaaWlpYkxCW4yIbNnxo4dK0yriH///VeXNl+b2b9/v0H5ALX5Yqof6iLx6KOPijG1Y3zvvfcstm2qud6fKQt6YnFwYzzXsBuSXT0M1qMWTkO7Ak9NletuT/yswa65gI+nXIpB9dgkpPILzBNl5yMlLN4sj0P8gVkTLPGuGEvRqqEGY7S90q/GwqAdW2WITZIw+RUJuXJXUdw+XI5EsyhmGKa2waK7FkLGUWQgRZChFBlLWZIGDRqINkEE1cqSqRrXzNo/jpJarkAu++rabo52s4GarUW7fXzkWugffvhB11veEjjd2Ry7fEPxWsPO+LVuCzQIdxLtul6/R4NV72pwbakGSWs0+O9zJ3zyqBPuHCW3c+rdDvhpTjy8tfp89W7gjrclFGoj5qbw/h8SJO3qT03VwMuDI5K2xv9u1Z+TL5dXPtJdUChh2usSorWWAYM6Az+9wO3cGIapnXDLsFoGiV+KXlEdK3Hy5EnRNszSUHSmc+fOOnd0SpGcNWsWHB1HbTlBN/z0nij9uEmTJuL6cYT3R5F7ah+WmZkpsj7ItCogIAC18XrLysoS7aloQo7EXkxMjE70MTUDdYRQotwPPvigyByyBCcvy87hXVoAnZpTVFtj1vV2ObkRxj8HXfTyzlHAzyaIqWuxEppPl1BYBPj7QIh7P28W3bZGcbGEtjMlnLsu/33sJw06NjP/PD31dTE+W6Kv3T/0vQZ1A03fjqP+P2VsE77eGGvD32K1DDKMUgQ3GUlZQ3ATbm5u+Oabb3R/P//880hM1E53M3bHr7/+qmsBR23CHOUGqE6dOrq2Z1SzThHF2sqyZct0GTC33XYbC24bYM6cOboyDqq1JwFiCShq/eRUDQZ30ZgsuNUM6QL89Y4GrlorkN82Ag9+QhHs8qOiHy2UBbdS18uC2zahyZP/qWq7v1hqfrR78X+STnDTdbLsTfMEN8MwjKPhGHfOjMmoU2jVRlLWYPDgwbj99tvFODk5GS+88IJVX4+xfm9uqsMjR2tHQp1iTgaDinN3bUNtoHbvvffW6L4wMkFBQbp2jgUFBXjnnXds5tBQb+Ulb2jg7Cz//f1q4IkvyxbeMYkSftC6YVNbqsdVKcyM7UGO8nW0iS5/bAISU00X3qeuGDqVf/E/Kk3g880wTO2GRXctggySyDCKaNasGcaNG2f11/z444/h5+cnxhRF3Lt3r9Vfk7Es1HNdyY4YOnSoSPVzJFq2bClM1Yjr16/relTXJs6fP48dO3aIcZs2bdC7N/fbsRWeeuop3Xco+SpcuXIFtsKkARr88TKllct/f7kceGG+ceH96RIJedp09IduAoLqsAizZXy8NLhP/loU5+271aY9Ly1Tws0vScjK0Yv3B2+y3n4yDMPYCyy6axFfffWVbkzOuNWRIkw1om+++abubzJVK1L6hjB2gaMZqBlDiSYSX3zxBWrzOb7vvvvYWdiGIKNLJSuJsjBsKdpNTBumwYLn9AL6gz+Bt34xXCcpTcK3q+Sxu5tsoMbYPo/eQi7j8viblZIwRquoFvyudyVc0Ha469wCmPc0O5UzDMMQLLprCSkpKaIulyBzpOoUT9QHvGPHjmJ85MgRi5kBMdaHDMaWLJEL8yjadvPNNzvkYR85ciRat24txtu3b8fRo0dRWyAh98svskpycXERHQ0Y2+LJJ58U/gMElXpcvnwZtsRdYzT4do5eSL+2QBL122oHbCXySdHT8GAW3fZAk3oaTOwnj6MSgBXbyl///T+AVTv1LedWvKWBpzufa4ZhGIJFdy2BUruzs7PFmAS3cgNXHdCNvNpU7eWXX0ZcXFy1vT5TeZYvXy5crRVzLS8vfX9fR4Jq1dXR7trUPmzDhg3CqZyYMGGC6BHN2BbkqP/EE0+IMWUKvf3227A1HrxJg08f1QusZ7+V8PVyCelZEr5cJj/m4gw8ezuLMHtCXXv/xbKyI93/7Jfw8g/ycoqO//mqRoh2hmEYRoZFdy2JZJFBlDq1vLrp16+fziWa2jRRD1rGvtKOlfPnqFCEV5mM+vPPP5GQkIDaABuo2Qckuv39/cWYspYUnwVbghzR375fL7Qe+0LCpBclpGbKf98xEmgUxkLMnhjcBejQVB7vOQUcOFNaeF+NkTD9TX3/9Tfu1QijPYZhGEYPi+5aABlDkUEUQYZRZBxVE3zwwQe6m8bffvtNpPEytguVAmzbJucTUm93RzfXorKL+++/X4zz8vJEb3lHhzJO1qxZo/NfGD16dE3vElMG9N1Jpmq2HO0mXpqpwUuqCoUtR6CLfr5wBwsxu8wCUkW7qVRATW6ehMmvSEhOl/8e3xcG559hGIaRYdFdC1AbQ1m7TVh5UNrqu+++a1DrTW1wGPO4ceMGpk2bJtK933//fZEeXNV0/eLiYpw8eVLU28+YMUM4lHft2lW3nEoS6ObL0VEbDFJJhKNfnzT5pbRIo0wGKgVhbBf6/qZUc+XcXbhwAbbIW/dTH3DDx6YOAVo2cPzvEEdkxghym5fHizfL7d8Icql/5DMJh8/Ly5pFAL+9RG72fJ4ZhmFKwqLbwSFDKCWiTEZRI0aMqNH9mT17Nrp37y7GJPLUjuqMaZAAJnOzxYsXi97nY8aMQVhYmIhUUibDiy++KJbTDTmJaWNQJHf37t0i+4DqeIODg9GhQwfhLk+p1UpmBOHt7Y2ZM2fWitPTuHFjTJw4UYyjo6OxbJm2GNUGiYyMxCeffIKNGzeW2Ru5POg56tRyR3WmdyTIzHDOnDliTJ/tt956C7YITdB98ogGD03SO5a/PJOFmL1CZmizJ8jjgkJg3t+Srjf7gnXKOsCKtzXw9+XzzDAMYwyNVJm7NTuCbkyuXbsmInfV0SLL1qDoleJMTJG7hx56qKZ3CQcOHECvXr3ETT+l9J49exYRERFwBKx9vf33338YPny4yevT8e3UqRM6d+4sRDWJaeq7vX//fuTm5pb5PDJMo3TyAQMGYOrUqWjbti1qC1u3bsWQIUPEmI7Bnj17YCvQZ4ZS/mmyauXKlbpJFZp4+f777836HNH76tu3rxgPHDhQV0rA2Dbp6elo0qQJkpOTxXfM6dOnRfmHLX6/0fW6+TAQ6g90aMZizJ6JjJPQ5DYJ1PEzNABY9qYGw5+SkK9NBvrjFQ1uH2HZc1zb79+Y6oWvN8basOh2YEhgNWvWTKSPUkoi/U0izBZ48MEHMX/+fDGmVOlFixbBEbDmlzbdwNJkBU1aEB9++KGIcFM2A/1QDTa1hqsMFOkmgd2/f3/x06VLF7i6uqI2QseZJimOHz8u/t63bx969uxZo/tEDvK///67MESkDJGyoqCffvop7r33XpNKAah+XYl0Uxuqu+66y+L7zViH9957T2S0ELfffjv++OOPajnUfFNau5n2WjGWbNFnL+Tly+P/TQa+eNzyopivN6Y64euNsTYsuh28/k9pffTqq6/ijTfegK1AURqKziQmJoq/KcpG0TZ7x5pf2itWrMDkyZPFmKLWJLTVr0FikVKOFRGuCPGrV6+W2lbTpk11Ipt+k7lebajZNhUSo4qpWnWKmpJQP+a5c+diwYIFSE1NNVhGEy5U10/7pnZap57jFPVu2LBhuf3XqRyBfvv6+oqWYVRGwNgHGRkZItqdlJQkPrenTp1CmzZtrP66fFNau9l9QkK/RwyTI/t3BDZ/roGri+X/f/D1xlQnfL0xVkdycIqKiqTLly+L37WJ+Ph4ydPTk/47Sl5eXlJCQoJka3z//fdi/+inR48eDnGOrHW9FRQUSG3atNEdr9WrV5v83JSUFGnr1q3S3LlzpcWLF0tRUVEW3TdHJDs7WwoKChLH2sXFpVqPGV07GzZskMaNGydpNBrdOVd++vbtKy1cuFDKy8sT6x4+fFi68847Ddbx9fWV5s2bJxUXFxt9jQULFujWnT17drW9N8ZyfPDBB7pzeNttt1XLoa2t/08ZGfo+6T6rSMIA+SfspiIpOsH4d4wl4OuNqU74emOsDRfJOChU85mTkyPGs2bNEunDtgYZN1HElqCUaUdJMbcG5FR85swZXc/zcePGmdVqaNCgQcIkjeqz69WrZ8U9dQw8PT3xwAMPiDGVZ8ybN69aanUpM4UiltS6a+3atTqDNHd3d/F5OXToEHbt2iUi3G5ubrrzS+nh1PpLqemmSCiVcFD9/5UrV0q9Fvfmtn+o+0NISIgYk6kiRbsZxppQVsWrd2lE+zcyTlv6pgbhwZwhxTAMY5X08kuXLuHEiRNCxJHJUMkWM+T4SzWQlLJIqaseHh5mLbc0tTFdhG64KbWU0lHp/FCKaoMGDWCL/PPPPxg1apQY0z6TqRoJHnvFGtcbGZ5R+jeljhPkRk8p4Yz1W7ORmzn1RCZxQ+fVWtcmOcnTRErJFHL63NJkCaW6G5s4K3m9paWlCXdrtaimtHFyqScTRVrn3LlzopMB0a5dO/F9zqUF9snHH3+MZ555RoxpQo3EtzWpjf9PmdKcuSrh/+3dCbzN1f7/8WWqTBEZQ0nqJk1XSKUM11SGjkhKEaVRqEyZTuSqCFcpQ6VO11AuV2W66lEkkQaJJCIlSTIlM+3/471+//V9fDfnOPucs7/nnL336/l4nIfvHp2z99prfz9rfdZnFS5oTKUywQbctDdkJ9obgpahb01tT6O1wSrko5kfbSOkAj/O559/bmdgVBk5JSXFFvTxV0hO73ZEx8SJE72T9w4dOuTagNutP9WsnqjQm39PcfwffdZcwK0twQi4s0eFChVMmzZt7LHWTGtP9CCoD1Rf6g+4VT1da/g1YNa3b9+IM1WKFStmXn75ZbuNmFvTrT5a+483aNDAfP/993Z9uBNp0TXkThpIKV26tD2eMWNGmkX2gGi6+Lw8gQfcABB3MpKLvnLlSu/42LFjoaSkpLC1pXfccUdo8uTJ3hrUdu3a2bWHkd4ehERbo3Ho0KFQ+fLl7To/rQddu3ZtKLdbvXp1KG/evN5aVK1Hj1XRbm9//PFH6Oyzz/bWbvo/gwiePj9a063X/vTTTw9t2LAh6v9HcnKy9/7WqlUrtGbNmqi0t71794buv//+sLXeqvNQrFgxe1ygQIGY/qzh/zz33HPe+zts2LBAX5ZE+z5FzqK9gfaGeJKhmW5to+Pky5fP7uXrKK1RqcFuD2GlNWtmZfny5RHdjuhQBoFS+OXmm2/Oloq2WVW9enXTpUsXLzU+OTk5p3+lXENbQLkK7+3btw/7DCJ4+vw8+uij9vjw4cOmW7du3jrraNByHW3/5PpEzUIr5TsatIXYSy+9ZPd2V5q8qM6D+mJp2bKltyYYsUtr95VBpiUKbhsxAACQu4QvyI6AUsQVPLt13Y0aNbLXuy1rypQp491XaW+LFi2K6PbUHDlyxP6E/cL583sFhCJdo+H/N55p7an2bnZ69+4dM3+3Au1p06bZLYy0f7fWscbCgEGQ7U2fGa3ZdO1er1GsvJ/xpH///mbq1Kl2jfeCBQvMzJkzTevWrbP8vAreFcQrmHdb/KnNZ+Q9jqS91atXz6xatcoGZNp+zOnUqRPtKQ6oLorb0i7o/iGRvk+R82hvoL0hVkRS5yTDQbdmSbZu3Wr3WS5QoIANklRZ13WO/vWBmg0/sdNM6/bUTJ482e4369e2bVtbMCaj3JrYeKZqx1qzKXXq1LEDHCp6Eyu6du1qZ3Y1ePDII4/YtamxKhrt7amnnrKfL1Gb1+ctlt7PeNKvXz9bLVrUNhUc+zN9MuO9994z8+fPt8f6rHbs2DHT728k7U0F1lQP4IUXXrCF+apVq0Z7QmDtDYgW2huyE+0NmVG5cuXoVy/3U9XUsmXL2pO5nTt32irU8+bN8wq7KGjWzLhmV9K7PciZbn2AVEwsnqut6m2sWbOmWblypb2sQkoulT9WHDhwwFZV1qCOC0q0BCGWRKu9qajcRRddZNu/KmavX7+erb5y+POlInaqtu+ySFxaeGbbupZVuCBbWR6ZGUxMlP4NuQPtDbQ3xCv6N+SamW6lQGofWf8aQKW1uZnqkiVL2mq52s5IFX91krpkyRK7LVgkt6dGwXVGAuz0Xox4PilVkO0C7ho1ati0/1irSlykSBEzbNgwm/bqAhsNysTi+5bV9jZkyBBvwEkzq6qkjZylGWIFynpflJGhdprZJRAK2F3ArcGxdu3aZenzGu/9G3IX2htob4hX9G8ISsRBt4LrHj16mMsuu8ymQn777bd2v23/frBahzt06FCzbds2e0K5fft2c8stt0R8OzLPv52RUmFjLeB27rzzTrttmAYQ9PPGG2/YtNtEos/W66+/bo+LFy9u+vTpk9O/EowxVatWte+F+rBjx47ZdHMVKcvoZ037ZI8YMcIea8mAgvlY/bwCAAAgfRFPjSjFVWtslfKqfV+Vyjx79mxTpUoV7z6asRk7dqwdJbr00kttwKR9YyO9HZmjCvCuIJ3WaqpqeaxS29B+8P4iVkrFTSQDBgzwMkg023/WWWfl9K8E34CWW7fz4YcfmunTp2fotVGGj/bMPnr0qLdER30qAAAA4leW1nTHAgUvmlU/99xz4zb9UkH222+/bY+VedC5c2cT67Sd0bvvvmuPNbOoQDQR2ttnn31matWqZY9VL0GF8QoXLhzAb4rMmjNnjmnRooU9LleunN3NQdtzReKtt96yqeSiNrJ27dosFWRLhP4NuQftDbQ3xCv6NwSNs7QY980333gB9znnnGM6dOhg4oG2PlN1e5c6/+uvv5pEmUl1Bg0aRMCdCzVv3twOComWygwePDiix2kP+p49e3qXtYwiqxXQAQAAkPsRdMc4/77cqiIfrcJzOU1VzO+77z57rOUMCkDj3fvvv2/XCMv5559vunTpktO/EtIwZswYW0hSnn/+efP111+n+1o9+eST5pdffrHHN910kxe4AwAAIL4RdMcwpZVOnTrVHpcoUcLce++9Jp4kJyd7abtKm1+zZo3JzWlJSg1XzQKlH2tWMyO0ysM/y62U+ngZQIlHWtetegOifeVVJNKtw0+N2q4CdVGwrnZC8TQAAIDEQNAdw0aOHGmrKEu3bt3sllvxRNvTPfHEE/ZYAY2KTuUmO3bsMP/+979tSr8q+mstttKHtcWXLmut/ZQpU+xWe+mZNWuW3R5NtEPAbbfdlg1/AbJC7VEVzWXp0qUmJSUlzQEVVTpXcC4aXFEmAwAAABIDhdRi1G+//WaLJx06dMiuC/3pp5/sXujxRn+fqjvr73P7kTdu3DhHfhcFTStWrDDz5883CxYssEFyJHUINWPdpEkT07ZtW1uAS9uA+WngRNX8VZBLNFOu9GPkfgsXLrTvrRsk0nZgJ1ab1y4Nd911lz3Wbg+a9Xap6VlF4RdkJ9obaG+IV/RvCBoz3TFK6akKSKVr165xGXCLgpPhw4d7lx9//HFvxjA7qIDba6+9ZmeeFVRdc801NvVbqeT+gFtZBprZ1vviZr6dI0eO2ErsCrxKly5tC3FpH+7du3fb2zVD6gLu6667ztx4443Z9vchazQA1KZNGy/zwaWcO3v27LFt1tGe3NEKuAEAABAbmOmOQUpX1iy3TugLFChgNm7caCpWrGjiefTx6quvtoGuaL/4oIuMbd682QbPShtOi9LAmzVrZpo2bWqDcc1ou5HSChUqmGXLlpkZM2aYmTNn2irXJ9J7p73rV61a5RXYWrJkiQ28ETt+/vlnW/hPBf+0TlvZEFdddZW9TUsNVGhNkpKS7DKCaGJkHtmJ9gbaG+IV/RuCxkx3DJowYYINuEWBYTwH3KL9h5977jnvsvbs/vPPPwP7/zSDnVrArbRwpYirqNvWrVttsKztzOrVq3dS0TNtd3b99dfbgEtBmYJpBWDa1s05evSoTVX3V7Qm4I49GmBx24ap7aiomrIxVq5cacaNG2ev1xIQV0gNAAAAiYWgO8YopXzUqFH2WLNqvXv3Nomgbt26dqbQpXyPGDEisP9L68ZdwF2uXDmbMvzxxx/b9OG33nrLdO7c2ZQvXz5DgwYKprUvs9am67l79OhhgzV/kD5s2LBA/h4ET+9ntWrV7LEyMiZNmhRW0XzgwIGmUqVKvBUAAAAJiPTyGDNx4kRv/+rWrVvb1OVEsWHDBhvYqPBYwYIFzfr168MC12jQTGXNmjXNF198YS8rPdyt2Y12epLuq1TkDz/80NSuXds0aNAgy78/cs6iRYtM/fr1vUEUV3tAqefKighiCzjS4ZCdaG+gvSFe0b8haMx0xxCdxD/77LPe5b59+5pEou2ZtPWSHDx40NtOLJrefvttL+C+4oor7MBGUBSUa626tpAi4I59WmZwxx132GN/sT+lmLPnOgAAQOJipjubaZZW230pRVo/Koqm9cmR/Ggdt2ZRpWHDhub99983iWbXrl02+Na/snz5cjtLHA0KlBRoa0snUcVxVRrPCEZKE5s+09rizu3Nrqr306ZNC+z/o70hO9HeQHtDvKJ/Q9DyB/4/JAgFxSqYpZNuVap2QbX/R9f//vvvEe3tnJ5Em+V2SpQoYZ588knTrVs3by3tJ598Yte3Z5XWa7uAW4E8e2Ujo8qWLWtGjx5tq+uraJ6/ACAAAAASE0F3FEyfPt3uwaxq1EHR3r7aC1o/t956q53pTlT333+/eemll8zatWvtTLdmEm+//fYsZyC4CtSiombRCOSReFRoT2u7Ve3+rLPOyulfBwAAADmMoDuLtm/fbh544IF0A26t6dQsmP+nTJky9qS8aNGiXkCd2k/hwoXtns74/402f35bwV37Y0ufPn1Mq1at7OuUWSkpKbZQm1ubyxprZEXlypV5AQEAAGARdGfRo48+6u2ZXatWLbs3s7aZOjHAVnDNzGn0NGnSxKZ/z50716b1awux5OTkTD3X4cOHbcq6M3ToUN4rAAAAAFFB0J0FCxcuNFOnTvXWGs+ZM8eUKlUqOu8M0qX1stpTW6nhququdbQVK1bM8Cv3yiuv2P2zRbPn2lMbAAAAAKKBLcMySVtWPfjgg95lBX0E3NlLVaIffvhh7/3ITHE5Pe6pp57yLvuPAQAAACCrCLozSYW2Nm7caI/r1q1r7r777iy/Gci4QYMGmZIlS9pjZR0sW7YsQ49/8cUXbVV5SUpKMjVq1OBtAAAAABA1BN2ZoKrZmtkWFTgbP368yZuXlzInaK38kCFDvMvaQkx7LUZi37595umnn7bHWm/vfx4AAAAAiAYixQxSQKctq1y18t69e5tq1apF5c1A5nTt2tVccskl9njFihVmypQpET1u7Nixdt90ad++valevTpvAQAAAICoIujOoNdee80sWbLEHlepUsX0798/uu8IMrWF2OjRo73LWtu9f//+Uz5m9+7dtuK55MuXL2yPbgAAAACIFoLuDNixY4fp1atX2HrgggULRu3NQOY1atTItGjRwh7/8ssv5plnnkm38vnevXvtcceOHc2FF17Iyw8AAAAg6gi6M+Dxxx83u3bt8tKRGzduHP13BJk2cuRIu8ZeNIv9448/pjl4MmbMGHus+w8cOJBXHQAAAEAgCLoj9MEHH5iUlBR7XLx4cTNq1Khg3hFkmmaru3XrZo8PHTqU5hZimgV36edaD37eeefxqgMAAAAIBEF3BBTAPfDAA95lVbwuW7ZsMO8IskSz1meffbY9nj59ulm6dGnY7Uo9HzdunD0+44wzzBNPPMErDgAAACAwBN0RUJC9fv16e1ynTh1z7733BveOIEuUhTB06NA0txDT/uoaRJGHHnrIlC9fnlccAAAAQGAIutPx3XffmeHDh3tVsidMmMCe3LncPffcYy699FJ7/Pnnn5s33njDHm/evNlMmjTJHhcpUsT06dMnR39PAAAAAPEvroPuTz75xNx+++12/fWWLVsy/PhQKGT35D5y5Ii9/Nhjj3nBHGJnC7F+/fqZP//8086Au/3VNQNeqlSpHPwtAQAAACSCuAy6d+7caWc7r732WvPmm2+aF154we6p3aZNG7N48WIbTEdCM6SLFi2yxyq2NWjQoIB/c0RLw4YNTatWrezxtm3bbMG0119/3UtB1wAKAAAAAAQtroJurd2dPHmyueiii8wrr7wSdtvx48fNzJkzTb169czll19uJk6c6FWwTitw9wdm2pO7UKFCgf7+CG4LsWnTptk24LZ+U+ANAAAAAEGLm6B7zZo15oYbbjCdO3e2AbMULVrUBl7du3cPqza+evVqc99995kKFSrYwHrTpk0nPV/v3r3N77//bo/btm1rmjVrlo1/DaLhggsusO+9nyqbP/LII7zAAAAAALJFzAfdWqurAPnKK680H3/8sXd9u3btzLp160zPnj1t4PXDDz+YqVOn2urjzp49e+x6bwVnLVq0MAsXLrSz5R999JF59dVX7X3OPPNMM2bMmBz525B1AwYMCFu7rfXdGowBAAAAgOwQs0G31mXPnj3bVKtWzYwYMcIcO3bMXq8AWsGz9mj2bwd12mmnmfbt29viaqpo3alTJ3P66ad7zzVnzhzTpEkT+3wdO3b0HqfK5WwrFbuKFStmK87r/a9du3bYfusAAAAAELSYDLq19VPLli1NUlKSV5VcAXRycrJNHW/UqNEpH1+jRg279luPVVBdsWLFsC3C9PxSq1Ytm4aO2KZ2sm/fPjvgUrBgwZz+dQAAAAAkkJgLup9++mk7G62Zaadx48Y22B48eLA544wzIn4upR337dvXrulWkbX69et7t+XLl8/OkOpfxD7NdOfNG3PNHQAAAECMy29ijNbkOuXKlbPrrVXoLE+ePFna17l169b2RwXZ3n33Xbvd2BVXXBGl3xoAAAAAkIhiLugWzVh269bNDBkyxBY6i6bq1avbHwAAAAAAEi7oVjGsl156yVYrBwAAAAAgN4u5oFvFsFibCwAAAACIBTFXWYqAGwAAAAAQK2Iu6AYAAAAAIFYQdAMAAAAAEBCCbgAAAAAAAkLQDQAAAABAQAi6AQAAAAAICEE3AAAAAAABIegGAAAAACAgBN0AAAAAAASEoBsAAAAAgIAQdAMAAAAAEBCCbgAAAAAAApInFAqFgnpyAAAAAAASGTPdAAAAAAAEhKAbAAAAAICAEHQDAAAAABAQgm4AAAAAAAJC0A0AAAAAQEAIugEAAAAACAhBNwAAAAAAASHoBgAAAAAgIPlNjOjfv785evSoPe7YsaO55JJLwm7fvXu3eeutt8zPP/9sLrroInPrrbea0047zbu9X79+5vjx497lK664wtx+++0R347E8uSTT5r9+/fb4/bt25srr7wy7PY//vjDvPnmm+ann34yVapUMbfddps544wzvNsHDx5sDh486F2uVq2a6dSpU9hzfPPNN2bu3LkmFAqZtm3bmvPPPz/wvwu509NPP2127dplj1u3bm2uvvrqsNv//PNP27/98MMP5rzzzrNtslChQt7tw4YNM3v37vUuq03ed9999lh94tixY0/6P5OSkkydOnUC/KuQW40aNcr8+uuv9rh58+bm+uuvD7tdfZfa28aNG02FChXsd2GRIkW820eOHGl+++0377Lu88gjj3iXDxw4YGbOnGm+//57U7x4cXPzzTebypUrZ8vfhtxn3Lhx5scff7THjRo1sj9+hw8fNjNmzDAbNmwwZcuWtf2b2o2j/kv9mFO6dGnz+OOPR/x4JJZJkybZtiDq29TH+SmWUP/07bff2rak87eSJUuG3Wfr1q1m1qxZNrZo1qyZqVmzZtjtCxYsMJ988oltZ+3atTPnnHNONvxliHUxM9P9j3/8wzRu3NisWrXK7Nix46QT0g4dOthOWR+Mjz76yAwcODDsPh988IG55ppr7HPo57LLLsvQ7Ugs9evXt+1g3bp1Ztu2bWG3HTp0yAbQOiGtVauW+eyzz0zv3r3D7rN48WJTo0YNrz1pEMdv0aJF5uGHHzZnnXWW+dvf/maeeuop246RmOrWrWvbyaZNm8JOLt0Jwj333GPWrFlj29vq1atN9+7d7WCNs3TpUnPppZd67e2qq67ybjvzzDO96/Wj51B/V6pUqWz9G5F7uO86tTUXDDkafL7//vvN559/br9PdfL6wAMPhA1KL1u2zFx44YVemzpx8KZHjx72e1iPVzu96667TmrXSBy1a9e27UTnburj/NQ+NGCzZMkS22+pnXTt2tWbZBF9x2qw0bW36667LkOPR2JRO1A70UC0Bv5O1KtXL7Nw4UJ7jvb777+bLl26hE2S6NxOfdaRI0fM3//+d/PGG2+YtWvXerfr8r/+9S/7navJmc6dO5s9e/Zk29+HGBaKMa1atQp9+OGHYdfNmjUr1KZNm9Bff/1lL+/duzdUu3bt0IYNG7z71KpVK7Rjx440nze925GY2rdvH5o7d27YdfPnzw81b948dOzYMXv5wIEDobp164ZWrVrl3eeGG24I/fTTT6k+59GjR0MtW7YMLVmyxLtOz6Hrkdg6d+4cmjFjRth1ixcvDjVq1Ch05MgRe/nw4cOhBg0ahJYtW+bdp1mzZqF169ZF9H9MmTIldMcdd0T5N0csevjhh0MpKSlh13322Weh66+/PnTw4EF7Wf3SjTfeGPrggw+8+7Ru3Tq0cuXKVJ9zz549oRo1aoS2bNniXXf33Xef1K6ReHr16hUaP3582HVr1qwJ1alTJ7Rv3z57WedxSUlJoTlz5nj36dChQ2jp0qWpPmckj0diGjx4cGj06NFh123atClUs2bN0K5du8LO8/z9U/fu3UMvv/yyd/n48eNe+9J5X8OGDcPiEPVvkydPDvivQTyImZnuU9m5c6cpX768yZMnjzezU7RoUfPVV1+F3U8pSkOHDjWzZ88OG7WP9HbAtbdy5cqZfPny2csFCxa0M9Yntrfx48ebIUOGmP/85z/m2LFj3vWaPd+3b59N11Qa+5gxY2yqZv78MbPaA9nc3pQCV6BAAXtZy2Y0S62sH7/Jkyfb9qRlDxqhT8ucOXNOSrcDHM38KNXSLZdRv1SmTJmT+rcpU6aY5ORkM3XqVJv94xQuXNgUK1bMbN++3V7WjKP7jgZS69/UXtzyBZ3H6fv1xPam9HEt29Iso5YvZPTxgGsv7pzNUWq4ay9aqqDMserVq5vhw4ebZ555xn7Xuva1ZcsWO6ut7A1Hx19//TUvMNIVF0H3BRdcYFMvXXqH0kC0DkM/jj48WtuhlDh12n369Al7jvRuB5yqVaua7777zp6citLltD7S394U/ChFXWu5dbLgTwfWWiEN6owePdqmnev4zjvvNL/88gsvMlJtb1rL7ZY5KH1StQT87e2JJ56wS3CU7vbuu++elA7sKFVY7bVp06a80kjz+1R90ebNm+1lDQiq3fjbm9IzmzRpYvuv9957zy5/cAOLCtK15lsD2Er7VX2VFi1a2JR24ESqZaJ6FhqMFp3Haa2tP11X7eimm26ytVWURq66Pm6gJ5LHA46WKajtuCBby/oUMLv+Td+zOlfTZIj6Qg1w6/xNS2pc+zr99NNt4O4ogPf3j0Ba4mJq7YYbbrAFqVTMQEGzRtjPPfdcO+PtNGjQIOxYHbhOPl3xqvRuBxytidUAjYq1XHzxxTaIVkeu0XZ/m3QUDKk9qXCaRk8VDGkdkEbtXfvSusp33nnHrqUE/NRmNDOtuhUqIKmgW0Wp/P2bf42j1rLp/l9++eVJxV/UxrR+nCJDSItONNW33X333XYQRwM8am/+/s1f6E8DOC1btrSzQ+r3FHxPnDjRPk+9evVs//jf//7XHus6wE9F+LQmVoUfVUtHM4n6PvX3b/5+TN+lKjapuihqe5E8HnDOPvts8+CDD9pAWu1F/VvFihW99uIGDzWw4wanXWFJ1a5QhqM/c9Fl85CpiIQJupVONGLECLN+/Xo7Kq+TVAXgCrxTo5ErpZ9rpjK1oDq92wHN4qhAh2a41d7UQafV3hTgaCTUzYy7NEt/uqWOXfVq4ETaXUEVVhXAKPDWSUNa7U1pcEpHd+3N0YnC//73P7sTBHAqOiFVxXEFMCr0qEKRabU3paErnde1Nw326LtYhYrcEhyldE6fPt0MGDCAFx4nUcCsYFrZFcrs0bKstNqbltko0Pb3bxl5PKDzNVXQ18SadvrQbg4aqBH1ZXnz5g07P9N1KubnjjVxolhD37NudlxV84GESC+X5cuX21luzfjMnz/fjsprRlKUdqSTVefjjz+2a4LcqHt6twOptTe1D7U3jbiLZhBFwbi/IvAXX3xhTxC0lZ0oSC9RooSdGXJriFQp2N0OpNbeNNuo9qYvf6WyNWzY0N6mE01/hVYttXHBkp/am9Lmrr32Wl5gpPt9qqBF7U3fj+rP3KyPvitdKq8o9VztT1k/bk23Zob8g4h6jH/LMeDE9qZAWu1NfZf6MGVPiCqea8cGR21RWWP+/u1UjwdS698UVKu9aEBQl7WFpuu/VLHcnZ/pO1Op5e78TDPlOlbWmKg+j3YDced/QFzMdLt9GvUBSUlJMfPmzbOjmxqlEu2np5Q2FRDSfZ577jk7WuVG4rUGTR8m0Sh83759beATye1IPBMmTLDbRmhto2ZoFFgr3dKdWGpgR/f566+/7Gy3im249CK1J7UfFbzSdTpB7dmzpx0hFV2n2Uall6vd6iShUqVKplWrVjn6NyPnvPbaa7YWhQJopeKuWLHC7o3stppT+3vxxRftzKHayz//+U+v0JXWlqkGhTJ+tNZMJ6RapnDivsgqoKbAiTQ4qPiZ1jTqu84FNW3atPEGqj/99FPz/PPP2zamNqmCaS5oVntT36XvWl2nx2p7HdWvEGViaEBImRkaYFQfqvRLPQaJScVE1acpGFZ9Cn23Kih2y2K0plZbMKk96TZt+eqWwKgNap9vLclSCrDa2y233BK2LeKpHo/Eo7omWvuvtf3KjFAfpBoUbqBaA4Wa3VYb0bG+P92stSgeUDaZsnbU7tR/+es8KfNH53TqJ/XcGgDSMkIgPXlUwtzEAM3uaM89P+2x5yoQ6s9Qh64CCVqnoZNPP31odFKrf5V+5F+fFsntSCyanT6xMIYCII1yOmovGuW8/PLLvQDIn8qrDl/tUTPi/kqZjgaHdB83cuqq7yPxKAA6MR1c62lVNdrR4I2KuKh/K1SoUNh9le6mtqQTBLU3VZ8+kfZN1qAR+3ND35UaLPRT0OxPqdTstQJytcMTZ6k12KhikvpOVnvz94uOgnUNlCtQ0nMz2JO41Df5swlF33laS+u4gqQaqDlxPbbO7zRApO9kDSb6+8VIHo/Eoraitdp+6qdcCrnLmNAAttpLagM0ynZV1XINMmog0e0e4qjv0wCQYgU9B+dviKugGwAAAACAWBM3a7oBAAAAAMhtCLoBAAAAAAgIQTcAAAAAAAEh6AYAAAAAICAE3QAAAAAABISgGwAAAACAgOQP6okBAED8+uGHH+yeuHnz5jWNGjXK6V8HAIBci6AbAIBcZtu2bebrr7/2Ljdo0MAUKFDAu7xlyxazdu1a73KTJk0C+T327NljPv30U3tcp04dc+aZZ3q3LV682LzwwgsmX758BN0AAJwCQTcAALnMypUrzaBBg7zLycnJpnnz5t7lZ5991ixbtizwoHvz5s2mf//+9jglJcVUq1YtkP8HAIB4RtANAEAuN336dC/o3rRpk1m+fPkp779z506zbt06c+TIEVOhQgVTtWrVU6aG//jjj/anbNmy5sILL/QC7hUrVniP0f+pGfaSJUuaq6666qT/M7XnAAAABN0AAORqpUqVsgG0Zr+vvPJKM23aNBMKhez1O3bsCLvv8ePHzciRI82sWbNMmTJl7I8ed/HFF5vhw4fbANyfGq6ge968eTY4X7Nmjdm/f79p1aqVGThwoA2wv/rqK++5v/zyS7NhwwZzwQUXhAXd+l169uyZ6nMAAACqlwMAkKu1adPG/jt16lS7xlpBcpEiRcyNN9540n1fffVVM2PGDFO8eHF7/0mTJtkZ8m+//dY89thj5q+//gq7vy5fd911Zty4caZ79+72urffftv8+uuvpm7duqZr167efR988EEbuHfp0iXi5wAAAATdAADkag0bNrQz1h999JEZO3asOXz4sLn55ptNwYIFT7rv7NmzvaJnCszFVRbfuHGjWb169UmPady4sf23UqVK3nUZDZij8RwAAMQr9ukGACAXU3XwW2+91aaOv/POO/Zyu3btTrqfbt++fbs9LlGihHe91mD7q6Kf+NxFixa1x/nzZ67MSzSeAwCAeEbQDQBALpeUlOTNbNevX9+UK1cu1eC3cOHC9vjgwYPe9QcOHPCOXXAMAACyD0E3AAC5nPbHfuihh2yqeKdOndK837XXXmv/9e/x7Y6Vbn755Zdn6P897bTTwmbSAQBAxpEHBgBADLjtttvsz6n06NHDFk377rvvzJAhQ0yVKlXM5MmTbfA8YMAAb513pLRGW7Pnqkj+5ptvmq1bt9rq5foBAACRIegGACCXKV++vFcArVChQqneRwG1u49TunRpu6XYggULzDfffGOD7w4dOpimTZuaihUreverXLmyfaxS0h1VPHfPp2NRkD5hwgRbMX3Xrl12qzE9RkF3pM8BAECiyxPSBpsAAAAAACDqWNMNAAAAAEBACLoBAAAAAAgIQTcAAAAAAAEh6AYAAAAAICAE3QAAAAAABISgGwAAAACAgBB0AwAAAAAQEIJuAAAAAAACQtANAAAAAEBACLoBAAAAAAgIQTcAAAAAAAEh6AYAAAAAwATj/wH4ti+gzVt0TwAAAABJRU5ErkJggg==", @@ -483,7 +494,8 @@ "execution_count": 11, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Launch the MLflow UI with this command in your terminal:\n", "\n", @@ -559,7 +571,8 @@ "execution_count": 53, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "INFO: GPU available: True (mps), used: False\n", "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", @@ -587,6 +600,7 @@ ] }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -600,7 +614,8 @@ } }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/torch/utils/data/dataloader.py:775: UserWarning: 'pin_memory' argument is set as true but not supported on MPS now, device pinned memory won't be used.\n", " super().__init__(loader)\n", @@ -609,6 +624,7 @@ ] }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -622,6 +638,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -635,13 +652,15 @@ } }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/core/module.py:512: You called `self.log('train_MAE', ..., logger=True)` but have no logger configured. You can enable one by doing `Trainer(logger=ALogger(...))`\n", "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/core/module.py:512: You called `self.log('train_MSE', ..., logger=True)` but have no logger configured. You can enable one by doing `Trainer(logger=ALogger(...))`\n" ] }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -655,6 +674,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -668,6 +688,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -681,6 +702,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -694,6 +716,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -707,6 +730,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -720,6 +744,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -733,6 +758,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -746,6 +772,7 @@ } }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -759,7 +786,8 @@ } }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "INFO: `Trainer.fit` stopped: `max_epochs=10` reached.\n", "INFO:lightning.pytorch.utilities.rank_zero:`Trainer.fit` stopped: `max_epochs=10` reached.\n", @@ -772,6 +800,7 @@ ] }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -785,7 +814,8 @@ } }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "NBEATS MAPE: 13.64%\n", "NBEATS RMSE: 63.33\n" @@ -859,7 +889,8 @@ "execution_count": 13, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "All logged metrics (5):\n", " mae: 46.0220\n", @@ -940,13 +971,15 @@ "execution_count": 14, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Aggregate metrics: {'ae': 44.196, 'mae': 51.316}\n", "Mean MAE over series: 51.316\n" ] }, { + "metadata": {}, "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { @@ -960,13 +993,16 @@ } }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "\n", "Per-series breakdown (metrics_per_series.json):\n" ] }, { + "metadata": {}, + "execution_count": null, "output_type": "execute_result", "data": { "text/html": [ @@ -1055,13 +1091,15 @@ "execution_count": 15, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "2026/07/23 18:50:10 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "\n", "Files in model directory:\n", @@ -1097,7 +1135,8 @@ "execution_count": 16, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Loaded model successfully!\n", "Predictions shape: (5, 1)\n" @@ -1150,7 +1189,8 @@ "execution_count": 17, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Found 5 runs in experiment 'darts-quickstart':\n", "\n", @@ -1228,13 +1268,15 @@ "execution_count": 18, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Loading best model from run: exponential-smoothing-baseline\n", "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" ] }, { + "metadata": {}, "output_type": "display_data", "data": { "image/png": "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", @@ -1277,13 +1319,15 @@ "execution_count": 60, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Registered version: 1\n" ] }, { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "Successfully registered model 'darts-air-passengers'.\n", "Created version '1' of model 'darts-air-passengers'.\n" @@ -1361,7 +1405,8 @@ "execution_count": 19, "outputs": [ { - "output_type": "stream", + "name": "stdout", +"output_type": "stream", "text": [ "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" ] From c035d150a8920e271402fd305bf5b8f405f83b98 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 14 Aug 2026 14:02:38 +0200 Subject: [PATCH 140/154] improve docs --- INSTALL.md | 4 +- darts/tests/optional_deps/test_mlflow.py | 16 +- darts/utils/mlflow.py | 254 +++++++++++++++-------- 3 files changed, 176 insertions(+), 98 deletions(-) diff --git a/INSTALL.md b/INSTALL.md index 302c7d7421..262aa692f2 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -24,8 +24,8 @@ Some models have additional dependencies that are not included in the `all` inst Some optional integrations also require additional dependencies: -| Integration | Dependencies | -|-------------------------|--------------| +| Integration | Dependencies | +|----------------------|--------------| | `darts.utils.mlflow` | mlflow>=3.0 | diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 38c6a7b736..402ed656fd 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1414,7 +1414,7 @@ def test_autolog_backtest_per_window_steps(self, mlflow_tracking, autolog_contex history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") assert len(history) > 1, "Expected multiple per-window steps" steps = sorted(m.step for m in history) - assert steps == list(range(-len(history), 0)) + assert steps == list(range(len(history))) logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, np.asarray(ref, dtype=float), atol=1e-5) @@ -1791,16 +1791,16 @@ def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") logged = {m.step: m.value for m in history} - assert logged == pytest.approx({-5: 1.0, -4: 2.0, -3: 6.5, -2: 12.0, -1: 17.5}) + assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) rows = self._read_per_series_table(run.info.run_id) by_step = {(r["series_index"], r["step"]): r["value"] for r in rows} - assert by_step[(0, -5)] == pytest.approx(1.0) - assert by_step[(0, -1)] == pytest.approx(5.0) - assert by_step[(1, -3)] == pytest.approx(10.0) - assert by_step[(1, -1)] == pytest.approx(30.0) - assert (1, -5) not in by_step - assert (1, -4) not in by_step + assert by_step[(0, 0)] == pytest.approx(1.0) + assert by_step[(0, 4)] == pytest.approx(5.0) + assert by_step[(1, 2)] == pytest.approx(10.0) + assert by_step[(1, 4)] == pytest.approx(30.0) + assert (1, 0) not in by_step + assert (1, 1) not in by_step def test_log_backtest_metrics_aligns_last_points_only_time_axis( self, mlflow_tracking diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index d59aecd524..6455b905d5 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -2,23 +2,168 @@ MLflow Integration ------------------ +.. _darts-mlflow-autolog-logging: + Custom MLflow model flavor for Darts forecasting models. Supports saving, loading, and logging any Darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) -to MLflow, as well as automatic logging (``autolog()``) of: - -- Model parameters and data metadata: The model creation parameters, target series, and covariate usage information. -- Model storage: The trained model artifact after each ``fit()`` call when ``log_models=True`` (default ``False``). -- Metrics: - - The score for each metric called inside an active MLflow run. - - The score(s) from a ``backtest()`` call. - - Per-epoch training/validation metrics for PyTorch-based models. +to MLflow, as well as automatic logging via ``autolog()``. See the `MLflow quickstart example `_ for an end-to-end walkthrough. -To keep auto-logged metrics comparable across runs, use the same evaluation -time frame, forecast horizon, and evaluation start date for every -``backtest()`` / metric call you intend to compare. +.. dropdown:: Here's a quick start example + + .. highlight:: python + .. code-block:: python + + import os + import tempfile + + import mlflow + + import darts.metrics as metrics + from darts.datasets import AirPassengersDataset + from darts.models import LinearRegressionModel + from darts.utils.mlflow import autolog + + # dummy temporary directory for local MLflow tracking; + # use a permanent location for real use cases + tmpdir = tempfile.mkdtemp() + mlflow_db = os.path.join(tmpdir, "mlflow.db") + + mlflow.set_tracking_uri(f"sqlite:///{mlflow_db}") + mlflow.set_experiment("darts-quickstart") + + # load series and create train and val splits + series = AirPassengersDataset().load() + train, val = series[:-36], series[-36:] + + # two models to compare with different lookback windows + model_lags, names = [12, 24], ["one-year", "two-years"] + horizon = 12 + + # activate autologging and try out the models + autolog() + for lags, name in zip(model_lags, names): + with mlflow.start_run(run_name=name) as run: + model = LinearRegressionModel(lags=lags) + model.fit(train) # autolog logs params and covariate metadata + + # log standalone metrics from manual predictions + pred = model.predict(n=horizon) + metrics.mae(val, pred) # time-aggregated logged as scaler metric + metrics.ae(val, pred) # time-dependent logged as stepped metric + + # log backtest metrics from historical forecasts over val set + bt = model.backtest( + series=series, + start=val.start_time(), + retrain=False, + forecast_horizon=horizon, + reduction=None, # `None` logs as stepped metric, scalar otherwise + metric=[metrics.mae, metrics.rmse], + ) + autolog(disable=True) + + # you can launch the MLflow UI with the command below from your terminal; + # then open the returned address for example in a browser (similar to http://localhost:5000) + print(f"mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}") + +When ``autolog()`` is enabled, the following functionalities emit detailed logs when inside +an active MLflow run (e.g. within ``with mlflow.start_run():``): + +- Calling ``ForecastingModel.fit()``: + + - Logs model creation parameters (``model.model_params``), both as MLflow + params and as a ``model_params.json`` artifact. + - Logs target series info and covariate usage information (past, future, + and static covariates) as a ``series_info.json`` artifact. + - Stores the trained model artifact when ``log_models=True`` (default: + ``False``). + - Logs per-epoch training and validation metrics for PyTorch-based models. +- Calling ``ForecastingModel.historical_forecasts(retrain=True)``: + + - Logs the same model creation parameters and ``series_info.json`` as + ``fit()`` (overwriting any prior ``fit()`` artifacts in the same run). + - Does not log the trained model artifact; call ``fit()`` + or ``log_model()`` manually if needed. +- Calling any Darts metric: + + - Logs the result of that metric call as an MLflow metric. More information + in the notes below. +- Calling ``ForecastingModel.backtest()``: + + - Logs all evaluation metrics under ``backtest_*`` keys. More information + in the notes below. + +.. important:: + + **Cross-Model Run Comparability**: Metric values are only comparable + across runs when the evaluation settings match. Use the same evaluation + time frame, forecast horizon, and evaluation start date for every + ``backtest()`` / metric call you intend to compare. + +.. note:: + + **Metric Naming Convention**: Logged metric keys follow the pattern + ``{metric_name}{component}{quantile_or_label}`` (e.g., + ``"mae_target0_q0_500"``), where each part is included only when the + corresponding axis is present: + + - ``metric_name`` – the metric function name, or the ``name`` metric + keyword argument when provided (e.g., ``"mae"``). + - ``component`` – the component name: e.g., ``"_target0"`` when + ``component_reduction=None``. + - ``quantile_or_label``: + + - the quantile label: e.g., ``"_q0_500"`` for quantile metrics with + keyword argument ``q=[0.5]`` + - the quantile interval label: e.g., ``"_qi_80_000"`` for quantile + interval metrics with keyword argument ``q_interval=[(0.1, 0.9)]`` + (80% interval between quantiles 0.1 and 0.9). + - the class label: e.g., ``"_label1"`` for classification metrics with + keyword argument ``labels`` when ``label_reduction=None``. + + **Backtest metrics** are prefixed by ``"backtest_"``. + +.. note:: + + **Metric Logging and Display**: Darts offers many ways of evaluating + forecasting models. To offer the highest value, we adapt what is logged + to MLflow based on the use case scenario. + + - Metric type: + + - Time-aggregated metrics (e.g. ``mae()``): Logged as + scaler values. + - Per-time step metrics (e.g. ``ae()`` where ``time_reduction=None``): + Logged as stepped metrics (one value per step in the forecast horizon). + - Single or Multi-series: + + - Single series: Logged as explained above. + - Multiple (a list of) series: When the metric's + ``series_reduction=None``, the logged metric is aggregated over all + series using autolog's ``agg_func``. The detailed per-series metrics / + backtest metrics are logged under a single ``metrics_per_series.json`` + table run artifact. + + - Standalone or backtest metric: + + - Standalone metric: Logged as explained above. + - Backtest metric: If backtest's ``reduction`` is other than ``None``, + the windowed forecast metrics are aggregated and logged as explained + above. If ``None``, metrics are logged as stepped MLflow metrics. + + - Time-aggregated metrics: each step represents a specifc forecast + (window) metric. Steps represent the historical forecast windows + (0, 1, ..., n_windows - 1). + - Per-time step metrics: each step represents a step in the forecast + horizon aggregated over all windows. Steps represent the steps in + the forecast horizon (0, 1, ..., horizon - 1). + + When components are preserved (``component_reduction=None``), all + series scored together must have the same number of components; names + are taken from the first series. """ import inspect @@ -345,86 +490,21 @@ def autolog( ) -> None: """Enable (or disable) automatic MLflow logging for Darts. - When enabled, the following functionalities emit detailed logs: - - - Calling ``ForecastingModel.fit()`` inside an active MLflow run (e.g. within - ``with mlflow.start_run():``); does nothing if no run is active: - - - Logs model creation parameters (``model.model_params``), both as MLflow - params and as a ``model_params.json`` artifact. - - Logs target series info and covariate usage information (past, future, - and static covariates) as a ``series_info.json`` artifact. - - Stores the trained model artifact when ``log_models=True`` (default: - ``False``). - - Logs per-epoch training and validation metrics for PyTorch-based models. - - Calling ``ForecastingModel.historical_forecasts(retrain=True)`` inside an - active MLflow run; does nothing if no run is active or ``retrain`` is not - ``True``: - - - Logs the same model creation parameters and ``series_info.json`` as - ``fit()`` (overwriting any prior ``fit()`` artifacts in the same run). - - Does not log the trained model artifact; call ``log_model()`` manually - if needed. - - Calling any Darts metric inside an active MLflow run; does nothing if no - run is active: - - - Logs the result of that metric call as an MLflow metric. More information - in the notes below. - - Calling ``ForecastingModel.backtest()`` inside an active MLflow run; does - nothing if no run is active: - - - Logs all evaluation metrics under ``backtest_*`` keys. More information - in the notes below. - - .. note:: - - Logged metric keys follow the pattern - ``{metric_name}{component}{quantile_or_label}``, where each part is - included only when the corresponding axis is present: - - - ``metric_name`` – the metric function name, or the ``name`` metric - keyword argument when provided. - - ``component`` – the component name when ``component_reduction=None``. - - ``quantile_or_label``, e.g.: - - - ``_q0.500`` for quantile metrics with keyword argument ``q=[0.5]`` - - ``_qi_80.000`` for quantile interval metrics with keyword argument - ``q_interval=[(0.1, 0.9)]`` (80% interval between quantiles 0.1 and - 0.9). - - ``_label1`` for classification metrics with keyword argument - ``labels`` when ``label_reduction=None``. - - Per-timestep metrics (``time_reduction=None``) are charted across the - MLflow ``step``. - - When ``series_reduction`` is set on a metric call, results are already - aggregated across series inside the metric itself, so the - cross-series aggregation described below does not apply. - - For a list of series, the logged metric is aggregated over all series - using ``agg_func``. The detailed per-series metrics / backtest metrics - are logged under a single ``metrics_per_series.json`` table - artifact. - - When components are preserved (``component_reduction=None``), all - series scored together must have the same number of components; names - are taken from the first series. - - Metric values are only comparable across runs when the evaluation - settings match. Use the same evaluation time frame, forecast horizon, - and evaluation start date for every ``backtest()`` / metric call you - intend to compare. + For a detailed overview of logged params, metrics, and artifacts, see + :ref:`the detailed documentation `. Parameters ---------- log_models - If ``True``, log the trained model artifact after ``fit()``. Defaults to - ``False``. + If ``True``, log the trained model artifact when calling ``fit()``. + Defaults to ``False``. log_params - If ``True`` (default), log model creation parameters. + If ``True`` (default), log model creation parameters when calling + ``fit()`` or ``historical_forecasts()``. log_metrics If ``True`` (default), log the result of any Darts metric call made - inside an active MLflow run. + inside an active MLflow run, including standalone metric calls or via + backtest. log_torch_metrics If ``True`` (default), enable ``mlflow.pytorch.autolog(log_models=False)`` around PyTorch-based model training to automatically log per-epoch @@ -633,9 +713,7 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): if active_run is None: return result - bound = inspect.signature(ForecastingModel.historical_forecasts).bind( - self, *args, **kwargs - ) + bound = inspect.signature(original).bind(self, *args, **kwargs) bound.apply_defaults() if bound.arguments["retrain"] is not True: return result @@ -1339,7 +1417,7 @@ def _log_backtest_metrics( if has_time_axis: step = t - t_size if t_axis_is_calendar else t else: - step = aligned_w - max_w_size + step = aligned_w value = float(canonical[w, t, c, m]) agg.setdefault((key, step), []).append(value) rows.append({ From 1e47e3419bc97323e00f4170417447770d37a019 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 14 Aug 2026 16:21:09 +0200 Subject: [PATCH 141/154] improve encoder handling for covariates metadata --- darts/utils/mlflow.py | 125 +++++++++++++++++++++++++----------------- 1 file changed, 74 insertions(+), 51 deletions(-) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 6455b905d5..2d83136972 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -228,6 +228,7 @@ import darts from darts import TimeSeries +from darts.dataprocessing.encoders.encoders import SequentialEncoder from darts.logging import get_logger, raise_log from darts.metrics.utils import ( _LabelReduction, @@ -654,9 +655,9 @@ def _patched_fit(original, self, *args, **kwargs): fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments _log_model_setup( - self, - autologging_client, - run_id, + model=self, + autologging_client=autologging_client, + run_id=run_id, series=fit_args["series"], past_covariates=fit_args.get("past_covariates"), future_covariates=fit_args.get("future_covariates"), @@ -720,9 +721,9 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): autologging_client = MlflowAutologgingQueueingClient() _log_model_setup( - self, - autologging_client, - active_run.info.run_id, + model=self, + autologging_client=autologging_client, + run_id=active_run.info.run_id, series=bound.arguments["series"], past_covariates=bound.arguments.get("past_covariates"), future_covariates=bound.arguments.get("future_covariates"), @@ -747,7 +748,7 @@ def _patched_backtest(original, self, *args, **kwargs): if not log_metrics or active_run is None: return result - bound = inspect.signature(ForecastingModel.backtest).bind(self, *args, **kwargs) + bound = inspect.signature(original).bind(self, *args, **kwargs) bound.apply_defaults() backtest_args = bound.arguments @@ -765,30 +766,30 @@ def _patched_backtest(original, self, *args, **kwargs): # patch `fit()` for all forecasting models for _, cls in _get_forecasting_models(): safe_patch( - FLAVOR_NAME, - cls, - "fit", - _patched_fit, + autologging_integration=FLAVOR_NAME, + destination=cls, + function_name="fit", + patch_function=_patched_fit, ) # patch `historical_forecasts()` for all forecasting models so that the - # N internal fit() calls don't each log, and so that retrain=True calls + # N internal fit() calls do not log themselves, and so that retrain=True calls # log model setup once for _, cls in _get_forecasting_models(): safe_patch( - FLAVOR_NAME, - cls, - "historical_forecasts", - _patched_historical_forecasts, + autologging_integration=FLAVOR_NAME, + destination=cls, + function_name="historical_forecasts", + patch_function=_patched_historical_forecasts, ) # patch `backtest()` for all forecasting models to log metric results for _, cls in _get_forecasting_models(): safe_patch( - FLAVOR_NAME, - cls, - "backtest", - _patched_backtest, + autologging_integration=FLAVOR_NAME, + destination=cls, + function_name="backtest", + patch_function=_patched_backtest, ) @@ -830,23 +831,16 @@ def _infer_covariate_usage( ``False``. Fall back to call args / ``add_encoders`` / static covariates on ``series``, gated by ``supports_*`` / ``considers_static_covariates``. """ - # encoder keys like "datetime_attribute" map to {"past": ..., "future": ...}; - # non-dict values ("tz", "transformer") are ignored by the isinstance check - enc_types = { - cov - for val in (model.add_encoders or {}).values() - if isinstance(val, dict) - for cov in ("past", "future") - if cov in val - } + # encoders can add past and future covariates + encoders = _get_model_encoders(model) first_series = get_single_series(series) uses_past = model.uses_past_covariates or ( model.supports_past_covariates - and (past_covariates is not None or "past" in enc_types) + and (past_covariates is not None or len(encoders.past_encoders) > 0) ) uses_future = model.uses_future_covariates or ( model.supports_future_covariates - and (future_covariates is not None or "future" in enc_types) + and (future_covariates is not None or len(encoders.future_encoders) > 0) ) uses_static = model.uses_static_covariates or ( first_series is not None @@ -904,7 +898,7 @@ def _log_model_setup( autologging_client.set_tags( run_id=run_id, tags=_get_model_info_tags( - model, + model=model, series=series, past_covariates=past_covariates, future_covariates=future_covariates, @@ -914,7 +908,7 @@ def _log_model_setup( autologging_client.log_params(run_id=run_id, params=model.model_params) mlflow.log_dict(model.model_params, "model_params.json") _log_series_info( - model, + model=model, series=series, past_covariates=past_covariates, future_covariates=future_covariates, @@ -955,33 +949,46 @@ def _log_series_info( ``None``. """ first_series = get_single_series(series) + first_past_covariates = get_single_series(past_covariates) + first_future_covariates = get_single_series(future_covariates) uses_past, uses_future, uses_static = _infer_covariate_usage( - model, series, past_covariates, future_covariates + model=model, + series=series, + past_covariates=past_covariates, + future_covariates=future_covariates, ) + + encoders = _get_model_encoders(model) + if encoders.encoding_available: + first_past_covariates, first_future_covariates = encoders.encode_train( + target=first_series, + past_covariates=first_past_covariates, + future_covariates=first_future_covariates, + ) + series_info = { "series": { "count": first_series.n_components, "names": first_series.components.tolist(), }, "past_covariates": _extract_covariate_metadata( - uses_past, - get_single_series(past_covariates), - "components", - encoded_names=model.encoders.past_components, + uses=uses_past, + single_cov=first_past_covariates, + names_attr="components", ), "future_covariates": _extract_covariate_metadata( - uses_future, - get_single_series(future_covariates), - "components", - encoded_names=model.encoders.future_components, + uses=uses_future, + single_cov=first_future_covariates, + names_attr="components", ), } - static_covariates = ( first_series.static_covariates if first_series is not None else None ) series_info["static_covariates"] = _extract_covariate_metadata( - uses_static, static_covariates, "columns" + uses=uses_static, + single_cov=static_covariates, + names_attr="columns", ) if uses_static and static_covariates is not None: # static covariates are global (one shared row) unless there is one row @@ -1014,7 +1021,6 @@ def _extract_covariate_metadata( uses: bool, single_cov: TimeSeries | pd.DataFrame | None, names_attr: str, - encoded_names: pd.Index | list[str] | None = None, ) -> dict: """Extract metadata for a single covariate type from its (already singular) value. @@ -1029,10 +1035,6 @@ def _extract_covariate_metadata( names_attr : str Attribute holding the feature names ("components" for a ``TimeSeries``, "columns" for a static-covariates ``DataFrame``). - encoded_names - Additional covariate names generated by encoders (``add_encoders``), - appended to the names extracted from ``single_cov``. Ignored when - ``uses`` is ``False``. Returns ------- @@ -1044,8 +1046,6 @@ def _extract_covariate_metadata( if uses: info["used"] = True names = list(getattr(single_cov, names_attr)) if single_cov is not None else [] - if encoded_names is not None: - names = names + list(encoded_names) info["names"] = names info["count"] = len(names) @@ -1072,6 +1072,29 @@ def _sanitize_mlflow_key(name: str) -> str: return re.sub(r"[^\w-]", "_", name) +def _get_model_encoders(model: ForecastingModel) -> SequentialEncoder: + """Get the encoders for a model. + + Gets either the trained encoder of a fitted model or the + fresh encoders of a model that has not been fitted yet. + + Parameters + ---------- + model + A Darts forecasting model instance. + + Returns + ------- + SequentialEncoder + The encoders for the model. + """ + if model.add_encoders and not model.encoders.encoding_available: + # model has encoders but it was not fitted yet + return model.initialize_encoders() + # model has been fitted, or does not have encodings available + return model.encoders + + def _build_metric_keys( metric_names: list[str], components: list[str], From 92580e1c1d9c1650559b05448983e26a31ed5a6d Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 16 Aug 2026 13:32:45 +0200 Subject: [PATCH 142/154] improve metric keys and series metadata logging --- darts/tests/optional_deps/test_mlflow.py | 36 ++-- darts/utils/mlflow.py | 233 +++++++++++++---------- 2 files changed, 147 insertions(+), 122 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 402ed656fd..dc0fb796e9 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -445,8 +445,8 @@ def test_autolog_series_info_add_encoders(self, mlflow_tracking, autolog_context expected_names = model.encoders.future_components.tolist() assert expected_names # sanity check: encoders actually generated something assert series_info["future_covariates"]["used"] is True - assert series_info["future_covariates"]["count"] == len(expected_names) - assert series_info["future_covariates"]["names"] == expected_names + assert series_info["future_covariates"]["count"] == 0 + assert series_info["future_covariates"]["encodings"] == expected_names assert series_info["past_covariates"]["used"] is False def test_autolog_series_info_static_is_global( @@ -464,7 +464,8 @@ def test_autolog_series_info_static_is_global( series_info = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/series_info.json" ) - assert series_info["static_covariates"]["is_global"] is True + assert series_info["static_covariates"]["count"] == 2 + assert series_info["static_covariates"]["names"] == ["a", "b"] # one row per component (2 components, 2 rows) -> component-specific per_component_target = self.ts_multivariate.with_static_covariates( @@ -476,7 +477,8 @@ def test_autolog_series_info_static_is_global( series_info = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/series_info.json" ) - assert series_info["static_covariates"]["is_global"] is False + assert series_info["static_covariates"]["count"] == 1 + assert series_info["static_covariates"]["names"] == ["a"] def test_autolog_historical_forecasts_series_info_covariates( self, mlflow_tracking, autolog_context @@ -1121,7 +1123,7 @@ def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): ref = np.asarray(ref, dtype=float) # shape (n_quantiles,) m = mlflow.get_run(run.info.run_id).data.metrics - for i, key in enumerate(("mql_q0_100", "mql_q0_500", "mql_q0_900")): + for i, key in enumerate(("mql_q0.100", "mql_q0.500", "mql_q0.900")): assert key in m, f"Expected quantile key {key}" assert m[key] == pytest.approx(ref[i], abs=1e-5) @@ -1140,8 +1142,8 @@ def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context ref = dm.miw(actual, pred, q_interval=(0.1, 0.9)) m = mlflow.get_run(run.info.run_id).data.metrics - assert "miw_qi_80_000" in m - assert m["miw_qi_80_000"] == pytest.approx(float(ref), abs=1e-5) + assert "miw_qi0.800" in m + assert m["miw_qi0.800"] == pytest.approx(float(ref), abs=1e-5) def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): """A list of series logs the mean over series; per-series values go to a table.""" @@ -1235,7 +1237,7 @@ def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): direct = mlflow.get_run(run_direct.info.run_id).data.metrics assert "custom" in direct assert "mae" not in direct, "default metric name should be replaced" - assert "myq_q0_500" in direct, "quantile suffix should be preserved" + assert "myq_q0.500" in direct, "quantile suffix should be preserved" bt = mlflow.get_run(run_bt.info.run_id).data.metrics assert "backtest_custom" in bt @@ -1597,9 +1599,9 @@ def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): m = mlflow.get_run(run.info.run_id).data.metrics for key in ( - "backtest_mql_q0_100", - "backtest_mql_q0_500", - "backtest_mql_q0_900", + "backtest_mql_q0.100", + "backtest_mql_q0.500", + "backtest_mql_q0.900", ): assert key in m, f"Expected quantile key {key}" assert np.isfinite(m[key]) @@ -1879,7 +1881,7 @@ def test_infer_metric_axes_quantiles(): def test_infer_metric_axes_quantile_interval(): has_time, _, axis_labels = _infer_metric_axes(dm.iw, {"q_interval": (0.1, 0.9)}) - assert axis_labels == ["_qi_80.000"] + assert axis_labels == ["_qi0.800"] assert has_time is True @@ -1906,10 +1908,10 @@ def test_build_metric_keys_components_and_quantiles(): assert c_size == 4 assert keys == [ [ - "backtest_mae_temp_q0_100", - "backtest_mae_temp_q0_900", - "backtest_mae_hum_q0_100", - "backtest_mae_hum_q0_900", + "backtest_mae_temp_q0.100", + "backtest_mae_temp_q0.900", + "backtest_mae_hum_q0.100", + "backtest_mae_hum_q0.900", ], [ "backtest_f1_temp_label0", @@ -1930,7 +1932,7 @@ def test_build_metric_keys_no_components_no_prefix(): metric_axes=metric_axes, ) assert c_size == 1 - assert keys == [["mql_q0_500"]] + assert keys == [["mql_q0.500"]] def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 2d83136972..0efc8bf454 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -116,9 +116,9 @@ ``component_reduction=None``. - ``quantile_or_label``: - - the quantile label: e.g., ``"_q0_500"`` for quantile metrics with + - the quantile label: e.g., ``"_q0.500"`` for quantile metrics with keyword argument ``q=[0.5]`` - - the quantile interval label: e.g., ``"_qi_80_000"`` for quantile + - the quantile interval label: e.g., ``"_qi0.800"`` for quantile interval metrics with keyword argument ``q_interval=[(0.1, 0.9)]`` (80% interval between quantiles 0.1 and 0.9). - the class label: e.g., ``"_label1"`` for classification metrics with @@ -683,6 +683,7 @@ def _patched_fit(original, self, *args, **kwargs): registered_model_name=registered_model_name, model_id=model.model_id, ) + # TODO dennis: maybe let it fail naturally? except Exception: raise_log( ValueError( @@ -716,7 +717,7 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): bound = inspect.signature(original).bind(self, *args, **kwargs) bound.apply_defaults() - if bound.arguments["retrain"] is not True: + if bound.arguments["retrain"] is False: return result autologging_client = MlflowAutologgingQueueingClient() @@ -735,8 +736,9 @@ def _patched_historical_forecasts(original, self, *args, **kwargs): def _patched_backtest(original, self, *args, **kwargs): """Wrap ``backtest`` to log metric result(s) to the active MLflow run. - Delegates to ``_log_backtest_metrics``, which infers result shape from - the metric signature and logs every cell under a descriptive key. + Suppresses per-window metric logging. Delegates to ``_log_backtest_metrics``, + which infers result shape from the metric signature and logs every cell under + a descriptive key. """ _autolog_state.in_backtest = True try: @@ -763,7 +765,7 @@ def _patched_backtest(original, self, *args, **kwargs): autologging_client.flush(synchronous=False).await_completion() return result - # patch `fit()` for all forecasting models + # patch `fit()` to log model setup and model artifact for _, cls in _get_forecasting_models(): safe_patch( autologging_integration=FLAVOR_NAME, @@ -772,9 +774,8 @@ def _patched_backtest(original, self, *args, **kwargs): patch_function=_patched_fit, ) - # patch `historical_forecasts()` for all forecasting models so that the - # N internal fit() calls do not log themselves, and so that retrain=True calls - # log model setup once + # patch `historical_forecasts()` to log model setup only once (when retrain=True); + # suppresses internal fit() call logging for _, cls in _get_forecasting_models(): safe_patch( autologging_integration=FLAVOR_NAME, @@ -783,7 +784,8 @@ def _patched_backtest(original, self, *args, **kwargs): patch_function=_patched_historical_forecasts, ) - # patch `backtest()` for all forecasting models to log metric results + # patch `backtest()` to log backtest metrics once while suppressing per-window + # metric logging for _, cls in _get_forecasting_models(): safe_patch( autologging_integration=FLAVOR_NAME, @@ -833,6 +835,7 @@ def _infer_covariate_usage( """ # encoders can add past and future covariates encoders = _get_model_encoders(model) + first_series = get_single_series(series) uses_past = model.uses_past_covariates or ( model.supports_past_covariates @@ -923,8 +926,8 @@ def _log_series_info( ) -> None: """Log target series and covariate usage information to MLflow. - Extracts information about the target series, and about past, future, - and static covariates used during training and logs them as a JSON + Extracts information about the target series, past, future, and + static covariates used during training and logs them as a JSON artifact for easy filtering, comparison, and documentation. Logs: @@ -951,6 +954,9 @@ def _log_series_info( first_series = get_single_series(series) first_past_covariates = get_single_series(past_covariates) first_future_covariates = get_single_series(future_covariates) + first_static_covariates = ( + first_series.static_covariates if first_series is not None else None + ) uses_past, uses_future, uses_static = _infer_covariate_usage( model=model, series=series, @@ -958,44 +964,39 @@ def _log_series_info( future_covariates=future_covariates, ) + # if available, train encoders to get past and future encodings encoders = _get_model_encoders(model) if encoders.encoding_available: - first_past_covariates, first_future_covariates = encoders.encode_train( + _ = encoders.encode_train( target=first_series, past_covariates=first_past_covariates, future_covariates=first_future_covariates, ) series_info = { - "series": { - "count": first_series.n_components, - "names": first_series.components.tolist(), - }, - "past_covariates": _extract_covariate_metadata( + "series": _extract_data_metadata( + uses=True, + data=first_series, + names_attr="components", + ), + "past_covariates": _extract_data_metadata( uses=uses_past, - single_cov=first_past_covariates, + data=first_past_covariates, names_attr="components", + encodings=encoders.past_components, ), - "future_covariates": _extract_covariate_metadata( + "future_covariates": _extract_data_metadata( uses=uses_future, - single_cov=first_future_covariates, + data=first_future_covariates, names_attr="components", + encodings=encoders.future_components, + ), + "static_covariates": _extract_data_metadata( + uses=uses_static, + data=first_static_covariates, + names_attr="columns", ), } - static_covariates = ( - first_series.static_covariates if first_series is not None else None - ) - series_info["static_covariates"] = _extract_covariate_metadata( - uses=uses_static, - single_cov=static_covariates, - names_attr="columns", - ) - if uses_static and static_covariates is not None: - # static covariates are global (one shared row) unless there is one row - # per series component, in which case they are component-specific - series_info["static_covariates"]["is_global"] = ( - len(static_covariates) != first_series.n_components - ) # log complete information as JSON artifact mlflow.log_dict(series_info, "series_info.json") @@ -1017,37 +1018,44 @@ def _is_torch_model(model) -> bool: return TORCH_AVAILABLE and isinstance(model, TorchForecastingModel) -def _extract_covariate_metadata( +def _extract_data_metadata( uses: bool, - single_cov: TimeSeries | pd.DataFrame | None, + data: TimeSeries | pd.DataFrame | None, names_attr: str, + encodings: pd.Index | None = None, ) -> dict: - """Extract metadata for a single covariate type from its (already - singular) value. + """Extract data metadata. + + Encodings are logged under the "encodings" key since they are not part + of the input series. Parameters ---------- uses - Whether the model uses this covariate type. - single_cov - The covariate's value for one series: a ``TimeSeries`` (past/future - covariates) or a static-covariates ``DataFrame``, or ``None``. - names_attr : str + Whether the model uses this data type. + data + The data from a single series: a ``TimeSeries`` (target or past/future covariates) + or a static-covariates ``DataFrame``, or ``None``. + names_attr Attribute holding the feature names ("components" for a ``TimeSeries``, "columns" for a static-covariates ``DataFrame``). + encodings + The encodings for the data: a ``pd.Index`` of encoding names, or ``None``. Returns ------- dict Dictionary with keys: "used" (bool), "count" (int), "names" (list). """ - info = {"used": False, "count": 0, "names": []} + info = {"used": False, "count": 0, "names": [], "encodings": []} if uses: info["used"] = True - names = list(getattr(single_cov, names_attr)) if single_cov is not None else [] + names = list(getattr(data, names_attr)) if data is not None else [] info["names"] = names info["count"] = len(names) + if encodings is not None: + info["encodings"] = list(encodings) return info @@ -1055,9 +1063,9 @@ def _extract_covariate_metadata( def _sanitize_mlflow_key(name: str) -> str: """Sanitize a string for use as an MLflow metric key. - Replaces any character that is not alphanumeric, a hyphen, or an - underscore with an underscore, so component names become valid - MLflow keys. + Replaces any invalid character from the metric key. Valid keys may + only contain slashes, alphanumerics, underscores, periods, dashes, + and spaces. Parameters ---------- @@ -1069,7 +1077,7 @@ def _sanitize_mlflow_key(name: str) -> str: str A string safe for use as an MLflow metric key. """ - return re.sub(r"[^\w-]", "_", name) + return re.sub(r"[^/\w.\- ]", "_", name) def _get_model_encoders(model: ForecastingModel) -> SequentialEncoder: @@ -1122,32 +1130,31 @@ def _build_metric_keys( Returns ------- tuple[int, list[list[str]]] - ``(c_size, keys)`` where ``c_size`` is - ``(n_components if has_comp_axis else 1) * axis_size`` and ``keys[m][c]`` - is the sanitized key for metric ``m`` and flat component/axis index ``c``. + ``(n_scores, keys)`` where ``n_scores`` is + ``(n_components if has_comp_axis else 1) * n_labels`` and ``keys[m][c]`` + is the sanitized key for metric ``m`` and flat index ``c``. Flat index + ``c`` walks axis labels innermost, then components. """ - axis_size = len(metric_axes[0][2]) - c_size = (len(components) if has_comp_axis else 1) * axis_size + component_names = components if has_comp_axis else [None] + n_labels = len(metric_axes[0][2]) + n_scores = len(component_names) * n_labels + keys: list[list[str]] = [] - for m, metric_name in enumerate(metric_names): - axis_labels = metric_axes[m][2] - keys_m = [] - for c in range(c_size): - # c is a flat index into the (n_components x axis_size) C axis: - # c = comp_i * axis_size + axis_idx - component_index, axis_idx = divmod(c, axis_size) - comp_part = ( - "_" + _sanitize_mlflow_key(components[component_index]) - if has_comp_axis - else "" + for metric_idx, metric_name in enumerate(metric_names): + labels = metric_axes[metric_idx][2] + metric_keys: list[str] = [] + for component in component_names: + component_suffix = ( + f"_{_sanitize_mlflow_key(component)}" if component is not None else "" ) - keys_m.append( - _sanitize_mlflow_key( - f"{prefix}{metric_name}{comp_part}{axis_labels[axis_idx]}" + for label in labels: + metric_keys.append( + _sanitize_mlflow_key( + f"{prefix}{metric_name}{component_suffix}{label}" + ) ) - ) - keys.append(keys_m) - return c_size, keys + keys.append(metric_keys) + return n_scores, keys def _log_per_series_table(rows: list[dict]) -> None: @@ -1170,7 +1177,12 @@ def _log_per_series_table(rows: list[dict]) -> None: """ if not rows: return - df = pd.DataFrame(rows).sort_values(["key", "series_index", "step"]) + + df = pd.DataFrame(rows) + sort_by = ["key", "series_index", "step"] + if "window_index" in df.columns: + sort_by.append("window_index") + df = df.sort_values(sort_by) mlflow.log_table(data=df, artifact_file="metrics_per_series.json") @@ -1251,11 +1263,21 @@ def _log_backtest_metrics( must have the same number of components; names are taken from the first series. - Series can have different lengths and intersect in different ways, - so the time axis is aligned from the end rather than the start: a shorter - series lines up on its last value instead of its first. To represent this, - the time axis is mapped to the MLflow ``step`` as ``t - t_size`` when - ``has_time_axis`` is ``True``. + Series can have different lengths and intersect in different ways. + We align the time axis from the end rather than the start: a shorter + series lines up on its last value instead of its first. This is an + assumption which does not hold true for all cases (series can also end + at different times). + + The last step logged to MLflow represents the last window of each series. + There will be ``max_n_windows`` steps logged. Shorter series will not + contribute to the first steps. In the multi-series case, the values at the + same step are aggregated over all series. + + For time-dependent metrics (e.g. ``ae()``), the steps represent the + forecast horizon rather than backteset windows. There will be + ``forecast_horizon`` steps logged. In the multi-series case, the values at + the same step are aggregated over all series. Raises ------ @@ -1321,24 +1343,25 @@ def _log_backtest_metrics( has_time_axis, has_comp_axis, _ = metric_axes[0] series = backtest_args.get("series") + is_single_series = get_series_seq_type(series) == SeriesType.SINGLE + series = series2seq(series) + forecast_horizon = backtest_args.get("forecast_horizon") historical_forecasts = backtest_args.get("historical_forecasts") last_points_only = backtest_args.get("last_points_only", False) - # if last_points_only is True, has_windows will be False, so fc_hzn is not needed + # if last_points_only is True, has_windows will be False, so fc_hzn is not needed; + # otherwise, the forecast horizon is the length of one historical forecast if historical_forecasts is not None and not last_points_only: first_series_hf = ( - historical_forecasts - if get_series_seq_type(series) == SeriesType.SINGLE - else historical_forecasts[0] + historical_forecasts[0] if is_single_series else historical_forecasts[0][0] ) - forecast_horizon = len(first_series_hf[0]) + forecast_horizon = len(first_series_hf) - series_seq = series2seq(series) - results = [result] if get_series_seq_type(series) == SeriesType.SINGLE else result + results = [result] if is_single_series else result # component names are only used when the metric preserves components if has_comp_axis: - n_components = {s.n_components for s in series_seq} + n_components = {s.n_components for s in series} if len(n_components) > 1: raise_log( ValueError( @@ -1354,12 +1377,12 @@ def _log_backtest_metrics( rows: list[dict] = [] # component names/count from the first series (all series share n_components) - comps = series_seq[0].components.tolist() - c_size, base_keys = _build_metric_keys( - metric_names, - comps, - has_comp_axis, - metric_axes, + comps = series[0].components.tolist() + n_scores, base_keys = _build_metric_keys( + metric_names=metric_names, + components=comps, + has_comp_axis=has_comp_axis, + metric_axes=metric_axes, prefix="backtest_", ) @@ -1369,13 +1392,13 @@ def _log_backtest_metrics( for r in results: arr = np.asarray(r, dtype=float) # after stripping C and M axes, rest = W*T (or W or T alone) - rest, extra = divmod(arr.size, c_size * n_metrics) + rest, extra = divmod(arr.size, n_scores * n_metrics) if extra: raise_log( ValueError( f"Backtest metric logging failed: result size ({arr.size}) " - f"is not divisible by c_size * n_metrics ({c_size} * " - f"{n_metrics} = {c_size * n_metrics}). The metric output " + f"is not divisible by n_scores * n_metrics ({n_scores} * " + f"{n_metrics} = {n_scores * n_metrics}). The metric output " "shape does not match the inferred axes." ) ) @@ -1403,7 +1426,7 @@ def _log_backtest_metrics( series_shapes.append(( t_size, w_size, - arr.reshape(w_size, t_size, c_size, n_metrics), + arr.reshape(w_size, t_size, n_scores, n_metrics), )) # align the calendar-relative axes from the end @@ -1413,7 +1436,7 @@ def _log_backtest_metrics( for series_index, (t_size, w_size, canonical) in enumerate(series_shapes): w_offset = max_w_size - w_size if has_windows else 0 for m in range(n_metrics): - for c in range(c_size): + for c in range(n_scores): key = base_keys[m][c] if has_time_axis and has_windows: # Keep window-level values in the detailed table, but aggregate @@ -1457,7 +1480,7 @@ def _log_backtest_metrics( agg, agg_func=agg_func, table_rows=( - rows if len(series_seq) > 1 or (has_time_axis and has_windows) else None + rows if len(series) > 1 or (has_time_axis and has_windows) else None ), ) @@ -1507,7 +1530,7 @@ def effective(param_name: str) -> Any: q_interval, q = metric_kwargs.get("q_interval"), metric_kwargs.get("q") if "q_interval" in params and q_interval is not None: intervals = np.atleast_2d(np.array(q_interval, dtype=float)) - axis_labels = [f"_qi_{100 * (hi - lo):.3f}" for lo, hi in intervals] + axis_labels = [f"_qi{(hi - lo):.3f}" for lo, hi in intervals] elif "q" in params and q is not None: axis_labels = [f"_q{v:.3f}" for v in np.atleast_1d(np.array(q, dtype=float))] elif "label_reduction" in params and getattr(metric, "__name__", ""): @@ -1566,7 +1589,7 @@ def _log_metric_result( present: - ``component`` – ``_{component_name}`` when ``has_comp_axis``. - - ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi_80.000`` / ``_label1``. + - ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi0.800`` / ``_label1``. When more than one series is scored, the logged value is ``agg_func`` applied over series for each cell, and the granular per-series breakdown @@ -1636,7 +1659,7 @@ def _log_metric_result( # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() - c_size, base_keys = _build_metric_keys( + n_scores, base_keys = _build_metric_keys( [metric_name], comps, has_comp_axis, @@ -1650,13 +1673,13 @@ def _log_metric_result( for r in results: arr = np.asarray(r, dtype=float) # after stripping the C axis, the remainder is the time axis (or scalar) - n_times, extra = divmod(arr.size, c_size) + n_times, extra = divmod(arr.size, n_scores) if extra: raise_log( ValueError( f"Metric logging failed for `{metric_name}`: result size " f"({arr.size}) is not divisible by the inferred " - f"component/quantile size ({c_size}). The metric output " + f"component/quantile size ({n_scores}). The metric output " "shape does not match the inferred axes." ) ) @@ -1675,7 +1698,7 @@ def _log_metric_result( else: t_size = 1 - series_shapes.append((t_size, arr.reshape(t_size, c_size))) + series_shapes.append((t_size, arr.reshape(t_size, n_scores))) # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} @@ -1726,7 +1749,7 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: argument when provided (it overrides only this token). - ``component`` – ``_{component_name}`` when ``component_reduction=None``. - ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, - ``_qi_80.000``, ``_label1``) when applicable. + ``_qi0.800``, ``_label1``) when applicable. When the input is a ``Sequence[TimeSeries]`` with more than one series, the logged value is ``autolog()``'s ``agg_func`` applied over series, and the From 2a340bf42693232a944c015bcc60e5a8f5127214 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 20 Aug 2026 16:32:17 +0200 Subject: [PATCH 143/154] refactor backtest flow --- darts/tests/optional_deps/test_mlflow.py | 39 +- darts/utils/mlflow.py | 651 +++++++++++++---------- 2 files changed, 403 insertions(+), 287 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index dc0fb796e9..7765591e48 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1550,7 +1550,8 @@ def test_autolog_backtest_per_timestep_per_window( assert len(rows) == ref.size for row in rows: assert row["key"] == "backtest_ae" - assert row["window_index"] in range(-len(ref), 0) + assert row["window_index"] in range(len(ref)) + assert {int(r["window_index"]) for r in rows} == set(range(len(ref))) def test_autolog_backtest_historical_forecasts_horizon_inferred( self, mlflow_tracking, autolog_context @@ -1772,9 +1773,10 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): """A shorter series' window axis aligns from the end, not the start, - so its negative steps overlap the tail of a longer series. Calls - _log_backtest_metrics directly with a fabricated result so the window - counts per series are exact.""" + so its last windows overlap the tail of a longer series. Steps and + ``window_index`` are ``0 .. max_w - 1``. Calls _log_backtest_metrics + directly with a fabricated result so the window counts per series + are exact.""" backtest_args = { "metric": dm.mae, "metric_kwargs": {}, @@ -1803,13 +1805,16 @@ def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): assert by_step[(1, 4)] == pytest.approx(30.0) assert (1, 0) not in by_step assert (1, 1) not in by_step + for r in rows: + assert r["window_index"] == r["step"] def test_log_backtest_metrics_aligns_last_points_only_time_axis( self, mlflow_tracking ): """last_points_only stitches windows into one series scored per real - timestep -- a separate code path from the window-axis case above that - needs the same end-date alignment.""" + timestep. Shorter series align from the end, same as the window-axis + case, with steps ``0 .. t_max - 1`` rather than end-relative indexes. + """ backtest_args = { "metric": dm.ae, "metric_kwargs": {}, @@ -1828,7 +1833,17 @@ def test_log_backtest_metrics_aligns_last_points_only_time_axis( history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") logged = {m.step: m.value for m in history} - assert logged == pytest.approx({-5: 1.0, -4: 2.0, -3: 6.5, -2: 12.0, -1: 17.5}) + assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) + + rows = self._read_per_series_table(run.info.run_id) + by_step = {(r["series_index"], r["step"]): r["value"] for r in rows} + assert by_step[(0, 0)] == pytest.approx(1.0) + assert by_step[(0, 4)] == pytest.approx(5.0) + assert by_step[(1, 2)] == pytest.approx(10.0) + assert by_step[(1, 4)] == pytest.approx(30.0) + assert (1, 0) not in by_step + assert (1, 1) not in by_step + assert all(pd.isna(r["window_index"]) for r in rows) @staticmethod def _read_per_series_table(run_id): @@ -1898,15 +1913,16 @@ def test_build_metric_keys_components_and_quantiles(): (False, True, ["_q0.100", "_q0.900"]), (False, True, ["_label0", "_label1"]), ] - c_size, keys = _build_metric_keys( + metric_keys = _build_metric_keys( ["mae", "f1"], ["temp", "hum"], has_comp_axis=True, metric_axes=metric_axes, prefix="backtest_", ) + c_size = len(metric_keys[0]) assert c_size == 4 - assert keys == [ + assert metric_keys == [ [ "backtest_mae_temp_q0.100", "backtest_mae_temp_q0.900", @@ -1925,14 +1941,15 @@ def test_build_metric_keys_components_and_quantiles(): def test_build_metric_keys_no_components_no_prefix(): """Without components, each metric gets one key per axis label.""" metric_axes = [(False, False, ["_q0.500"])] - c_size, keys = _build_metric_keys( + metric_keys = _build_metric_keys( ["mql"], ["ignored"], has_comp_axis=False, metric_axes=metric_axes, ) + c_size = len(metric_keys[0]) assert c_size == 1 - assert keys == [["mql_q0.500"]] + assert metric_keys == [["mql_q0.500"]] def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 0efc8bf454..22be3e3063 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -1103,123 +1103,6 @@ def _get_model_encoders(model: ForecastingModel) -> SequentialEncoder: return model.encoders -def _build_metric_keys( - metric_names: list[str], - components: list[str], - has_comp_axis: bool, - metric_axes: list[tuple[bool, bool, list[str]]], - *, - prefix: str = "", -) -> tuple[int, list[list[str]]]: - """Build sanitized MLflow metric keys for each metric x component x axis label. - - Parameters - ---------- - metric_names - One sanitized metric-name token per metric. - components - Component names from the first series (used only when ``has_comp_axis``). - has_comp_axis - Whether components are preserved in the metric output. - metric_axes - Per-metric ``(has_time_axis, has_comp_axis, axis_labels)`` tuples from - ``_infer_metric_axes``. Axis size is taken from the first entry. - prefix - Optional key prefix (e.g. ``"backtest_"``). - - Returns - ------- - tuple[int, list[list[str]]] - ``(n_scores, keys)`` where ``n_scores`` is - ``(n_components if has_comp_axis else 1) * n_labels`` and ``keys[m][c]`` - is the sanitized key for metric ``m`` and flat index ``c``. Flat index - ``c`` walks axis labels innermost, then components. - """ - component_names = components if has_comp_axis else [None] - n_labels = len(metric_axes[0][2]) - n_scores = len(component_names) * n_labels - - keys: list[list[str]] = [] - for metric_idx, metric_name in enumerate(metric_names): - labels = metric_axes[metric_idx][2] - metric_keys: list[str] = [] - for component in component_names: - component_suffix = ( - f"_{_sanitize_mlflow_key(component)}" if component is not None else "" - ) - for label in labels: - metric_keys.append( - _sanitize_mlflow_key( - f"{prefix}{metric_name}{component_suffix}{label}" - ) - ) - keys.append(metric_keys) - return n_scores, keys - - -def _log_per_series_table(rows: list[dict]) -> None: - """Append the granular per-series metric breakdown to a single, run-wide - table artifact. - - Each row is a single metric cell for one series, with columns ``key`` (the - aggregate MLflow key, without any series suffix), ``series_index``, ``step`` - (the time or window index charted by MLflow), ``window_index`` (the source - backtest window, or ``None``), and ``value``. All calls within a run append - to the same ``metrics_per_series.json`` artifact. - Used when more than one series is scored, since the logged metric keys - only carry the aggregate over series. - - Parameters - ---------- - rows - One dict per metric cell with keys ``key``, ``series_index``, ``step``, - ``window_index``, and ``value``. - """ - if not rows: - return - - df = pd.DataFrame(rows) - sort_by = ["key", "series_index", "step"] - if "window_index" in df.columns: - sort_by.append("window_index") - df = df.sort_values(sort_by) - mlflow.log_table(data=df, artifact_file="metrics_per_series.json") - - -def _flush_logged_metrics( - autologging_client: MlflowAutologgingQueueingClient, - run_id: str, - agg: dict[tuple[str, int], list[float]], - agg_func: Callable, - table_rows: list[dict] | None = None, -) -> None: - """Aggregate per-series cells, log MLflow metrics, and optionally write the - per-series table artifact. - - Parameters - ---------- - autologging_client - MLflow autologging client used to queue metric writes. - run_id - ID of the active MLflow run. - agg - Map of ``(key, step) -> list of per-series float values``. - agg_func - Aggregation over the per-series values for each ``(key, step)``. - table_rows - Granular cells for ``metrics_per_series.json``. ``None`` skips writing - the table artifact. - """ - metrics_by_step: dict[int, dict[str, float]] = {} - for (key, step), values in agg.items(): - metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) - for step, metrics in metrics_by_step.items(): - autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) - - if table_rows is not None: - _log_per_series_table(table_rows) - - def _log_backtest_metrics( autologging_client: MlflowAutologgingQueueingClient, run_id: str, @@ -1303,63 +1186,22 @@ def _log_backtest_metrics( single value logged for a list of series. Called as ``agg_func(values)`` on a list of floats. """ - metric = backtest_args.get("metric") - metric = metric if isinstance(metric, list) else [metric] - metric_kwargs = backtest_args.get("metric_kwargs") or {} - metric_kwargs = ( - metric_kwargs if isinstance(metric_kwargs, list) else [metric_kwargs] - ) - # backtest accepts a single dict that applies to all metrics; broadcast it - if len(metric_kwargs) != len(metric): - metric_kwargs = [metric_kwargs[0]] * len(metric) - # the `name` entry in metric_kwargs overrides the metric-name token in the key - metric_names = [ - _sanitize_mlflow_key( - metric_kwargs[i].get("name") or getattr(m, "__name__", f"metric_{i}") - ) - for i, m in enumerate(metric) - ] - n_metrics = len(metric) - - # reduction=None means no aggregation across windows -> one value per window. - # last_points_only collapses all windows into one TimeSeries before scoring, - # so there is effectively only one window regardless of reduction. - has_windows = backtest_args.get("reduction") is None and not backtest_args.get( - "last_points_only", False - ) - - # series_reduction inside the metric itself already aggregates across windows, - # so the result has no window axis even when backtest.reduction is None. - metric_0_params = inspect.signature(metric[0]).parameters - if "series_reduction" in metric_0_params: - effective_sr = metric_kwargs[0].get( - "series_reduction", metric_0_params["series_reduction"].default - ) - if effective_sr is not None: - has_windows = False - - # check the dim axes from the metric kwargs for each - metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metric, metric_kwargs)] + metrics, metric_kwargs, metric_names = _normalize_backtest_metrics(backtest_args) + metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metrics, metric_kwargs)] has_time_axis, has_comp_axis, _ = metric_axes[0] series = backtest_args.get("series") is_single_series = get_series_seq_type(series) == SeriesType.SINGLE series = series2seq(series) + results = [result] if is_single_series else result - forecast_horizon = backtest_args.get("forecast_horizon") - historical_forecasts = backtest_args.get("historical_forecasts") - last_points_only = backtest_args.get("last_points_only", False) - - # if last_points_only is True, has_windows will be False, so fc_hzn is not needed; - # otherwise, the forecast horizon is the length of one historical forecast - if historical_forecasts is not None and not last_points_only: - first_series_hf = ( - historical_forecasts[0] if is_single_series else historical_forecasts[0][0] - ) - forecast_horizon = len(first_series_hf) + has_windows, forecast_horizon = _resolve_backtest_layout( + backtest_args, + metrics[0], + metric_kwargs[0], + is_single_series, + ) - results = [result] if is_single_series else result - # component names are only used when the metric preserves components if has_comp_axis: n_components = {s.n_components for s in series} if len(n_components) > 1: @@ -1372,120 +1214,115 @@ def _log_backtest_metrics( ) ) - # agg maps (key, step) -> per-series values, aggregated into the logged metric. - agg: dict[tuple[str, int], list[float]] = {} - rows: list[dict] = [] - # component names/count from the first series (all series share n_components) - comps = series[0].components.tolist() - n_scores, base_keys = _build_metric_keys( + metric_keys = _build_metric_keys( metric_names=metric_names, - components=comps, + components=series[0].components.tolist(), has_comp_axis=has_comp_axis, metric_axes=metric_axes, prefix="backtest_", ) + series_metrics = [ + _reshape_backtest_result( + series=series_, + result=r, + metric_keys=metric_keys, + has_time_axis=has_time_axis, + has_windows=has_windows, + forecast_horizon=forecast_horizon, + ) + for series_, r in zip(series, results) + ] + stepped_metrics, detailed_metrics = _collect_stepped_and_detailed_metrics( + series_metrics=series_metrics, + metric_keys=metric_keys, + has_time_axis=has_time_axis, + has_windows=has_windows, + ) - # first pass: reshape each series' result into a canonical (W, T, C, M) - # array, recording its window-axis length for the alignment pass below. - series_shapes = [] - for r in results: - arr = np.asarray(r, dtype=float) - # after stripping C and M axes, rest = W*T (or W or T alone) - rest, extra = divmod(arr.size, n_scores * n_metrics) - if extra: - raise_log( - ValueError( - f"Backtest metric logging failed: result size ({arr.size}) " - f"is not divisible by n_scores * n_metrics ({n_scores} * " - f"{n_metrics} = {n_scores * n_metrics}). The metric output " - "shape does not match the inferred axes." - ) - ) + write_table = len(series) > 1 or (has_time_axis and has_windows) + _flush_logged_metrics( + autologging_client, + run_id, + stepped_metrics, + agg_func=agg_func, + table_rows=detailed_metrics if write_table else None, + ) - # both time and window axes present: backtest returns (W*T*C*M,) in C order so we can - # recover W and T only if forecast_horizon is known (T = forecast_horizon) - if has_time_axis and has_windows: - t_size, w_size = forecast_horizon, rest // forecast_horizon - elif has_time_axis: - t_size, w_size = rest, 1 - elif has_windows: - t_size, w_size = 1, rest - else: - if rest != 1: - raise_log( - ValueError( - f"Backtest metric logging failed: expected a single " - f"scalar per component/metric after reduction, but got " - f"{rest} elements. Check time_reduction and " - "component_reduction defaults." - ) - ) - t_size, w_size = 1, 1 - series_shapes.append(( - t_size, - w_size, - arr.reshape(w_size, t_size, n_scores, n_metrics), - )) +def _normalize_backtest_metrics( + backtest_args: dict, +) -> tuple[list, list[dict], list[str]]: + """Normalize ``metric`` / ``metric_kwargs`` to parallel lists and key names. - # align the calendar-relative axes from the end - max_w_size = max((w_size for _, w_size, _ in series_shapes), default=0) - t_axis_is_calendar = has_time_axis and not has_windows and last_points_only + ``backtest()`` accepts a single metric or a list, and a single kwargs + dict (broadcast to all metrics) or a list of dicts. A ``name`` entry in + ``metric_kwargs`` overrides the metric-name token in the MLflow key. + """ + metrics = backtest_args.get("metric") + metrics = metrics if isinstance(metrics, list) else [metrics] + metric_kwargs = backtest_args.get("metric_kwargs") or {} + metric_kwargs = ( + metric_kwargs if isinstance(metric_kwargs, list) else [metric_kwargs] + ) + if len(metric_kwargs) != len(metrics): + metric_kwargs = [metric_kwargs[0]] * len(metrics) - for series_index, (t_size, w_size, canonical) in enumerate(series_shapes): - w_offset = max_w_size - w_size if has_windows else 0 - for m in range(n_metrics): - for c in range(n_scores): - key = base_keys[m][c] - if has_time_axis and has_windows: - # Keep window-level values in the detailed table, but aggregate - # windows into one chart value per horizon step for this series. - for t in range(t_size): - values = canonical[:, t, c, m] - agg.setdefault((key, t), []).append(float(np.nanmean(values))) - for w, value in enumerate(values): - window_index = w + w_offset - rows.append({ - "key": key, - "series_index": series_index, - "step": t, - "window_index": window_index - max_w_size, - "value": float(value), - }) - continue + metric_names = [ + _sanitize_mlflow_key( + metric_kwargs[i].get("name") or getattr(m, "__name__", f"metric_{i}") + ) + for i, m in enumerate(metrics) + ] + return metrics, metric_kwargs, metric_names - for w in range(w_size): - aligned_w = w + w_offset - for t in range(t_size): - # MLflow step maps to the axis the UI should chart: - # horizon when present, otherwise end-relative calendar axis - if has_time_axis: - step = t - t_size if t_axis_is_calendar else t - else: - step = aligned_w - value = float(canonical[w, t, c, m]) - agg.setdefault((key, step), []).append(value) - rows.append({ - "key": key, - "series_index": series_index, - "step": step, - "window_index": None, - "value": value, - }) - _flush_logged_metrics( - autologging_client, - run_id, - agg, - agg_func=agg_func, - table_rows=( - rows if len(series) > 1 or (has_time_axis and has_windows) else None - ), - ) +def _resolve_backtest_layout( + backtest_args: dict, + metric: Callable, + metric_kwargs: dict, + is_single_series: bool, +) -> tuple[bool, int | None]: + """Infer whether a window axis is present and the forecast horizon. + + A window axis is present only when backtest did not aggregate windows + (``reduction is None``), forecasts were not concatenated first + (``last_points_only`` is false), and the metric's own + ``series_reduction`` did not already collapse windows. + + When the caller passed ``historical_forecasts``, ``backtest()`` ignores + ``forecast_horizon``, so the horizon is read from the first forecast. + + Returns + ------- + tuple + ``(has_windows, forecast_horizon)``. + """ + last_points_only = backtest_args.get("last_points_only", False) + has_windows = backtest_args.get("reduction") is None and not last_points_only + + params = inspect.signature(metric).parameters + if has_windows and "series_reduction" in params: + series_reduction = metric_kwargs.get( + "series_reduction", params["series_reduction"].default + ) + if series_reduction is not None: + has_windows = False + + forecast_horizon = backtest_args.get("forecast_horizon") + historical_forecasts = backtest_args.get("historical_forecasts") + if historical_forecasts is not None and not last_points_only: + first_forecast = ( + historical_forecasts[0] if is_single_series else historical_forecasts[0][0] + ) + forecast_horizon = len(first_forecast) + return has_windows, forecast_horizon -def _infer_metric_axes(metric: Callable, metric_kwargs: dict) -> tuple: + +def _infer_metric_axes( + metric: Callable, metric_kwargs: dict +) -> tuple[bool, bool, list[str]]: """Infer a metric's output axes from its signature and ``metric_kwargs``. Covers ``time_reduction``, ``component_reduction``, ``q``, ``q_interval``, @@ -1533,7 +1370,7 @@ def effective(param_name: str) -> Any: axis_labels = [f"_qi{(hi - lo):.3f}" for lo, hi in intervals] elif "q" in params and q is not None: axis_labels = [f"_q{v:.3f}" for v in np.atleast_1d(np.array(q, dtype=float))] - elif "label_reduction" in params and getattr(metric, "__name__", ""): + elif "label_reduction" in params: label_reduction = effective("label_reduction") if isinstance(label_reduction, _LabelReduction): label_reduction = label_reduction.value @@ -1556,7 +1393,268 @@ def effective(param_name: str) -> Any: else: axis_labels = [""] - return (has_time_axis, has_comp_axis, axis_labels) + return has_time_axis, has_comp_axis, axis_labels + + +def _build_metric_keys( + metric_names: list[str], + components: list[str], + has_comp_axis: bool, + metric_axes: list[tuple[bool, bool, list[str]]], + *, + prefix: str = "", +) -> list[list[str]]: + """Build sanitized MLflow metric keys for each metric x component x axis label. + + Parameters + ---------- + metric_names + One sanitized metric-name token per metric. + components + Component names from the first series (used only when ``has_comp_axis``). + has_comp_axis + Whether components are preserved in the metric output. + metric_axes + Per-metric ``(has_time_axis, has_comp_axis, axis_labels)`` tuples from + ``_infer_metric_axes``. Axis size is taken from the first entry. + prefix + Optional key prefix (e.g. ``"backtest_"``). + + Returns + ------- + list[list[str]] + A list of lists of metric keys, where each inner list contains the sub-metric + keys for a single metric. ``keys[m][i]`` is the sanitized key for metric index + ``m`` and sub-metric index ``i``. Sub-metric index ``i`` is the component-label + index walking axis labels innermost, then components (e.g. ``[_q0.100_comp1, + _q0.900_comp1, _q0.100_comp2, _q0.900_comp2]``). + """ + component_names = components if has_comp_axis else [None] + + metric_keys: list[list[str]] = [] + for metric_idx, metric_name in enumerate(metric_names): + labels = metric_axes[metric_idx][2] + sub_metric_keys: list[str] = [] + for component in component_names: + component_suffix = ( + f"_{_sanitize_mlflow_key(component)}" if component is not None else "" + ) + for label in labels: + sub_metric_keys.append( + _sanitize_mlflow_key( + f"{prefix}{metric_name}{component_suffix}{label}" + ) + ) + metric_keys.append(sub_metric_keys) + return metric_keys + + +def _reshape_backtest_result( + series: TimeSeries, + result, + *, + metric_keys: list[list[str]], + has_time_axis: bool, + has_windows: bool, + forecast_horizon: int | None, +) -> np.ndarray: + """Reshape one series' backtest result to canonical ``(W, T, C, M)``. + + - ``C`` is ``n_sub_metrics`` (n_components * n_quantiles/n_labels) + - ``M`` is ``n_metrics`` + - ``T`` is ``1`` if not present, and otherwise the ``forecast_horizon`` or + the length of the series (with ``last_points_only=True``). + - ``W`` is ``1`` if not present, and otherwise the number of windows + + After stripping the ``C`` and ``M`` axes, the leftover element count is split into + ``(t_size, w_size)``: + + - time axis and windows: ``T = forecast_horizon``, ``W = rest / T`` + - time axis only: ``T = rest``, ``W = 1`` + - windows only: ``T = 1``, ``W = rest`` + - neither: ``T = W = 1`` (``rest`` must be 1) + + Returns + ------- + np.ndarray + Series metric values with shape ``(W, T, C, M)``. + """ + arr = np.asarray(result, dtype=series.dtype) + n_metrics = len(metric_keys) + n_sub_metrics = len(metric_keys[0]) + n_round_multiples, remainder = divmod(arr.size, n_sub_metrics * n_metrics) + if remainder: + raise_log( + ValueError( + f"Backtest metric logging failed: result size ({arr.size}) " + f"is not divisible by n_sub_metrics * n_metrics ({n_sub_metrics} * " + f"{n_metrics} = {n_sub_metrics * n_metrics}). The metric output " + "shape does not match the inferred axes." + ) + ) + + if has_time_axis and has_windows: + # T is the forecast horizon; W is recovered from the leftover length; + # time-dependent metrics + last_points_only=False + no reduction + assert forecast_horizon is not None + t_size, w_size = forecast_horizon, n_round_multiples // forecast_horizon + elif has_time_axis: + # time-dependent metrics + last_points_only=False + reduction + t_size, w_size = n_round_multiples, 1 + elif has_windows: + # time-aggregated metrics + last_points_only=False + no reduction + t_size, w_size = 1, n_round_multiples + elif n_round_multiples == 1: + # time-aggregated metrics + reduction + t_size, w_size = 1, 1 + else: + raise_log( + ValueError( + f"Backtest metric logging failed: expected a single " + f"scalar per component/metric after reduction, but got " + f"{n_round_multiples} elements. Check time_reduction and " + "component_reduction defaults." + ) + ) + + return arr.reshape(w_size, t_size, n_sub_metrics, n_metrics) + + +def _collect_stepped_and_detailed_metrics( + series_metrics: list[np.ndarray], + metric_keys: list[list[str]], + *, + has_time_axis: bool, + has_windows: bool, +) -> tuple[dict[tuple[str, int], list[float]], list[dict]]: + """Parse series metrics and build inputs for MLflow stepped metrics and detailed metric table. + + Each ``series_metrics`` array has shape ``(w_size, t_size, n_metrics * n_sub_metrics)``. + Shorter series are aligned from the end of the longest remaining axis (windows, + or time when there is no window axis). + + The MLflow ``step`` is the axis the UI should chart, always ``0 .. n-1``: + + - forecast-horizon index when a time axis is present (time-dependent metrics) + - if windows are present: each horizon step is aggregated over the windows + - if multi-series: each horizon step is aggregated over the series + - end-aligned window index otherwise (time-aggregated metrics) + - if multi-series: each window is aggregated over the series (end-aligned) + """ + stepped_metrics: dict[tuple[str, int], list[float]] = {} + detailed_metrics: list[dict] = [] + + w_axis, t_axis = 0, 1 + max_w_size = max((values.shape[w_axis] for values in series_metrics), default=0) + max_t_size = max((values.shape[t_axis] for values in series_metrics), default=0) + + for series_index, values in enumerate(series_metrics): + w_size = values.shape[w_axis] + t_size = values.shape[t_axis] + # pad shorter series so their last point lines up with the longest + w_offset = max_w_size - w_size if has_windows else 0 + t_offset = max_t_size - t_size if has_time_axis and not has_windows else 0 + + window_agg = np.nanmean(values, axis=w_axis) + for metric_idx, sub_metric_keys in enumerate(metric_keys): + for sub_metric_idx, key in enumerate(sub_metric_keys): + for w in range(w_size): + window_index = w + w_offset if has_windows else None + for t in range(t_size): + value = float(values[w, t, sub_metric_idx, metric_idx]) + if has_time_axis and has_windows: + # time-dependent metrics + last_points_only=False + no reduction + step = t + + # stepped metric chart: one value per horizon (windows averaged) + if w == 0: + stepped_metrics.setdefault((key, step), []).append( + float(window_agg[t, sub_metric_idx, metric_idx]) + ) + else: + if has_time_axis: + # time-dependent metrics + last_points_only=False + reduction + step = t + t_offset + else: + step = window_index + + # stepped metric chart: one value per window or horizon + stepped_metrics.setdefault((key, step), []).append(value) + + # table: one value per window and horizon + detailed_metrics.append({ + "key": key, + "series_index": series_index, + "step": step, + "window_index": window_index, + "value": value, + }) + + return stepped_metrics, detailed_metrics + + +def _flush_logged_metrics( + autologging_client: MlflowAutologgingQueueingClient, + run_id: str, + agg: dict[tuple[str, int], list[float]], + agg_func: Callable, + table_rows: list[dict] | None = None, +) -> None: + """Aggregate per-series cells, log MLflow metrics, and optionally write the + per-series table artifact. + + Parameters + ---------- + autologging_client + MLflow autologging client used to queue metric writes. + run_id + ID of the active MLflow run. + agg + Map of ``(key, step) -> list of per-series float values``. + agg_func + Aggregation over the per-series values for each ``(key, step)``. + table_rows + Granular cells for ``metrics_per_series.json``. ``None`` skips writing + the table artifact. + """ + metrics_by_step: dict[int, dict[str, float]] = {} + for (key, step), values in agg.items(): + metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) + for step, metrics in metrics_by_step.items(): + autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + + if table_rows is not None: + _log_per_series_table(table_rows) + + +def _log_per_series_table(rows: list[dict]) -> None: + """Append the granular per-series metric breakdown to a single, run-wide + table artifact. + + Each row is a single metric cell for one series, with columns ``key`` (the + aggregate MLflow key, without any series suffix), ``series_index``, ``step`` + (the time or window index charted by MLflow), ``window_index`` (the + end-aligned source backtest window ``0 .. max_w - 1``, or ``None`` when + there is no window axis), and ``value``. All calls within a run append + to the same ``metrics_per_series.json`` artifact. + Used when more than one series is scored, since the logged metric keys + only carry the aggregate over series. + + Parameters + ---------- + rows + One dict per metric cell with keys ``key``, ``series_index``, ``step``, + ``window_index``, and ``value``. + """ + if not rows: + return + + df = pd.DataFrame(rows) + sort_by = ["key", "series_index", "step"] + if "window_index" in df.columns: + sort_by.append("window_index") + df = df.sort_values(sort_by) + mlflow.log_table(data=df, artifact_file="metrics_per_series.json") def _log_metric_result( @@ -1659,27 +1757,28 @@ def _log_metric_result( # component names/count from the first series (all series share n_components) comps = series_seq[0].components.tolist() - n_scores, base_keys = _build_metric_keys( + metric_keys = _build_metric_keys( [metric_name], comps, has_comp_axis, [(has_time_axis, has_comp_axis, axis_labels)], ) - keys = base_keys[0] + sub_metric_keys = metric_keys[0] + n_sub_metrics = len(sub_metric_keys) # first pass: reshape each series' result into a canonical (T, C) array, # recording its time-axis length for the alignment pass below. - series_shapes = [] + series_metrics = [] for r in results: arr = np.asarray(r, dtype=float) # after stripping the C axis, the remainder is the time axis (or scalar) - n_times, extra = divmod(arr.size, n_scores) + n_times, extra = divmod(arr.size, n_sub_metrics) if extra: raise_log( ValueError( f"Metric logging failed for `{metric_name}`: result size " f"({arr.size}) is not divisible by the inferred " - f"component/quantile size ({n_scores}). The metric output " + f"component/quantile size ({n_sub_metrics}). The metric output " "shape does not match the inferred axes." ) ) @@ -1698,13 +1797,13 @@ def _log_metric_result( else: t_size = 1 - series_shapes.append((t_size, arr.reshape(t_size, n_scores))) + series_metrics.append((t_size, arr.reshape(t_size, n_sub_metrics))) # agg maps (key, step) -> per-series values, aggregated into the logged metric. agg: dict[tuple[str, int], list[float]] = {} rows: list[dict] = [] - for series_index, (t_size, canonical) in enumerate(series_shapes): - for c, key in enumerate(keys): + for series_index, (t_size, canonical) in enumerate(series_metrics): + for c, key in enumerate(sub_metric_keys): for t in range(t_size): # Forecast positions are zero-based: the first prediction is 0. step = t if has_time_axis else 0 From 86beb936ed30fcd3afb9e096a31aa4cb9ff15ddc Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 21 Aug 2026 15:36:21 +0200 Subject: [PATCH 144/154] refactor metric flow --- darts/tests/optional_deps/test_mlflow.py | 8 +- darts/utils/mlflow.py | 563 +++++++++++------------ 2 files changed, 280 insertions(+), 291 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 7765591e48..b78724a1f5 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1095,17 +1095,17 @@ def test_autolog_metric_aligns_time_axis_by_forecast_position( history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") by_step = {m.step: m.value for m in history} assert len(by_step) == 50 - for step in range(40): - assert by_step[step] == pytest.approx(1.5, abs=1e-4), step - for step in range(40, 50): + for step in range(10): assert by_step[step] == pytest.approx(1.0, abs=1e-4), step + for step in range(10, 50): + assert by_step[step] == pytest.approx(1.5, abs=1e-4), step rows = self._read_per_series_table(run.info.run_id) steps_by_series = {0: set(), 1: set()} for r in rows: steps_by_series[r["series_index"]].add(r["step"]) assert steps_by_series[0] == set(range(50)) - assert steps_by_series[1] == set(range(40)) + assert steps_by_series[1] == set(range(10, 50)) def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile with matching values.""" diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 22be3e3063..1b9054740b 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -795,6 +795,85 @@ def _patched_backtest(original, self, *args, **kwargs): ) +def _mlflow_metric_callback(func, result, args, kwargs) -> None: + """Metric callback registered with ``darts.metrics.utils`` for autologging. + + Invoked by ``multi_ts_support`` (the outermost decorator on every Darts + metric) after every top-level metric call, so it fires regardless of how + the metric was imported. It is not invoked for internal metric-to-metric + calls (e.g. ``rmse`` calling ``mse`` internally via ``_get_wrapped_metric``), + since those bypass ``multi_ts_support`` entirely. + + When an active MLflow run exists, infers the output axes from the metric + signature and call kwargs (via ``_infer_metric_axes``) and delegates to + ``_log_standalone_metric``, which logs each cell under a key built as:: + + {metric_name}{component}{quantile_or_label} + + where: + + - ``metric_name`` – the metric function name, or the ``name`` keyword + argument when provided (it overrides only this token). + - ``component`` – ``_{component_name}`` when ``component_reduction=None``. + - ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, + ``_qi0.800``, ``_label1``) when applicable. + + When the input is a ``Sequence[TimeSeries]`` with more than one series, the + logged value is ``autolog()``'s ``agg_func`` applied over series, and the + per-series breakdown is appended to the run's ``metrics_per_series.json`` + table artifact instead of per-series keys. + + The per-timestep axis (``time_reduction=None``) is mapped to the MLflow + ``step``. + + Parameters + ---------- + func + The Darts metric function that was called (used for its name and + signature). + result + The metric's return value. + args + Positional arguments the metric was called with. + kwargs + Keyword arguments the metric was called with. + """ + active_run = mlflow.active_run() + if active_run is None: + return + + # backtest() calls metric functions internally; _patched_backtest + # handles logging the aggregated result, so skip here to avoid + # generating one flat key per window (series_gen_mape_0, _1, …). + if getattr(_autolog_state, "in_backtest", False): + return + + func_signature = inspect.signature(func) + bound = func_signature.bind( + *args, **{k: v for k, v in kwargs.items() if k in func_signature.parameters} + ) + bound.apply_defaults() + metric_args = bound.arguments + + # _mlflow_metric_callback is a bare registered callback, not a closure over + # autolog()'s call kwargs, so agg_func is read back from the autologging + # config store that autolog() populated. + agg_func = get_autologging_config( + flavor_name=FLAVOR_NAME, config_key="agg_func", default_value=np.mean + ) + + autologging_client = MlflowAutologgingQueueingClient() + _log_standalone_metric( + autologging_client=autologging_client, + run_id=active_run.info.run_id, + result=result, + metric=func, + metric_args=metric_args, + agg_func=agg_func, + ) + autologging_client.flush(synchronous=False).await_completion() + + def get_default_pip_requirements(): """Return the default pip requirements for logging a Darts model. @@ -1140,7 +1219,7 @@ def _log_backtest_metrics( When more than one series is scored, the logged value is ``agg_func`` applied over series for each cell, and the granular per-series breakdown is appended to the run's ``metrics_per_series.json`` table artifact - (shared with ``_log_metric_result``). For a single series the aggregate + (shared with ``_log_standalone_metric``). For a single series the aggregate is just the value itself and no artifact is written. When components are preserved (``component_reduction=None``), all series scored together must have the same number of components; names are taken from the first @@ -1186,7 +1265,10 @@ def _log_backtest_metrics( single value logged for a list of series. Called as ``agg_func(values)`` on a list of floats. """ - metrics, metric_kwargs, metric_names = _normalize_backtest_metrics(backtest_args) + metrics, metric_kwargs, metric_names = _normalize_metrics( + metrics=backtest_args["metric"], + metric_kwargs=backtest_args["metric_kwargs"] or dict(), + ) metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metrics, metric_kwargs)] has_time_axis, has_comp_axis, _ = metric_axes[0] @@ -1195,13 +1277,6 @@ def _log_backtest_metrics( series = series2seq(series) results = [result] if is_single_series else result - has_windows, forecast_horizon = _resolve_backtest_layout( - backtest_args, - metrics[0], - metric_kwargs[0], - is_single_series, - ) - if has_comp_axis: n_components = {s.n_components for s in series} if len(n_components) > 1: @@ -1222,16 +1297,24 @@ def _log_backtest_metrics( metric_axes=metric_axes, prefix="backtest_", ) + + has_windows, forecast_horizon = _resolve_backtest_layout( + backtest_args=backtest_args, + metric=metrics[0], + metric_kwargs=metric_kwargs[0], + is_single_series=is_single_series, + ) series_metrics = [ - _reshape_backtest_result( + _reshape_metric_result( series=series_, result=r, metric_keys=metric_keys, has_time_axis=has_time_axis, has_windows=has_windows, forecast_horizon=forecast_horizon, + is_backtest=True, ) - for series_, r in zip(series, results) + for r, series_ in zip(results, series) ] stepped_metrics, detailed_metrics = _collect_stepped_and_detailed_metrics( series_metrics=series_metrics, @@ -1240,7 +1323,7 @@ def _log_backtest_metrics( has_windows=has_windows, ) - write_table = len(series) > 1 or (has_time_axis and has_windows) + write_table = not is_single_series or (has_time_axis and has_windows) _flush_logged_metrics( autologging_client, run_id, @@ -1250,8 +1333,179 @@ def _log_backtest_metrics( ) -def _normalize_backtest_metrics( - backtest_args: dict, +def _log_standalone_metric( + autologging_client: MlflowAutologgingQueueingClient, + run_id: str, + result, + metric: Callable, + metric_args: dict[str, Any], + agg_func: Callable = np.mean, +): + """Log a a standalone metric call result to the active MLflow run. + + Reshapes each per-series result into a canonical ``(T, C)`` layout + (timesteps, components x quantiles/intervals/labels) inferred from the + metric signature and call kwargs by ``_infer_metric_axes``, logging every + cell under a descriptive key with the time axis mapped to the MLflow + ``step``. This mirrors ``_log_backtest_metrics`` (without the + window/``forecast_horizon`` split, since ``multi_ts_support`` returns a + clean per-series list). + + The logged MLflow key follows the pattern:: + + {metric_name}{component}{quantile_or_label} + + where each optional part is included only when the corresponding axis is + present: + + - ``component`` – ``_{component_name}`` when ``has_comp_axis``. + - ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi0.800`` / ``_label1``. + + When more than one series is scored, the logged value is ``agg_func`` + applied over series for each cell, and the granular per-series breakdown + is appended to the run's ``metrics_per_series.json`` table artifact + (shared with ``_log_backtest_metrics``). For a single series the + aggregate is just the value itself and no artifact is written. + + Series can have different lengths and intersect in different ways, + so the time axis is aligned from the end rather than the start: a shorter + series lines up on its last value instead of its first. To represent this, + the time axis is mapped to the MLflow ``step`` as ``t - t_size`` when + ``has_time_axis`` is ``True``. + + Raises + ------ + ValueError + On a shape mismatch between the metric result and the inferred + axes, or when ``has_comp_axis`` is ``True`` and series in a sequence + have different numbers of components. + + Parameters + ---------- + autologging_client + MLflow autologging client used to queue metric writes. + run_id + ID of the active MLflow run. + result + Return value of ``backtest()``. + metric + The ``metric`` callable that was called. + metric_args + Bound arguments of the ``metric()`` call (from + ``inspect.BoundArguments.arguments`` after ``apply_defaults``). + agg_func + Function used to aggregate a metric's per-series values into the + single value logged for a list of series. Called as + ``agg_func(values)`` on a list of floats. + """ + + metrics, metric_kwargs, metric_names = _normalize_metrics( + metrics=metric, + metric_kwargs=metric_args, + ) + metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metrics, metric_kwargs)] + has_time_axis, has_comp_axis, axis_labels = metric_axes[0] + + series = metric_args["actual_series"] + is_single_series = get_series_seq_type(series) == SeriesType.SINGLE + series = series2seq(series) + # series_reduction collapses the series axis inside the metric, so the + # result has no leading series axis even for list input. + series_reduced = metric_args["series_reduction"] is not None + if series_reduced: + # series_reduction aggregated across series -> single result, no series axis + results = [result] + else: + results = [result] if is_single_series else result + + if has_comp_axis and not series_reduced: + n_components = {s.n_components for s in series} + if len(n_components) > 1: + raise_log( + ValueError( + "Backtest metric logging failed: all series must have the same " + f"number of components, got {sorted(n_components)}. Consider " + f"setting a metric `component_reduction`, or make sure all series " + f"have the same number of components." + ) + ) + + # component names/count from the first series (all series share n_components) + metric_keys = _build_metric_keys( + metric_names=metric_names, + components=series[0].components.tolist(), + has_comp_axis=has_comp_axis, + metric_axes=metric_axes, + prefix="", + ) + + has_windows = False + series_metrics = [ + _reshape_metric_result( + series=series_, + result=r, + metric_keys=metric_keys, + has_time_axis=has_time_axis, + has_windows=has_windows, + forecast_horizon=0, + is_backtest=False, + ) + for r, series_ in zip(results, series) + ] + stepped_metrics, detailed_metrics = _collect_stepped_and_detailed_metrics( + series_metrics=series_metrics, + metric_keys=metric_keys, + has_time_axis=has_time_axis, + has_windows=has_windows, + ) + + series_metrics = [ + _reshape_metric_result( + series=series_, + result=r, + metric_keys=metric_keys, + has_time_axis=has_time_axis, + has_windows=False, + forecast_horizon=0, + is_backtest=False, + )[0, :, :, 0] + for r, series_ in zip(results, series) + ] + + sub_metric_keys = metric_keys[0] + + # agg maps (key, step) -> per-series values, aggregated into the logged metric. + agg: dict[tuple[str, int], list[float]] = {} + rows: list[dict] = [] + for series_index, values in enumerate(series_metrics): + t_size = values.shape[0] + for c, key in enumerate(sub_metric_keys): + for t in range(t_size): + # Forecast positions are zero-based: the first prediction is 0. + step = t if has_time_axis else 0 + value = float(values[t, c]) + agg.setdefault((key, step), []).append(value) + rows.append({ + "key": key, + "series_index": series_index, + "step": step, + "window_index": None, + "value": value, + }) + + write_table = not series_reduced and not is_single_series + _flush_logged_metrics( + autologging_client, + run_id, + stepped_metrics, + agg_func=agg_func, + table_rows=detailed_metrics if write_table else None, + ) + + +def _normalize_metrics( + metrics: Callable | list[Callable], + metric_kwargs: dict[str, Any] | list[dict[str, Any]], ) -> tuple[list, list[dict], list[str]]: """Normalize ``metric`` / ``metric_kwargs`` to parallel lists and key names. @@ -1259,9 +1513,7 @@ def _normalize_backtest_metrics( dict (broadcast to all metrics) or a list of dicts. A ``name`` entry in ``metric_kwargs`` overrides the metric-name token in the MLflow key. """ - metrics = backtest_args.get("metric") metrics = metrics if isinstance(metrics, list) else [metrics] - metric_kwargs = backtest_args.get("metric_kwargs") or {} metric_kwargs = ( metric_kwargs if isinstance(metric_kwargs, list) else [metric_kwargs] ) @@ -1449,7 +1701,7 @@ def _build_metric_keys( return metric_keys -def _reshape_backtest_result( +def _reshape_metric_result( series: TimeSeries, result, *, @@ -1457,6 +1709,7 @@ def _reshape_backtest_result( has_time_axis: bool, has_windows: bool, forecast_horizon: int | None, + is_backtest: bool, ) -> np.ndarray: """Reshape one series' backtest result to canonical ``(W, T, C, M)``. @@ -1486,10 +1739,10 @@ def _reshape_backtest_result( if remainder: raise_log( ValueError( - f"Backtest metric logging failed: result size ({arr.size}) " - f"is not divisible by n_sub_metrics * n_metrics ({n_sub_metrics} * " - f"{n_metrics} = {n_sub_metrics * n_metrics}). The metric output " - "shape does not match the inferred axes." + f"{'Backtest metric' if is_backtest else 'Metric'} logging failed: " + f"result size ({arr.size}) is not divisible by n_sub_metrics * " + f"n_metrics ({n_sub_metrics} * {n_metrics} = {n_sub_metrics * n_metrics}). " + f"The metric output shape does not match the inferred axes." ) ) @@ -1510,8 +1763,8 @@ def _reshape_backtest_result( else: raise_log( ValueError( - f"Backtest metric logging failed: expected a single " - f"scalar per component/metric after reduction, but got " + f"{'Backtest metric' if is_backtest else 'Metric'} logging failed: " + f"expected a single scalar per component/metric after reduction, but got " f"{n_round_multiples} elements. Check time_reduction and " "component_reduction defaults." ) @@ -1655,267 +1908,3 @@ def _log_per_series_table(rows: list[dict]) -> None: sort_by.append("window_index") df = df.sort_values(sort_by) mlflow.log_table(data=df, artifact_file="metrics_per_series.json") - - -def _log_metric_result( - autologging_client: MlflowAutologgingQueueingClient, - run_id: str, - metric_name: str, - result, - series, - has_time_axis: bool, - has_comp_axis: bool, - axis_labels: list[str], - series_reduced: bool = False, - agg_func: Callable = np.mean, -) -> None: - """Log a metric result to the active MLflow run. - - Reshapes each per-series result into a canonical ``(T, C)`` layout - (timesteps, components x quantiles/intervals/labels) inferred from the - metric signature and call kwargs by ``_infer_metric_axes``, logging every - cell under a descriptive key with the time axis mapped to the MLflow - ``step``. This mirrors ``_log_backtest_metrics`` (without the - window/``forecast_horizon`` split, since ``multi_ts_support`` returns a - clean per-series list). - - The logged MLflow key follows the pattern:: - - {metric_name}{component}{quantile_or_label} - - where each optional part is included only when the corresponding axis is - present: - - - ``component`` – ``_{component_name}`` when ``has_comp_axis``. - - ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi0.800`` / ``_label1``. - - When more than one series is scored, the logged value is ``agg_func`` - applied over series for each cell, and the granular per-series breakdown - is appended to the run's ``metrics_per_series.json`` table artifact - (shared with ``_log_backtest_metrics``). For a single series the - aggregate is just the value itself and no artifact is written. - - Series can have different lengths and intersect in different ways, - so the time axis is aligned from the end rather than the start: a shorter - series lines up on its last value instead of its first. To represent this, - the time axis is mapped to the MLflow ``step`` as ``t - t_size`` when - ``has_time_axis`` is ``True``. - - Raises - ------ - ValueError - On a shape mismatch between the metric result and the inferred - axes, or when ``has_comp_axis`` is ``True`` and series in a sequence - have different numbers of components. - - Parameters - ---------- - metric_name - Metric name used as the MLflow key (the metric's ``name`` keyword - argument when provided, otherwise the metric function name). - result - The metric result to log. - series - The ``actual_series`` argument passed to the metric (single series or - ``Sequence[TimeSeries]``); used for component names and series count. - When ``has_comp_axis`` is ``True``, all series in a sequence must have - the same number of components; names are taken from the first series. - has_time_axis - ``True`` when the result carries a per-timestep axis (``time_reduction=None``). - has_comp_axis - ``True`` when components are expanded (``component_reduction=None``). - axis_labels - One key suffix per quantile/interval/label entry. - series_reduced - ``True`` when ``series_reduction`` collapsed the series axis inside the - metric, so the result has no leading series axis even for list input. - agg_func - Function used to aggregate a metric's per-series values into the - single value logged for a list of series. Called as - ``agg_func(values)`` on a list of floats. - """ - if series_reduced: - # series_reduction aggregated across series -> single result, no series axis - series_seq = [get_single_series(series)] - results = [result] - else: - series_seq = series2seq(series) - results = ( - [result] if get_series_seq_type(series) == SeriesType.SINGLE else result - ) - # component names are only used when the metric preserves components - if has_comp_axis: - n_components = {s.n_components for s in series_seq} - if len(n_components) > 1: - raise_log( - ValueError( - f"Metric logging failed for `{metric_name}`: all series must " - f"have the same number of components, got " - f"{sorted(n_components)}." - ) - ) - - # component names/count from the first series (all series share n_components) - comps = series_seq[0].components.tolist() - metric_keys = _build_metric_keys( - [metric_name], - comps, - has_comp_axis, - [(has_time_axis, has_comp_axis, axis_labels)], - ) - sub_metric_keys = metric_keys[0] - n_sub_metrics = len(sub_metric_keys) - - # first pass: reshape each series' result into a canonical (T, C) array, - # recording its time-axis length for the alignment pass below. - series_metrics = [] - for r in results: - arr = np.asarray(r, dtype=float) - # after stripping the C axis, the remainder is the time axis (or scalar) - n_times, extra = divmod(arr.size, n_sub_metrics) - if extra: - raise_log( - ValueError( - f"Metric logging failed for `{metric_name}`: result size " - f"({arr.size}) is not divisible by the inferred " - f"component/quantile size ({n_sub_metrics}). The metric output " - "shape does not match the inferred axes." - ) - ) - - if has_time_axis: - t_size = n_times - elif n_times != 1: - raise_log( - ValueError( - f"Metric logging failed for `{metric_name}`: expected a " - f"single value per component/quantile after reduction, " - f"but got {n_times} elements. Check time_reduction and " - "component_reduction." - ) - ) - else: - t_size = 1 - - series_metrics.append((t_size, arr.reshape(t_size, n_sub_metrics))) - - # agg maps (key, step) -> per-series values, aggregated into the logged metric. - agg: dict[tuple[str, int], list[float]] = {} - rows: list[dict] = [] - for series_index, (t_size, canonical) in enumerate(series_metrics): - for c, key in enumerate(sub_metric_keys): - for t in range(t_size): - # Forecast positions are zero-based: the first prediction is 0. - step = t if has_time_axis else 0 - value = float(canonical[t, c]) - agg.setdefault((key, step), []).append(value) - rows.append({ - "key": key, - "series_index": series_index, - "step": step, - "window_index": None, - "value": value, - }) - - _flush_logged_metrics( - autologging_client, - run_id, - agg, - agg_func=agg_func, - table_rows=rows if len(series_seq) > 1 else None, - ) - autologging_client.flush(synchronous=False).await_completion() - - -def _mlflow_metric_callback(func, result, args, kwargs) -> None: - """Metric callback registered with ``darts.metrics.utils`` for autologging. - - Invoked by ``multi_ts_support`` (the outermost decorator on every Darts - metric) after every top-level metric call, so it fires regardless of how - the metric was imported. It is not invoked for internal metric-to-metric - calls (e.g. ``rmse`` calling ``mse`` internally via ``_get_wrapped_metric``), - since those bypass ``multi_ts_support`` entirely. - - When an active MLflow run exists, infers the output axes from the metric - signature and call kwargs (via ``_infer_metric_axes``) and delegates to - ``_log_metric_result``, which logs each cell under a key built as:: - - {metric_name}{component}{quantile_or_label} - - where: - - - ``metric_name`` – the metric function name, or the ``name`` keyword - argument when provided (it overrides only this token). - - ``component`` – ``_{component_name}`` when ``component_reduction=None``. - - ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, - ``_qi0.800``, ``_label1``) when applicable. - - When the input is a ``Sequence[TimeSeries]`` with more than one series, the - logged value is ``autolog()``'s ``agg_func`` applied over series, and the - per-series breakdown is appended to the run's ``metrics_per_series.json`` - table artifact instead of per-series keys. - - The per-timestep axis (``time_reduction=None``) is mapped to the MLflow - ``step``. - - Parameters - ---------- - func - The Darts metric function that was called (used for its name and - signature). - result - The metric's return value. - args - Positional arguments the metric was called with. - kwargs - Keyword arguments the metric was called with. - """ - active_run = mlflow.active_run() - if active_run is None: - return - - # backtest() calls metric functions internally; _patched_backtest - # handles logging the aggregated result, so skip here to avoid - # generating one flat key per window (series_gen_mape_0, _1, …). - if getattr(_autolog_state, "in_backtest", False): - return - - series = args[0] if len(args) > 0 else kwargs["actual_series"] - - autologging_client = MlflowAutologgingQueueingClient() - run_id = active_run.info.run_id - - # the `name` kwarg overrides the metric-name token in the logged key - key_name = _sanitize_mlflow_key(kwargs.get("name") or func.__name__) - - # infer output axes from the metric signature + call kwargs - has_time_axis, has_comp_axis, axis_labels = _infer_metric_axes(func, kwargs) - - # series_reduction collapses the series axis inside the metric, so the - # result has no leading series axis even for list input. - params = inspect.signature(func).parameters - series_reduced = False - if "series_reduction" in params: - effective_sr = kwargs.get( - "series_reduction", params["series_reduction"].default - ) - series_reduced = effective_sr is not None - - # _mlflow_metric_callback is a bare registered callback, not a closure over - # autolog()'s call kwargs, so agg_func is read back from the autologging - # config store that autolog() populated. - agg_func = get_autologging_config( - flavor_name=FLAVOR_NAME, config_key="agg_func", default_value=np.mean - ) - _log_metric_result( - autologging_client, - run_id, - key_name, - result, - series, - has_time_axis, - has_comp_axis, - axis_labels, - series_reduced=series_reduced, - agg_func=agg_func, - ) From 02bcb39db2e3699fcfb5577a9518039154bc29cc Mon Sep 17 00:00:00 2001 From: dennisbader Date: Sun, 23 Aug 2026 12:58:42 +0200 Subject: [PATCH 145/154] unify backetst and standalone metric logging --- darts/tests/optional_deps/test_mlflow.py | 64 ++- darts/utils/mlflow.py | 473 ++++++++++------------- 2 files changed, 258 insertions(+), 279 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index b78724a1f5..5d3d165f1c 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -88,6 +88,18 @@ def assert_mlflow_artifacts_exist(path: str, is_torch: bool = False): assert os.path.exists(os.path.join(path, "model.pkl")) +BT_REQUIRED_DEFAUTLS = { + "historical_forecasts": None, + "forecast_horizon": 1, + "last_points_only": False, + "past_covariates": None, + "future_covariates": None, + "reduction": np.nanmean, + "metric": dm.mape, + "metric_kwargs": None, +} + + def assert_predictions_equal( model1: ForecastingModel, model2: ForecastingModel, @@ -1095,17 +1107,17 @@ def test_autolog_metric_aligns_time_axis_by_forecast_position( history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") by_step = {m.step: m.value for m in history} assert len(by_step) == 50 - for step in range(10): - assert by_step[step] == pytest.approx(1.0, abs=1e-4), step - for step in range(10, 50): + for step in range(40): assert by_step[step] == pytest.approx(1.5, abs=1e-4), step + for step in range(40, 50): + assert by_step[step] == pytest.approx(1.0, abs=1e-4), step rows = self._read_per_series_table(run.info.run_id) steps_by_series = {0: set(), 1: set()} for r in rows: steps_by_series[r["series_index"]].add(r["step"]) assert steps_by_series[0] == set(range(50)) - assert steps_by_series[1] == set(range(10, 50)) + assert steps_by_series[1] == set(range(40)) def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile with matching values.""" @@ -1503,7 +1515,11 @@ def test_autolog_backtest_multi_series_custom_agg_func(self, mlflow_tracking): with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() _log_backtest_metrics( - client, run.info.run_id, result, backtest_args, agg_func=np.median + client, + run.info.run_id, + result, + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, + agg_func=np.median, ) client.flush(synchronous=True) @@ -1683,7 +1699,12 @@ def test_log_backtest_metrics_component_count_mismatch_allowed_when_reduced( with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() - _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + _log_backtest_metrics( + client, + run.info.run_id, + result, + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, + ) client.flush(synchronous=True) m = mlflow.get_run(run.info.run_id).data.metrics @@ -1711,7 +1732,12 @@ def test_log_backtest_metrics_component_count_mismatch_raises( with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() with pytest.raises(ValueError, match="same number of components"): - _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + _log_backtest_metrics( + client, + run.info.run_id, + result, + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, + ) assert not mlflow.get_run(run.info.run_id).data.metrics @@ -1736,7 +1762,10 @@ def test_log_backtest_metrics_unknown_labels_raises(self, mlflow_tracking): client = MlflowAutologgingQueueingClient() with pytest.raises(ValueError, match="requires explicit `labels`"): _log_backtest_metrics( - client, run.info.run_id, np.array([0.5]), backtest_args + client, + run.info.run_id, + np.array([0.5]), + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, ) def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): @@ -1766,7 +1795,10 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): client = MlflowAutologgingQueueingClient() with pytest.raises(ValueError, match="not divisible"): _log_backtest_metrics( - client, run.info.run_id, fake_result, backtest_args + client, + run.info.run_id, + fake_result, + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, ) assert not mlflow.get_run(run.info.run_id).data.metrics @@ -1790,7 +1822,12 @@ def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() - _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + _log_backtest_metrics( + client, + run.info.run_id, + result, + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, + ) client.flush(synchronous=True) history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") @@ -1828,7 +1865,12 @@ def test_log_backtest_metrics_aligns_last_points_only_time_axis( with mlflow.start_run() as run: client = MlflowAutologgingQueueingClient() - _log_backtest_metrics(client, run.info.run_id, result, backtest_args) + _log_backtest_metrics( + client, + run.info.run_id, + result, + {**BT_REQUIRED_DEFAUTLS, **backtest_args}, + ) client.flush(synchronous=True) history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 1b9054740b..49146bcc05 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -485,7 +485,7 @@ def autolog( log_params: bool = True, log_metrics: bool = True, log_torch_metrics: bool = True, - agg_func: Callable = np.mean, + agg_func: Callable = np.nanmean, disable: bool = False, silent: bool = False, ) -> None: @@ -512,7 +512,7 @@ def autolog( training and validation metrics. Only effective for PyTorch-based models. agg_func Function used to aggregate a metric's per-series values into the - single value logged for a list of series (e.g. ``np.mean``, the + single value logged for a list of series (e.g. ``np.nanmean``, the default, or ``np.median``). Called as ``agg_func(values)`` on a list of floats. disable @@ -595,7 +595,7 @@ def _autolog( log_models: bool = True, log_params: bool = True, log_metrics: bool = True, - agg_func: Callable = np.mean, + agg_func: Callable = np.nanmean, disable: bool = False, silent: bool = False, ) -> None: @@ -653,14 +653,14 @@ def _patched_fit(original, self, *args, **kwargs): return result run_id = active_run.info.run_id - fit_args = inspect.signature(original).bind(self, *args, **kwargs).arguments + fit_kwargs = inspect.signature(original).bind(self, *args, **kwargs).arguments _log_model_setup( model=self, autologging_client=autologging_client, run_id=run_id, - series=fit_args["series"], - past_covariates=fit_args.get("past_covariates"), - future_covariates=fit_args.get("future_covariates"), + series=fit_kwargs["series"], + past_covariates=fit_kwargs.get("past_covariates"), + future_covariates=fit_kwargs.get("future_covariates"), log_params=log_params, ) @@ -752,14 +752,14 @@ def _patched_backtest(original, self, *args, **kwargs): bound = inspect.signature(original).bind(self, *args, **kwargs) bound.apply_defaults() - backtest_args = bound.arguments + backtest_kwargs = bound.arguments autologging_client = MlflowAutologgingQueueingClient() _log_backtest_metrics( autologging_client=autologging_client, run_id=active_run.info.run_id, result=result, - backtest_args=backtest_args, + backtest_kwargs=backtest_kwargs, agg_func=agg_func, ) autologging_client.flush(synchronous=False).await_completion() @@ -853,22 +853,22 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: *args, **{k: v for k, v in kwargs.items() if k in func_signature.parameters} ) bound.apply_defaults() - metric_args = bound.arguments + metric_kwargs = bound.arguments # _mlflow_metric_callback is a bare registered callback, not a closure over # autolog()'s call kwargs, so agg_func is read back from the autologging # config store that autolog() populated. agg_func = get_autologging_config( - flavor_name=FLAVOR_NAME, config_key="agg_func", default_value=np.mean + flavor_name=FLAVOR_NAME, config_key="agg_func", default_value=np.nanmean ) autologging_client = MlflowAutologgingQueueingClient() - _log_standalone_metric( + _log_metric_results( autologging_client=autologging_client, run_id=active_run.info.run_id, result=result, - metric=func, - metric_args=metric_args, + metrics=func, + metric_kwargs=metric_kwargs, agg_func=agg_func, ) autologging_client.flush(synchronous=False).await_completion() @@ -1186,199 +1186,141 @@ def _log_backtest_metrics( autologging_client: MlflowAutologgingQueueingClient, run_id: str, result, - backtest_args: dict, - agg_func: Callable = np.mean, + backtest_kwargs: dict, + agg_func: Callable = np.nanmean, ) -> None: """Log backtest metric result(s) to MLflow. - Reshapes each per-series result to a canonical ``(W, T, C, M)`` layout - (windows, timesteps, components x quantiles, metrics) inferred from the - metric signatures and ``backtest_args``, logging every cell under a - descriptive key with the time axis (or window axis when time is reduced) - mapped to the MLflow ``step``. A metric's ``name`` entry in - ``metric_kwargs`` overrides the metric-name token in the key (the - ``backtest_`` prefix and axis suffixes are preserved). - - Shape inference respects all kwargs that affect output dimensions: - - - ``time_reduction`` – collapses the time axis (``T=1``). - - ``component_reduction`` – collapses the component axis (``C=1``). - - ``series_reduction`` – if other than ``None``, windows are already aggregated - inside the metric, so ``W=1`` regardless of ``backtest.reduction``. - - ``q`` / ``q_interval`` – expand the component axis with one entry per - quantile / interval. - - ``labels`` - expand each component with one entry per label along - the component axis. - - ``label_reduction`` – collapses the labels along the component axis. - value; ``labels`` only restricts which classes are scored. - - ``reduction=None`` – no aggregation across windows -> one value per window. - - ``last_points_only`` – collapses all windows into one TimeSeries before scoring, - so there is effectively only one window regardless of reduction. - - - When more than one series is scored, the logged value is ``agg_func`` - applied over series for each cell, and the granular per-series breakdown - is appended to the run's ``metrics_per_series.json`` table artifact - (shared with ``_log_standalone_metric``). For a single series the aggregate - is just the value itself and no artifact is written. When components - are preserved (``component_reduction=None``), all series scored together - must have the same number of components; names are taken from the first - series. - - Series can have different lengths and intersect in different ways. - We align the time axis from the end rather than the start: a shorter - series lines up on its last value instead of its first. This is an - assumption which does not hold true for all cases (series can also end - at different times). - - The last step logged to MLflow represents the last window of each series. - There will be ``max_n_windows`` steps logged. Shorter series will not - contribute to the first steps. In the multi-series case, the values at the - same step are aggregated over all series. - - For time-dependent metrics (e.g. ``ae()``), the steps represent the - forecast horizon rather than backteset windows. There will be - ``forecast_horizon`` steps logged. In the multi-series case, the values at - the same step are aggregated over all series. - - Raises - ------ - ValueError - On a shape/size mismatch between the metric result and the inferred - axes, when ``component_reduction=None`` and series in a sequence have - different numbers of components, or when ``label_reduction=None`` is - requested without explicit ``labels``. - - Parameters - ---------- - autologging_client - MLflow autologging client used to queue metric writes. - run_id - ID of the active MLflow run. - result - Return value of ``backtest()``. - backtest_args - Bound arguments of the ``backtest()`` call (from - ``inspect.BoundArguments.arguments`` after ``apply_defaults``). - agg_func - Function used to aggregate a metric's per-series values into the - single value logged for a list of series. Called as - ``agg_func(values)`` on a list of floats. + Helper function for ``autolog()`` to log backtest metric results to MLflow. + Details are documented in ``_log_metric_results()``. """ - metrics, metric_kwargs, metric_names = _normalize_metrics( - metrics=backtest_args["metric"], - metric_kwargs=backtest_args["metric_kwargs"] or dict(), - ) - metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metrics, metric_kwargs)] - has_time_axis, has_comp_axis, _ = metric_axes[0] - - series = backtest_args.get("series") - is_single_series = get_series_seq_type(series) == SeriesType.SINGLE - series = series2seq(series) - results = [result] if is_single_series else result - - if has_comp_axis: - n_components = {s.n_components for s in series} - if len(n_components) > 1: - raise_log( - ValueError( - "Backtest metric logging failed: all series must have the same " - f"number of components, got {sorted(n_components)}. Consider " - f"setting a metric `component_reduction`, or make sure all series " - f"have the same number of components." - ) - ) - - # component names/count from the first series (all series share n_components) - metric_keys = _build_metric_keys( - metric_names=metric_names, - components=series[0].components.tolist(), - has_comp_axis=has_comp_axis, - metric_axes=metric_axes, - prefix="backtest_", - ) - - has_windows, forecast_horizon = _resolve_backtest_layout( - backtest_args=backtest_args, - metric=metrics[0], - metric_kwargs=metric_kwargs[0], - is_single_series=is_single_series, - ) - series_metrics = [ - _reshape_metric_result( - series=series_, - result=r, - metric_keys=metric_keys, - has_time_axis=has_time_axis, - has_windows=has_windows, - forecast_horizon=forecast_horizon, - is_backtest=True, - ) - for r, series_ in zip(results, series) - ] - stepped_metrics, detailed_metrics = _collect_stepped_and_detailed_metrics( - series_metrics=series_metrics, - metric_keys=metric_keys, - has_time_axis=has_time_axis, - has_windows=has_windows, - ) - - write_table = not is_single_series or (has_time_axis and has_windows) - _flush_logged_metrics( - autologging_client, - run_id, - stepped_metrics, + _log_metric_results( + autologging_client=autologging_client, + run_id=run_id, + result=result, + metrics=backtest_kwargs["metric"], + metric_kwargs=backtest_kwargs["metric_kwargs"] or dict(), agg_func=agg_func, - table_rows=detailed_metrics if write_table else None, + backtest_kwargs=backtest_kwargs, ) -def _log_standalone_metric( +def _log_metric_results( autologging_client: MlflowAutologgingQueueingClient, run_id: str, result, - metric: Callable, - metric_args: dict[str, Any], - agg_func: Callable = np.mean, -): - """Log a a standalone metric call result to the active MLflow run. + metrics: Callable | list[Callable], + metric_kwargs: dict[str, Any] | list[dict[str, Any]], + backtest_kwargs: dict[str, Any] | None = None, + agg_func: Callable = np.nanmean, +) -> None: + """Log backtest or standalone metric result(s) to MLflow. - Reshapes each per-series result into a canonical ``(T, C)`` layout - (timesteps, components x quantiles/intervals/labels) inferred from the - metric signature and call kwargs by ``_infer_metric_axes``, logging every - cell under a descriptive key with the time axis mapped to the MLflow - ``step``. This mirrors ``_log_backtest_metrics`` (without the - window/``forecast_horizon`` split, since ``multi_ts_support`` returns a - clean per-series list). + Shared implementation used by ``_log_backtest_metrics`` and + ``_log_standalone_metric``. The two entry points differ only in how they + populate the arguments below; all reshaping, key construction, step + assignment, multi-series aggregation, and artifact writing happen here. - The logged MLflow key follows the pattern:: + Entry modes + ----------- + **Backtest** (``backtest_kwargs`` is not ``None``): - {metric_name}{component}{quantile_or_label} + - ``metrics`` / ``metric_kwargs`` come from backtesting. + - MLflow keys are prefixed with ``backtest_``. + - A window axis ``W`` may be present (see *MLflow keys and steps*). + + **Standalone** (``backtest_kwargs`` is ``None``): + + - ``metrics`` / ``metric_kwargs`` describe a direct ``metric()`` call. + - MLflow keys have no prefix. + - There is never a backtest window axis (``W=1``); only the metric's own + time / component / quantile / label axes apply. - where each optional part is included only when the corresponding axis is - present: + Canonical layout + ---------------- + Each per-series result is reshaped to ``(W, T, C, M)``: - - ``component`` – ``_{component_name}`` when ``has_comp_axis``. - - ``quantile_or_label`` – e.g. ``_q0.500`` / ``_qi0.800`` / ``_label1``. + - ``W`` – backtest windows (``1`` for standalone, or when windows were + aggregated before scoring). + - ``T`` – timesteps (``1`` when ``time_reduction`` is set). + - ``C`` – sub-metrics per component (components × quantiles / intervals / + labels; ``1`` when ``component_reduction`` is set). + - ``M`` – number of metrics when several are logged at once. - When more than one series is scored, the logged value is ``agg_func`` - applied over series for each cell, and the granular per-series breakdown - is appended to the run's ``metrics_per_series.json`` table artifact - (shared with ``_log_backtest_metrics``). For a single series the - aggregate is just the value itself and no artifact is written. + Axis sizes are inferred from each metric's signature and the corresponding + ``metric_kwargs``. - Series can have different lengths and intersect in different ways, - so the time axis is aligned from the end rather than the start: a shorter - series lines up on its last value instead of its first. To represent this, - the time axis is mapped to the MLflow ``step`` as ``t - t_size`` when - ``has_time_axis`` is ``True``. + Kwargs that affect output dimensions (both modes unless noted): + + - ``time_reduction`` – collapses the time axis (``T=1``). + - ``component_reduction`` – collapses the component axis (``C=1``). + - ``q`` / ``q_interval`` – one sub-metric per quantile / interval. + - ``labels`` – when ``label_reduction=None``, one sub-metric per label; + otherwise ``labels`` only restricts which classes are scored. + - ``label_reduction`` – collapses label outputs to a scalar per component. + - ``series_reduction`` – collapses the series axis inside the metric, so + the caller's ``result`` is already aggregated and treated as a single + series (``W=1`` for backtest regardless of ``reduction``). + + Backtest-only kwargs: + + - ``reduction=None`` – no aggregation across windows → one value per + window (``W > 1``). + - ``last_points_only`` – concatenates all windows into one ``TimeSeries`` + before scoring, so there is effectively one window regardless of + ``reduction``. + - ``forecast_horizon`` / ``historical_forecasts`` – set the time-axis + length for time-dependent metrics when windows are preserved. + + MLflow keys and steps + --------------------- + Every scalar cell is logged under a descriptive key built from the metric + name, optional component suffix, and optional quantile / interval / label + suffix (see ``_build_metric_keys``). A metric's ``name`` entry in + ``metric_kwargs`` overrides the function-name token; the ``backtest_`` + prefix (when present) and axis suffixes are preserved. + + The MLflow ``step`` is the axis the UI should chart: + + - **Time-dependent metrics** (``time_reduction=None``): steps index the + forecast horizon (``0 .. T-1``). When both time and window axes are + present (backtest, no reduction, not ``last_points_only``), each step + holds the ``agg_func`` aggregation over windows at that horizon index. + - **Time-aggregated metrics**: steps index backtest windows end-aligned + across series (``0 .. max_W-1``; shorter series skip early steps). + Standalone calls with a time axis but no window axis end-align timesteps + the same way across series of different lengths. + + Series can differ in length and overlap in time. We align from the end, not + the start: a shorter series contributes at the last steps/windows, not the + first. This matches the usual backtest layout but is an assumption — series + may also end at different calendar times. + + Multi-series aggregation and artifacts + ---------------------------------------- + When more than one series is scored (and ``series_reduction`` did not + already collapse them), the logged value at each ``(key, step)`` is + ``agg_func`` applied over series. The per-series breakdown is appended to + the run's ``metrics_per_series.json`` table artifact when: + + - several series were scored together, or + - (backtest only) a time-dependent metric retains both time and window axes, + so the aggregate steps average over windows but the table keeps every + ``(window, horizon)`` cell. + + For a single series, the aggregate is the value itself and no table is + written unless the backtest time+window case above applies. When components + are preserved (``component_reduction=None``), all series in a batch must + have the same number of components; component names are taken from the first + series. Raises ------ ValueError - On a shape mismatch between the metric result and the inferred - axes, or when ``has_comp_axis`` is ``True`` and series in a sequence - have different numbers of components. + On a shape/size mismatch between the metric result and the inferred + axes, when ``component_reduction=None`` and series in a sequence have + different numbers of components, or when ``label_reduction=None`` is + requested without explicit ``labels``. Parameters ---------- @@ -1387,33 +1329,63 @@ def _log_standalone_metric( run_id ID of the active MLflow run. result - Return value of ``backtest()``. - metric - The ``metric`` callable that was called. - metric_args - Bound arguments of the ``metric()`` call (from - ``inspect.BoundArguments.arguments`` after ``apply_defaults``). + Return value of ``backtest()`` or ``metric()``. Either a scalar/array + for one series, a list of per-series results, or a single aggregate when + ``series_reduction`` is set. + metrics + One metric callable or a list of callables logged together. + metric_kwargs + Keyword arguments forwarded to ``metrics``, either one dict shared by + all metrics or one dict per metric. For standalone logging this is the + bound ``metric()`` arguments; for backtest logging this is + ``backtest_kwargs["metric_kwargs"]``. + backtest_kwargs + Bound arguments of the ``backtest()`` call (from + ``inspect.BoundArguments.arguments`` after ``apply_defaults``). When + ``None``, the call is treated as standalone metric logging. agg_func - Function used to aggregate a metric's per-series values into the - single value logged for a list of series. Called as - ``agg_func(values)`` on a list of floats. + Function used to aggregate per-series values at each ``(key, step)``. + Called as ``agg_func(values)`` on a list of floats. """ - metrics, metric_kwargs, metric_names = _normalize_metrics( - metrics=metric, - metric_kwargs=metric_args, + metrics=metrics, + metric_kwargs=metric_kwargs, ) metric_axes = [_infer_metric_axes(m, kw) for m, kw in zip(metrics, metric_kwargs)] - has_time_axis, has_comp_axis, axis_labels = metric_axes[0] + has_time_axis, has_comp_axis, _ = metric_axes[0] - series = metric_args["actual_series"] + series: TimeSeriesLike = ( + metric_kwargs[0]["actual_series"] + if backtest_kwargs is None + else backtest_kwargs["series"] + ) is_single_series = get_series_seq_type(series) == SeriesType.SINGLE series = series2seq(series) - # series_reduction collapses the series axis inside the metric, so the - # result has no leading series axis even for list input. - series_reduced = metric_args["series_reduction"] is not None + + if backtest_kwargs is None: + # standalone metric + is_backtest = False + prefix = "" + # `series_reduction` collapses the series axis inside the metric, so the + # result has no leading series axis even for list input. + series_reduced = metric_kwargs[0]["series_reduction"] is not None + last_points_only = False + has_windows = False + forecast_horizon = 0 + else: + # backtest metric + is_backtest = True + prefix = "backtest_" + series_reduced = False + last_points_only = backtest_kwargs["last_points_only"] + has_windows, forecast_horizon = _resolve_backtest_layout( + backtest_kwargs=backtest_kwargs, + metric=metrics[0], + metric_kwargs=metric_kwargs[0], + is_single_series=is_single_series, + ) + if series_reduced: - # series_reduction aggregated across series -> single result, no series axis results = [result] else: results = [result] if is_single_series else result @@ -1430,16 +1402,13 @@ def _log_standalone_metric( ) ) - # component names/count from the first series (all series share n_components) metric_keys = _build_metric_keys( metric_names=metric_names, components=series[0].components.tolist(), has_comp_axis=has_comp_axis, metric_axes=metric_axes, - prefix="", + prefix=prefix, ) - - has_windows = False series_metrics = [ _reshape_metric_result( series=series_, @@ -1447,8 +1416,8 @@ def _log_standalone_metric( metric_keys=metric_keys, has_time_axis=has_time_axis, has_windows=has_windows, - forecast_horizon=0, - is_backtest=False, + forecast_horizon=forecast_horizon, + is_backtest=is_backtest, ) for r, series_ in zip(results, series) ] @@ -1457,43 +1426,12 @@ def _log_standalone_metric( metric_keys=metric_keys, has_time_axis=has_time_axis, has_windows=has_windows, + last_points_only=last_points_only, ) - series_metrics = [ - _reshape_metric_result( - series=series_, - result=r, - metric_keys=metric_keys, - has_time_axis=has_time_axis, - has_windows=False, - forecast_horizon=0, - is_backtest=False, - )[0, :, :, 0] - for r, series_ in zip(results, series) - ] - - sub_metric_keys = metric_keys[0] - - # agg maps (key, step) -> per-series values, aggregated into the logged metric. - agg: dict[tuple[str, int], list[float]] = {} - rows: list[dict] = [] - for series_index, values in enumerate(series_metrics): - t_size = values.shape[0] - for c, key in enumerate(sub_metric_keys): - for t in range(t_size): - # Forecast positions are zero-based: the first prediction is 0. - step = t if has_time_axis else 0 - value = float(values[t, c]) - agg.setdefault((key, step), []).append(value) - rows.append({ - "key": key, - "series_index": series_index, - "step": step, - "window_index": None, - "value": value, - }) - - write_table = not series_reduced and not is_single_series + write_table = (not series_reduced and not is_single_series) or ( + has_time_axis and has_windows + ) _flush_logged_metrics( autologging_client, run_id, @@ -1530,7 +1468,7 @@ def _normalize_metrics( def _resolve_backtest_layout( - backtest_args: dict, + backtest_kwargs: dict, metric: Callable, metric_kwargs: dict, is_single_series: bool, @@ -1550,8 +1488,8 @@ def _resolve_backtest_layout( tuple ``(has_windows, forecast_horizon)``. """ - last_points_only = backtest_args.get("last_points_only", False) - has_windows = backtest_args.get("reduction") is None and not last_points_only + last_points_only = backtest_kwargs["last_points_only"] + has_windows = backtest_kwargs["reduction"] is None and not last_points_only params = inspect.signature(metric).parameters if has_windows and "series_reduction" in params: @@ -1561,8 +1499,8 @@ def _resolve_backtest_layout( if series_reduction is not None: has_windows = False - forecast_horizon = backtest_args.get("forecast_horizon") - historical_forecasts = backtest_args.get("historical_forecasts") + forecast_horizon = backtest_kwargs["forecast_horizon"] + historical_forecasts = backtest_kwargs["historical_forecasts"] if historical_forecasts is not None and not last_points_only: first_forecast = ( historical_forecasts[0] if is_single_series else historical_forecasts[0][0] @@ -1579,7 +1517,7 @@ def _infer_metric_axes( Covers ``time_reduction``, ``component_reduction``, ``q``, ``q_interval``, and ``label_reduction`` / ``labels`` for classification metrics. - ``series_reduction`` is handled at the ``_log_backtest_metrics`` level. + ``series_reduction`` is handled at the ``_log_metric_results`` level. Parameters ---------- @@ -1779,6 +1717,7 @@ def _collect_stepped_and_detailed_metrics( *, has_time_axis: bool, has_windows: bool, + last_points_only: bool, ) -> tuple[dict[tuple[str, int], list[float]], list[dict]]: """Parse series metrics and build inputs for MLflow stepped metrics and detailed metric table. @@ -1804,36 +1743,32 @@ def _collect_stepped_and_detailed_metrics( for series_index, values in enumerate(series_metrics): w_size = values.shape[w_axis] t_size = values.shape[t_axis] + # pad shorter series so their last point lines up with the longest w_offset = max_w_size - w_size if has_windows else 0 t_offset = max_t_size - t_size if has_time_axis and not has_windows else 0 - window_agg = np.nanmean(values, axis=w_axis) for metric_idx, sub_metric_keys in enumerate(metric_keys): for sub_metric_idx, key in enumerate(sub_metric_keys): for w in range(w_size): window_index = w + w_offset if has_windows else None for t in range(t_size): - value = float(values[w, t, sub_metric_idx, metric_idx]) - if has_time_axis and has_windows: - # time-dependent metrics + last_points_only=False + no reduction + if has_time_axis and (has_windows or not last_points_only): + # bt: backtest, sm: standalone metric + # (bt) time-dependent metrics + last_points_only=False + no reduction + # (bt) time-dependent metrics + last_points_only=False + reduction + # (sm) time-dependent metrics step = t - - # stepped metric chart: one value per horizon (windows averaged) - if w == 0: - stepped_metrics.setdefault((key, step), []).append( - float(window_agg[t, sub_metric_idx, metric_idx]) - ) + elif has_time_axis: + # (bt) time-dependent metrics + last_points_only=True + no reduction + step = t + t_offset else: - if has_time_axis: - # time-dependent metrics + last_points_only=False + reduction - step = t + t_offset - else: - step = window_index - - # stepped metric chart: one value per window or horizon - stepped_metrics.setdefault((key, step), []).append(value) + # (bt) last_points_only=False + reduction (window index is None) + # (bt) last_points_only=False + no reduction (window index is not None) + # (sm) time-aggregated metrics (window index is None) + step = window_index + value = float(values[w, t, sub_metric_idx, metric_idx]) # table: one value per window and horizon detailed_metrics.append({ "key": key, @@ -1842,6 +1777,8 @@ def _collect_stepped_and_detailed_metrics( "window_index": window_index, "value": value, }) + # stepped metric chart: one value per window or horizon + stepped_metrics.setdefault((key, step), []).append(value) return stepped_metrics, detailed_metrics From 32ac8e13b162185933a4734387ba4509dfbabb93 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 28 Aug 2026 12:07:25 +0200 Subject: [PATCH 146/154] update tests --- darts/tests/optional_deps/test_mlflow.py | 1681 +++++++++++----------- 1 file changed, 853 insertions(+), 828 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 5d3d165f1c..d06595c3cc 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,3 +1,4 @@ +import copy import logging import os @@ -13,7 +14,12 @@ ForecastingModel, GlobalForecastingModel, ) -from darts.tests.conftest import MLFLOW_AVAILABLE, TORCH_AVAILABLE, tfm_kwargs_dev +from darts.tests.conftest import ( + MLFLOW_AVAILABLE, + TORCH_AVAILABLE, + tfm_kwargs, + tfm_kwargs_dev, +) if not MLFLOW_AVAILABLE: pytest.skip( @@ -45,6 +51,22 @@ from darts.models import NBEATSModel +TS_UNIVARIATE = tg.sine_timeseries(length=50).astype("float32") +TS_MULTIVARIATE = TS_UNIVARIATE.stack(TS_UNIVARIATE * 1.5) +TS_WITH_STATIC = TS_UNIVARIATE.with_static_covariates( + pd.DataFrame({"static_feat": [1.0]}) +) +TS_PAST_COV = tg.sine_timeseries(length=62).astype("float32") +TS_FUTURE_COV = tg.constant_timeseries(value=1.0, length=62).astype("float32") +# binary classification series with values {0.0, 1.0} +TS_BINARY = tg.constant_timeseries(value=0.0, length=50).with_values( + np.random.default_rng(42) + .choice([0.0, 1.0], size=50) + .astype(np.float32) + .reshape(-1, 1) +) + + @pytest.fixture def mlflow_tracking(tmpdir_fn): """Set up MLflow tracking with a temporary database.""" @@ -136,28 +158,33 @@ def assert_predictions_equal( ) -class TestMLflow: - ts_univariate = tg.linear_timeseries( - start_value=10, end_value=50, length=50 - ).astype("float32") - ts_multivariate = ts_univariate.stack(ts_univariate * 1.5) - ts_with_static = ts_univariate.with_static_covariates( - pd.DataFrame({"static_feat": [1.0]}) - ) - ts_past_cov = tg.sine_timeseries(length=62).astype("float32") - ts_future_cov = tg.constant_timeseries(value=1.0, length=62).astype("float32") - # binary classification series with values {0.0, 1.0} - ts_binary = tg.constant_timeseries(value=0.0, length=50).with_values( - np.random.default_rng(42) - .choice([0.0, 1.0], size=50) - .astype(np.float32) - .reshape(-1, 1) +def _read_per_series_table(run_id): + """Load the run's consolidated per-series metric table into row dicts.""" + df = mlflow.load_table(artifact_file="metrics_per_series.json", run_ids=[run_id]) + return df.to_dict("records") + + +def _fit_lr(series=None): + """Fit and return a fresh LinearRegressionModel (no active run).""" + model = LinearRegressionModel(lags=1) + model.fit(series if series is not None else TS_UNIVARIATE) + return model + + +def _fit_qlr(series=None): + """Fit and return a fresh quantile LinearRegressionModel (no active run).""" + model = LinearRegressionModel( + lags=1, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] ) + model.fit(series if series is not None else TS_UNIVARIATE) + return model + +class TestMLflow: def test_save_load_statistical_model(self, tmpdir_fn): """Test save/load round-trip for statistical model""" model = ExponentialSmoothing() - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) @@ -170,7 +197,7 @@ def test_save_load_statistical_model(self, tmpdir_fn): def test_save_load_regression_model(self, tmpdir_fn): """Test save/load round-trip for regression model""" model = LinearRegressionModel(lags=5) - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) @@ -178,7 +205,7 @@ def test_save_load_regression_model(self, tmpdir_fn): assert_mlflow_artifacts_exist(model_path, is_torch=False) loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=3, series=self.ts_univariate) + assert_predictions_equal(model, loaded_model, n=3, series=TS_UNIVARIATE) @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") def test_save_load_torch_model(self, tmpdir_fn): @@ -186,7 +213,7 @@ def test_save_load_torch_model(self, tmpdir_fn): model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, n_epochs=1, **tfm_kwargs_dev ) - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) @@ -199,12 +226,12 @@ def test_save_load_torch_model(self, tmpdir_fn): f"file://{model_path}", pl_trainer_kwargs=tfm_kwargs_dev.get("pl_trainer_kwargs", {}), ) - assert_predictions_equal(model, loaded_model, n=2, series=self.ts_univariate) + assert_predictions_equal(model, loaded_model, n=2, series=TS_UNIVARIATE) def test_log_model_basic(self, mlflow_tracking): """Test basic log_model functionality""" model = ExponentialSmoothing() - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) with mlflow.start_run(): log_info = log_model(model, name="model") @@ -215,7 +242,7 @@ def test_log_model_basic(self, mlflow_tracking): def test_log_model_with_covariates(self, mlflow_tracking): """Test that covariate info is logged with correct values""" model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit(self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40]) + model.fit(TS_UNIVARIATE[:40], past_covariates=TS_PAST_COV[:40]) with mlflow.start_run(): log_model(model, name="model") @@ -226,8 +253,8 @@ def test_log_model_with_covariates(self, mlflow_tracking): model, loaded_model, n=5, - series=self.ts_univariate[:40], - past_covariates=self.ts_past_cov, + series=TS_UNIVARIATE[:40], + past_covariates=TS_PAST_COV, ) def test_log_model_with_all_covariate_types(self, mlflow_tracking): @@ -237,9 +264,9 @@ def test_log_model_with_all_covariate_types(self, mlflow_tracking): lags=5, lags_past_covariates=3, lags_future_covariates=[0, 1] ) model.fit( - self.ts_with_static[:40], - past_covariates=self.ts_past_cov[:40], - future_covariates=self.ts_future_cov[:50], + TS_WITH_STATIC[:40], + past_covariates=TS_PAST_COV[:40], + future_covariates=TS_FUTURE_COV[:50], ) with mlflow.start_run(): @@ -251,41 +278,37 @@ def test_log_model_with_all_covariate_types(self, mlflow_tracking): model, loaded_model, n=5, - series=self.ts_with_static[:40], - past_covariates=self.ts_past_cov, - future_covariates=self.ts_future_cov, + series=TS_WITH_STATIC[:40], + past_covariates=TS_PAST_COV, + future_covariates=TS_FUTURE_COV, ) def test_autolog_enable_disable(self, mlflow_tracking, autolog_context): """Test autolog can be enabled and disabled""" - with autolog_context(): - with mlflow.start_run(): - model = ExponentialSmoothing() - model.fit(self.ts_univariate) + client = mlflow_tracking + runs = mlflow.search_runs() + assert len(runs) == 0 + autolog() + with mlflow.start_run(): runs = mlflow.search_runs() - assert len(runs) == 1, "Expected exactly one run after autolog fit" - - # verify the run has expected content - last_run = runs.iloc[0] - assert last_run["tags.model_class"] == "ExponentialSmoothing" - assert last_run["tags.mlflow.runName"] is not None + assert len(runs) == 1 + run_id = runs.iloc[0]["run_id"] - # after context exits, autolog should be disabled - model2 = ExponentialSmoothing() - model2.fit(self.ts_univariate) + # metric is auto-logged + dm.mae(TS_UNIVARIATE, TS_UNIVARIATE, name="auto_logged") + assert len(client.get_metric_history(run_id, "auto_logged")) == 1 - runs_after_disable = mlflow.search_runs() - assert len(runs_after_disable) == 1, ( - "No new run should be created after disable" - ) + autolog(disable=True) + dm.mae(TS_UNIVARIATE, TS_UNIVARIATE, name="not_logged") + assert len(client.get_metric_history(run_id, "not_logged")) == 0 def test_autolog_parameters(self, mlflow_tracking, autolog_context): """Test that autolog logs model parameters""" with autolog_context(): with mlflow.start_run(): model = ExponentialSmoothing(seasonal_periods=12) - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) runs = mlflow.search_runs() assert len(runs) == 1 @@ -301,7 +324,7 @@ def test_autolog_model_params_json_artifact(self, mlflow_tracking, autolog_conte with autolog_context(): with mlflow.start_run() as run: model = ExponentialSmoothing(seasonal_periods=12) - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) params = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/model_params.json" @@ -309,120 +332,19 @@ def test_autolog_model_params_json_artifact(self, mlflow_tracking, autolog_conte assert params["seasonal_periods"] == 12 assert params["trend"] == str(model.model_params["trend"]) - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_torch_metrics(self, mlflow_tracking, autolog_context): - """Test that autolog logs training metrics for torch models""" - with autolog_context(): - with mlflow.start_run(): - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) - - runs = mlflow.search_runs() - assert len(runs) == 1, "Expected exactly one run" - last_run = runs.iloc[0] - last_run_id = last_run["run_id"] - assert last_run["tags.model_class"] == "NBEATSModel" - - client = mlflow.tracking.MlflowClient() - - # check train_loss metrics - train_metrics = client.get_metric_history(last_run_id, "train_loss") - assert len(train_metrics) > 0, "Expected train_loss metrics to be logged" - assert len(train_metrics) <= 2, "Expected at most 2 epochs of train_loss" - - for m in train_metrics: - assert np.isfinite(m.value), f"train_loss is not finite: {m.value}" - assert m.value >= 0, f"train_loss is negative: {m.value}" - assert m.step >= 0, "Metric step should be non-negative" - - val_metrics = client.get_metric_history(last_run_id, "val_loss") - if val_metrics: - for m in val_metrics: - assert np.isfinite(m.value), f"val_loss is not finite: {m.value}" - assert m.value >= 0, f"val_loss is negative: {m.value}" - - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_pytorch_autolog_enabled(self, mlflow_tracking, autolog_context): - """Test that autolog enables mlflow.pytorch.autolog and logs per-epoch - train_loss, val_loss, and custom torch_metrics with finite non-negative values.""" - import torchmetrics - from mlflow.utils.autologging_utils import autologging_is_disabled - - n_epochs = 2 - - def assert_metric(history, key): - assert len(history) > 0, f"{key} not logged" - assert len(history) <= n_epochs, f"too many {key} entries" - assert all(np.isfinite(m.value) and m.value >= 0 for m in history) - - with autolog_context(): - assert not autologging_is_disabled("pytorch") - - with mlflow.start_run(): - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=n_epochs, - torch_metrics=torchmetrics.MeanAbsoluteError(), - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) - - runs = mlflow.search_runs() - assert len(runs) == 1 - run_id = runs.iloc[0]["run_id"] - assert runs.iloc[0]["tags.model_class"] == "NBEATSModel" - - client = mlflow.tracking.MlflowClient() - assert_metric(client.get_metric_history(run_id, "train_loss"), "train_loss") - assert_metric(client.get_metric_history(run_id, "val_loss"), "val_loss") - # custom torch_metrics: in normal use both train_/val_ prefixes are logged, but - # fast_dev_run suppresses the Lightning logger during traininge - assert_metric( - client.get_metric_history(run_id, "val_MeanAbsoluteError"), - "val_MeanAbsoluteError", - ) - - assert autologging_is_disabled("pytorch") - - def test_autolog_series_info_single_series(self, mlflow_tracking, autolog_context): + @pytest.mark.parametrize("single_series", [True, False]) + def test_autolog_series_info_single_series( + self, mlflow_tracking, autolog_context, single_series + ): """The series_info.json artifact reports the target series' component names/count, plus covariate usage, count, and names, for a single-series fit.""" - with autolog_context(): - with mlflow.start_run() as run: - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.fit( - self.ts_univariate[:40], past_covariates=self.ts_past_cov[:40] - ) + series = TS_UNIVARIATE[:40] + past_covs = TS_PAST_COV[:40] + if not single_series: + series = [series] * 2 + past_covs = [past_covs] * 2 - series_info = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/series_info.json" - ) - assert series_info["series"]["count"] == self.ts_univariate.n_components - assert series_info["series"]["names"] == self.ts_univariate.components.tolist() - assert series_info["past_covariates"]["used"] is True - assert series_info["past_covariates"]["count"] == 1 - assert ( - series_info["past_covariates"]["names"] - == self.ts_past_cov.components.tolist() - ) - assert series_info["future_covariates"]["used"] is False - assert series_info["static_covariates"]["used"] is False - - def test_autolog_series_info_multi_series(self, mlflow_tracking, autolog_context): - """Fitting on a list of series doesn't leave past_covariates unreported: - `model.past_covariate_series` stays None for a multi-series fit, so the - info must come from the actual `fit()` call arguments instead.""" - series = [self.ts_univariate, self.ts_univariate * 1.2] - past_covs = [self.ts_past_cov[:50], self.ts_past_cov[:50]] with autolog_context(): with mlflow.start_run() as run: model = LinearRegressionModel(lags=5, lags_past_covariates=3) @@ -431,12 +353,15 @@ def test_autolog_series_info_multi_series(self, mlflow_tracking, autolog_context series_info = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/series_info.json" ) + assert series_info["series"]["count"] == TS_UNIVARIATE.n_components + assert series_info["series"]["names"] == TS_UNIVARIATE.components.tolist() assert series_info["past_covariates"]["used"] is True assert series_info["past_covariates"]["count"] == 1 assert ( - series_info["past_covariates"]["names"] - == self.ts_past_cov.components.tolist() + series_info["past_covariates"]["names"] == TS_PAST_COV.components.tolist() ) + assert series_info["future_covariates"]["used"] is False + assert series_info["static_covariates"]["used"] is False def test_autolog_series_info_add_encoders(self, mlflow_tracking, autolog_context): """Covariates generated purely via `add_encoders` (no explicit @@ -449,7 +374,7 @@ def test_autolog_series_info_add_encoders(self, mlflow_tracking, autolog_context lags_future_covariates=[0], add_encoders={"datetime_attribute": {"future": ["month"]}}, ) - model.fit(self.ts_univariate[:40]) + model.fit(TS_UNIVARIATE[:40]) series_info = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/series_info.json" @@ -461,13 +386,11 @@ def test_autolog_series_info_add_encoders(self, mlflow_tracking, autolog_context assert series_info["future_covariates"]["encodings"] == expected_names assert series_info["past_covariates"]["used"] is False - def test_autolog_series_info_static_is_global( + def test_autolog_series_info_static_covariates( self, mlflow_tracking, autolog_context ): - """`is_global` is based on row count vs. the number of series - components, not the number of static-covariate columns.""" # one shared row over 2 components -> global - global_target = self.ts_multivariate.with_static_covariates( + global_target = TS_MULTIVARIATE.with_static_covariates( pd.DataFrame({"a": [1.0], "b": [2.0]}) ) with autolog_context(): @@ -480,7 +403,7 @@ def test_autolog_series_info_static_is_global( assert series_info["static_covariates"]["names"] == ["a", "b"] # one row per component (2 components, 2 rows) -> component-specific - per_component_target = self.ts_multivariate.with_static_covariates( + per_component_target = TS_MULTIVARIATE.with_static_covariates( pd.DataFrame({"a": [1.0, 2.0]}) ) with autolog_context(): @@ -492,23 +415,29 @@ def test_autolog_series_info_static_is_global( assert series_info["static_covariates"]["count"] == 1 assert series_info["static_covariates"]["names"] == ["a"] + @pytest.mark.parametrize("method", ["historical_forecasts", "backtest"]) def test_autolog_historical_forecasts_series_info_covariates( - self, mlflow_tracking, autolog_context + self, mlflow_tracking, autolog_context, method ): - """HF without a prior fit() still reports explicit covariates and static - covariates in series_info / tags (outer model stays unfitted).""" - target = self.ts_univariate.with_static_covariates( + """HF and backtest without a prior fit() still reports model params and series_info + (but not the model artifact).""" + target = TS_UNIVARIATE.with_static_covariates( pd.DataFrame({"static_feat": [1.0]}) ) - with autolog_context(): + with autolog_context(log_models=True): with mlflow.start_run() as run: - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.historical_forecasts( + model = LinearRegressionModel( + lags=5, + lags_past_covariates=3, + lags_future_covariates=[0], + add_encoders={"datetime_attribute": {"future": ["month"]}}, + ) + _ = getattr(model, method)( series=target, - past_covariates=self.ts_past_cov, + past_covariates=TS_PAST_COV, forecast_horizon=1, retrain=True, - start=0.5, + start=-1, ) series_info = mlflow.artifacts.load_dict( @@ -516,104 +445,37 @@ def test_autolog_historical_forecasts_series_info_covariates( ) assert series_info["past_covariates"]["used"] is True assert ( - series_info["past_covariates"]["names"] - == self.ts_past_cov.components.tolist() + series_info["past_covariates"]["names"] == TS_PAST_COV.components.tolist() ) + assert series_info["future_covariates"]["used"] is True assert series_info["static_covariates"]["used"] is True assert series_info["static_covariates"]["names"] == ["static_feat"] tags = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.tags + assert tags["model_uses_future_covariates"] == "True" assert tags["model_uses_past_covariates"] == "True" assert tags["model_uses_static_covariates"] == "True" - def test_autolog_historical_forecasts_series_info_add_encoders( - self, mlflow_tracking, autolog_context - ): - """HF with add_encoders (no explicit cov args) marks future covariates - as used even though the outer model remains unfitted.""" - with autolog_context(): - with mlflow.start_run() as run: - model = LinearRegressionModel( - lags=5, - lags_future_covariates=[0], - add_encoders={"datetime_attribute": {"future": ["month"]}}, - ) - model.historical_forecasts( - series=self.ts_univariate, - forecast_horizon=1, - retrain=True, - start=0.5, - ) - - series_info = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/series_info.json" - ) - assert series_info["future_covariates"]["used"] is True - tags = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.tags - assert tags["model_uses_future_covariates"] == "True" - - def test_autolog_backtest_series_info_covariates( - self, mlflow_tracking, autolog_context - ): - """backtest(retrain=True) without a prior fit() reports covariates via - the internal historical_forecasts path.""" - with autolog_context(): - with mlflow.start_run() as run: - model = LinearRegressionModel(lags=5, lags_past_covariates=3) - model.backtest( - series=self.ts_univariate, - past_covariates=self.ts_past_cov, - forecast_horizon=1, - retrain=True, - start=0.5, - metric=dm.mae, - ) - - series_info = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/series_info.json" - ) - assert series_info["past_covariates"]["used"] is True - assert ( - series_info["past_covariates"]["names"] - == self.ts_past_cov.components.tolist() - ) - - def test_autolog_historical_forecasts_logs_model_setup( - self, mlflow_tracking, autolog_context - ): - """historical_forecasts(retrain=True) without a prior fit() still logs - model params and series_info (but not the model artifact).""" - with autolog_context(): - with mlflow.start_run() as run: - model = NaiveSeasonal(K=1) - model.historical_forecasts( - series=self.ts_univariate, forecast_horizon=1, retrain=True - ) - params = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/model_params.json" ) - assert params["K"] == 1 - series_info = mlflow.artifacts.load_dict( - f"runs:/{run.info.run_id}/series_info.json" - ) - assert series_info["series"]["names"] == self.ts_univariate.components.tolist() - client = mlflow.tracking.MlflowClient() - artifact_paths = [a.path for a in client.list_artifacts(run.info.run_id)] - assert "model" not in artifact_paths - assert ( - client.get_run(run.info.run_id).data.tags["model_class"] == "NaiveSeasonal" + assert params["lags"] == 5 + + # model artifact is not available + logged_models = mlflow_tracking.search_logged_models( + experiment_ids=[run.info.experiment_id] ) + assert len(logged_models) == 0 def test_autolog_historical_forecasts_retrain_false_skips_model_setup( self, mlflow_tracking, autolog_context ): """historical_forecasts(retrain=False) does not log model setup.""" model = LinearRegressionModel(lags=5) - model.fit(self.ts_univariate[:40]) + model.fit(TS_UNIVARIATE[:40]) with autolog_context(): with mlflow.start_run() as run: model.historical_forecasts( - series=self.ts_univariate, + series=TS_UNIVARIATE, forecast_horizon=1, retrain=False, start=0.5, @@ -632,9 +494,9 @@ def test_autolog_historical_forecasts_overwrites_fit_setup( with autolog_context(): with mlflow.start_run() as run: model = LinearRegressionModel(lags=5) - model.fit(self.ts_univariate[:30]) + model.fit(TS_UNIVARIATE[:30]) model.historical_forecasts( - series=self.ts_multivariate, + series=TS_MULTIVARIATE, forecast_horizon=1, retrain=True, start=0.5, @@ -643,14 +505,12 @@ def test_autolog_historical_forecasts_overwrites_fit_setup( series_info = mlflow.artifacts.load_dict( f"runs:/{run.info.run_id}/series_info.json" ) - assert ( - series_info["series"]["names"] == self.ts_multivariate.components.tolist() - ) + assert series_info["series"]["names"] == TS_MULTIVARIATE.components.tolist() def test_multivariate_with_all_covariate_types(self, mlflow_tracking): """Test saving/loading multivariate series with all covariate types""" # create multivariate target with static covariates - target = self.ts_multivariate.with_static_covariates( + target = TS_MULTIVARIATE.with_static_covariates( pd.DataFrame({"static_feat_1": [1.0], "static_feat_2": [2.0]}) ) @@ -659,8 +519,8 @@ def test_multivariate_with_all_covariate_types(self, mlflow_tracking): ) model.fit( target[:40], - past_covariates=self.ts_past_cov[:40], - future_covariates=self.ts_future_cov[:50], + past_covariates=TS_PAST_COV[:40], + future_covariates=TS_FUTURE_COV[:50], ) with mlflow.start_run(): @@ -673,54 +533,63 @@ def test_multivariate_with_all_covariate_types(self, mlflow_tracking): model, n=5, series=target[:40], - past_covariates=self.ts_past_cov, - future_covariates=self.ts_future_cov, + past_covariates=TS_PAST_COV, + future_covariates=TS_FUTURE_COV, ) @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_pytorch_autolog_with_existing_callbacks( - self, mlflow_tracking, autolog_context - ): - """Test pytorch autolog works when model already has callbacks""" - # create model with existing callback - if TORCH_AVAILABLE: - import pytorch_lightning as pl + def test_autolog_pytorch(self, mlflow_tracking, autolog_context): + """Test that autolog logs training metrics for torch models""" + import pytorch_lightning as pl + import torchmetrics + from mlflow.utils.autologging_utils import autologging_is_disabled - existing_callback = pl.callbacks.EarlyStopping(monitor="train_loss") - else: - pytest.skip("PyTorch Lightning not available") + existing_callback = pl.callbacks.EarlyStopping(monitor="train_loss") + tfm_kwargs_ = copy.deepcopy(tfm_kwargs) + tfm_kwargs_["pl_trainer_kwargs"] = { + **tfm_kwargs_["pl_trainer_kwargs"], + "callbacks": [existing_callback], + } with autolog_context(): - model = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=2, - pl_trainer_kwargs={ - **tfm_kwargs_dev.get("pl_trainer_kwargs", {}), - "callbacks": [existing_callback], - }, - **{k: v for k, v in tfm_kwargs_dev.items() if k != "pl_trainer_kwargs"}, - ) + assert not autologging_is_disabled("pytorch") + with mlflow.start_run(): + model = NBEATSModel( + input_chunk_length=4, + output_chunk_length=2, + n_epochs=2, + torch_metrics=torchmetrics.MeanAbsoluteError(), + **tfm_kwargs_, + ) + train, val = TS_UNIVARIATE.split_before(0.7) + model.fit(train, val_series=val) + assert autologging_is_disabled("pytorch") - train, val = self.ts_univariate.split_before(0.7) - model.fit(train, val_series=val) + # verify existing callback is still present (not removed by autolog) + callbacks = model.trainer_params.get("callbacks", []) + has_existing = any( + isinstance(cb, pl.callbacks.EarlyStopping) for cb in callbacks + ) + assert has_existing, "Existing EarlyStopping callback should be preserved" - # verify existing callback is still present (not removed by autolog) - callbacks = model.trainer_params.get("callbacks", []) - has_existing = any( - isinstance(cb, pl.callbacks.EarlyStopping) for cb in callbacks - ) - assert has_existing, "Existing EarlyStopping callback should be preserved" + runs = mlflow.search_runs() + assert len(runs) == 1, "Expected exactly one run" + last_run = runs.iloc[0] + last_run_id = last_run["run_id"] + assert last_run["tags.model_class"] == "NBEATSModel" - # verify metrics were still logged via mlflow.pytorch.autolog - runs = mlflow.search_runs() - assert len(runs) >= 1, "Expected at least one run" - last_run_id = runs.iloc[0]["run_id"] - client = mlflow.tracking.MlflowClient() - train_metrics = client.get_metric_history(last_run_id, "train_loss") - assert len(train_metrics) > 0, ( - "Expected train_loss metrics to be logged via pytorch autolog" - ) + client = mlflow.tracking.MlflowClient() + + # check train_loss metrics + train_metrics = client.get_metric_history(last_run_id, "train_loss") + val_metrics = client.get_metric_history(last_run_id, "val_loss") + torch_metrics = client.get_metric_history(last_run_id, "val_MeanAbsoluteError") + + for metrics in [train_metrics, val_metrics, torch_metrics]: + assert len(metrics) == 2 + for idx, m in enumerate(metrics): + assert np.isfinite(m.value) + assert m.step == idx def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): """Test that multiple fits with autolog create separate runs""" @@ -729,10 +598,10 @@ def test_autolog_multiple_fits(self, mlflow_tracking, autolog_context): # so we explicitly start runs for each fit with mlflow.start_run(): model2 = LinearRegressionModel(lags=5) - model2.fit(self.ts_univariate) + model2.fit(TS_UNIVARIATE) with mlflow.start_run(): model1 = ExponentialSmoothing() - model1.fit(self.ts_univariate) + model1.fit(TS_UNIVARIATE) runs = mlflow.search_runs() assert len(runs) == 2, "Expected two separate runs for two fits" @@ -763,7 +632,7 @@ def test_autolog_ensemble_model_fit_logs_once( with autolog_context(log_models=True): with mlflow.start_run() as run: - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) logged_models = mlflow_tracking.search_logged_models( experiment_ids=[run.info.experiment_id] @@ -774,59 +643,11 @@ def test_autolog_ensemble_model_fit_logs_once( ) assert logged_models[0].name == "RegressionEnsembleModel" - @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_autolog_torch_model_multiple_fits(self, mlflow_tracking, autolog_context): - """Test autolog with multiple fits of a torch model""" - with autolog_context(): - with mlflow.start_run(): - model1 = NBEATSModel( - input_chunk_length=4, - output_chunk_length=2, - n_epochs=1, - **tfm_kwargs_dev, - ) - train, val = self.ts_univariate.split_before(0.7) - model1.fit(train, val_series=val) - - with mlflow.start_run(): - model2 = LinearRegressionModel(lags=5) - model2.fit(self.ts_univariate) - - runs = mlflow.search_runs() - assert len(runs) == 2, "Expected two separate runs for two fits" - - for _, run in runs.iterrows(): - assert run["tags.model_class"] in [ - "NBEATSModel", - "LinearRegressionModel", - ] - assert run["tags.mlflow.runName"] is not None - - def test_save_load_preserves_series_metadata(self, tmpdir_fn): - """Test that save/load preserves multivariate and static covariate structure""" - target = self.ts_multivariate.with_static_covariates( - pd.DataFrame({"stat1": [1.0], "stat2": [2.0]}) - ) - - model = LinearRegressionModel(lags=5) - model.fit(target) - - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) - - loaded_model = load_model(f"file://{model_path}") - - pred_original = model.predict(n=3) - pred_loaded = loaded_model.predict(n=3, series=target) - - # verify multivariate structure preserved - assert pred_original.width == pred_loaded.width == 2, ( - "Should maintain 2 components" - ) - assert pred_original.n_components == pred_loaded.n_components == 2 - - np.testing.assert_array_almost_equal( - pred_original.values(), pred_loaded.values(), decimal=4 + assert_predictions_equal( + model, + load_model(logged_models[0].model_uri), + n=5, + series=TS_UNIVARIATE, ) def test_load_nonexistent_model(self): @@ -846,7 +667,7 @@ def test_load_corrupted_mlmodel_fails(self, tmpdir_fn): """Test that loading with corrupted MLmodel file fails""" # save a valid model model = LinearRegressionModel(lags=5) - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) @@ -864,7 +685,7 @@ def test_load_missing_model_file_fails(self, tmpdir_fn): """Test that loading with missing model data file fails""" # save a valid model model = LinearRegressionModel(lags=5) - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) @@ -891,7 +712,7 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): else: model = model_cls() - model.fit(self.ts_univariate) + model.fit(TS_UNIVARIATE) model_path = os.path.join(tmpdir_fn, "test_model") save_model(model, model_path) @@ -900,89 +721,41 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): # Only pass series for global models (LinearRegressionModel) # Local models (ExponentialSmoothing) don't need it if isinstance(model, GlobalForecastingModel): - assert_predictions_equal(model, loaded, n=5, series=self.ts_univariate) + assert_predictions_equal(model, loaded, n=5, series=TS_UNIVARIATE) else: assert_predictions_equal(model, loaded, n=5, is_global=False) @pytest.mark.parametrize( "series,series_name", [ - ("ts_multivariate", "multivariate"), - ("ts_with_static", "static_covariates"), + (TS_MULTIVARIATE, "multivariate"), + (TS_WITH_STATIC, "static_covariates"), ], ) def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): """Test save/load with multivariate and static covariate series""" - test_series = getattr(self, series) - model = LinearRegressionModel(lags=5) - model.fit(test_series) + model.fit(series) model_path = os.path.join(tmpdir_fn, f"test_model_{series_name}") save_model(model, model_path) loaded_model = load_model(f"file://{model_path}") - assert_predictions_equal(model, loaded_model, n=3, series=test_series) + assert_predictions_equal(model, loaded_model, n=3, series=series) # verify the series dimensions are preserved pred_original = model.predict(n=3) - pred_loaded = loaded_model.predict(n=3, series=test_series) + pred_loaded = loaded_model.predict(n=3, series=series) assert pred_original.width == pred_loaded.width - def test_autolog_metric_logging_scalar(self, mlflow_tracking, autolog_context): - """Calling a darts metric inside an active run logs a scalar to MLflow.""" - with autolog_context(log_metrics=True): - with mlflow.start_run() as run: - result = dm.mae(self.ts_univariate, self.ts_univariate * 1.1) - - run_data = mlflow.get_run(run.info.run_id).data - assert "mae" in run_data.metrics, "mae should be logged to MLflow" - assert np.isfinite(run_data.metrics["mae"]) - assert np.isscalar(result) - assert np.isfinite(float(result)) - - def test_autolog_metric_repeated_call(self, mlflow_tracking, autolog_context): - """Calling the same metric twice overwrites the value (last-value-wins).""" - with autolog_context(log_metrics=True): - with mlflow.start_run() as run: - dm.rmse(self.ts_univariate, self.ts_univariate * 1.1) - dm.rmse(self.ts_univariate, self.ts_univariate * 1.2) - - run_data = mlflow.get_run(run.info.run_id).data - assert "rmse" in run_data.metrics, "rmse should be logged to MLflow" - - def test_autolog_metric_per_component(self, mlflow_tracking, autolog_context): - """Non-scalar metric results logged per-component as {name}_{component_name}. - - ts_multivariate = ts_univariate.stack(ts_univariate * 1.5), whose component - names are ['linear', 'linear_1']. With component_reduction=None the result - is a 1-D array (one value per component), so the expected keys are - 'mae_linear' and 'mae_linear_1'. - """ - with autolog_context(log_metrics=True): - with mlflow.start_run() as run: - dm.mae( - self.ts_multivariate, - self.ts_multivariate * 1.1, - component_reduction=None, - ) - - run_data = mlflow.get_run(run.info.run_id).data - assert "mae_linear" in run_data.metrics, ( - "Component 'linear' should be logged as mae_linear" - ) - assert "mae_linear_1" in run_data.metrics, ( - "Component 'linear_1' should be logged as mae_linear_1" - ) - assert np.isfinite(run_data.metrics["mae_linear"]) - assert np.isfinite(run_data.metrics["mae_linear_1"]) +class TestAutoLogStandaloneMetrics: def test_autolog_metric_no_active_run(self, mlflow_tracking, autolog_context): """Calling a metric without an active run does not raise and returns correctly.""" with autolog_context(log_metrics=True): # called outside any start_run — must not raise - result = dm.mse(self.ts_univariate, self.ts_univariate * 1.1) + result = dm.mse(TS_UNIVARIATE, TS_UNIVARIATE * 1.1) assert np.isscalar(result) assert np.isfinite(float(result)) @@ -992,13 +765,13 @@ def test_autolog_metric_returns_correct_value( ): """The patched metric returns the same value whether inside or outside a run.""" with autolog_context(log_metrics=True): - pred = self.ts_univariate * 1.05 + pred = TS_UNIVARIATE * 1.05 with mlflow.start_run(): - result_inside = dm.mae(self.ts_univariate, pred) + result_inside = dm.mae(TS_UNIVARIATE, pred) # call outside a run — no logging, same computation - result_outside = dm.mae(self.ts_univariate, pred) + result_outside = dm.mae(TS_UNIVARIATE, pred) np.testing.assert_almost_equal(result_inside, result_outside, decimal=6) assert np.isfinite(result_inside) @@ -1007,7 +780,7 @@ def test_autolog_log_metrics_false(self, mlflow_tracking, autolog_context): """autolog(log_metrics=False) leaves metrics unpatched — nothing is logged.""" with autolog_context(log_metrics=False): with mlflow.start_run() as run: - dm.mape(self.ts_univariate, self.ts_univariate * 1.1) + dm.mape(TS_UNIVARIATE, TS_UNIVARIATE * 1.1) run_data = mlflow.get_run(run.info.run_id).data assert "mape" not in run_data.metrics, ( @@ -1023,31 +796,19 @@ def test_autolog_metric_any_import_path_logs( attribute, and `darts.metrics.mae` and `darts.metrics.metrics.mae` are the same function object. """ + from darts.metrics import mae + with autolog_context(log_metrics=True): with mlflow.start_run() as run_public: - dm.mae(self.ts_univariate, self.ts_univariate * 1.1) - with mlflow.start_run() as run_impl: - dmm.mae(self.ts_univariate, self.ts_univariate * 1.1) + dm.mae(TS_UNIVARIATE, TS_UNIVARIATE * 1.1) + with mlflow.start_run() as run_module: + dmm.mae(TS_UNIVARIATE, TS_UNIVARIATE * 1.1) + with mlflow.start_run() as run_explicit: + mae(TS_UNIVARIATE, TS_UNIVARIATE * 1.1) assert "mae" in mlflow.get_run(run_public.info.run_id).data.metrics - assert "mae" in mlflow.get_run(run_impl.info.run_id).data.metrics - - def test_autolog_metric_import_order_independent( - self, mlflow_tracking, autolog_context - ): - """A metric imported via `from darts.metrics import ` *before* - autolog() is enabled still logs correctly, since the hook lives inside - the metric's own `multi_ts_support` decorator rather than patching a - module attribute after the fact.""" - from darts.metrics import mae as mae_imported_before_autolog - - with autolog_context(log_metrics=True): - with mlflow.start_run() as run: - mae_imported_before_autolog( - self.ts_univariate, self.ts_univariate * 1.1 - ) - - assert "mae" in mlflow.get_run(run.info.run_id).data.metrics + assert "mae" in mlflow.get_run(run_module.info.run_id).data.metrics + assert "mae" in mlflow.get_run(run_explicit.info.run_id).data.metrics def test_autolog_metric_internal_composite_call_not_double_logged( self, mlflow_tracking, autolog_context @@ -1057,12 +818,87 @@ def test_autolog_metric_internal_composite_call_not_double_logged( not twice (rmse and the internal mse call).""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - dm.rmse(self.ts_univariate, self.ts_univariate * 1.1) + dm.rmse(TS_UNIVARIATE, TS_UNIVARIATE * 1.1) metrics = mlflow.get_run(run.info.run_id).data.metrics assert "rmse" in metrics assert "mse" not in metrics + def test_autolog_metric_logging_scalar(self, mlflow_tracking, autolog_context): + """Calling a darts metric inside an active run logs a scalar to MLflow.""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + result = dm.mae(TS_UNIVARIATE, TS_UNIVARIATE + 0.1) + + run_data = mlflow.get_run(run.info.run_id).data + assert "mae" in run_data.metrics, "mae should be logged to MLflow" + assert run_data.metrics["mae"] == result == pytest.approx(0.1, abs=1e-5) + + def test_autolog_metric_repeated_call(self, mlflow_tracking, autolog_context): + """Calling the same metric twice overwrites the value (last-value-wins).""" + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + dm.rmse(TS_UNIVARIATE, TS_UNIVARIATE) + result = dm.rmse(TS_UNIVARIATE, TS_UNIVARIATE + 2.0) + + run_data = mlflow.get_run(run.info.run_id).data + assert "rmse" in run_data.metrics, "rmse should be logged to MLflow" + assert run_data.metrics["rmse"] == result == pytest.approx(2.0, abs=1e-5) + + def test_autolog_metric_per_component(self, mlflow_tracking, autolog_context): + """Non-scalar metric results logged per-component as {name}_{component_name}. + + ts_multivariate = ts_univariate.stack(ts_univariate * 1.5), whose component + names are ['sine', 'sine_1']. With component_reduction=None the result + is a 1-D array (one value per component), so the expected keys are + 'mae_sine' and 'mae_sine_1'. + """ + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + result = dm.mae( + TS_MULTIVARIATE, + TS_MULTIVARIATE * 1.1, + component_reduction=None, + ) + comps = TS_MULTIVARIATE.components + assert result.shape == (len(comps),) + run_data = mlflow.get_run(run.info.run_id).data + for comp, value in zip(comps, result): + assert f"mae_{comp}" in run_data.metrics + assert run_data.metrics[f"mae_{comp}"] == value + + def test_autolog_metric_per_component_and_q_label( + self, mlflow_tracking, autolog_context + ): + """Non-scalar metric results logged per-component and quantile / label as + {name}_{component_name}_q{quantile / label}. + + E.g. ["mae_comp0_q0.100", ..., "mae_comp0_q0.900", "mae_comp1_q0.100", ..., "mae_comp1_q0.900"] + """ + vals = TS_MULTIVARIATE.all_values() + series_prob = TS_MULTIVARIATE.with_values( + np.concatenate([vals * 0.9, vals, vals * 1.2], axis=2) + ) + quantiles = [0.1, 0.5, 0.9] + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + result = dm.mae( + TS_MULTIVARIATE, + series_prob, + component_reduction=None, + q=quantiles, + ) + comps = TS_MULTIVARIATE.components + assert result.shape == (len(comps) * len(quantiles),) + run_data = mlflow.get_run(run.info.run_id).data + for c_idx, comp in enumerate(comps): + for q_idx, q in enumerate(quantiles): + value = result[c_idx * len(quantiles) + q_idx] + assert f"mae_{comp}_q{q:.3f}" in run_data.metrics + assert run_data.metrics[f"mae_{comp}_q{q:.3f}"] == pytest.approx( + value, abs=1e-5 + ) + def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): """A per-timestep metric (ae) logs one value per timestep across MLflow steps. @@ -1070,17 +906,14 @@ def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): axis, which is mapped to the MLflow step (mirroring the backtest path) rather than being mislabeled as per-component. """ - train = self.ts_univariate[:40] - model = LinearRegressionModel(lags=4) - model.fit(train) - pred = model.predict(n=10) - actual = self.ts_univariate[40:] - + actual = TS_UNIVARIATE[40:] with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = dm.ae(actual, pred) + ref = dm.ae(actual, actual + 1.0) ref = np.asarray(ref, dtype=float) # shape (n_timesteps,) + assert ref.shape == (len(actual),) + history = mlflow_tracking.get_metric_history(run.info.run_id, "ae") assert len(history) == len(ref), "Expected one step per timestep" steps = sorted(m.step for m in history) @@ -1088,11 +921,47 @@ def test_autolog_metric_per_timestep(self, mlflow_tracking, autolog_context): logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, ref, atol=1e-5) + def test_autolog_metric_per_timestep_component_and_q_label( + self, mlflow_tracking, autolog_context + ): + """A per-timestep metric (ae) logs one value per timestep and component and quantile / label as + {name}_{component_name}_q{quantile / label}. + + E.g. ["mae_comp0_q0.100", ..., "mae_comp0_q0.900", "mae_comp1_q0.100", ..., "mae_comp1_q0.900"] + """ + actual = TS_MULTIVARIATE[40:] + vals = actual.all_values() + series_prob = actual.with_values( + np.concatenate([vals * 0.9, vals, vals * 1.2], axis=2) + ) + quantiles = [0.1, 0.5, 0.9] + comps = actual.components + + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = dm.ae(actual, series_prob, component_reduction=None, q=quantiles) + + ref = np.asarray(ref, dtype=float) + assert ref.shape == (len(actual), len(comps) * len(quantiles)) + + for c_idx, comp in enumerate(comps): + for q_idx, q in enumerate(quantiles): + history = mlflow_tracking.get_metric_history( + run.info.run_id, f"ae_{comp}_q{q:.3f}" + ) + assert len(history) == len(ref) + steps = sorted(m.step for m in history) + assert steps == list(range(len(actual))) + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose( + logged, ref[:, c_idx * len(quantiles) + q_idx], atol=1e-5 + ) + def test_autolog_metric_aligns_time_axis_by_forecast_position( self, mlflow_tracking, autolog_context ): """Each series starts at forecast position zero.""" - ts_long = self.ts_univariate # length 50 + ts_long = TS_UNIVARIATE # length 50 ts_short = ts_long[10:] # length 40, same end, starts 10 steps later # distinct constant error per series, so a step's mean reveals exactly @@ -1112,7 +981,7 @@ def test_autolog_metric_aligns_time_axis_by_forecast_position( for step in range(40, 50): assert by_step[step] == pytest.approx(1.0, abs=1e-4), step - rows = self._read_per_series_table(run.info.run_id) + rows = _read_per_series_table(run.info.run_id) steps_by_series = {0: set(), 1: set()} for r in rows: steps_by_series[r["series_index"]].add(r["step"]) @@ -1121,19 +990,20 @@ def test_autolog_metric_aligns_time_axis_by_forecast_position( def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile with matching values.""" - train = self.ts_univariate[:40] - model = LinearRegressionModel( - lags=4, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] + actual = TS_UNIVARIATE[40:] + vals = actual.all_values() + pred = actual.with_values( + np.concatenate([vals - 1.0, vals, vals + 1.0], axis=2) ) - model.fit(train) - pred = model.predict(n=10, num_samples=200) - actual = self.ts_univariate[40:] + quantiles = [0.1, 0.5, 0.9] with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = dm.mql(actual, pred, q=[0.1, 0.5, 0.9]) + ref = dm.mql(actual, pred, q=quantiles) ref = np.asarray(ref, dtype=float) # shape (n_quantiles,) + assert ref.shape == (len(quantiles),) + m = mlflow.get_run(run.info.run_id).data.metrics for i, key in enumerate(("mql_q0.100", "mql_q0.500", "mql_q0.900")): assert key in m, f"Expected quantile key {key}" @@ -1141,38 +1011,45 @@ def test_autolog_metric_quantile(self, mlflow_tracking, autolog_context): def test_autolog_metric_quantile_interval(self, mlflow_tracking, autolog_context): """A quantile interval metric (miw) logs one key per interval.""" - train = self.ts_univariate[:40] - model = LinearRegressionModel( - lags=4, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] + actual = TS_UNIVARIATE[40:] + vals = actual.all_values() + pred = actual.with_values( + np.concatenate([vals - 1.0, vals, vals + 1.0], axis=2) ) - model.fit(train) - pred = model.predict(n=10, num_samples=200) - actual = self.ts_univariate[40:] + q_intervals = [(0.1, 0.9), (0.2, 0.8)] with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = dm.miw(actual, pred, q_interval=(0.1, 0.9)) + ref = dm.miw( + actual, + pred, + q_interval=q_intervals, + ) + ref = np.atleast_1d(ref) + assert ref.shape == (len(q_intervals),) m = mlflow.get_run(run.info.run_id).data.metrics - assert "miw_qi0.800" in m - assert m["miw_qi0.800"] == pytest.approx(float(ref), abs=1e-5) + for i, key in enumerate(("miw_qi0.800", "miw_qi0.600")): + assert key in m, f"Expected quantile key {key}" + assert m[key] == pytest.approx(ref[i], abs=1e-5) def test_autolog_metric_multi_series(self, mlflow_tracking, autolog_context): """A list of series logs the mean over series; per-series values go to a table.""" - series = [self.ts_univariate, self.ts_univariate * 1.2] + series = [TS_UNIVARIATE, TS_UNIVARIATE * 1.2] pred = [s * 1.1 for s in series] with autolog_context(log_metrics=True): with mlflow.start_run() as run: ref = dm.mae(series, pred) - ref = np.asarray(ref, dtype=float) # shape (n_series,) + ref = np.atleast_1d(ref) + assert ref.shape == (len(series),) m = mlflow.get_run(run.info.run_id).data.metrics - # aggregate = mean over series, no per-series _s{i} keys - assert m["mae"] == pytest.approx(float(np.mean(ref)), abs=1e-5) + # agg_func = np.nanmean over series, no per-series _s{i} keys + assert m["mae"] == pytest.approx(float(np.nanmean(ref)), abs=1e-5) assert not any(k.startswith("mae_s") for k in m) # granular per-series breakdown written to a table artifact - rows = self._read_per_series_table(run.info.run_id) + rows = _read_per_series_table(run.info.run_id) by_series = {int(row["series_index"]): float(row["value"]) for row in rows} assert by_series == pytest.approx({0: ref[0], 1: ref[1]}, abs=1e-5) @@ -1182,7 +1059,7 @@ def test_autolog_metric_multi_series_custom_agg_func( """autolog()'s agg_func controls how per-series values are aggregated into the single logged metric (default np.mean).""" # 3 series with distinct, asymmetric per-series errors so median != mean - series = [self.ts_univariate * f for f in (1.0, 1.2, 5.0)] + series = [TS_UNIVARIATE * f for f in (1.0, 1.2, 5.0)] pred = [s * 1.1 for s in series] with autolog_context(log_metrics=True, agg_func=np.median): @@ -1199,37 +1076,39 @@ def test_autolog_metric_multi_series_per_component( ): """A list of multivariate series with component_reduction=None logs the per-component mean over series; the CSV carries one row per (component, series).""" - series = [self.ts_multivariate, self.ts_multivariate * 1.2] + series = [TS_MULTIVARIATE, TS_MULTIVARIATE * 1.2] pred = [s * 1.1 for s in series] with autolog_context(log_metrics=True): with mlflow.start_run() as run: ref = dm.mae(series, pred, component_reduction=None) - ref = np.asarray(ref, dtype=float) # shape (n_series, n_components) + ref = np.asarray(ref, dtype=float) + assert ref.shape == (len(series), len(series[0].components)) + m = mlflow.get_run(run.info.run_id).data.metrics # aggregate per component = mean over series, no per-series _s{i} keys - assert m["mae_linear"] == pytest.approx(float(ref[:, 0].mean()), abs=1e-5) - assert m["mae_linear_1"] == pytest.approx(float(ref[:, 1].mean()), abs=1e-5) + assert m["mae_sine"] == pytest.approx(float(ref[:, 0].mean()), abs=1e-5) + assert m["mae_sine_1"] == pytest.approx(float(ref[:, 1].mean()), abs=1e-5) assert not any(k.endswith(("_s0", "_s1")) for k in m) # granular CSV: one row per (component, series) - rows = self._read_per_series_table(run.info.run_id) + rows = _read_per_series_table(run.info.run_id) got = { (row["key"], int(row["series_index"])): float(row["value"]) for row in rows } - assert got[("mae_linear", 0)] == pytest.approx(ref[0, 0], abs=1e-5) - assert got[("mae_linear", 1)] == pytest.approx(ref[1, 0], abs=1e-5) - assert got[("mae_linear_1", 0)] == pytest.approx(ref[0, 1], abs=1e-5) - assert got[("mae_linear_1", 1)] == pytest.approx(ref[1, 1], abs=1e-5) + assert got[("mae_sine", 0)] == pytest.approx(ref[0, 0], abs=1e-5) + assert got[("mae_sine", 1)] == pytest.approx(ref[1, 0], abs=1e-5) + assert got[("mae_sine_1", 0)] == pytest.approx(ref[0, 1], abs=1e-5) + assert got[("mae_sine_1", 1)] == pytest.approx(ref[1, 1], abs=1e-5) def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): """The metric `name` kwarg overrides only the metric-name token in the key, keeping the backtest prefix and the quantile/axis suffixes.""" - actual = self.ts_univariate - train = self.ts_univariate[:40] - qmodel = self._fit_qlr(train) + actual = TS_UNIVARIATE + train = TS_UNIVARIATE[:40] + qmodel = _fit_qlr(train) pred = qmodel.predict(n=10, num_samples=200) - target = self.ts_univariate[40:] + target = TS_UNIVARIATE[40:] with autolog_context(log_metrics=True): # direct call: name replaces the metric token; suffix (_q0_500) preserved @@ -1238,12 +1117,13 @@ def test_autolog_metric_name_override(self, mlflow_tracking, autolog_context): dm.mql(target, pred, q=0.5, name="myq") # backtest: name replaces the metric token; backtest_ prefix preserved with mlflow.start_run() as run_bt: - self._fit_lr().backtest( - self.ts_univariate, + _fit_lr().backtest( + TS_UNIVARIATE, + forecast_horizon=1, + start=-1, metric=dm.mae, metric_kwargs={"name": "custom"}, retrain=False, - stride=10, ) direct = mlflow.get_run(run_direct.info.run_id).data.metrics @@ -1273,11 +1153,13 @@ def test_autolog_metric_multi_series_classification_labels_explicit( series = [binary1, binary2] pred = series # perfect predictions → f1 == 1.0 per label per series + labels = [0, 1] with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = dm.f1(series, pred, label_reduction=None, labels=[0, 1]) + ref = dm.f1(series, pred, label_reduction=None, labels=labels) - ref = [np.asarray(r, dtype=float).flatten() for r in ref] + ref = np.array(ref) + assert ref.shape == (len(series), len(labels)) m = mlflow.get_run(run.info.run_id).data.metrics # aggregate per label = mean over series, no per-series _s{i} keys assert m["f1_label0"] == pytest.approx( @@ -1288,7 +1170,7 @@ def test_autolog_metric_multi_series_classification_labels_explicit( ) assert not any(k.endswith(("_s0", "_s1")) for k in m) # granular CSV: one row per (label, series) - rows = self._read_per_series_table(run.info.run_id) + rows = _read_per_series_table(run.info.run_id) got = { (row["key"], int(row["series_index"])): float(row["value"]) for row in rows } @@ -1301,7 +1183,7 @@ def test_autolog_metric_component_count_mismatch_allowed_when_reduced( ): """Default mae reduces components to scalars, so mixed component counts are valid and log under a single aggregated key.""" - series = [self.ts_univariate, self.ts_multivariate] + series = [TS_UNIVARIATE, TS_MULTIVARIATE] pred = [s * 1.1 for s in series] with autolog_context(log_metrics=True): @@ -1316,7 +1198,7 @@ def test_autolog_metric_component_count_mismatch_raises( ): """When components are preserved, mixed component counts raise rather than taking names from the first series and mislabeling the rest.""" - series = [self.ts_univariate, self.ts_multivariate] + series = [TS_UNIVARIATE, TS_MULTIVARIATE] pred = [s * 1.1 for s in series] with autolog_context(log_metrics=True): @@ -1333,13 +1215,13 @@ def test_autolog_metric_size_mismatch_raises( (and logs an error), propagating out of the public metric call — the metric callback isn't invoked through MLflow's safe_patch, so nothing catches it. No metrics are written for the failed call.""" - actual = self.ts_univariate[40:] + actual = TS_UNIVARIATE[40:] # mae with component_reduction=None on a univariate series produces shape (T,), # which is size T — divisible by c_size=1 (1 component × 1 quantile), so we # need to force a mismatch. We do that by monkey-patching _infer_metric_axes # to report has_comp_axis=True with a fake 3-component count, making c_size=3 # while the actual result is shape (T,). - train = self.ts_univariate[:40] + train = TS_UNIVARIATE[:40] model = LinearRegressionModel(lags=4) model.fit(train) pred = model.predict(n=10) @@ -1373,13 +1255,14 @@ def test_autolog_metric_per_series_table_schema_and_single_series_skip( """The per-series table has the expected schema for multi-series input, and no artifact is written for single-series input (mean == the value itself).""" # multi-series: artifact exists with the documented columns - multi = [self.ts_univariate, self.ts_univariate * 1.2] + multi = [TS_UNIVARIATE, TS_UNIVARIATE * 1.2] pred_multi = [s * 1.1 for s in multi] with autolog_context(log_metrics=True): with mlflow.start_run() as run_multi: - dm.mae(multi, pred_multi) + ref = np.asarray(dm.mae(multi, pred_multi), dtype=float) - rows = self._read_per_series_table(run_multi.info.run_id) + assert ref.shape == (len(multi),) + rows = _read_per_series_table(run_multi.info.run_id) assert list(rows[0].keys()) == [ "key", "series_index", @@ -1387,10 +1270,15 @@ def test_autolog_metric_per_series_table_schema_and_single_series_skip( "window_index", "value", ] - assert {int(r["series_index"]) for r in rows} == {0, 1} + for idx, (row, ref_i) in enumerate(zip(rows, ref)): + assert row["key"] == "mae" + assert int(row["series_index"]) == idx + assert np.isnan(row["step"]) + assert np.isnan(row["window_index"]) + assert row["value"] == pytest.approx(ref_i, abs=1e-5) # single-series: no per-series table artifact should be created - single = self.ts_univariate + single = TS_UNIVARIATE pred_single = single * 1.1 with autolog_context(log_metrics=True): with mlflow.start_run() as run_single: @@ -1401,71 +1289,199 @@ def test_autolog_metric_per_series_table_schema_and_single_series_skip( "Single-series input should not write a per-series table artifact" ) + +class TestAutoLogBacktestMetrics: def test_autolog_backtest_scalar(self, mlflow_tracking, autolog_context): """Default (reduced) backtest of a single univariate series logs one scalar.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr().backtest( - self.ts_univariate, metric=dm.mae, retrain=False, stride=10 + ref = _fit_lr().backtest( + TS_UNIVARIATE, metric=dm.mae, retrain=False, start=-2 ) - + ref = np.atleast_1d(ref) + assert ref.shape == (1,) run_data = mlflow.get_run(run.info.run_id).data assert "backtest_mae" in run_data.metrics - assert run_data.metrics["backtest_mae"] == pytest.approx(float(ref), abs=1e-5) + np.testing.assert_almost_equal(run_data.metrics["backtest_mae"], ref) def test_autolog_backtest_per_window_steps(self, mlflow_tracking, autolog_context): - """reduction=None logs per-window values at end-relative steps.""" + """reduction=None logs per-window values at steps.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr().backtest( - self.ts_univariate, + ref = _fit_lr().backtest( + TS_UNIVARIATE, metric=dm.mae, retrain=False, - stride=10, + start=-2, reduction=None, ) + ref = np.atleast_1d(ref) + assert ref.shape == (2,) history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") - assert len(history) > 1, "Expected multiple per-window steps" + assert len(history) == 2 steps = sorted(m.step for m in history) assert steps == list(range(len(history))) logged = [m.value for m in sorted(history, key=lambda m: m.step)] - np.testing.assert_allclose(logged, np.asarray(ref, dtype=float), atol=1e-5) + np.testing.assert_array_almost_equal(logged, ref) def test_autolog_backtest_per_component(self, mlflow_tracking, autolog_context): """component_reduction=None logs one key per component name.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr(self.ts_multivariate).backtest( - self.ts_multivariate, + ref = _fit_lr(TS_MULTIVARIATE).backtest( + TS_MULTIVARIATE, metric=dm.mae, retrain=False, - stride=10, + start=-2, metric_kwargs={"component_reduction": None}, ) + ref = np.atleast_1d(ref) + assert ref.shape == (TS_MULTIVARIATE.n_components,) run_data = mlflow.get_run(run.info.run_id).data - assert "backtest_mae_linear" in run_data.metrics - assert "backtest_mae_linear_1" in run_data.metrics + assert "backtest_mae_sine" in run_data.metrics + assert "backtest_mae_sine_1" in run_data.metrics ref = np.asarray(ref, dtype=float) - assert run_data.metrics["backtest_mae_linear"] == pytest.approx( - ref[0], abs=1e-5 - ) - assert run_data.metrics["backtest_mae_linear_1"] == pytest.approx( + assert run_data.metrics["backtest_mae_sine"] == pytest.approx(ref[0], abs=1e-5) + assert run_data.metrics["backtest_mae_sine_1"] == pytest.approx( ref[1], abs=1e-5 ) + def test_autolog_backtest_per_component_and_q_label( + self, mlflow_tracking, autolog_context + ): + """Aggregated windows; component_reduction=None logs one key per component name and + quantile / label as {name}_{component_name}_q{quantile / label}. + + E.g. ["backtest_mae_comp0_q0.100", ..., "backtest_mae_comp0_q0.900", "backtest_mae_comp1_q0.100", + ..., "backtest_mae_comp1_q0.900"] + """ + quantiles = [0.1, 0.5, 0.9] + comps = TS_MULTIVARIATE.components + n_windows = 2 + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = _fit_qlr(TS_MULTIVARIATE).backtest( + TS_MULTIVARIATE, + metric=dm.mae, + retrain=False, + start=-n_windows, + num_samples=3, + metric_kwargs={"component_reduction": None, "q": quantiles}, + reduction=np.nanmean, + ) + ref = np.atleast_1d(ref) + assert ref.shape == (len(comps) * len(quantiles),) + + run_data = mlflow.get_run(run.info.run_id).data + for c_idx, comp in enumerate(comps): + for q_idx, q in enumerate(quantiles): + name = f"backtest_mae_{comp}_q{q:.3f}" + assert name in run_data.metrics + assert run_data.metrics[name] == pytest.approx( + ref[c_idx * len(quantiles) + q_idx], abs=1e-5 + ) + + def test_autolog_backtest_per_window_component_and_q_label( + self, mlflow_tracking, autolog_context + ): + """Stepped window metrics; component_reduction=None logs one key per window, component name and + quantile / label as {name}_{component_name}_q{quantile / label}. + + E.g. ["backtest_mae_comp0_q0.100", ..., "backtest_mae_comp0_q0.900", "backtest_mae_comp1_q0.100", + ..., "backtest_mae_comp1_q0.900"] + """ + quantiles = [0.1, 0.5, 0.9] + comps = TS_MULTIVARIATE.components + n_windows = 2 + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = _fit_qlr(TS_MULTIVARIATE).backtest( + TS_MULTIVARIATE, + metric=dm.mae, + retrain=False, + start=-n_windows, + num_samples=3, + metric_kwargs={"component_reduction": None, "q": quantiles}, + reduction=None, + ) + ref = np.atleast_2d(ref) + assert ref.shape == (n_windows, len(comps) * len(quantiles)) + + for c_idx, comp in enumerate(comps): + for q_idx, q in enumerate(quantiles): + history = mlflow_tracking.get_metric_history( + run.info.run_id, f"backtest_mae_{comp}_q{q:.3f}" + ) + assert len(history) == len(ref) + steps = sorted(m.step for m in history) + assert steps == list(range(len(ref))) + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose( + logged, ref[:, c_idx * len(quantiles) + q_idx], atol=1e-5 + ) + + @pytest.mark.parametrize("reduction", [None, np.nanmean]) + def test_autolog_backtest_per_timestep_component_and_q_label( + self, mlflow_tracking, autolog_context, reduction + ): + """Stepped horizon metrics; component_reduction=None logs one key per window, component name and + quantile / label as {name}_{component_name}_q{quantile / label}. + + E.g. ["backtest_mae_comp0_q0.100", ..., "backtest_mae_comp0_q0.900", "backtest_mae_comp1_q0.100", + ..., "backtest_mae_comp1_q0.900"] + """ + quantiles = [0.1, 0.5, 0.9] + comps = TS_MULTIVARIATE.components + horizon = 3 + n_windows = 2 + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = _fit_qlr(TS_MULTIVARIATE).backtest( + TS_MULTIVARIATE, + metric=dm.ae, + retrain=False, + start=-(horizon + n_windows - 1), + forecast_horizon=horizon, + num_samples=3, + metric_kwargs={"component_reduction": None, "q": quantiles}, + reduction=reduction, + ) + if reduction is None: + assert ref.shape == (n_windows, horizon, len(comps) * len(quantiles)) + ref = np.nanmean(ref, axis=0) + + ref = np.atleast_2d(ref) + assert ref.shape == (horizon, len(comps) * len(quantiles)) + + for c_idx, comp in enumerate(comps): + for q_idx, q in enumerate(quantiles): + history = mlflow_tracking.get_metric_history( + run.info.run_id, f"backtest_ae_{comp}_q{q:.3f}" + ) + assert len(history) == len(ref) + steps = sorted(m.step for m in history) + assert steps == list(range(len(ref))) + logged = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_allclose( + logged, ref[:, c_idx * len(quantiles) + q_idx], atol=1e-5 + ) + def test_autolog_backtest_multi_metric(self, mlflow_tracking, autolog_context): """Multiple metrics are logged under one key each.""" + metrics = [dm.mae, dm.rmse] with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr().backtest( - self.ts_univariate, - metric=[dm.mae, dm.rmse], + ref = _fit_lr().backtest( + TS_UNIVARIATE, + metric=metrics, retrain=False, - stride=10, + start=-2, ) + ref = np.array(ref) + assert ref.shape == (len(metrics),) run_data = mlflow.get_run(run.info.run_id).data assert "backtest_mae" in run_data.metrics assert "backtest_rmse" in run_data.metrics @@ -1478,12 +1494,14 @@ def test_autolog_backtest_multi_metric(self, mlflow_tracking, autolog_context): def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): """A list of series logs the mean over series; per-series values go to a table.""" - series = [self.ts_univariate, self.ts_univariate * 1.2] + series = [TS_UNIVARIATE, TS_UNIVARIATE * 1.2] with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr(series).backtest( - series, metric=dm.mae, retrain=False, stride=10 + ref = _fit_lr(series).backtest( + series, metric=dm.mae, retrain=False, start=-2 ) + ref = np.atleast_1d(ref) + assert ref.shape == (len(series),) run_data = mlflow.get_run(run.info.run_id).data # aggregate = mean over series, no per-series _s{i} keys @@ -1492,96 +1510,115 @@ def test_autolog_backtest_multi_series(self, mlflow_tracking, autolog_context): ) assert not any(k.startswith("backtest_mae_s") for k in run_data.metrics) # granular per-series breakdown written to a table artifact - rows = self._read_per_series_table(run.info.run_id) + rows = _read_per_series_table(run.info.run_id) by_series = {int(row["series_index"]): float(row["value"]) for row in rows} assert by_series == pytest.approx( {0: float(ref[0]), 1: float(ref[1])}, abs=1e-5 ) - def test_autolog_backtest_multi_series_custom_agg_func(self, mlflow_tracking): + @pytest.mark.parametrize("horizon", [1, 3]) + def test_autolog_backtest_multi_series_custom_agg_func( + self, autolog_context, mlflow_tracking, horizon + ): """autolog()'s agg_func also controls the backtest() aggregation (default np.mean). Calls _log_backtest_metrics directly with a fabricated result so the per-series values are exact.""" - backtest_args = { - "metric": dm.mae, - "metric_kwargs": {}, - "series": [self.ts_univariate, self.ts_univariate, self.ts_univariate], - "forecast_horizon": 1, - "reduction": np.mean, - "last_points_only": True, - } - result = [1.0, 2.0, 100.0] # asymmetric -> median != mean - - with mlflow.start_run() as run: - client = MlflowAutologgingQueueingClient() - _log_backtest_metrics( - client, - run.info.run_id, - result, - {**BT_REQUIRED_DEFAUTLS, **backtest_args}, - agg_func=np.median, - ) - client.flush(synchronous=True) - + series = TS_UNIVARIATE + series = [series] * 3 + with autolog_context(log_metrics=True, agg_func=np.median): + with mlflow.start_run() as run: + ref = _fit_lr(series[0]).backtest( + metric=dm.mae, + series=series, + last_points_only=True, + start=-(horizon + 1), + forecast_horizon=horizon, + ) + ref = np.atleast_1d(ref) + assert ref.shape == (len(series),) # (n_series,) m = mlflow.get_run(run.info.run_id).data.metrics - assert m["backtest_mae"] == pytest.approx(2.0) - def test_autolog_backtest_per_timestep_scalar( - self, mlflow_tracking, autolog_context + assert m["backtest_mae"] == pytest.approx(np.median(ref)) + + @pytest.mark.parametrize("horizon", [1, 3]) + def test_autolog_backtest_per_timestep_with_reduction( + self, mlflow_tracking, autolog_context, horizon ): - """A per-timestep metric (ae) under default reduction collapses to one scalar.""" + """A per-timestep metric (ae) under default reduction collapses to one + scalar per forecast horizon.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr().backtest( - self.ts_univariate, metric=dm.ae, retrain=False, stride=10 + ref = _fit_lr().backtest( + TS_UNIVARIATE, + metric=dm.ae, + retrain=False, + start=-(horizon + 1), + last_points_only=False, + forecast_horizon=horizon, + reduction=np.nanmean, ) - + ref = np.atleast_1d(ref) + assert ref.shape == (horizon,) # (n_windows, horizon) history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") - assert len(history) == 1, "Default reduction should yield a single value" - assert history[0].value == pytest.approx(float(ref), abs=1e-5) + assert len(history) == horizon, "Default reduction should yield a single value" + values = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_array_almost_equal(values, ref) - def test_autolog_backtest_per_timestep_per_window( - self, mlflow_tracking, autolog_context + # no per-series table due to reduction + with pytest.raises(mlflow.exceptions.MlflowException): + _ = _read_per_series_table(run.info.run_id) + + @pytest.mark.parametrize("horizon", [1, 3]) + def test_autolog_backtest_per_timestep_without_reduction( + self, mlflow_tracking, autolog_context, horizon ): - """Window-level ae results aggregate per horizon step in the chart and - remain available with their window index in the detailed table.""" + """A per-timestep metric (ae) under default reduction collapses to one + scalar per forecast horizon.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - ref = self._fit_lr().backtest( - self.ts_univariate, + ref = _fit_lr().backtest( + TS_UNIVARIATE, metric=dm.ae, retrain=False, - stride=10, - forecast_horizon=4, + start=-(horizon + 1), + last_points_only=False, + forecast_horizon=horizon, reduction=None, ) - - ref = np.asarray(ref, dtype=float) # shape (n_windows, forecast_horizon) + n_windows = 2 + ref = np.atleast_2d(ref) + ref = ref.T if ref.shape[1] == n_windows else ref + assert ref.shape == (n_windows, horizon) # (n_windows, horizon) history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") - assert len(history) == 4, "Expected one step per forecast horizon timestep" - logged = [m.value for m in sorted(history, key=lambda m: m.step)] - np.testing.assert_allclose(logged, np.nanmean(ref, axis=0), atol=1e-5) + assert len(history) == horizon, "Default reduction should yield a single value" + values = [m.value for m in sorted(history, key=lambda m: m.step)] + np.testing.assert_array_almost_equal(values, np.nanmean(ref, axis=0)) - rows = self._read_per_series_table(run.info.run_id) + rows = _read_per_series_table(run.info.run_id) assert len(rows) == ref.size - for row in rows: - assert row["key"] == "backtest_ae" - assert row["window_index"] in range(len(ref)) - assert {int(r["window_index"]) for r in rows} == set(range(len(ref))) - + for t_idx in range(horizon): + for w_idx in range(n_windows): # windows + row = rows[t_idx * n_windows + w_idx] + assert row["key"] == "backtest_ae" + assert row["series_index"] == 0 + assert row["step"] == t_idx + assert row["window_index"] == w_idx + assert row["value"] == pytest.approx(ref[w_idx, t_idx]) + + @pytest.mark.parametrize("horizon", [1, 3]) def test_autolog_backtest_historical_forecasts_horizon_inferred( - self, mlflow_tracking, autolog_context + self, mlflow_tracking, autolog_context, horizon ): """When `historical_forecasts` is user-supplied, `backtest()` ignores the `forecast_horizon` argument, autologging must infer the true window length from the historical forecasts themselves, not from the (unused, defaulted) `forecast_horizon` argument.""" - model = self._fit_lr() + model = _fit_lr() hf = model.historical_forecasts( - self.ts_univariate, + TS_UNIVARIATE, retrain=False, - stride=10, - forecast_horizon=4, + start=-(horizon + 1), + forecast_horizon=horizon, last_points_only=False, ) with autolog_context(log_metrics=True): @@ -1589,15 +1626,20 @@ def test_autolog_backtest_historical_forecasts_horizon_inferred( # forecast_horizon is not passed (defaults to 1) and would be # wrong; the real horizon (4) must come from `hf`. ref = model.backtest( - self.ts_univariate, + TS_UNIVARIATE, historical_forecasts=hf, metric=dm.ae, reduction=None, ) - ref = np.asarray(ref, dtype=float) # shape (n_windows, forecast_horizon) + n_windows = 2 + ref = np.atleast_2d(ref) + ref = ref.T if ref.shape[1] == n_windows else ref + assert ref.shape == (n_windows, horizon) history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") - assert len(history) == 4, "Expected one step per forecast horizon timestep" + assert len(history) == horizon, ( + "Expected one step per forecast horizon timestep" + ) logged = [m.value for m in sorted(history, key=lambda m: m.step)] np.testing.assert_allclose(logged, np.nanmean(ref, axis=0), atol=1e-5) @@ -1605,23 +1647,25 @@ def test_autolog_backtest_quantile(self, mlflow_tracking, autolog_context): """A quantile metric (mql) logs one key per quantile.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - self._fit_qlr().backtest( - self.ts_univariate, + ref = _fit_qlr().backtest( + TS_UNIVARIATE, metric=dm.mql, metric_kwargs={"q": [0.1, 0.5, 0.9]}, retrain=False, - stride=10, + start=-2, num_samples=200, ) + ref = np.atleast_1d(ref) + assert ref.shape == (3,) # (n_quantiles,) m = mlflow.get_run(run.info.run_id).data.metrics - for key in ( + for idx, key in enumerate([ "backtest_mql_q0.100", "backtest_mql_q0.500", "backtest_mql_q0.900", - ): + ]): assert key in m, f"Expected quantile key {key}" - assert np.isfinite(m[key]) + assert m[key] == pytest.approx(ref[idx]) def test_autolog_backtest_mixed_degenerate_axes_keep_metric_names( self, mlflow_tracking, autolog_context @@ -1629,11 +1673,11 @@ def test_autolog_backtest_mixed_degenerate_axes_keep_metric_names( """Metrics whose differing axes have size one keep their metric names.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - self._fit_lr().backtest( - self.ts_univariate, + _ = _fit_lr().backtest( + TS_UNIVARIATE, metric=[dm.mae, dm.ae], retrain=False, - stride=10, + start=-2, ) m = mlflow.get_run(run.info.run_id).data.metrics @@ -1647,12 +1691,12 @@ def test_autolog_backtest_classification_labels_in_data( """f1 with explicit labels present in the series logs finite per-label keys.""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - self._fit_lr(self.ts_binary).backtest( - self.ts_binary, + _fit_lr(TS_BINARY).backtest( + TS_BINARY, metric=dm.f1, metric_kwargs={"label_reduction": None, "labels": [0, 1]}, retrain=False, - stride=10, + start=10, ) m = mlflow.get_run(run.info.run_id).data.metrics @@ -1668,8 +1712,8 @@ def test_autolog_backtest_classification_labels_not_in_data( the scores are NaN (the labels never appear in any window).""" with autolog_context(log_metrics=True): with mlflow.start_run() as run: - self._fit_lr(self.ts_binary).backtest( - self.ts_binary, + _fit_lr(TS_BINARY).backtest( + TS_BINARY, metric=dm.f1, metric_kwargs={"label_reduction": None, "labels": [5, 10]}, retrain=False, @@ -1683,32 +1727,28 @@ def test_autolog_backtest_classification_labels_not_in_data( assert np.isnan(m["backtest_f1_label10"]) def test_log_backtest_metrics_component_count_mismatch_allowed_when_reduced( - self, mlflow_tracking + self, autolog_context, mlflow_tracking ): """Default mae reduces components to scalars, so mixed component counts aggregate normally. Calls _log_backtest_metrics directly.""" - backtest_args = { - "metric": dm.mae, - "metric_kwargs": {}, - "series": [self.ts_univariate, self.ts_multivariate], - "forecast_horizon": 1, - "reduction": np.mean, - "last_points_only": True, - } - result = [1.0, 3.0] - with mlflow.start_run() as run: - client = MlflowAutologgingQueueingClient() - _log_backtest_metrics( - client, - run.info.run_id, - result, - {**BT_REQUIRED_DEFAUTLS, **backtest_args}, - ) - client.flush(synchronous=True) + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = _fit_lr().backtest( + metric=dm.mae, + metric_kwargs={}, + series=[TS_UNIVARIATE, TS_MULTIVARIATE], + forecast_horizon=1, + reduction=np.mean, + last_points_only=True, + start=-2, + retrain=True, + ) + ref = np.atleast_1d(ref) + assert ref.shape == (2,) # (n_series,) m = mlflow.get_run(run.info.run_id).data.metrics - assert m["backtest_mae"] == pytest.approx(2.0) + assert m["backtest_mae"] == pytest.approx(np.mean(ref)) def test_log_backtest_metrics_component_count_mismatch_raises( self, mlflow_tracking @@ -1722,7 +1762,7 @@ def test_log_backtest_metrics_component_count_mismatch_raises( backtest_args = { "metric": dm.mae, "metric_kwargs": {"component_reduction": None}, - "series": [self.ts_univariate, self.ts_multivariate], + "series": [TS_UNIVARIATE, TS_MULTIVARIATE], "forecast_horizon": 1, "reduction": np.mean, "last_points_only": True, @@ -1803,234 +1843,219 @@ def test_log_backtest_metrics_label_count_mismatch(self, mlflow_tracking): assert not mlflow.get_run(run.info.run_id).data.metrics - def test_log_backtest_metrics_aligns_windows_by_end_date(self, mlflow_tracking): + def test_log_backtest_metrics_aligns_windows_by_end_date( + self, autolog_context, mlflow_tracking + ): """A shorter series' window axis aligns from the end, not the start, so its last windows overlap the tail of a longer series. Steps and ``window_index`` are ``0 .. max_w - 1``. Calls _log_backtest_metrics directly with a fabricated result so the window counts per series are exact.""" - backtest_args = { - "metric": dm.mae, - "metric_kwargs": {}, - "series": [self.ts_univariate, self.ts_univariate], - "forecast_horizon": 1, - "reduction": None, - "last_points_only": False, - } - # series 0 has 5 windows; series 1 (shorter, later-starting) has 3 - result = [np.array([1.0, 2.0, 3.0, 4.0, 5.0]), np.array([10.0, 20.0, 30.0])] - - with mlflow.start_run() as run: - client = MlflowAutologgingQueueingClient() - _log_backtest_metrics( - client, - run.info.run_id, - result, - {**BT_REQUIRED_DEFAUTLS, **backtest_args}, - ) - client.flush(synchronous=True) + model = _fit_lr() + input_length = abs(min(model.lags["target"])) + n_windows = 2 + series_two_windows = TS_UNIVARIATE[-(input_length + n_windows) :] + # series 0 has 2 windows; series 1 (shorter, later-starting) has 1 + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = model.backtest( + metric=dm.mae, + metric_kwargs={}, + series=[series_two_windows, series_two_windows[1:]], + forecast_horizon=1, + reduction=None, + last_points_only=False, + start=-n_windows, + retrain=False, + ) + expected_shapes = [(n_windows,), (n_windows - 1,)] + for ref_i, shape in zip(ref, expected_shapes): + assert ref_i.shape == shape history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") logged = {m.step: m.value for m in history} - assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) - - rows = self._read_per_series_table(run.info.run_id) - by_step = {(r["series_index"], r["step"]): r["value"] for r in rows} - assert by_step[(0, 0)] == pytest.approx(1.0) - assert by_step[(0, 4)] == pytest.approx(5.0) - assert by_step[(1, 2)] == pytest.approx(10.0) - assert by_step[(1, 4)] == pytest.approx(30.0) - assert (1, 0) not in by_step - assert (1, 1) not in by_step - for r in rows: - assert r["window_index"] == r["step"] + assert logged == pytest.approx({ + 0: ref[0][0], + 1: np.mean([ref[0][1], ref[1][0]]), + }) + + rows = _read_per_series_table(run.info.run_id) + for s_idx, shape in enumerate(expected_shapes): + w_size = shape[0] + for w_idx in range(w_size): + row = rows[s_idx * n_windows + w_idx] + window_index = w_idx + n_windows - w_size + assert row["key"] == "backtest_mae" + assert row["series_index"] == s_idx + assert row["step"] == window_index + assert row["window_index"] == window_index + assert row["value"] == pytest.approx(ref[s_idx][w_idx]) def test_log_backtest_metrics_aligns_last_points_only_time_axis( - self, mlflow_tracking + self, autolog_context, mlflow_tracking ): """last_points_only stitches windows into one series scored per real timestep. Shorter series align from the end, same as the window-axis case, with steps ``0 .. t_max - 1`` rather than end-relative indexes. """ - backtest_args = { - "metric": dm.ae, - "metric_kwargs": {}, - "series": [self.ts_univariate, self.ts_univariate], - "forecast_horizon": 1, - "reduction": None, - "last_points_only": True, - } - # series 0 has 5 timesteps; series 1 (shorter, later-starting) has 3 - result = [np.array([1.0, 2.0, 3.0, 4.0, 5.0]), np.array([10.0, 20.0, 30.0])] + model = _fit_lr() + input_length = abs(min(model.lags["target"])) + n_windows = 2 + horizon = 3 + series_two_windows = TS_UNIVARIATE[-(input_length + horizon + n_windows - 1) :] + # series 0 forecast has 2 timesteps; series 1 (shorter, later-starting) has 1 + with autolog_context(log_metrics=True): + with mlflow.start_run() as run: + ref = model.backtest( + metric=dm.ae, + series=[series_two_windows, series_two_windows[1:]], + forecast_horizon=horizon, + reduction=None, + last_points_only=True, + start=-(horizon + n_windows - 1), + retrain=False, + ) - with mlflow.start_run() as run: - client = MlflowAutologgingQueueingClient() - _log_backtest_metrics( - client, - run.info.run_id, - result, - {**BT_REQUIRED_DEFAUTLS, **backtest_args}, - ) - client.flush(synchronous=True) + ref = [np.atleast_1d(ref_i) for ref_i in ref] + expected_shapes = [(n_windows,), (n_windows - 1,)] + for ref_i, shape in zip(ref, expected_shapes): + assert ref_i.shape == shape history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") logged = {m.step: m.value for m in history} - assert logged == pytest.approx({0: 1.0, 1: 2.0, 2: 6.5, 3: 12.0, 4: 17.5}) - - rows = self._read_per_series_table(run.info.run_id) - by_step = {(r["series_index"], r["step"]): r["value"] for r in rows} - assert by_step[(0, 0)] == pytest.approx(1.0) - assert by_step[(0, 4)] == pytest.approx(5.0) - assert by_step[(1, 2)] == pytest.approx(10.0) - assert by_step[(1, 4)] == pytest.approx(30.0) - assert (1, 0) not in by_step - assert (1, 1) not in by_step - assert all(pd.isna(r["window_index"]) for r in rows) - - @staticmethod - def _read_per_series_table(run_id): - """Load the run's consolidated per-series metric table into row dicts.""" - df = mlflow.load_table( - artifact_file="metrics_per_series.json", run_ids=[run_id] - ) - return df.to_dict("records") - - def _fit_lr(self, series=None): - """Fit and return a fresh LinearRegressionModel (no active run).""" - model = LinearRegressionModel(lags=4) - model.fit(series if series is not None else self.ts_univariate) - return model - - def _fit_qlr(self, series=None): - """Fit and return a fresh quantile LinearRegressionModel (no active run).""" - model = LinearRegressionModel( - lags=4, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] - ) - model.fit(series if series is not None else self.ts_univariate) - return model - - -@pytest.mark.parametrize( - "metric_name, metric_kwargs, expected", - [ - ("mae", {}, dict(has_time_axis=False, has_comp_axis=False, axis_size=1)), - ("ae", {}, dict(has_time_axis=True, has_comp_axis=False, axis_size=1)), - ("mae", {"component_reduction": None}, dict(has_comp_axis=True)), - ], -) -def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): - has_time_axis, has_comp_axis, axis_labels = _infer_metric_axes( - getattr(dm, metric_name), metric_kwargs - ) - actual = { - "has_time_axis": has_time_axis, - "has_comp_axis": has_comp_axis, - "axis_size": len(axis_labels), - } - for attr, value in expected.items(): - assert actual[attr] == value - - -def test_infer_metric_axes_quantiles(): - _, _, axis_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) - assert axis_labels == ["_q0.100", "_q0.500", "_q0.900"] - - -def test_infer_metric_axes_quantile_interval(): - has_time, _, axis_labels = _infer_metric_axes(dm.iw, {"q_interval": (0.1, 0.9)}) - assert axis_labels == ["_qi0.800"] - assert has_time is True - - -def test_infer_metric_axes_unknown_labels_raises(): - """label_reduction=None with no explicit labels cannot determine the number - of output labels ahead of time, so this raises rather than falling back.""" - with pytest.raises(ValueError, match="requires explicit `labels`"): - _infer_metric_axes(dm.f1, {"label_reduction": None}) - - -def test_build_metric_keys_components_and_quantiles(): - """Shared key builder expands components x quantile suffixes per metric.""" - metric_axes = [ - (False, True, ["_q0.100", "_q0.900"]), - (False, True, ["_label0", "_label1"]), - ] - metric_keys = _build_metric_keys( - ["mae", "f1"], - ["temp", "hum"], - has_comp_axis=True, - metric_axes=metric_axes, - prefix="backtest_", - ) - c_size = len(metric_keys[0]) - assert c_size == 4 - assert metric_keys == [ - [ - "backtest_mae_temp_q0.100", - "backtest_mae_temp_q0.900", - "backtest_mae_hum_q0.100", - "backtest_mae_hum_q0.900", - ], + assert logged == pytest.approx({ + 0: ref[0][0], + 1: np.mean([ref[0][1], ref[1][0]]), + }) + + rows = _read_per_series_table(run.info.run_id) + for s_idx, shape in enumerate(expected_shapes): + w_size = shape[0] + for w_idx in range(w_size): + row = rows[s_idx * n_windows + w_idx] + window_index = w_idx + n_windows - w_size + assert row["key"] == "backtest_ae" + assert row["series_index"] == s_idx + assert row["step"] == window_index + assert np.isnan(row["window_index"]) + assert row["value"] == pytest.approx(ref[s_idx][w_idx]) + + +class TestAutoLogMetricHelperFunctions: + @pytest.mark.parametrize( + "metric_name, metric_kwargs, expected", [ - "backtest_f1_temp_label0", - "backtest_f1_temp_label1", - "backtest_f1_hum_label0", - "backtest_f1_hum_label1", + ("mae", {}, dict(has_time_axis=False, has_comp_axis=False, axis_size=1)), + ("ae", {}, dict(has_time_axis=True, has_comp_axis=False, axis_size=1)), + ("mae", {"component_reduction": None}, dict(has_comp_axis=True)), ], - ] - - -def test_build_metric_keys_no_components_no_prefix(): - """Without components, each metric gets one key per axis label.""" - metric_axes = [(False, False, ["_q0.500"])] - metric_keys = _build_metric_keys( - ["mql"], - ["ignored"], - has_comp_axis=False, - metric_axes=metric_axes, ) - c_size = len(metric_keys[0]) - assert c_size == 1 - assert metric_keys == [["mql_q0.500"]] - - -def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): - """Cells are aggregated with agg_func; supplied table rows are persisted.""" - agg = { - ("mae", 0): [1.0, 3.0], - ("mae", 1): [10.0, 30.0], - } - rows = [ - {"key": "mae", "series_index": 0, "step": 0, "value": 1.0}, - {"key": "mae", "series_index": 1, "step": 0, "value": 3.0}, - {"key": "mae", "series_index": 0, "step": 1, "value": 10.0}, - {"key": "mae", "series_index": 1, "step": 1, "value": 30.0}, - ] - with mlflow.start_run() as run: - client = MlflowAutologgingQueueingClient() - _flush_logged_metrics( - client, run.info.run_id, agg, agg_func=np.mean, table_rows=rows + def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): + has_time_axis, has_comp_axis, axis_labels = _infer_metric_axes( + getattr(dm, metric_name), metric_kwargs ) - client.flush(synchronous=True) - - history0 = mlflow_tracking.get_metric_history(run.info.run_id, "mae") - logged = {m.step: m.value for m in history0} - assert logged[0] == pytest.approx(2.0) - assert logged[1] == pytest.approx(20.0) - table = mlflow.load_table( - artifact_file="metrics_per_series.json", run_ids=[run.info.run_id] - ) - assert len(table) == 4 + actual = { + "has_time_axis": has_time_axis, + "has_comp_axis": has_comp_axis, + "axis_size": len(axis_labels), + } + for attr, value in expected.items(): + assert actual[attr] == value + + def test_infer_metric_axes_quantiles(): + _, _, axis_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) + assert axis_labels == ["_q0.100", "_q0.500", "_q0.900"] + + def test_infer_metric_axes_quantile_interval(): + has_time, _, axis_labels = _infer_metric_axes(dm.iw, {"q_interval": (0.1, 0.9)}) + assert axis_labels == ["_qi0.800"] + assert has_time is True + + def test_infer_metric_axes_unknown_labels_raises(): + """label_reduction=None with no explicit labels cannot determine the number + of output labels ahead of time, so this raises rather than falling back.""" + with pytest.raises(ValueError, match="requires explicit `labels`"): + _infer_metric_axes(dm.f1, {"label_reduction": None}) + + def test_build_metric_keys_components_and_quantiles(): + """Shared key builder expands components x quantile suffixes per metric.""" + metric_axes = [ + (False, True, ["_q0.100", "_q0.900"]), + (False, True, ["_label0", "_label1"]), + ] + metric_keys = _build_metric_keys( + ["mae", "f1"], + ["temp", "hum"], + has_comp_axis=True, + metric_axes=metric_axes, + prefix="backtest_", + ) + c_size = len(metric_keys[0]) + assert c_size == 4 + assert metric_keys == [ + [ + "backtest_mae_temp_q0.100", + "backtest_mae_temp_q0.900", + "backtest_mae_hum_q0.100", + "backtest_mae_hum_q0.900", + ], + [ + "backtest_f1_temp_label0", + "backtest_f1_temp_label1", + "backtest_f1_hum_label0", + "backtest_f1_hum_label1", + ], + ] + def test_build_metric_keys_no_components_no_prefix(): + """Without components, each metric gets one key per axis label.""" + metric_axes = [(False, False, ["_q0.500"])] + metric_keys = _build_metric_keys( + ["mql"], + ["ignored"], + has_comp_axis=False, + metric_axes=metric_axes, + ) + c_size = len(metric_keys[0]) + assert c_size == 1 + assert metric_keys == [["mql_q0.500"]] + + def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): + """Cells are aggregated with agg_func; supplied table rows are persisted.""" + agg = { + ("mae", 0): [1.0, 3.0], + ("mae", 1): [10.0, 30.0], + } + rows = [ + {"key": "mae", "series_index": 0, "step": 0, "value": 1.0}, + {"key": "mae", "series_index": 1, "step": 0, "value": 3.0}, + {"key": "mae", "series_index": 0, "step": 1, "value": 10.0}, + {"key": "mae", "series_index": 1, "step": 1, "value": 30.0}, + ] + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _flush_logged_metrics( + client, run.info.run_id, agg, agg_func=np.mean, table_rows=rows + ) + client.flush(synchronous=True) + + history0 = mlflow_tracking.get_metric_history(run.info.run_id, "mae") + logged = {m.step: m.value for m in history0} + assert logged[0] == pytest.approx(2.0) + assert logged[1] == pytest.approx(20.0) + table = mlflow.load_table( + artifact_file="metrics_per_series.json", run_ids=[run.info.run_id] + ) + assert len(table) == 4 -def test_flush_logged_metrics_skips_table_without_rows(mlflow_tracking): - """Omitting table rows logs the aggregate only.""" - agg = {("mae", 0): [1.5]} - with mlflow.start_run() as run: - client = MlflowAutologgingQueueingClient() - _flush_logged_metrics(client, run.info.run_id, agg, agg_func=np.mean) - client.flush(synchronous=True) + def test_flush_logged_metrics_skips_table_without_rows(mlflow_tracking): + """Omitting table rows logs the aggregate only.""" + agg = {("mae", 0): [1.5]} + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _flush_logged_metrics(client, run.info.run_id, agg, agg_func=np.mean) + client.flush(synchronous=True) - assert mlflow.get_run(run.info.run_id).data.metrics["mae"] == pytest.approx(1.5) - artifacts = mlflow_tracking.list_artifacts(run.info.run_id) - assert not any(a.path == "metrics_per_series.json" for a in artifacts) + assert mlflow.get_run(run.info.run_id).data.metrics["mae"] == pytest.approx(1.5) + artifacts = mlflow_tracking.list_artifacts(run.info.run_id) + assert not any(a.path == "metrics_per_series.json" for a in artifacts) From 30cb5b34ecb2e9b2ea2f5caa161be2a0dddff296 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Wed, 2 Sep 2026 10:34:09 +0200 Subject: [PATCH 147/154] make tests more efficient --- darts/tests/optional_deps/test_mlflow.py | 131 +++++++++++++---------- 1 file changed, 77 insertions(+), 54 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index d06595c3cc..4695d695d7 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,6 +1,8 @@ import copy import logging import os +import uuid +from contextlib import contextmanager import numpy as np import pandas as pd @@ -67,11 +69,41 @@ ) +@pytest.fixture(scope="module") +def _mlflow_store(tmp_path_factory): + """Shared MLflow backend for the whole module (one SQLite DB).""" + store_dir = tmp_path_factory.mktemp("mlflow") + mlflow.set_tracking_uri(f"sqlite:///{store_dir / 'mlflow.db'}") + return store_dir + + @pytest.fixture -def mlflow_tracking(tmpdir_fn): - """Set up MLflow tracking with a temporary database.""" - mlflow.set_tracking_uri(f"sqlite:///{tmpdir_fn}/mlflow.db") - return mlflow.tracking.MlflowClient() +def mlflow_tracking(_mlflow_store, request): + """Isolated MLflow experiment per test on the shared module store.""" + exp_name = f"darts_mlflow_{request.node.name}" + artifact_root = _mlflow_store / f"artifacts_{uuid.uuid4().hex}" + artifact_root.mkdir(parents=True, exist_ok=True) + + client = mlflow.tracking.MlflowClient() + exp_id = client.create_experiment( + exp_name, + artifact_location=str(artifact_root), + ) + mlflow.set_experiment(experiment_id=exp_id) + + autolog(disable=True) + yield client + autolog(disable=True) + + +@contextmanager +def _autolog_context(**kwargs): + autolog(disable=True) + autolog(**kwargs) + try: + yield + finally: + autolog(disable=True) @pytest.fixture @@ -80,19 +112,8 @@ def autolog_context(): Usage: with autolog_context(): # default autolog - with autolog_context(log_training_metrics=True): # custom kwargs + with autolog_context(log_models=True): # custom kwargs """ - from contextlib import contextmanager - - @contextmanager - def _autolog_context(**kwargs): - autolog(disable=True) # clean state - autolog(**kwargs) # enable with custom kwargs - try: - yield - finally: - autolog(disable=True) # clean up - return _autolog_context @@ -165,60 +186,62 @@ def _read_per_series_table(run_id): def _fit_lr(series=None): - """Fit and return a fresh LinearRegressionModel (no active run).""" + """Fit and return a LinearRegressionModel (no active run).""" + series = TS_UNIVARIATE if series is None else series model = LinearRegressionModel(lags=1) - model.fit(series if series is not None else TS_UNIVARIATE) + model.fit(series) return model def _fit_qlr(series=None): - """Fit and return a fresh quantile LinearRegressionModel (no active run).""" + """Fit and return a quantile LinearRegressionModel (no active run).""" + series = TS_UNIVARIATE if series is None else series model = LinearRegressionModel( lags=1, likelihood="quantile", quantiles=[0.1, 0.5, 0.9] ) - model.fit(series if series is not None else TS_UNIVARIATE) + model.fit(series) return model class TestMLflow: - def test_save_load_statistical_model(self, tmpdir_fn): + def test_save_load_statistical_model(self, tmp_path): """Test save/load round-trip for statistical model""" model = ExponentialSmoothing() model.fit(TS_UNIVARIATE) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) + model_path = tmp_path / "test_model" + save_model(model, str(model_path)) - assert_mlflow_artifacts_exist(model_path, is_torch=False) + assert_mlflow_artifacts_exist(str(model_path), is_torch=False) loaded_model = load_model(f"file://{model_path}") assert_predictions_equal(model, loaded_model, n=5, is_global=False) - def test_save_load_regression_model(self, tmpdir_fn): + def test_save_load_regression_model(self, tmp_path): """Test save/load round-trip for regression model""" model = LinearRegressionModel(lags=5) model.fit(TS_UNIVARIATE) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) + model_path = tmp_path / "test_model" + save_model(model, str(model_path)) - assert_mlflow_artifacts_exist(model_path, is_torch=False) + assert_mlflow_artifacts_exist(str(model_path), is_torch=False) loaded_model = load_model(f"file://{model_path}") assert_predictions_equal(model, loaded_model, n=3, series=TS_UNIVARIATE) @pytest.mark.skipif(not TORCH_AVAILABLE, reason="requires torch") - def test_save_load_torch_model(self, tmpdir_fn): + def test_save_load_torch_model(self, tmp_path): """Test save/load round-trip for torch model""" model = NBEATSModel( input_chunk_length=4, output_chunk_length=2, n_epochs=1, **tfm_kwargs_dev ) model.fit(TS_UNIVARIATE) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) + model_path = tmp_path / "test_model" + save_model(model, str(model_path)) - assert_mlflow_artifacts_exist(model_path, is_torch=True) + assert_mlflow_artifacts_exist(str(model_path), is_torch=True) # save(clean=True) strips pl_trainer_kwargs; explicitly restore accelerator # so Lightning doesn't default to MPS on Github macOS runner @@ -663,17 +686,17 @@ def test_load_invalid_uri_fails(self): with pytest.raises(Exception): load_model("file:///nonexistent/path/to/model") - def test_load_corrupted_mlmodel_fails(self, tmpdir_fn): + def test_load_corrupted_mlmodel_fails(self, tmp_path): """Test that loading with corrupted MLmodel file fails""" # save a valid model model = LinearRegressionModel(lags=5) model.fit(TS_UNIVARIATE) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) + model_path = tmp_path / "test_model" + save_model(model, str(model_path)) # corrupt the MLmodel file - mlmodel_path = os.path.join(model_path, "MLmodel") + mlmodel_path = model_path / "MLmodel" with open(mlmodel_path, "w") as f: f.write("corrupted content that is not valid YAML {[[") @@ -681,17 +704,17 @@ def test_load_corrupted_mlmodel_fails(self, tmpdir_fn): with pytest.raises(Exception): load_model(f"file://{model_path}") - def test_load_missing_model_file_fails(self, tmpdir_fn): + def test_load_missing_model_file_fails(self, tmp_path): """Test that loading with missing model data file fails""" # save a valid model model = LinearRegressionModel(lags=5) model.fit(TS_UNIVARIATE) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) + model_path = tmp_path / "test_model" + save_model(model, str(model_path)) # remove the model data file - model_data_path = os.path.join(model_path, "model.pkl") + model_data_path = model_path / "model.pkl" os.remove(model_data_path) # loading should fail @@ -705,7 +728,7 @@ def test_load_missing_model_file_fails(self, tmpdir_fn): (LinearRegressionModel, {"lags": 5}), ], ) - def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): + def test_save_load_multiple_models(self, tmp_path, model_cls, fit_kwargs): """Test save/load for multiple model types""" if fit_kwargs: model = model_cls(**fit_kwargs) @@ -714,8 +737,8 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): model.fit(TS_UNIVARIATE) - model_path = os.path.join(tmpdir_fn, "test_model") - save_model(model, model_path) + model_path = tmp_path / "test_model" + save_model(model, str(model_path)) loaded = load_model(f"file://{model_path}") # Only pass series for global models (LinearRegressionModel) @@ -732,13 +755,13 @@ def test_save_load_multiple_models(self, tmpdir_fn, model_cls, fit_kwargs): (TS_WITH_STATIC, "static_covariates"), ], ) - def test_save_load_with_special_series(self, tmpdir_fn, series, series_name): + def test_save_load_with_special_series(self, tmp_path, series, series_name): """Test save/load with multivariate and static covariate series""" model = LinearRegressionModel(lags=5) model.fit(series) - model_path = os.path.join(tmpdir_fn, f"test_model_{series_name}") - save_model(model, model_path) + model_path = tmp_path / f"test_model_{series_name}" + save_model(model, str(model_path)) loaded_model = load_model(f"file://{model_path}") @@ -1950,7 +1973,7 @@ class TestAutoLogMetricHelperFunctions: ("mae", {"component_reduction": None}, dict(has_comp_axis=True)), ], ) - def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): + def test_infer_metric_axes_reductions(self, metric_name, metric_kwargs, expected): has_time_axis, has_comp_axis, axis_labels = _infer_metric_axes( getattr(dm, metric_name), metric_kwargs ) @@ -1962,22 +1985,22 @@ def test_infer_metric_axes_reductions(metric_name, metric_kwargs, expected): for attr, value in expected.items(): assert actual[attr] == value - def test_infer_metric_axes_quantiles(): + def test_infer_metric_axes_quantiles(self): _, _, axis_labels = _infer_metric_axes(dm.mql, {"q": [0.1, 0.5, 0.9]}) assert axis_labels == ["_q0.100", "_q0.500", "_q0.900"] - def test_infer_metric_axes_quantile_interval(): + def test_infer_metric_axes_quantile_interval(self): has_time, _, axis_labels = _infer_metric_axes(dm.iw, {"q_interval": (0.1, 0.9)}) assert axis_labels == ["_qi0.800"] assert has_time is True - def test_infer_metric_axes_unknown_labels_raises(): + def test_infer_metric_axes_unknown_labels_raises(self): """label_reduction=None with no explicit labels cannot determine the number of output labels ahead of time, so this raises rather than falling back.""" with pytest.raises(ValueError, match="requires explicit `labels`"): _infer_metric_axes(dm.f1, {"label_reduction": None}) - def test_build_metric_keys_components_and_quantiles(): + def test_build_metric_keys_components_and_quantiles(self): """Shared key builder expands components x quantile suffixes per metric.""" metric_axes = [ (False, True, ["_q0.100", "_q0.900"]), @@ -2007,7 +2030,7 @@ def test_build_metric_keys_components_and_quantiles(): ], ] - def test_build_metric_keys_no_components_no_prefix(): + def test_build_metric_keys_no_components_no_prefix(self): """Without components, each metric gets one key per axis label.""" metric_axes = [(False, False, ["_q0.500"])] metric_keys = _build_metric_keys( @@ -2020,7 +2043,7 @@ def test_build_metric_keys_no_components_no_prefix(): assert c_size == 1 assert metric_keys == [["mql_q0.500"]] - def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): + def test_flush_logged_metrics_aggregates_and_writes_table(self, mlflow_tracking): """Cells are aggregated with agg_func; supplied table rows are persisted.""" agg = { ("mae", 0): [1.0, 3.0], @@ -2048,7 +2071,7 @@ def test_flush_logged_metrics_aggregates_and_writes_table(mlflow_tracking): ) assert len(table) == 4 - def test_flush_logged_metrics_skips_table_without_rows(mlflow_tracking): + def test_flush_logged_metrics_skips_table_without_rows(self, mlflow_tracking): """Omitting table rows logs the aggregate only.""" agg = {("mae", 0): [1.5]} with mlflow.start_run() as run: From 6312c28e03fb15b0395c070128d26fe2c4e0ce83 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Sep 2026 10:03:30 +0200 Subject: [PATCH 148/154] add option to log backtest agg and series align from start --- darts/tests/optional_deps/test_mlflow.py | 182 +++++++++++++++++++++++ darts/utils/mlflow.py | 135 ++++++++++++++--- 2 files changed, 294 insertions(+), 23 deletions(-) diff --git a/darts/tests/optional_deps/test_mlflow.py b/darts/tests/optional_deps/test_mlflow.py index 4695d695d7..fd50c607c7 100644 --- a/darts/tests/optional_deps/test_mlflow.py +++ b/darts/tests/optional_deps/test_mlflow.py @@ -1,4 +1,5 @@ import copy +import itertools import logging import os import uuid @@ -1963,6 +1964,163 @@ def test_log_backtest_metrics_aligns_last_points_only_time_axis( assert np.isnan(row["window_index"]) assert row["value"] == pytest.approx(ref[s_idx][w_idx]) + def test_log_backtest_metrics_aligns_windows_by_start( + self, autolog_context, mlflow_tracking + ): + """A shorter series' window axis aligns from the start when + ``series_align='start'``, so its first windows overlap the head of a + longer series.""" + model = _fit_lr() + input_length = abs(min(model.lags["target"])) + n_windows = 2 + series_two_windows = TS_UNIVARIATE[-(input_length + n_windows) :] + with autolog_context(log_metrics=True, series_align="start"): + with mlflow.start_run() as run: + ref = model.backtest( + metric=dm.mae, + metric_kwargs={}, + series=[series_two_windows, series_two_windows[1:]], + forecast_horizon=1, + reduction=None, + last_points_only=False, + start=-n_windows, + retrain=False, + ) + expected_shapes = [(n_windows,), (n_windows - 1,)] + for ref_i, shape in zip(ref, expected_shapes): + assert ref_i.shape == shape + + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") + logged = {m.step: m.value for m in history} + assert logged == pytest.approx({ + 0: np.mean([ref[0][0], ref[1][0]]), + 1: ref[0][1], + }) + + rows = _read_per_series_table(run.info.run_id) + for s_idx, shape in enumerate(expected_shapes): + w_size = shape[0] + for w_idx in range(w_size): + row = rows[s_idx * n_windows + w_idx] + assert row["key"] == "backtest_mae" + assert row["series_index"] == s_idx + assert row["step"] == w_idx + assert row["window_index"] == w_idx + assert row["value"] == pytest.approx(ref[s_idx][w_idx]) + + def test_log_backtest_metrics_aligns_last_points_only_by_start( + self, autolog_context, mlflow_tracking + ): + """last_points_only with ``series_align='start'`` aligns shorter series + at early timesteps.""" + model = _fit_lr() + input_length = abs(min(model.lags["target"])) + n_windows = 2 + horizon = 3 + series_two_windows = TS_UNIVARIATE[-(input_length + horizon + n_windows - 1) :] + with autolog_context(log_metrics=True, series_align="start"): + with mlflow.start_run() as run: + ref = model.backtest( + metric=dm.ae, + series=[series_two_windows, series_two_windows[1:]], + forecast_horizon=horizon, + reduction=None, + last_points_only=True, + start=-(horizon + n_windows - 1), + retrain=False, + ) + + ref = [np.atleast_1d(ref_i) for ref_i in ref] + expected_shapes = [(n_windows,), (n_windows - 1,)] + for ref_i, shape in zip(ref, expected_shapes): + assert ref_i.shape == shape + + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") + logged = {m.step: m.value for m in history} + assert logged == pytest.approx({ + 0: np.mean([ref[0][0], ref[1][0]]), + 1: ref[0][1], + }) + + rows = _read_per_series_table(run.info.run_id) + for s_idx, shape in enumerate(expected_shapes): + w_size = shape[0] + for w_idx in range(w_size): + row = rows[s_idx * n_windows + w_idx] + assert row["key"] == "backtest_ae" + assert row["series_index"] == s_idx + assert row["step"] == w_idx + assert np.isnan(row["window_index"]) + assert row["value"] == pytest.approx(ref[s_idx][w_idx]) + + @pytest.mark.parametrize("config", list(itertools.product([1, 3], [True, False]))) + def test_autolog_backtest_log_aggregate_scalar( + self, autolog_context, mlflow_tracking, config + ): + """log_backtest_aggregate logs backtest_agg_* equal to scalar backtest_*.""" + horizon, lpo = config + n_windows = 2 + with autolog_context(log_metrics=True, log_backtest_aggregate=True): + with mlflow.start_run() as run: + ref = _fit_lr().backtest( + TS_UNIVARIATE, + metric=dm.mae, + retrain=False, + start=-(horizon + n_windows - 1), + last_points_only=lpo, + forecast_horizon=horizon, + reduction=None, + ) + ref = np.nanmean(ref) + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["backtest_agg_mae"] == pytest.approx(ref) + + @pytest.mark.parametrize("horizon", [1, 3]) + def test_autolog_backtest_log_aggregate_stepped( + self, autolog_context, mlflow_tracking, horizon + ): + """log_backtest_aggregate collapses stepped backtest metrics via agg_func.""" + with autolog_context( + log_metrics=True, log_backtest_aggregate=True, agg_func=np.nanmean + ): + with mlflow.start_run() as run: + _fit_lr().backtest( + TS_UNIVARIATE, + metric=dm.ae, + retrain=False, + start=-(horizon + 1), + last_points_only=False, + forecast_horizon=horizon, + reduction=np.nanmean, + ) + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_ae") + stepped_values = [m.value for m in sorted(history, key=lambda m: m.step)] + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["backtest_agg_ae"] == pytest.approx(np.nanmean(stepped_values)) + + @pytest.mark.parametrize("horizon", [1, 3]) + def test_autolog_backtest_log_aggregate_custom_agg_func( + self, autolog_context, mlflow_tracking, horizon + ): + """log_backtest_aggregate uses autolog's agg_func over all logged steps.""" + series = TS_UNIVARIATE + series = [series * 0.9, series, series * 1.1] + with autolog_context( + log_metrics=True, log_backtest_aggregate=True, agg_func=np.median + ): + with mlflow.start_run() as run: + ref = _fit_lr(series[0]).backtest( + metric=dm.mae, + series=series, + last_points_only=True, + start=-(horizon + 1), + forecast_horizon=horizon, + ) + ref = np.atleast_1d(ref) + assert ref.shape == (len(series),) + m = mlflow.get_run(run.info.run_id).data.metrics + assert m["backtest_agg_mae"] == pytest.approx(np.median(ref)) + class TestAutoLogMetricHelperFunctions: @pytest.mark.parametrize( @@ -2082,3 +2240,27 @@ def test_flush_logged_metrics_skips_table_without_rows(self, mlflow_tracking): assert mlflow.get_run(run.info.run_id).data.metrics["mae"] == pytest.approx(1.5) artifacts = mlflow_tracking.list_artifacts(run.info.run_id) assert not any(a.path == "metrics_per_series.json" for a in artifacts) + + def test_flush_logged_metrics_backtest_aggregate(self, mlflow_tracking): + """log_backtest_aggregate logs backtest_agg_* as agg_func over all steps.""" + agg = { + ("backtest_mae", 0): [1.0, 3.0], + ("backtest_mae", 1): [10.0, 30.0], + } + with mlflow.start_run() as run: + client = MlflowAutologgingQueueingClient() + _flush_logged_metrics( + client, + run.info.run_id, + agg, + agg_func=np.mean, + log_backtest_aggregate=True, + ) + client.flush(synchronous=True) + + m = mlflow.get_run(run.info.run_id).data.metrics + history = mlflow_tracking.get_metric_history(run.info.run_id, "backtest_mae") + logged = {h.step: h.value for h in history} + assert logged[0] == pytest.approx(2.0) + assert logged[1] == pytest.approx(20.0) + assert m["backtest_agg_mae"] == pytest.approx(np.mean([2.0, 20.0])) diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 49146bcc05..470d13bdf4 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -161,6 +161,19 @@ horizon aggregated over all windows. Steps represent the steps in the forecast horizon (0, 1, ..., horizon - 1). + - Multi-series alignment (``series_align`` autolog option): + + - ``"end"`` (default): shorter series skip early steps/windows so their + last points overlap the tail of longer series. + - ``"start"``: shorter series contribute at early steps/windows; longer + series have fewer contributing series at tail steps. + + - Backtest aggregate (``log_backtest_aggregate`` autolog option): + + - When enabled, logs an additional scalar per backtest metric key under + ``backtest_agg_{metric_key}`` (e.g. ``backtest_agg_mae``), computed + as ``agg_func`` over all logged steps for that key. + When components are preserved (``component_reduction=None``), all series scored together must have the same number of components; names are taken from the first series. @@ -173,7 +186,7 @@ from collections.abc import Callable from operator import itemgetter from pathlib import Path -from typing import Any +from typing import Any, Literal from darts.logging import raise_log from darts.typing import TimeSeriesLike @@ -486,6 +499,8 @@ def autolog( log_metrics: bool = True, log_torch_metrics: bool = True, agg_func: Callable = np.nanmean, + series_align: Literal["start", "end"] = "end", + log_backtest_aggregate: bool = False, disable: bool = False, silent: bool = False, ) -> None: @@ -514,7 +529,17 @@ def autolog( Function used to aggregate a metric's per-series values into the single value logged for a list of series (e.g. ``np.nanmean``, the default, or ``np.median``). Called as ``agg_func(values)`` on a list - of floats. + of floats. Also used when ``log_backtest_aggregate=True`` to collapse + all logged steps of a backtest metric into a single scalar. + series_align + How to align shorter series when multiple series differ in window or + time length. ``"end"`` (default) aligns from the end so shorter series + skip early steps/windows; ``"start"`` aligns from the start so shorter + series contribute at early steps/windows. + log_backtest_aggregate + If ``True``, log an additional scalar per backtest metric key under + ``backtest_agg_{metric_key}`` (e.g. ``backtest_agg_mae``), computed as + ``agg_func`` over all logged steps for that key. Defaults to ``False``. disable If ``True``, restore the original ``fit()`` methods and stop autologging. @@ -522,6 +547,13 @@ def autolog( If ``True`` (default ``False``), suppress all event logging and warnings from MLflow during autologging. """ + if series_align not in ("start", "end"): + raise_log( + ValueError( + f"`series_align` must be 'start' or 'end', got {series_align!r}." + ) + ) + # Enable/disable mlflow.pytorch.autolog for per-epoch metrics on torch models. # This must happen outside the @autologging_integration-decorated _autolog() # because that decorator short-circuits _autolog()'s body entirely when @@ -563,6 +595,8 @@ def autolog( log_params=log_params, log_metrics=log_metrics, agg_func=agg_func, + series_align=series_align, + log_backtest_aggregate=log_backtest_aggregate, disable=disable, silent=silent, ) @@ -596,6 +630,8 @@ def _autolog( log_params: bool = True, log_metrics: bool = True, agg_func: Callable = np.nanmean, + series_align: Literal["start", "end"] = "end", + log_backtest_aggregate: bool = False, disable: bool = False, silent: bool = False, ) -> None: @@ -761,6 +797,8 @@ def _patched_backtest(original, self, *args, **kwargs): result=result, backtest_kwargs=backtest_kwargs, agg_func=agg_func, + series_align=series_align, + log_backtest_aggregate=log_backtest_aggregate, ) autologging_client.flush(synchronous=False).await_completion() return result @@ -861,6 +899,9 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: agg_func = get_autologging_config( flavor_name=FLAVOR_NAME, config_key="agg_func", default_value=np.nanmean ) + series_align = get_autologging_config( + flavor_name=FLAVOR_NAME, config_key="series_align", default_value="end" + ) autologging_client = MlflowAutologgingQueueingClient() _log_metric_results( @@ -870,6 +911,7 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: metrics=func, metric_kwargs=metric_kwargs, agg_func=agg_func, + series_align=series_align, ) autologging_client.flush(synchronous=False).await_completion() @@ -1188,6 +1230,8 @@ def _log_backtest_metrics( result, backtest_kwargs: dict, agg_func: Callable = np.nanmean, + series_align: Literal["start", "end"] = "end", + log_backtest_aggregate: bool = False, ) -> None: """Log backtest metric result(s) to MLflow. @@ -1201,6 +1245,8 @@ def _log_backtest_metrics( metrics=backtest_kwargs["metric"], metric_kwargs=backtest_kwargs["metric_kwargs"] or dict(), agg_func=agg_func, + series_align=series_align, + log_backtest_aggregate=log_backtest_aggregate, backtest_kwargs=backtest_kwargs, ) @@ -1213,6 +1259,8 @@ def _log_metric_results( metric_kwargs: dict[str, Any] | list[dict[str, Any]], backtest_kwargs: dict[str, Any] | None = None, agg_func: Callable = np.nanmean, + series_align: Literal["start", "end"] = "end", + log_backtest_aggregate: bool = False, ) -> None: """Log backtest or standalone metric result(s) to MLflow. @@ -1286,15 +1334,17 @@ def _log_metric_results( forecast horizon (``0 .. T-1``). When both time and window axes are present (backtest, no reduction, not ``last_points_only``), each step holds the ``agg_func`` aggregation over windows at that horizon index. - - **Time-aggregated metrics**: steps index backtest windows end-aligned - across series (``0 .. max_W-1``; shorter series skip early steps). - Standalone calls with a time axis but no window axis end-align timesteps - the same way across series of different lengths. - - Series can differ in length and overlap in time. We align from the end, not - the start: a shorter series contributes at the last steps/windows, not the - first. This matches the usual backtest layout but is an assumption — series - may also end at different calendar times. + - **Time-aggregated metrics**: steps index backtest windows aligned across + series (``0 .. max_W-1``; shorter series skip early or late steps depending + on ``series_align``). Standalone calls with a time axis but no window axis + align timesteps the same way across series of different lengths. + + Series can differ in length and overlap in time. By default + (``series_align="end"``), we align from the end: a shorter series contributes + at the last steps/windows, not the first. With ``series_align="start"``, + shorter series contribute at the first steps/windows instead. This matches + the usual backtest layout but is an assumption — series may also end at + different calendar times. Multi-series aggregation and artifacts ---------------------------------------- @@ -1314,6 +1364,11 @@ def _log_metric_results( have the same number of components; component names are taken from the first series. + When ``log_backtest_aggregate`` is enabled (backtest only), an additional + scalar per metric key is logged under ``backtest_agg_{metric_key}`` (e.g. + ``backtest_agg_mae``), computed as ``agg_func`` over all logged steps for + that key. + Raises ------ ValueError @@ -1345,7 +1400,15 @@ def _log_metric_results( ``None``, the call is treated as standalone metric logging. agg_func Function used to aggregate per-series values at each ``(key, step)``. - Called as ``agg_func(values)`` on a list of floats. + Called as ``agg_func(values)`` on a list of floats. Also used to + collapse all logged steps into a single scalar when + ``log_backtest_aggregate`` is enabled. + series_align + How to align shorter series when multiple series differ in window or + time length. ``"end"`` (default) or ``"start"``. + log_backtest_aggregate + If ``True`` (backtest only), log an additional scalar per metric key + under ``backtest_agg_{metric_key}``. """ metrics, metric_kwargs, metric_names = _normalize_metrics( metrics=metrics, @@ -1427,6 +1490,7 @@ def _log_metric_results( has_time_axis=has_time_axis, has_windows=has_windows, last_points_only=last_points_only, + series_align=series_align, ) write_table = (not series_reduced and not is_single_series) or ( @@ -1437,6 +1501,7 @@ def _log_metric_results( run_id, stepped_metrics, agg_func=agg_func, + log_backtest_aggregate=log_backtest_aggregate and is_backtest, table_rows=detailed_metrics if write_table else None, ) @@ -1718,20 +1783,22 @@ def _collect_stepped_and_detailed_metrics( has_time_axis: bool, has_windows: bool, last_points_only: bool, + series_align: Literal["start", "end"] = "end", ) -> tuple[dict[tuple[str, int], list[float]], list[dict]]: """Parse series metrics and build inputs for MLflow stepped metrics and detailed metric table. Each ``series_metrics`` array has shape ``(w_size, t_size, n_metrics * n_sub_metrics)``. - Shorter series are aligned from the end of the longest remaining axis (windows, - or time when there is no window axis). + Shorter series are aligned from the start or end of the longest remaining axis + (windows, or time when there is no window axis), controlled by ``series_align``. The MLflow ``step`` is the axis the UI should chart, always ``0 .. n-1``: - forecast-horizon index when a time axis is present (time-dependent metrics) - if windows are present: each horizon step is aggregated over the windows - if multi-series: each horizon step is aggregated over the series - - end-aligned window index otherwise (time-aggregated metrics) - - if multi-series: each window is aggregated over the series (end-aligned) + - window index otherwise (time-aggregated metrics), aligned across series + via ``series_align`` + - if multi-series: each window is aggregated over the series """ stepped_metrics: dict[tuple[str, int], list[float]] = {} detailed_metrics: list[dict] = [] @@ -1744,9 +1811,13 @@ def _collect_stepped_and_detailed_metrics( w_size = values.shape[w_axis] t_size = values.shape[t_axis] - # pad shorter series so their last point lines up with the longest - w_offset = max_w_size - w_size if has_windows else 0 - t_offset = max_t_size - t_size if has_time_axis and not has_windows else 0 + # pad shorter series so their last (end) or first (start) point lines up + if series_align == "end": + w_offset = max_w_size - w_size if has_windows else 0 + t_offset = max_t_size - t_size if has_time_axis and not has_windows else 0 + else: + w_offset = 0 + t_offset = 0 for metric_idx, sub_metric_keys in enumerate(metric_keys): for sub_metric_idx, key in enumerate(sub_metric_keys): @@ -1788,6 +1859,7 @@ def _flush_logged_metrics( run_id: str, agg: dict[tuple[str, int], list[float]], agg_func: Callable, + log_backtest_aggregate: bool = False, table_rows: list[dict] | None = None, ) -> None: """Aggregate per-series cells, log MLflow metrics, and optionally write the @@ -1803,16 +1875,33 @@ def _flush_logged_metrics( Map of ``(key, step) -> list of per-series float values``. agg_func Aggregation over the per-series values for each ``(key, step)``. + log_backtest_aggregate + If ``True``, log an additional scalar per backtest key under + ``backtest_agg_{metric_key}`` as ``agg_func`` over all logged steps. table_rows Granular cells for ``metrics_per_series.json``. ``None`` skips writing the table artifact. """ metrics_by_step: dict[int, dict[str, float]] = {} + backtest_agg: dict[str, list[float]] = {} for (key, step), values in agg.items(): - metrics_by_step.setdefault(step, {})[key] = float(agg_func(values)) + step_agg = float(agg_func(values)) + metrics_by_step.setdefault(step, {})[key] = step_agg + + if log_backtest_aggregate and key.startswith("backtest_"): + agg_key = key.replace("backtest_", "backtest_agg_", 1) + backtest_agg.setdefault(agg_key, []).append(step_agg) + for step, metrics in metrics_by_step.items(): autologging_client.log_metrics(run_id=run_id, metrics=metrics, step=step) + if backtest_agg: + aggregate_metrics = { + agg_key: float(agg_func(step_values)) + for agg_key, step_values in backtest_agg.items() + } + autologging_client.log_metrics(run_id=run_id, metrics=aggregate_metrics, step=0) + if table_rows is not None: _log_per_series_table(table_rows) @@ -1824,9 +1913,9 @@ def _log_per_series_table(rows: list[dict]) -> None: Each row is a single metric cell for one series, with columns ``key`` (the aggregate MLflow key, without any series suffix), ``series_index``, ``step`` (the time or window index charted by MLflow), ``window_index`` (the - end-aligned source backtest window ``0 .. max_w - 1``, or ``None`` when - there is no window axis), and ``value``. All calls within a run append - to the same ``metrics_per_series.json`` artifact. + source backtest window ``0 .. max_w - 1`` aligned per ``series_align``, or + ``None`` when there is no window axis), and ``value``. All calls within a run + append to the same ``metrics_per_series.json`` artifact. Used when more than one series is scored, since the logged metric keys only carry the aggregate over series. From 6b05b9efedf6fd81d8a9e909a9c55e010829ef08 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Sep 2026 16:10:52 +0200 Subject: [PATCH 149/154] add example notebook --- examples/29-MLflow-examples.ipynb | 1585 +++++ examples/29-MLflow-quickstart.ipynb | 6143 ----------------- examples/static/images/mlflow_charts.png | Bin 357183 -> 0 bytes .../images/mlflow_experiments_metrics.png | Bin 0 -> 335790 bytes .../images/mlflow_experiments_overview.png | Bin 0 -> 219488 bytes .../static/images/mlflow_model_registry.png | Bin 0 -> 148435 bytes examples/static/images/mlflow_models.png | Bin 361032 -> 0 bytes .../static/images/mlflow_models_overview.png | Bin 0 -> 186819 bytes examples/static/images/mlflow_overview.png | Bin 332549 -> 0 bytes examples/static/images/mlflow_run_detail.png | Bin 0 -> 429667 bytes 10 files changed, 1585 insertions(+), 6143 deletions(-) create mode 100644 examples/29-MLflow-examples.ipynb delete mode 100644 examples/29-MLflow-quickstart.ipynb delete mode 100644 examples/static/images/mlflow_charts.png create mode 100644 examples/static/images/mlflow_experiments_metrics.png create mode 100644 examples/static/images/mlflow_experiments_overview.png create mode 100644 examples/static/images/mlflow_model_registry.png delete mode 100644 examples/static/images/mlflow_models.png create mode 100644 examples/static/images/mlflow_models_overview.png delete mode 100644 examples/static/images/mlflow_overview.png create mode 100644 examples/static/images/mlflow_run_detail.png diff --git a/examples/29-MLflow-examples.ipynb b/examples/29-MLflow-examples.ipynb new file mode 100644 index 0000000000..7ffa551156 --- /dev/null +++ b/examples/29-MLflow-examples.ipynb @@ -0,0 +1,1585 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8a7af915", + "metadata": {}, + "source": [ + "# MLflow Examples for Darts\n", + "\n", + "This notebook walks through a practical MLOps workflow with Darts' native MLflow integration: enable autolog, compare forecasting models, promote the best one to the registry, and run inference from a production alias.\n", + "\n", + "If you are new to Darts, see the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) first.\n", + "\n", + "**Prerequisites:** install MLflow as an optional dependency:\n", + "\n", + "```bash\n", + "pip install \"mlflow>=3.0\"\n", + "```\n", + "\n", + "API reference: [darts.utils.mlflow](https://unit8co.github.io/darts/generated_api/darts.utils.mlflow.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7b28941c", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "11bca7fd", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import tempfile\n", + "import warnings\n", + "\n", + "import mlflow\n", + "from mlflow import MlflowClient\n", + "\n", + "import darts.metrics as metrics\n", + "from darts import set_option\n", + "from darts.datasets import AirPassengersDataset\n", + "from darts.models import LinearRegressionModel, RandomForestModel\n", + "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", + "from darts.utils.mlflow import autolog, load_model\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", + "set_option(\"plotting.use_darts_style\", True)\n", + "\n", + "PLOTLY_KWARGS = dict(\n", + " width=800,\n", + " height=400,\n", + " legend=dict(yanchor=\"top\", y=0.99, xanchor=\"left\", x=0.01),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4eb6fc63", + "metadata": {}, + "source": [ + "## 1. MLflow setup\n", + "\n", + "Point MLflow at a tracking backend and create an experiment. We use a temporary SQLite database so this notebook runs self-contained; in production, set `tracking_uri` to your team's MLflow server or local database." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7aced0df", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/09/03 16:10:25 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", + "2026/09/03 16:10:25 INFO mlflow.store.db.utils: Updating database tables\n", + "2026/09/03 16:10:26 INFO mlflow.tracking.fluent: Experiment with name 'darts-mlflow-examples' does not exist. Creating a new experiment.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tracking URI: sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmps5wn0e4a/mlflow.db\n", + "Experiment: darts-mlflow-examples\n", + "\n", + "To explore runs in the UI:\n", + " mlflow ui --backend-store-uri sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmps5wn0e4a/mlflow.db\n" + ] + } + ], + "source": [ + "tmpdir = tempfile.mkdtemp()\n", + "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "\n", + "EXPERIMENT_NAME = \"darts-mlflow-examples\"\n", + "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", + "mlflow.set_experiment(EXPERIMENT_NAME)\n", + "\n", + "print(f\"Tracking URI: {mlflow.get_tracking_uri()}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-mlflow-examples').name}\")\n", + "print(\n", + " f\"\\nTo explore runs in the UI:\\n mlflow ui --backend-store-uri sqlite:///{mlflow_db}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "72438a10", + "metadata": {}, + "source": [ + "## 2. Load data\n", + "\n", + "We use the classic AirPassengers dataset. The last 36 months are held-out for evaluation using a rolling backtest." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f7e5ffa6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: 108 points | Validation: 36 points\n" + ] + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "#Passengers: %{y:.3g}", + "legendgroup": "#Passengers", + "line": { + "color": "#000000" + }, + "mode": "lines", + "name": "#Passengers", + "type": "scatter", + "x": [ + "1949-01-01T00:00:00.000000000", + "1949-02-01T00:00:00.000000000", + "1949-03-01T00:00:00.000000000", + "1949-04-01T00:00:00.000000000", + "1949-05-01T00:00:00.000000000", + "1949-06-01T00:00:00.000000000", + "1949-07-01T00:00:00.000000000", + "1949-08-01T00:00:00.000000000", + "1949-09-01T00:00:00.000000000", + "1949-10-01T00:00:00.000000000", + "1949-11-01T00:00:00.000000000", + "1949-12-01T00:00:00.000000000", + "1950-01-01T00:00:00.000000000", + "1950-02-01T00:00:00.000000000", + "1950-03-01T00:00:00.000000000", + "1950-04-01T00:00:00.000000000", + "1950-05-01T00:00:00.000000000", + "1950-06-01T00:00:00.000000000", + "1950-07-01T00:00:00.000000000", + "1950-08-01T00:00:00.000000000", + "1950-09-01T00:00:00.000000000", + "1950-10-01T00:00:00.000000000", + "1950-11-01T00:00:00.000000000", + "1950-12-01T00:00:00.000000000", + "1951-01-01T00:00:00.000000000", + "1951-02-01T00:00:00.000000000", + "1951-03-01T00:00:00.000000000", + "1951-04-01T00:00:00.000000000", + "1951-05-01T00:00:00.000000000", + "1951-06-01T00:00:00.000000000", + "1951-07-01T00:00:00.000000000", + "1951-08-01T00:00:00.000000000", + "1951-09-01T00:00:00.000000000", + "1951-10-01T00:00:00.000000000", + "1951-11-01T00:00:00.000000000", + "1951-12-01T00:00:00.000000000", + "1952-01-01T00:00:00.000000000", + "1952-02-01T00:00:00.000000000", + "1952-03-01T00:00:00.000000000", + "1952-04-01T00:00:00.000000000", + "1952-05-01T00:00:00.000000000", + "1952-06-01T00:00:00.000000000", + "1952-07-01T00:00:00.000000000", + "1952-08-01T00:00:00.000000000", + "1952-09-01T00:00:00.000000000", + "1952-10-01T00:00:00.000000000", + "1952-11-01T00:00:00.000000000", + "1952-12-01T00:00:00.000000000", + "1953-01-01T00:00:00.000000000", + "1953-02-01T00:00:00.000000000", + "1953-03-01T00:00:00.000000000", + "1953-04-01T00:00:00.000000000", + "1953-05-01T00:00:00.000000000", + "1953-06-01T00:00:00.000000000", + "1953-07-01T00:00:00.000000000", + "1953-08-01T00:00:00.000000000", + "1953-09-01T00:00:00.000000000", + "1953-10-01T00:00:00.000000000", + "1953-11-01T00:00:00.000000000", + "1953-12-01T00:00:00.000000000", + "1954-01-01T00:00:00.000000000", + "1954-02-01T00:00:00.000000000", + "1954-03-01T00:00:00.000000000", + "1954-04-01T00:00:00.000000000", + "1954-05-01T00:00:00.000000000", + "1954-06-01T00:00:00.000000000", + "1954-07-01T00:00:00.000000000", + "1954-08-01T00:00:00.000000000", + "1954-09-01T00:00:00.000000000", + "1954-10-01T00:00:00.000000000", + "1954-11-01T00:00:00.000000000", + "1954-12-01T00:00:00.000000000", + "1955-01-01T00:00:00.000000000", + "1955-02-01T00:00:00.000000000", + "1955-03-01T00:00:00.000000000", + "1955-04-01T00:00:00.000000000", + "1955-05-01T00:00:00.000000000", + "1955-06-01T00:00:00.000000000", + "1955-07-01T00:00:00.000000000", + "1955-08-01T00:00:00.000000000", + "1955-09-01T00:00:00.000000000", + "1955-10-01T00:00:00.000000000", + "1955-11-01T00:00:00.000000000", + "1955-12-01T00:00:00.000000000", + "1956-01-01T00:00:00.000000000", + "1956-02-01T00:00:00.000000000", + "1956-03-01T00:00:00.000000000", + "1956-04-01T00:00:00.000000000", + "1956-05-01T00:00:00.000000000", + "1956-06-01T00:00:00.000000000", + "1956-07-01T00:00:00.000000000", + "1956-08-01T00:00:00.000000000", + "1956-09-01T00:00:00.000000000", + "1956-10-01T00:00:00.000000000", + "1956-11-01T00:00:00.000000000", + "1956-12-01T00:00:00.000000000", + "1957-01-01T00:00:00.000000000", + "1957-02-01T00:00:00.000000000", + "1957-03-01T00:00:00.000000000", + "1957-04-01T00:00:00.000000000", + "1957-05-01T00:00:00.000000000", + "1957-06-01T00:00:00.000000000", + "1957-07-01T00:00:00.000000000", + "1957-08-01T00:00:00.000000000", + "1957-09-01T00:00:00.000000000", + "1957-10-01T00:00:00.000000000", + "1957-11-01T00:00:00.000000000", + "1957-12-01T00:00:00.000000000", + "1958-01-01T00:00:00.000000000", + "1958-02-01T00:00:00.000000000", + "1958-03-01T00:00:00.000000000", + "1958-04-01T00:00:00.000000000", + "1958-05-01T00:00:00.000000000", + "1958-06-01T00:00:00.000000000", + "1958-07-01T00:00:00.000000000", + "1958-08-01T00:00:00.000000000", + "1958-09-01T00:00:00.000000000", + "1958-10-01T00:00:00.000000000", + "1958-11-01T00:00:00.000000000", + "1958-12-01T00:00:00.000000000", + "1959-01-01T00:00:00.000000000", + "1959-02-01T00:00:00.000000000", + "1959-03-01T00:00:00.000000000", + "1959-04-01T00:00:00.000000000", + "1959-05-01T00:00:00.000000000", + "1959-06-01T00:00:00.000000000", + "1959-07-01T00:00:00.000000000", + "1959-08-01T00:00:00.000000000", + "1959-09-01T00:00:00.000000000", + "1959-10-01T00:00:00.000000000", + "1959-11-01T00:00:00.000000000", + "1959-12-01T00:00:00.000000000", + "1960-01-01T00:00:00.000000000", + "1960-02-01T00:00:00.000000000", + "1960-03-01T00:00:00.000000000", + "1960-04-01T00:00:00.000000000", + "1960-05-01T00:00:00.000000000", + "1960-06-01T00:00:00.000000000", + "1960-07-01T00:00:00.000000000", + "1960-08-01T00:00:00.000000000", + "1960-09-01T00:00:00.000000000", + "1960-10-01T00:00:00.000000000", + "1960-11-01T00:00:00.000000000", + "1960-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "AAAAAAAAXEAAAAAAAIBdQAAAAAAAgGBAAAAAAAAgYEAAAAAAAEBeQAAAAAAA4GBAAAAAAACAYkAAAAAAAIBiQAAAAAAAAGFAAAAAAADAXUAAAAAAAABaQAAAAAAAgF1AAAAAAADAXEAAAAAAAIBfQAAAAAAAoGFAAAAAAADgYEAAAAAAAEBfQAAAAAAAoGJAAAAAAABAZUAAAAAAAEBlQAAAAAAAwGNAAAAAAACgYEAAAAAAAIBcQAAAAAAAgGFAAAAAAAAgYkAAAAAAAMBiQAAAAAAAQGZAAAAAAABgZEAAAAAAAIBlQAAAAAAAQGZAAAAAAADgaEAAAAAAAOBoQAAAAAAAAGdAAAAAAABAZEAAAAAAAEBiQAAAAAAAwGRAAAAAAABgZUAAAAAAAIBmQAAAAAAAIGhAAAAAAACgZkAAAAAAAOBmQAAAAAAAQGtAAAAAAADAbEAAAAAAAEBuQAAAAAAAIGpAAAAAAADgZ0AAAAAAAIBlQAAAAAAAQGhAAAAAAACAaEAAAAAAAIBoQAAAAAAAgG1AAAAAAABgbUAAAAAAAKBsQAAAAAAAYG5AAAAAAACAcEAAAAAAAABxQAAAAAAAoG1AAAAAAABgakAAAAAAAIBmQAAAAAAAIGlAAAAAAACAaUAAAAAAAIBnQAAAAAAAYG1AAAAAAABgbEAAAAAAAEBtQAAAAAAAgHBAAAAAAADgckAAAAAAAFByQAAAAAAAMHBAAAAAAACgbEAAAAAAAGBpQAAAAAAAoGxAAAAAAABAbkAAAAAAACBtQAAAAAAAsHBAAAAAAADQcEAAAAAAAOBwQAAAAAAAsHNAAAAAAADAdkAAAAAAALB1QAAAAAAAgHNAAAAAAAAgcUAAAAAAAKBtQAAAAAAAYHFAAAAAAADAcUAAAAAAAFBxQAAAAAAA0HNAAAAAAACQc0AAAAAAAOBzQAAAAAAAYHdAAAAAAADQeUAAAAAAAFB5QAAAAAAAMHZAAAAAAAAgc0AAAAAAAPBwQAAAAAAAIHNAAAAAAACwc0AAAAAAANByQAAAAAAAQHZAAAAAAADAdUAAAAAAADB2QAAAAAAAYHpAAAAAAAAQfUAAAAAAADB9QAAAAAAAQHlAAAAAAACwdUAAAAAAABBzQAAAAAAAAHVAAAAAAABAdUAAAAAAAOBzQAAAAAAAoHZAAAAAAADAdUAAAAAAALB2QAAAAAAAMHtAAAAAAACwfkAAAAAAAJB/QAAAAAAAQHlAAAAAAABwdkAAAAAAAGBzQAAAAAAAEHVAAAAAAACAdkAAAAAAAGB1QAAAAAAAYHlAAAAAAADAeEAAAAAAAEB6QAAAAAAAgH1AAAAAAAAggUAAAAAAAHiBQAAAAAAA8HxAAAAAAABweUAAAAAAAKB2QAAAAAAAUHlAAAAAAAAQekAAAAAAAHB4QAAAAAAAMHpAAAAAAADQfEAAAAAAAIB9QAAAAAAAuIBAAAAAAABwg0AAAAAAAPCCQAAAAAAAwH9AAAAAAADQfEAAAAAAAGB4QAAAAAAAAHtA", + "dtype": "f8" + } + } + ], + "layout": { + "annotations": [ + { + "showarrow": false, + "text": "Train / val split ", + "x": "1957-12-01T00:00:00", + "xanchor": "right", + "xref": "x", + "y": 1, + "yanchor": "top", + "yref": "y domain" + } + ], + "height": 400, + "hovermode": "x unified", + "legend": { + "x": 0.01, + "xanchor": "left", + "y": 0.99, + "yanchor": "top" + }, + "shapes": [ + { + "line": { + "color": "blue", + "dash": "dash" + }, + "type": "line", + "x0": "1957-12-01T00:00:00", + "x1": "1957-12-01T00:00:00", + "xref": "x", + "y0": 0, + "y1": 1, + "yref": "y domain" + } + ], + "template": { + "data": { + "scatter": [ + { + "line": { + "width": 3 + }, + "type": "scatter" + } + ] + }, + "layout": { + "colorway": [ + "#000000", + "#003dfd", + "#b512b8", + "#11a9ba", + "#0d780f", + "#f77f07", + "#ba0f0f" + ], + "font": { + "color": "black", + "family": "Arial, sans-serif", + "size": 14 + }, + "legend": { + "bgcolor": "rgba(255, 255, 255, 0.8)", + "borderwidth": 0, + "font": { + "size": 14 + }, + "x": 1, + "xanchor": "right", + "y": 1, + "yanchor": "top" + }, + "margin": { + "b": 50, + "l": 50, + "r": 50, + "t": 50 + }, + "paper_bgcolor": "white", + "plot_bgcolor": "white", + "showlegend": true, + "xaxis": { + "linecolor": "#dedede", + "showgrid": false, + "showline": true, + "title": { + "font": { + "color": "black", + "size": 16 + } + } + }, + "yaxis": { + "gridcolor": "#dedede", + "gridwidth": 1, + "showgrid": true, + "showline": false, + "zeroline": true, + "zerolinecolor": "#dedede" + } + } + }, + "title": { + "text": "Air Passengers" + }, + "width": 800, + "xaxis": { + "title": { + "text": "Month" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "FORECAST_HORIZON = 12\n", + "BACKTEST_STRIDE = 12\n", + "\n", + "series = AirPassengersDataset().load()\n", + "train, val = series[: -3 * FORECAST_HORIZON], series[-3 * FORECAST_HORIZON :]\n", + "\n", + "print(f\"Training: {len(train)} points | Validation: {len(val)} points\")\n", + "\n", + "fig = series.plotly()\n", + "fig.add_vline(\n", + " x=train.end_time(),\n", + " line_color=\"blue\",\n", + " line_dash=\"dash\",\n", + " annotation_text=\"Train / val split \",\n", + " annotation_position=\"top left\",\n", + ")\n", + "fig.update_layout(title=\"Air Passengers\", **PLOTLY_KWARGS)" + ] + }, + { + "cell_type": "markdown", + "id": "4c5db7bc", + "metadata": {}, + "source": [ + "## 3. Enable autolog\n", + "\n", + "One line turns on automatic experiment tracking for Darts models and metrics. We enable model logging (for the registry workflow) and backtest aggregate metrics (scalar `backtest_agg_*` keys for easy run comparison)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "71e43aa8", + "metadata": {}, + "outputs": [], + "source": [ + "autolog(log_models=True, log_backtest_aggregate=True)" + ] + }, + { + "cell_type": "markdown", + "id": "36acc84b", + "metadata": {}, + "source": [ + "
\n", + "What does autolog capture? (click to expand)\n", + "\n", + "| Trigger | Logged automatically |\n", + "|---|---|\n", + "| `model.fit(...)` | Model tags, hyperparameters, input series info, and trained model artifact when `log_models=True` |\n", + "| Standalone metric calls | Time-aggregated scalar metrics (e.g. `mae()`) and time-dependent stepped metrics (e.g. `ae()`); detailed breakdowns go to `metrics_per_series.json` |\n", + "| `model.backtest(...)` | Windowed-, per-horizon-, or aggregated metrics prefixed with `backtest_`; with `log_backtest_aggregate=True` also logs `backtest_agg_{metric}` |\n", + "| PyTorch models (NBEATS, TFT, …) | Per-epoch `train_loss` / `val_loss` via MLflow's PyTorch autolog |\n", + "\n", + "Disable anytime with `autolog(disable=True)`.\n", + "\n", + "For manual logging, save/load APIs, and metric-key details, see the [`Darts API reference`](https://unit8co.github.io/darts/generated_api/darts.utils.mlflow.html) and the [`MLflow API reference`](https://mlflow.org/docs/latest/ml/tracking/tracking-api/).\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "fdb06e85", + "metadata": {}, + "source": [ + "## 4. Compare model experiments\n", + "\n", + "We train three comparable sklearn-based models inside separate MLflow runs. Each run follows the same evaluation recipe:\n", + "\n", + "1. **Fit** (pre-train) on the training series (params and model artifact logged automatically).\n", + "2. **Historical forecasts** over the same validation period (rolling forecasts).\n", + "3. **Backtest** with windowed `mae` (`reduction=None` → stepped `backtest_mae` chart + scalar aggregate `backtest_agg_mae`).\n", + "4. **Backtest** with time-dependent `err` (per-horizon error profile `backtest_ae` + scalar aggregate `backtest_agg_ae`)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ff6030e8", + "metadata": {}, + "outputs": [], + "source": [ + "def run_experiment(run_name, model, *, plot_historical=False):\n", + " \"\"\"Fit, evaluate, and autolog a single forecasting experiment.\"\"\"\n", + " hfc_kwargs = {\n", + " \"series\": series,\n", + " \"start\": val.start_time(), # start time of the validation period\n", + " \"forecast_horizon\": FORECAST_HORIZON, # forecast horizon\n", + " \"stride\": BACKTEST_STRIDE, # step size between rolling forecasts\n", + " \"retrain\": False, # use pre-trained model\n", + " \"last_points_only\": False, # use all available points for each forecast\n", + " }\n", + "\n", + " with mlflow.start_run(run_name=run_name):\n", + " # log pre-trained model artifact\n", + " model.fit(train)\n", + "\n", + " hfcs = model.historical_forecasts(**hfc_kwargs)\n", + " bt_kwargs = {**hfc_kwargs, \"historical_forecasts\": hfcs, \"reduction\": None}\n", + "\n", + " # windowed aggregate metric: stepped backtest_mae + scalar backtest_agg_mae\n", + " model.backtest(metric=metrics.mae, **bt_kwargs)\n", + "\n", + " # time-dependent metric: per-horizon error `backtest_err` + scalar backtest_agg_err\n", + " model.backtest(metric=metrics.err, **bt_kwargs)\n", + "\n", + " if plot_historical:\n", + " fig = series.plotly(label=\"actual\")\n", + " for idx, hfc in enumerate(hfcs):\n", + " fig = hfc.plotly(label=f\"forecast {idx}\", fig=fig)\n", + " fig.update_layout(\n", + " title=f\"Historical forecasts — {run_name}\", **PLOTLY_KWARGS\n", + " )\n", + " fig.show()\n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "12ed056e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/09/03 16:10:29 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "actual: %{y:.3g}", + "legendgroup": "actual", + "line": { + "color": "#000000" + }, + "mode": "lines", + "name": "actual", + "type": "scatter", + "x": [ + "1949-01-01T00:00:00.000000000", + "1949-02-01T00:00:00.000000000", + "1949-03-01T00:00:00.000000000", + "1949-04-01T00:00:00.000000000", + "1949-05-01T00:00:00.000000000", + "1949-06-01T00:00:00.000000000", + "1949-07-01T00:00:00.000000000", + "1949-08-01T00:00:00.000000000", + "1949-09-01T00:00:00.000000000", + "1949-10-01T00:00:00.000000000", + "1949-11-01T00:00:00.000000000", + "1949-12-01T00:00:00.000000000", + "1950-01-01T00:00:00.000000000", + "1950-02-01T00:00:00.000000000", + "1950-03-01T00:00:00.000000000", + "1950-04-01T00:00:00.000000000", + "1950-05-01T00:00:00.000000000", + "1950-06-01T00:00:00.000000000", + "1950-07-01T00:00:00.000000000", + "1950-08-01T00:00:00.000000000", + "1950-09-01T00:00:00.000000000", + "1950-10-01T00:00:00.000000000", + "1950-11-01T00:00:00.000000000", + "1950-12-01T00:00:00.000000000", + "1951-01-01T00:00:00.000000000", + "1951-02-01T00:00:00.000000000", + "1951-03-01T00:00:00.000000000", + "1951-04-01T00:00:00.000000000", + "1951-05-01T00:00:00.000000000", + "1951-06-01T00:00:00.000000000", + "1951-07-01T00:00:00.000000000", + "1951-08-01T00:00:00.000000000", + "1951-09-01T00:00:00.000000000", + "1951-10-01T00:00:00.000000000", + "1951-11-01T00:00:00.000000000", + "1951-12-01T00:00:00.000000000", + "1952-01-01T00:00:00.000000000", + "1952-02-01T00:00:00.000000000", + "1952-03-01T00:00:00.000000000", + "1952-04-01T00:00:00.000000000", + "1952-05-01T00:00:00.000000000", + "1952-06-01T00:00:00.000000000", + "1952-07-01T00:00:00.000000000", + "1952-08-01T00:00:00.000000000", + "1952-09-01T00:00:00.000000000", + "1952-10-01T00:00:00.000000000", + "1952-11-01T00:00:00.000000000", + "1952-12-01T00:00:00.000000000", + "1953-01-01T00:00:00.000000000", + "1953-02-01T00:00:00.000000000", + "1953-03-01T00:00:00.000000000", + "1953-04-01T00:00:00.000000000", + "1953-05-01T00:00:00.000000000", + "1953-06-01T00:00:00.000000000", + "1953-07-01T00:00:00.000000000", + "1953-08-01T00:00:00.000000000", + "1953-09-01T00:00:00.000000000", + "1953-10-01T00:00:00.000000000", + "1953-11-01T00:00:00.000000000", + "1953-12-01T00:00:00.000000000", + "1954-01-01T00:00:00.000000000", + "1954-02-01T00:00:00.000000000", + "1954-03-01T00:00:00.000000000", + "1954-04-01T00:00:00.000000000", + "1954-05-01T00:00:00.000000000", + "1954-06-01T00:00:00.000000000", + "1954-07-01T00:00:00.000000000", + "1954-08-01T00:00:00.000000000", + "1954-09-01T00:00:00.000000000", + "1954-10-01T00:00:00.000000000", + "1954-11-01T00:00:00.000000000", + "1954-12-01T00:00:00.000000000", + "1955-01-01T00:00:00.000000000", + "1955-02-01T00:00:00.000000000", + "1955-03-01T00:00:00.000000000", + "1955-04-01T00:00:00.000000000", + "1955-05-01T00:00:00.000000000", + "1955-06-01T00:00:00.000000000", + "1955-07-01T00:00:00.000000000", + "1955-08-01T00:00:00.000000000", + "1955-09-01T00:00:00.000000000", + "1955-10-01T00:00:00.000000000", + "1955-11-01T00:00:00.000000000", + "1955-12-01T00:00:00.000000000", + "1956-01-01T00:00:00.000000000", + "1956-02-01T00:00:00.000000000", + "1956-03-01T00:00:00.000000000", + "1956-04-01T00:00:00.000000000", + "1956-05-01T00:00:00.000000000", + "1956-06-01T00:00:00.000000000", + "1956-07-01T00:00:00.000000000", + "1956-08-01T00:00:00.000000000", + "1956-09-01T00:00:00.000000000", + "1956-10-01T00:00:00.000000000", + "1956-11-01T00:00:00.000000000", + "1956-12-01T00:00:00.000000000", + "1957-01-01T00:00:00.000000000", + "1957-02-01T00:00:00.000000000", + "1957-03-01T00:00:00.000000000", + "1957-04-01T00:00:00.000000000", + "1957-05-01T00:00:00.000000000", + "1957-06-01T00:00:00.000000000", + "1957-07-01T00:00:00.000000000", + "1957-08-01T00:00:00.000000000", + "1957-09-01T00:00:00.000000000", + "1957-10-01T00:00:00.000000000", + "1957-11-01T00:00:00.000000000", + "1957-12-01T00:00:00.000000000", + "1958-01-01T00:00:00.000000000", + "1958-02-01T00:00:00.000000000", + "1958-03-01T00:00:00.000000000", + "1958-04-01T00:00:00.000000000", + "1958-05-01T00:00:00.000000000", + "1958-06-01T00:00:00.000000000", + "1958-07-01T00:00:00.000000000", + "1958-08-01T00:00:00.000000000", + "1958-09-01T00:00:00.000000000", + "1958-10-01T00:00:00.000000000", + "1958-11-01T00:00:00.000000000", + "1958-12-01T00:00:00.000000000", + "1959-01-01T00:00:00.000000000", + "1959-02-01T00:00:00.000000000", + "1959-03-01T00:00:00.000000000", + "1959-04-01T00:00:00.000000000", + "1959-05-01T00:00:00.000000000", + "1959-06-01T00:00:00.000000000", + "1959-07-01T00:00:00.000000000", + "1959-08-01T00:00:00.000000000", + "1959-09-01T00:00:00.000000000", + "1959-10-01T00:00:00.000000000", + "1959-11-01T00:00:00.000000000", + "1959-12-01T00:00:00.000000000", + "1960-01-01T00:00:00.000000000", + "1960-02-01T00:00:00.000000000", + "1960-03-01T00:00:00.000000000", + "1960-04-01T00:00:00.000000000", + "1960-05-01T00:00:00.000000000", + "1960-06-01T00:00:00.000000000", + "1960-07-01T00:00:00.000000000", + "1960-08-01T00:00:00.000000000", + "1960-09-01T00:00:00.000000000", + "1960-10-01T00:00:00.000000000", + "1960-11-01T00:00:00.000000000", + "1960-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "AAAAAAAAXEAAAAAAAIBdQAAAAAAAgGBAAAAAAAAgYEAAAAAAAEBeQAAAAAAA4GBAAAAAAACAYkAAAAAAAIBiQAAAAAAAAGFAAAAAAADAXUAAAAAAAABaQAAAAAAAgF1AAAAAAADAXEAAAAAAAIBfQAAAAAAAoGFAAAAAAADgYEAAAAAAAEBfQAAAAAAAoGJAAAAAAABAZUAAAAAAAEBlQAAAAAAAwGNAAAAAAACgYEAAAAAAAIBcQAAAAAAAgGFAAAAAAAAgYkAAAAAAAMBiQAAAAAAAQGZAAAAAAABgZEAAAAAAAIBlQAAAAAAAQGZAAAAAAADgaEAAAAAAAOBoQAAAAAAAAGdAAAAAAABAZEAAAAAAAEBiQAAAAAAAwGRAAAAAAABgZUAAAAAAAIBmQAAAAAAAIGhAAAAAAACgZkAAAAAAAOBmQAAAAAAAQGtAAAAAAADAbEAAAAAAAEBuQAAAAAAAIGpAAAAAAADgZ0AAAAAAAIBlQAAAAAAAQGhAAAAAAACAaEAAAAAAAIBoQAAAAAAAgG1AAAAAAABgbUAAAAAAAKBsQAAAAAAAYG5AAAAAAACAcEAAAAAAAABxQAAAAAAAoG1AAAAAAABgakAAAAAAAIBmQAAAAAAAIGlAAAAAAACAaUAAAAAAAIBnQAAAAAAAYG1AAAAAAABgbEAAAAAAAEBtQAAAAAAAgHBAAAAAAADgckAAAAAAAFByQAAAAAAAMHBAAAAAAACgbEAAAAAAAGBpQAAAAAAAoGxAAAAAAABAbkAAAAAAACBtQAAAAAAAsHBAAAAAAADQcEAAAAAAAOBwQAAAAAAAsHNAAAAAAADAdkAAAAAAALB1QAAAAAAAgHNAAAAAAAAgcUAAAAAAAKBtQAAAAAAAYHFAAAAAAADAcUAAAAAAAFBxQAAAAAAA0HNAAAAAAACQc0AAAAAAAOBzQAAAAAAAYHdAAAAAAADQeUAAAAAAAFB5QAAAAAAAMHZAAAAAAAAgc0AAAAAAAPBwQAAAAAAAIHNAAAAAAACwc0AAAAAAANByQAAAAAAAQHZAAAAAAADAdUAAAAAAADB2QAAAAAAAYHpAAAAAAAAQfUAAAAAAADB9QAAAAAAAQHlAAAAAAACwdUAAAAAAABBzQAAAAAAAAHVAAAAAAABAdUAAAAAAAOBzQAAAAAAAoHZAAAAAAADAdUAAAAAAALB2QAAAAAAAMHtAAAAAAACwfkAAAAAAAJB/QAAAAAAAQHlAAAAAAABwdkAAAAAAAGBzQAAAAAAAEHVAAAAAAACAdkAAAAAAAGB1QAAAAAAAYHlAAAAAAADAeEAAAAAAAEB6QAAAAAAAgH1AAAAAAAAggUAAAAAAAHiBQAAAAAAA8HxAAAAAAABweUAAAAAAAKB2QAAAAAAAUHlAAAAAAAAQekAAAAAAAHB4QAAAAAAAMHpAAAAAAADQfEAAAAAAAIB9QAAAAAAAuIBAAAAAAABwg0AAAAAAAPCCQAAAAAAAwH9AAAAAAADQfEAAAAAAAGB4QAAAAAAAAHtA", + "dtype": "f8" + } + }, + { + "hovertemplate": "forecast 0: %{y:.3g}", + "legendgroup": "forecast 0", + "line": { + "color": "#003dfd" + }, + "mode": "lines", + "name": "forecast 0", + "type": "scatter", + "x": [ + "1958-01-01T00:00:00.000000000", + "1958-02-01T00:00:00.000000000", + "1958-03-01T00:00:00.000000000", + "1958-04-01T00:00:00.000000000", + "1958-05-01T00:00:00.000000000", + "1958-06-01T00:00:00.000000000", + "1958-07-01T00:00:00.000000000", + "1958-08-01T00:00:00.000000000", + "1958-09-01T00:00:00.000000000", + "1958-10-01T00:00:00.000000000", + "1958-11-01T00:00:00.000000000", + "1958-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "DDQnI6QgdkBKYFmmDEZ1QNoNvZcioHhAIcYwrxV3eEDGoXpXwfh4QFCjzLQ19X1AjtbAxQprgEDQdLHYvXeAQBampaePpXxA/N2iqG9MeEBQFfttPoF1QLKTcZKhI3dA", + "dtype": "f8" + } + }, + { + "hovertemplate": "forecast 1: %{y:.3g}", + "legendgroup": "forecast 1", + "line": { + "color": "#b512b8" + }, + "mode": "lines", + "name": "forecast 1", + "type": "scatter", + "x": [ + "1959-01-01T00:00:00.000000000", + "1959-02-01T00:00:00.000000000", + "1959-03-01T00:00:00.000000000", + "1959-04-01T00:00:00.000000000", + "1959-05-01T00:00:00.000000000", + "1959-06-01T00:00:00.000000000", + "1959-07-01T00:00:00.000000000", + "1959-08-01T00:00:00.000000000", + "1959-09-01T00:00:00.000000000", + "1959-10-01T00:00:00.000000000", + "1959-11-01T00:00:00.000000000", + "1959-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "tglrg62hd0DcWMd7ADN2QMGurWZVy3hAZe8PRfpSeEAiIIv+AWh5QBIw56L3sn5AebRxL4NcgUCvuEOEs6qBQP5NWzXs03xAbBZl4Nj2eEBzPKKqWg12QGjR+vqpOHdA", + "dtype": "f8" + } + }, + { + "hovertemplate": "forecast 2: %{y:.3g}", + "legendgroup": "forecast 2", + "line": { + "color": "#11a9ba" + }, + "mode": "lines", + "name": "forecast 2", + "type": "scatter", + "x": [ + "1960-01-01T00:00:00.000000000", + "1960-02-01T00:00:00.000000000", + "1960-03-01T00:00:00.000000000", + "1960-04-01T00:00:00.000000000", + "1960-05-01T00:00:00.000000000", + "1960-06-01T00:00:00.000000000", + "1960-07-01T00:00:00.000000000", + "1960-08-01T00:00:00.000000000", + "1960-09-01T00:00:00.000000000", + "1960-10-01T00:00:00.000000000", + "1960-11-01T00:00:00.000000000", + "1960-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "4tWOkrWzeUCRUBweMXd4QO7LYWVTInxAobH0G48UfECQ9sMYrHJ9QFfj/mwc5IBA+LMuueVEg0AqcP9o8LaDQBC2RYNeYIBAYNmBHBZzfEBkyez9rWN5QNIWZm7fkXtA", + "dtype": "f8" + } + } + ], + "layout": { + "height": 400, + "hovermode": "x unified", + "legend": { + "x": 0.01, + "xanchor": "left", + "y": 0.99, + "yanchor": "top" + }, + "template": { + "data": { + "scatter": [ + { + "line": { + "width": 3 + }, + "type": "scatter" + } + ] + }, + "layout": { + "colorway": [ + "#000000", + "#003dfd", + "#b512b8", + "#11a9ba", + "#0d780f", + "#f77f07", + "#ba0f0f" + ], + "font": { + "color": "black", + "family": "Arial, sans-serif", + "size": 14 + }, + "legend": { + "bgcolor": "rgba(255, 255, 255, 0.8)", + "borderwidth": 0, + "font": { + "size": 14 + }, + "x": 1, + "xanchor": "right", + "y": 1, + "yanchor": "top" + }, + "margin": { + "b": 50, + "l": 50, + "r": 50, + "t": 50 + }, + "paper_bgcolor": "white", + "plot_bgcolor": "white", + "showlegend": true, + "xaxis": { + "linecolor": "#dedede", + "showgrid": false, + "showline": true, + "title": { + "font": { + "color": "black", + "size": 16 + } + } + }, + "yaxis": { + "gridcolor": "#dedede", + "gridwidth": 1, + "showgrid": true, + "showline": false, + "zeroline": true, + "zerolinecolor": "#dedede" + } + } + }, + "title": { + "text": "Historical forecasts — linear_regression" + }, + "width": 800, + "xaxis": { + "title": { + "text": "Month" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/09/03 16:10:29 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished run: linear_regression\n", + "Finished run: random_forest\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/09/03 16:10:29 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished run: linear_regression_lags24\n" + ] + } + ], + "source": [ + "experiments = [\n", + " (\n", + " \"linear_regression\",\n", + " LinearRegressionModel(lags=12, output_chunk_length=FORECAST_HORIZON),\n", + " True,\n", + " ),\n", + " (\n", + " \"random_forest\",\n", + " RandomForestModel(\n", + " lags=12,\n", + " output_chunk_length=FORECAST_HORIZON,\n", + " n_estimators=50,\n", + " random_state=42,\n", + " ),\n", + " False,\n", + " ),\n", + " (\n", + " \"linear_regression_lags24\",\n", + " LinearRegressionModel(lags=24, output_chunk_length=FORECAST_HORIZON),\n", + " False,\n", + " ),\n", + "]\n", + "\n", + "for run_name, model, plot_hist in experiments:\n", + " run_experiment(run_name, model, plot_historical=plot_hist)\n", + " print(f\"Finished run: {run_name}\")\n", + "\n", + "# disable autologging\n", + "autolog(disable=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b3221514", + "metadata": {}, + "source": [ + "### Explore in the MLflow UI\n", + "\n", + "Open the tracking UI and compare runs side by side — model parameters, metrics, model artifacts are all available automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ed4e0c35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "To explore runs in the UI:\n", + " mlflow ui --backend-store-uri sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmps5wn0e4a/mlflow.db\n" + ] + } + ], + "source": [ + "print(\n", + " f\"\\nTo explore runs in the UI:\\n mlflow ui --backend-store-uri sqlite:///{mlflow_db}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "834d1825", + "metadata": {}, + "source": [ + "
\n", + "MLflow Runs Table View\n", + "\n", + "The MLflow Runs Table shows all runs under an experiment in tabular style. It allows you to filter, sort, compare anything that was logged. You can add any logged parameter (metrics, model parameters, ...) to the table via the `Columns` dropdown.\n", + "\n", + "Here we see that `linear_regression` had the lowest aggregated MAE (`backtest_agg_mae`) and aggregated Horizon-Error (Bias) (`backtest_agg_err`) across all runs.\n", + "\n", + "![MLflow runs table view](./static/images/mlflow_experiments_overview.png)\n", + "\n", + "
\n", + "\n", + "
\n", + "MLflow Runs Chart View\n", + "\n", + "Click on the `Chart View` icon on the top left of the Runs Table to show a detailed view of all metrics across runs. In this view you can find scalar as well as stepped metric charts.\n", + "\n", + "- 📈 Stepped metrics (line charts): \n", + " - Windowed-backtest results for [time-aggregated metrics](https://unit8co.github.io/darts/generated_api/darts.metrics.html) - showing the score per rolling forecast (0, 1, ... number of rolling windows - 1). See `backtest_mae` below showing 3 steps corresponding to the 3 rolling historical forecasts. \n", + " - Horizon-based-backtest results for [time-dependent metrics](https://unit8co.github.io/darts/generated_api/darts.metrics.html) - showing the score per step in the forecast horizon (0, 1, ... horizon - 1) aggregated over all rolling forecasts. See `backtest_err` below showing 12 steps corresponding to `FORECAST_HORIZON`.\n", + "- 📊 Scalar metrics (bar charts) for: \n", + " - Aggregated backtest metrics, e.g. with `autolog(log_backtest_aggregate=True)`. See `backtest_agg_mae` and `backtest_agg_ae` below.\n", + " - Direct [time-aggregated metric](https://unit8co.github.io/darts/generated_api/darts.metrics.html) calls (e.g. `darts.metrics.mae()`)\n", + "\n", + "... and many other configurations. Read more in the [API reference](https://unit8co.github.io/darts/generated_api/darts.utils.mlflow.html).\n", + "\n", + "![MLflow runs chart view](./static/images/mlflow_experiments_metrics.png)\n", + "\n", + "
\n", + "\n", + "
\n", + "MLflow Run Detail Page (click to expand)\n", + "\n", + "Click on any run in the Runs Table to open the Run Detail Page. It shows an overview of the run, its recorded metrics, hyper-parameters, tags, and more. Play around with the UI to see the different views and features.\n", + "\n", + "Scroll down to the \"Model\" section and you will see the model that was logged during training. Click on the model to view the details (inclduing the logged model artifacts).\n", + "\n", + "![MLflow run detail page](./static/images/mlflow_run_detail.png)\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "248f15dc", + "metadata": {}, + "source": [ + "## 5. Find the best run\n", + "\n", + "Above, we could already see that `linear_regression` was the best performing model overall.\n", + "\n", + "Let's also do it programatically by finding the model with the lowest MAE. With `log_backtest_aggregate=True` we get a convient sort key: one scalar that summarizes rolling backtest performance, regardless of how many windows or time series were evaluated. `backtest_agg_mae` is such a key." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fa88b420", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
run_idtags.mlflow.runNamemetrics.backtest_agg_mae
0fb3ad151ba8c4192bb82857a5e255994linear_regression18.870433
141484b2e9f794a3a96ee6f89f4d789e4linear_regression_lags2424.509846
22302431c94a348d09dcd46bbc10dcdabrandom_forest77.316667
\n", + "
" + ], + "text/plain": [ + " run_id tags.mlflow.runName \\\n", + "0 fb3ad151ba8c4192bb82857a5e255994 linear_regression \n", + "1 41484b2e9f794a3a96ee6f89f4d789e4 linear_regression_lags24 \n", + "2 2302431c94a348d09dcd46bbc10dcdab random_forest \n", + "\n", + " metrics.backtest_agg_mae \n", + "0 18.870433 \n", + "1 24.509846 \n", + "2 77.316667 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Best run by backtest_agg_mae: linear_regression (fb3ad151ba8c4192bb82857a5e255994)\n" + ] + } + ], + "source": [ + "runs_df = mlflow.search_runs(\n", + " experiment_names=[EXPERIMENT_NAME],\n", + " order_by=[\"metrics.backtest_agg_mae ASC\"],\n", + ")\n", + "display(runs_df[[\"run_id\", \"tags.mlflow.runName\", \"metrics.backtest_agg_mae\"]])\n", + "\n", + "best_run = runs_df.iloc[0]\n", + "best_run_id = best_run.run_id\n", + "best_run_name = best_run[\"tags.mlflow.runName\"]\n", + "print(f\"\\nBest run by backtest_agg_mae: {best_run_name} ({best_run_id})\")" + ] + }, + { + "cell_type": "markdown", + "id": "f4606742", + "metadata": {}, + "source": [ + "## 6. Register the champion model\n", + "\n", + "We can promote the best run's model to the **MLflow Model Registry**, then assign a **champion** alias (or any other alias). Downstream code can then load the registered models via registered model name and alias.\n", + "\n", + "> This assumes that model logging was enabled: `autolog(log_models=True)` and `fit()` was called within each MLflow run" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "26ca96da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best model URI: models:/m-d142c7979f29495d90aa74b3e91638e0\n", + "Aliases set: @champion\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Successfully registered model 'darts-air-passengers-forecaster'.\n", + "Created version '1' of model 'darts-air-passengers-forecaster'.\n" + ] + } + ], + "source": [ + "# Get the logged model URI of the best run\n", + "model_outputs = mlflow.get_run(best_run_id).outputs.model_outputs\n", + "best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", + "print(f\"Best model URI: {best_model_uri}\")\n", + "\n", + "REGISTERED_MODEL_NAME = \"darts-air-passengers-forecaster\"\n", + "\n", + "registration = mlflow.register_model(\n", + " model_uri=best_model_uri,\n", + " name=REGISTERED_MODEL_NAME,\n", + ")\n", + "\n", + "client = MlflowClient()\n", + "client.set_registered_model_alias(\n", + " REGISTERED_MODEL_NAME, \"champion\", registration.version\n", + ")\n", + "print(\"Aliases set: @champion\")" + ] + }, + { + "cell_type": "markdown", + "id": "b7abaf63", + "metadata": {}, + "source": [ + "All logged models can be found in the MLflow Models View:\n", + "\n", + "![MLflow Model Table](./static/images/mlflow_models_overview.png)\n", + "\n", + "The registered models can be found in the MLflow Model Registry:\n", + "\n", + "![MLflow Model Registry](./static/images/mlflow_model_registry.png)" + ] + }, + { + "cell_type": "markdown", + "id": "5cd2ebab", + "metadata": {}, + "source": [ + "## 7. Load the champion and forecast\n", + "\n", + "Production inference loads the aliased registered model via `models:/@champion` without hard-coding a version number.\n", + "The loaded model can then be used for prediction:\n", + "\n", + "- Global models (like the sklearn regressors used here) need `series=` at predict time because the model is saved without training data.\n", + "- Local models (like `ExponentialSmoothing` and others) must be re-fit before prediction.\n", + "\n", + "> Always load Darts models with `from darts.utils.mlflow import load_model` — not `mlflow.pyfunc.load_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c12ba777", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "full series: %{y:.3g}", + "legendgroup": "full series", + "line": { + "color": "#000000" + }, + "mode": "lines", + "name": "full series", + "type": "scatter", + "x": [ + "1949-01-01T00:00:00.000000000", + "1949-02-01T00:00:00.000000000", + "1949-03-01T00:00:00.000000000", + "1949-04-01T00:00:00.000000000", + "1949-05-01T00:00:00.000000000", + "1949-06-01T00:00:00.000000000", + "1949-07-01T00:00:00.000000000", + "1949-08-01T00:00:00.000000000", + "1949-09-01T00:00:00.000000000", + "1949-10-01T00:00:00.000000000", + "1949-11-01T00:00:00.000000000", + "1949-12-01T00:00:00.000000000", + "1950-01-01T00:00:00.000000000", + "1950-02-01T00:00:00.000000000", + "1950-03-01T00:00:00.000000000", + "1950-04-01T00:00:00.000000000", + "1950-05-01T00:00:00.000000000", + "1950-06-01T00:00:00.000000000", + "1950-07-01T00:00:00.000000000", + "1950-08-01T00:00:00.000000000", + "1950-09-01T00:00:00.000000000", + "1950-10-01T00:00:00.000000000", + "1950-11-01T00:00:00.000000000", + "1950-12-01T00:00:00.000000000", + "1951-01-01T00:00:00.000000000", + "1951-02-01T00:00:00.000000000", + "1951-03-01T00:00:00.000000000", + "1951-04-01T00:00:00.000000000", + "1951-05-01T00:00:00.000000000", + "1951-06-01T00:00:00.000000000", + "1951-07-01T00:00:00.000000000", + "1951-08-01T00:00:00.000000000", + "1951-09-01T00:00:00.000000000", + "1951-10-01T00:00:00.000000000", + "1951-11-01T00:00:00.000000000", + "1951-12-01T00:00:00.000000000", + "1952-01-01T00:00:00.000000000", + "1952-02-01T00:00:00.000000000", + "1952-03-01T00:00:00.000000000", + "1952-04-01T00:00:00.000000000", + "1952-05-01T00:00:00.000000000", + "1952-06-01T00:00:00.000000000", + "1952-07-01T00:00:00.000000000", + "1952-08-01T00:00:00.000000000", + "1952-09-01T00:00:00.000000000", + "1952-10-01T00:00:00.000000000", + "1952-11-01T00:00:00.000000000", + "1952-12-01T00:00:00.000000000", + "1953-01-01T00:00:00.000000000", + "1953-02-01T00:00:00.000000000", + "1953-03-01T00:00:00.000000000", + "1953-04-01T00:00:00.000000000", + "1953-05-01T00:00:00.000000000", + "1953-06-01T00:00:00.000000000", + "1953-07-01T00:00:00.000000000", + "1953-08-01T00:00:00.000000000", + "1953-09-01T00:00:00.000000000", + "1953-10-01T00:00:00.000000000", + "1953-11-01T00:00:00.000000000", + "1953-12-01T00:00:00.000000000", + "1954-01-01T00:00:00.000000000", + "1954-02-01T00:00:00.000000000", + "1954-03-01T00:00:00.000000000", + "1954-04-01T00:00:00.000000000", + "1954-05-01T00:00:00.000000000", + "1954-06-01T00:00:00.000000000", + "1954-07-01T00:00:00.000000000", + "1954-08-01T00:00:00.000000000", + "1954-09-01T00:00:00.000000000", + "1954-10-01T00:00:00.000000000", + "1954-11-01T00:00:00.000000000", + "1954-12-01T00:00:00.000000000", + "1955-01-01T00:00:00.000000000", + "1955-02-01T00:00:00.000000000", + "1955-03-01T00:00:00.000000000", + "1955-04-01T00:00:00.000000000", + "1955-05-01T00:00:00.000000000", + "1955-06-01T00:00:00.000000000", + "1955-07-01T00:00:00.000000000", + "1955-08-01T00:00:00.000000000", + "1955-09-01T00:00:00.000000000", + "1955-10-01T00:00:00.000000000", + "1955-11-01T00:00:00.000000000", + "1955-12-01T00:00:00.000000000", + "1956-01-01T00:00:00.000000000", + "1956-02-01T00:00:00.000000000", + "1956-03-01T00:00:00.000000000", + "1956-04-01T00:00:00.000000000", + "1956-05-01T00:00:00.000000000", + "1956-06-01T00:00:00.000000000", + "1956-07-01T00:00:00.000000000", + "1956-08-01T00:00:00.000000000", + "1956-09-01T00:00:00.000000000", + "1956-10-01T00:00:00.000000000", + "1956-11-01T00:00:00.000000000", + "1956-12-01T00:00:00.000000000", + "1957-01-01T00:00:00.000000000", + "1957-02-01T00:00:00.000000000", + "1957-03-01T00:00:00.000000000", + "1957-04-01T00:00:00.000000000", + "1957-05-01T00:00:00.000000000", + "1957-06-01T00:00:00.000000000", + "1957-07-01T00:00:00.000000000", + "1957-08-01T00:00:00.000000000", + "1957-09-01T00:00:00.000000000", + "1957-10-01T00:00:00.000000000", + "1957-11-01T00:00:00.000000000", + "1957-12-01T00:00:00.000000000", + "1958-01-01T00:00:00.000000000", + "1958-02-01T00:00:00.000000000", + "1958-03-01T00:00:00.000000000", + "1958-04-01T00:00:00.000000000", + "1958-05-01T00:00:00.000000000", + "1958-06-01T00:00:00.000000000", + "1958-07-01T00:00:00.000000000", + "1958-08-01T00:00:00.000000000", + "1958-09-01T00:00:00.000000000", + "1958-10-01T00:00:00.000000000", + "1958-11-01T00:00:00.000000000", + "1958-12-01T00:00:00.000000000", + "1959-01-01T00:00:00.000000000", + "1959-02-01T00:00:00.000000000", + "1959-03-01T00:00:00.000000000", + "1959-04-01T00:00:00.000000000", + "1959-05-01T00:00:00.000000000", + "1959-06-01T00:00:00.000000000", + "1959-07-01T00:00:00.000000000", + "1959-08-01T00:00:00.000000000", + "1959-09-01T00:00:00.000000000", + "1959-10-01T00:00:00.000000000", + "1959-11-01T00:00:00.000000000", + "1959-12-01T00:00:00.000000000", + "1960-01-01T00:00:00.000000000", + "1960-02-01T00:00:00.000000000", + "1960-03-01T00:00:00.000000000", + "1960-04-01T00:00:00.000000000", + "1960-05-01T00:00:00.000000000", + "1960-06-01T00:00:00.000000000", + "1960-07-01T00:00:00.000000000", + "1960-08-01T00:00:00.000000000", + "1960-09-01T00:00:00.000000000", + "1960-10-01T00:00:00.000000000", + "1960-11-01T00:00:00.000000000", + "1960-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "AAAAAAAAXEAAAAAAAIBdQAAAAAAAgGBAAAAAAAAgYEAAAAAAAEBeQAAAAAAA4GBAAAAAAACAYkAAAAAAAIBiQAAAAAAAAGFAAAAAAADAXUAAAAAAAABaQAAAAAAAgF1AAAAAAADAXEAAAAAAAIBfQAAAAAAAoGFAAAAAAADgYEAAAAAAAEBfQAAAAAAAoGJAAAAAAABAZUAAAAAAAEBlQAAAAAAAwGNAAAAAAACgYEAAAAAAAIBcQAAAAAAAgGFAAAAAAAAgYkAAAAAAAMBiQAAAAAAAQGZAAAAAAABgZEAAAAAAAIBlQAAAAAAAQGZAAAAAAADgaEAAAAAAAOBoQAAAAAAAAGdAAAAAAABAZEAAAAAAAEBiQAAAAAAAwGRAAAAAAABgZUAAAAAAAIBmQAAAAAAAIGhAAAAAAACgZkAAAAAAAOBmQAAAAAAAQGtAAAAAAADAbEAAAAAAAEBuQAAAAAAAIGpAAAAAAADgZ0AAAAAAAIBlQAAAAAAAQGhAAAAAAACAaEAAAAAAAIBoQAAAAAAAgG1AAAAAAABgbUAAAAAAAKBsQAAAAAAAYG5AAAAAAACAcEAAAAAAAABxQAAAAAAAoG1AAAAAAABgakAAAAAAAIBmQAAAAAAAIGlAAAAAAACAaUAAAAAAAIBnQAAAAAAAYG1AAAAAAABgbEAAAAAAAEBtQAAAAAAAgHBAAAAAAADgckAAAAAAAFByQAAAAAAAMHBAAAAAAACgbEAAAAAAAGBpQAAAAAAAoGxAAAAAAABAbkAAAAAAACBtQAAAAAAAsHBAAAAAAADQcEAAAAAAAOBwQAAAAAAAsHNAAAAAAADAdkAAAAAAALB1QAAAAAAAgHNAAAAAAAAgcUAAAAAAAKBtQAAAAAAAYHFAAAAAAADAcUAAAAAAAFBxQAAAAAAA0HNAAAAAAACQc0AAAAAAAOBzQAAAAAAAYHdAAAAAAADQeUAAAAAAAFB5QAAAAAAAMHZAAAAAAAAgc0AAAAAAAPBwQAAAAAAAIHNAAAAAAACwc0AAAAAAANByQAAAAAAAQHZAAAAAAADAdUAAAAAAADB2QAAAAAAAYHpAAAAAAAAQfUAAAAAAADB9QAAAAAAAQHlAAAAAAACwdUAAAAAAABBzQAAAAAAAAHVAAAAAAABAdUAAAAAAAOBzQAAAAAAAoHZAAAAAAADAdUAAAAAAALB2QAAAAAAAMHtAAAAAAACwfkAAAAAAAJB/QAAAAAAAQHlAAAAAAABwdkAAAAAAAGBzQAAAAAAAEHVAAAAAAACAdkAAAAAAAGB1QAAAAAAAYHlAAAAAAADAeEAAAAAAAEB6QAAAAAAAgH1AAAAAAAAggUAAAAAAAHiBQAAAAAAA8HxAAAAAAABweUAAAAAAAKB2QAAAAAAAUHlAAAAAAAAQekAAAAAAAHB4QAAAAAAAMHpAAAAAAADQfEAAAAAAAIB9QAAAAAAAuIBAAAAAAABwg0AAAAAAAPCCQAAAAAAAwH9AAAAAAADQfEAAAAAAAGB4QAAAAAAAAHtA", + "dtype": "f8" + } + }, + { + "hovertemplate": "champion forecast: %{y:.3g}", + "legendgroup": "champion forecast", + "line": { + "color": "#003dfd" + }, + "mode": "lines", + "name": "champion forecast", + "type": "scatter", + "x": [ + "1961-01-01T00:00:00.000000000", + "1961-02-01T00:00:00.000000000", + "1961-03-01T00:00:00.000000000", + "1961-04-01T00:00:00.000000000", + "1961-05-01T00:00:00.000000000", + "1961-06-01T00:00:00.000000000", + "1961-07-01T00:00:00.000000000", + "1961-08-01T00:00:00.000000000", + "1961-09-01T00:00:00.000000000", + "1961-10-01T00:00:00.000000000", + "1961-11-01T00:00:00.000000000", + "1961-12-01T00:00:00.000000000" + ], + "y": { + "bdata": "apyip5ulfUA/xDkvmm97QP4XzmdWZ31AQE6TQYUXgEC2hog6wqyAQOfa9FT95YJAN3ns9M/4hUAandSvvzGFQHbuCyuuCIJAPJUZFfPuf0Bb3B5nYmh7QIoI0QyhXH1A", + "dtype": "f8" + } + } + ], + "layout": { + "height": 400, + "hovermode": "x unified", + "legend": { + "x": 0.01, + "xanchor": "left", + "y": 0.99, + "yanchor": "top" + }, + "template": { + "data": { + "scatter": [ + { + "line": { + "width": 3 + }, + "type": "scatter" + } + ] + }, + "layout": { + "colorway": [ + "#000000", + "#003dfd", + "#b512b8", + "#11a9ba", + "#0d780f", + "#f77f07", + "#ba0f0f" + ], + "font": { + "color": "black", + "family": "Arial, sans-serif", + "size": 14 + }, + "legend": { + "bgcolor": "rgba(255, 255, 255, 0.8)", + "borderwidth": 0, + "font": { + "size": 14 + }, + "x": 1, + "xanchor": "right", + "y": 1, + "yanchor": "top" + }, + "margin": { + "b": 50, + "l": 50, + "r": 50, + "t": 50 + }, + "paper_bgcolor": "white", + "plot_bgcolor": "white", + "showlegend": true, + "xaxis": { + "linecolor": "#dedede", + "showgrid": false, + "showline": true, + "title": { + "font": { + "color": "black", + "size": 16 + } + } + }, + "yaxis": { + "gridcolor": "#dedede", + "gridwidth": 1, + "showgrid": true, + "showline": false, + "zeroline": true, + "zerolinecolor": "#dedede" + } + } + }, + "title": { + "text": "Production inference — darts-air-passengers-forecaster@champion" + }, + "width": 800, + "xaxis": { + "title": { + "text": "Month" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "champion = load_model(f\"models:/{REGISTERED_MODEL_NAME}@champion\")\n", + "\n", + "if isinstance(champion, GlobalForecastingModel):\n", + " forecast = champion.predict(n=FORECAST_HORIZON, series=series)\n", + "else:\n", + " forecast = champion.fit(series).predict(n=FORECAST_HORIZON)\n", + "\n", + "fig = series.plotly(label=\"full series\")\n", + "fig = forecast.plotly(label=\"champion forecast\", fig=fig)\n", + "fig.update_layout(\n", + " title=f\"Production inference — {REGISTERED_MODEL_NAME}@champion\", **PLOTLY_KWARGS\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ac44a0ae", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In a few lines of code you get a complete experimentation loop:\n", + "\n", + "1. **Setup** — tracking URI + experiment.\n", + "2. **Autolog** — `autolog(log_models=True, log_backtest_aggregate=True)`.\n", + "3. **Experiment** — `with mlflow.start_run()`: fit, historical forecasts, backtest metrics, hold-out MAPE .\n", + "4. **Compare** — `mlflow.search_runs(..., order_by=[\"metrics.backtest_agg_mae ASC\"])`.\n", + "5. **Promote** — `register_model` + `set_registered_model_alias(..., \"champion\", ...)`.\n", + "6. **Serve** — `load_model(\"models:/@champion\").predict(...)`.\n", + "\n", + "**Learn more:**\n", + "\n", + "- [Darts MLflow API reference](https://unit8co.github.io/darts/generated_api/darts.utils.mlflow.html)\n", + "- [MLflow API reference](https://mlflow.org/docs/latest/ml/tracking/tracking-api/)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/29-MLflow-quickstart.ipynb b/examples/29-MLflow-quickstart.ipynb deleted file mode 100644 index b5a76dbb92..0000000000 --- a/examples/29-MLflow-quickstart.ipynb +++ /dev/null @@ -1,6143 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MLflow for Darts\n", - "\n", - "This notebook demonstrates how to use Darts with MLflow for experiment tracking, model versioning, and management.\n", - "If you are new to Darts, please check out the [Quickstart Guide](https://unit8co.github.io/darts/quickstart/00-quickstart.html) before proceeding.\n", - "\n", - "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, packaging code into reproducible runs, sharing and deploying models, and managing model versions in a central registry. With Darts' MLflow integration, you can easily log forecasting models, compare experiments, and manage model versions throughout your forecasting workflow.\n", - "\n", - "For more details, see the [MLflow documentation](https://mlflow.org/docs/latest/index.html)." - ], - "id": "aeddb542" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Installing MLflow\n", - "\n", - "MLflow is available as an optional dependency for Darts. Install it with:\n", - "\n", - "```bash\n", - "pip install \"mlflow>=3.0\"\n", - "```" - ], - "id": "f72894af" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup and Imports" - ], - "id": "42e3dcea" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.049165Z", - "iopub.status.busy": "2026-06-24T15:18:43.049088Z", - "iopub.status.idle": "2026-06-24T15:18:43.053693Z", - "shell.execute_reply": "2026-06-24T15:18:43.053435Z" - } - }, - "source": [ - "# fix python path if working locally\n", - "from utils import fix_pythonpath_if_working_locally\n", - "\n", - "fix_pythonpath_if_working_locally()\n", - "\n", - "import warnings\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=FutureWarning)" - ], - "execution_count": 2, - "outputs": [], - "id": "b346ce8f" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:43.054776Z", - "iopub.status.busy": "2026-06-24T15:18:43.054722Z", - "iopub.status.idle": "2026-06-24T15:18:46.599643Z", - "shell.execute_reply": "2026-06-24T15:18:46.599208Z" - } - }, - "source": [ - "%matplotlib inline\n", - "\n", - "import os\n", - "import tempfile\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import mlflow\n", - "import numpy as np\n", - "\n", - "import darts.metrics as metrics\n", - "from darts.datasets import AirPassengersDataset\n", - "from darts.models import ExponentialSmoothing, LinearRegressionModel, NBEATSModel\n", - "from darts.utils.mlflow import autolog, load_model, log_model, save_model" - ], - "execution_count": 3, - "outputs": [], - "id": "13b13fe4" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.600906Z", - "iopub.status.busy": "2026-06-24T15:18:46.600748Z", - "iopub.status.idle": "2026-06-24T15:18:46.634540Z", - "shell.execute_reply": "2026-06-24T15:18:46.634100Z" - } - }, - "source": [ - "# use darts plotting style\n", - "from darts import set_option\n", - "\n", - "set_option(\"plotting.use_darts_style\", True)" - ], - "execution_count": 4, - "outputs": [], - "id": "4d424e08" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## MLflow Setup\n", - "\n", - "First, let's configure MLflow tracking. We'll use a temporary directory for this example, however you can choose from any of the supported MLflow [tracking backends](https://mlflow.org/docs/latest/self-hosting/architecture/tracking-server/#backend-store) such as local filesystem, SQLite, PostgreSQL, MySQL, or cloud storage solutions like S3 or Azure Blob Storage." - ], - "id": "2f9c40d6" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:46.636640Z", - "iopub.status.busy": "2026-06-24T15:18:46.636565Z", - "iopub.status.idle": "2026-06-24T15:18:47.268439Z", - "shell.execute_reply": "2026-06-24T15:18:47.268081Z" - } - }, - "source": [ - "# temporary directory for MLflow tracking\n", - "tmpdir = tempfile.mkdtemp()\n", - "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", - "\n", - "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(\"darts-quickstart\")\n", - "\n", - "print(f\"MLflow tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-quickstart').name}\")" - ], - "execution_count": 5, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", - "2026/07/23 18:50:07 INFO mlflow.store.db.utils: Updating database tables\n", - "2026/07/23 18:50:08 INFO mlflow.tracking.fluent: Experiment with name 'darts-quickstart' does not exist. Creating a new experiment.\n" - ] - }, - { - "name": "stdout", -"output_type": "stream", - "text": [ - "MLflow tracking URI: sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", - "Experiment: darts-quickstart\n" - ] - } - ], - "id": "88320df5" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load Sample Data\n", - "\n", - "We'll use the classic AirPassengers dataset for this example." - ], - "id": "03d5209e" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.269628Z", - "iopub.status.busy": "2026-06-24T15:18:47.269548Z", - "iopub.status.idle": "2026-06-24T15:18:47.356588Z", - "shell.execute_reply": "2026-06-24T15:18:47.356201Z" - } - }, - "source": [ - "series = AirPassengersDataset().load()\n", - "train, val = series.split_before(0.75)\n", - "\n", - "print(f\"Training series: {len(train)} points\")\n", - "print(f\"Validation series: {len(val)} points\")\n", - "\n", - "series.plot()\n", - "plt.axvline(train.end_time(), color=\"red\", linestyle=\"--\", label=\"Train/Val split\")\n", - "plt.legend()\n", - "plt.title(\"AirPassengers Dataset\")\n", - "plt.show()" - ], - "execution_count": 6, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Training series: 107 points\n", - "Validation series: 37 points\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - } - } - ], - "id": "1596e07e" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basic Model Logging\n", - "\n", - "Let's train a simple model and log it to MLflow manually." - ], - "id": "34858645" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.357581Z", - "iopub.status.busy": "2026-06-24T15:18:47.357516Z", - "iopub.status.idle": "2026-06-24T15:18:47.450374Z", - "shell.execute_reply": "2026-06-24T15:18:47.449925Z" - } - }, - "source": [ - "model = ExponentialSmoothing()\n", - "model.fit(train)\n", - "\n", - "predictions = model.predict(n=len(val))\n", - "\n", - "# calculate metrics you want to log to MLflow\n", - "mape_score = metrics.mape(val, predictions)\n", - "rmse_score = metrics.rmse(val, predictions)\n", - "\n", - "print(f\"Validation MAPE: {mape_score:.2f}%\")\n", - "print(f\"Validation RMSE: {rmse_score:.2f}\")\n", - "\n", - "train[-50:].plot(label=\"Training\")\n", - "val.plot(label=\"Actual\")\n", - "predictions.plot(label=\"Forecast\")\n", - "plt.legend()\n", - "plt.title(\"Exponential Smoothing Forecast\")\n", - "plt.show()" - ], - "execution_count": 7, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Validation MAPE: 7.86%\n", - "Validation RMSE: 34.77\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHECAYAAADmnVpRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnupJREFUeJztnQV0G9fWhY/M7MR2HI7DjG3KTSlNm9Jr/zI3ZX7tK3Pfa19TfmVmZmZOmdNww4mDjp04MbP1r33lOxrJki3Zghl5f2t5eSyNxprRaO6ec/Y51+F0Op1CCCGEEBJl4qL9BgghhBBCAEUJIYQQQiwBRQkhhBBCLAFFCSGEEEIsAUUJIYQQQiwBRQkhhBBCLAFFCSGEEEIsAUUJIYQQQiwBRQkhNqKsrEzefPNNWb9+fURfGyuUlJSoY7Bp06Z21+XxIiTyONjRlUSK6upq+fjjj/0+37t3b9ltt926/AdSWloqX3/9tey6667Sp08fj+MxZ84cmTRpkrzxxhty5JFHBnWsgn1tXV2dLFmyRNatWyd5eXkycuRIycrKsvXxmzVrluy9997yySefyPTp09vcTmeOdSS+L9F4T5GkvLxcPv/8c9lxxx1lwIAB0X47JEIkROofEVJcXCxHHXWUDB8+XMaNG9fqgEyePJmiRESWLl2qjtM777wjhx12mMcx6tatmxxxxBHSr1+/sJ5QTz75pNxwww0SFxcnY8eOla1bt8rcuXPl8MMPl9tvv1369+9vy+MXDJE61h39vsS6KFmzZo3a/xdeeEFOPPHEaL8dEiEoSkjEOeSQQ+Suu+7ike8AAwcOVOmHcPLRRx/JmWeeKRdeeKH873//k4QE12Xi999/V4MDxImVRYmdjnUg8PtCuhIUJcSSILze2NioLshmVq9eLX/88Ydsv/32MmjQIOUR+Pbbb2XKlCnSs2dP+e2339RjEyZM8HuHi7QEtrFlyxa1zsSJE1VEQOO9zdmzZ8uGDRvU3WpBQYHPbTY3N8u8efPU3V337t1VyDk5OTnobSJV8s0336jln3/+WR0DgPVGjBihfA5ffPGF7LLLLtK3b19jfz744ANjG/i/ODaIcHSEt956S/2+9tprDUECdthhB/nxxx9l8+bNfvcLwgXpE+w/joMGxxs+DkTDsF5HPpdA1mvv+HnT1mfr61h35NxAlOnXX3+VlJQUlVIC77//vowfP15FQUIZIcJPamqqOs7Z2dkezyMVkpmZqfYHnwXee69evVSKCmBu1gULFqjvGNJ0+AyxLV8sWrRIVq5cqY4B9kOf601NTSpCpcHjSL1gHYfD0Wo7CxcuNL4zOF8zMjLU40VFRerYA5xTOHZg1KhRMmbMmJAdM2JB4CkhJBKsWrUKM1I7L7300nbXff7559W69957r/FYWVmZc/jw4c4RI0Y4y8vL1WPffPONWu+VV15x7rPPPs4pU6Y4J02a5IyPj3deffXVrbb71ltvOXv06OEcMGCAc9q0ac7c3Fy1vb/++stYR2/zzTffdB588MHO3Xff3bnddts54+LinLfeemurbf7888/qfWG7++23n9pefn6+8+OPPw56mz/88INz7733VuvusssuziOOOEL9vPPOO+p5vE8898Ybbxiv2bp1q7EefnAcMjMznRMmTHCuWbPGWM/Xa31x/vnnq/WWLl3a7uek9+vVV19V+77XXns5R44c6ezevbvzp59+cpaWljqnTp3q3HPPPZ2jRo1ypqSkON9///0OfS6BrNfe8Qvms/V1vII9N5566ilnWlqac9iwYc59991XfSbff/+92sadd94Zku9LUVGR+szxf3D8x44dq47zzJkzPdbDcTr00EOd999/v3P06NHqvZ977rnqudmzZzvHjBmjjieOK57H8ttvv+2xjT///NM5btw4Z3Z2tvpfO+20k9q3L7/8Uj1fU1PjcS7is8e6+OyXL19ubGfjxo3O7bffXv2P/fffX31v+/Xr53zggQfU83/88Yd6H9j/HXbYwdgevucktqEoIRFDX2QPOeQQdaH3/lmyZInH+meddZYzMTFRDW4AFyVceBcsWNBqkJg4caK6kGkee+wx9fgzzzxjPIYLb0JCgvPEE090NjQ0GAP6jjvu6OzZs6daNm8TF0O8RnPxxRer97N69WrjsZUrVzqzsrLUxb6yslI91tzcrAYSvNcVK1YEvU2IHKyrB1IzgQoL7AsGwAMPPDDo1/74449qkMXr8R4gBv2h92vy5MnO+fPnq8caGxvVYISB7bTTTnPOmTNHPd7U1KSEy6BBg4zjH8znEuh6bR2/YD6HtkRJIK//7bff1HG88MIL1TmhB+ODDjooKFHi6/uyePFiY73ddttN7b/5sbvvvlu99umnn/YQJTj2ODf1+4HwXL9+vTMnJ0d9NubP+sYbb3QmJSUZ37e1a9cqsQnRt3nzZmM9PP7JJ5/43Q/cQEC87LHHHsZjZ555prN///7GzQWoqKhwvvjii8bfOJ+wDy+88EKbx4nEFhQlJGLoiyyiCua7Kf3jfQddW1ur7kL79u3rvPbaa31eoPQgcdFFF7X6f4iYjB8/3vj71FNPdSYnJztLSko81vv222/VNvRdmt7m5Zdf7rHesmXL1ONPPvmk8dgFF1ygojLFxcUe6+KOEdGKq666KuhtdlSUYMD74osvVDQBzx9zzDHO1NRUJQbae603n376qbp7xaDqcDicgwcPViJx7ty5Huvp/briiit8RrouueQSj8dffvll9bgWMMF8LoGuF4goCeRzaEuUBPL6GTNmqHMAg60ZDLzBiBJf3xe9b7/++qvPbUF0QBQi+mEWJYhaaPGswTmKbRQWFno8DuGHiB/OcYB9xrmghXZbbNq0SUVP9Ll4yimnqO8JvhcAYhnREwhYf1CUdE3oKSGWNe4hHw2j4XbbbSe33HKLnHPOOX5d+MihewMPxBNPPKF8BfBG/PXXXzJkyBBV3mpmp512Uvlu5NjNwLdiRpclrl271ngMvoX8/HzltQAtQl/95OTkKJ9JsNvsSOnojBkzVC4fXhr4HxITE5W/oKamRnkacnNzg9rm/vvvr34qKipU3v+7776Thx56SJ5++ml5+eWXVVWEGXxGZrQHw9/j8H5oz0ugn0uwn19bdPZzCOT1eL/wsWifhL/Xdub7gv+hj4EZHA889swzzygPjvZ8jB49WtLT0z3WxTkMTweOH37M5zAe1+cwfDH4/AYPHuz3veJ/wST9yiuvKJ8NPD9JSUnKfwK/Cbws8N7ge3zCCSeocwDn0p577im77767hw+LdE0oSoilwUVOmxXbGljT0tJ8PoYLa0NDgxIl9fX1rS7IABdNDOL4X2a8jYJYD9TW1hqPYdDHdl988UWfQsnbbBrINoNl5syZ8t5778lPP/2khJgGRtX58+erY9BRYIzceeed1c8ZZ5yhjJlXXHFFK1Hib78C2d9AP5dgP7+26OznEOh++err4utc7Sj4H8DXcdGPYR092Pfo0aPVejiHYdT2dQ7j/IUQ1Pvm6/+Yueeee+Sll15S/WBgBtbceuutSkDpc/G4446TYcOGqf8J0y9uOrBt/EbVF+m6UJQQy1JVVaX6RMDhf+qpp6rBF83VDjjggFbrrlixotVjy5cvV6/VFQQo8cTdHi7A5qqOwsJCdeFGxUqw4IKNapRQlo76qlJoix9++EENHmZBAlBJ0RFQdeI96AJEfvB/UH2io0+hINDPJdD1gj1+4QLvF6LQG0QNQvk/wLJly1pFpfAYokoQlhpfxwbnMKppXn/9dZ/VThqICJznECe6GsbXuTh06FAPQeLvXIRo1xFOVDWdffbZctFFF6nvN7Zhlc+RRBa2mSeW5ayzzlIXcFwIcQe21157yUknnaRKCL3B3Zn5ThmC5NNPP5Wjjz7aeAzLKCPFumawbVwAzesGCkLVaHKFZmPeIEKD0sZg0REhiINAQCdclKXqu2aAXiLoatoREAlB2ssbhN6xXZRlhkqQBPO5BLpesMcvXCCahDSVuVwbPPvssyH7H1OnTlX7i9Qa0iNmEfDll1/KMccc0+42EAGrrKyU+++/v9Vz2ObGjRvV8mmnnaa+Y2ie541u249zEd8HpBQ1SCOi940Z7+8wIjhodIdICgSKlT5HElkYKSERBxcpX5EF5N516++HH35YeReeeuop1YcCIE+NngoYfL7//nsVstcgooLX4jlcYDFQIdVw0003GeucfPLJqv/J6aefrgZX9DvAwI0QMi606KUQLMj343/A74Jt7bHHHmrAXrx4sfJ4oPnYoYceGtQ2ccePu9L77rtP/Y2wtr8+GwB3l+gtgveCsDgiB++++66cd955cscddwS9T/ABnHvuufL444+r7cEzs2rVKiW8MGg89thjEkoC/VwCXS/Y4xcuTjnlFPW5HHvssXLJJZeo94W28bpXSSgiAUgFPffcc6q767777qs+L0TucN7heCAd0h777LOP8qxcfvnlyhuFv5HuwRQDb7/9tjq/sV08ju1dd911SvTg/yFqAtGF6Mall14qF1xwgerAeuCBB6r9xzxLaNOPx83vBecmRDRa/sOPA/GGzwt/oz8KQA8V7AOuBfgMcX1gn5LYh6KERAxcWCAewKuvvtrqedxlQVhs27ZNXRz//e9/q7szDVIxCDHfe++98tlnn8nBBx9sPIfUBVqgY+DEnRYukAgHm02GGATwfz/88EMVRUFzJhj30HDNnPrAXRveJy6K3uBx75bf119/vfrfuPjifWOgwDwxCGVjn4LdZnx8vNo/RCvwPrUnBoOqr9bn8HsgX4878K+++kpduLFvMDAiraX9BIG2Tcf+4O4ZwgbiCs2rkM65+uqr1d2/2dvjb7+QNsDjev81eC0e14bXYD6XQNdr6/gF8zn4Ol7BvB6pEHh9MEijoRvOSwzO2B7Oz/b8Gfr70p5YPuigg1T65fnnn1epNaQrITKOP/54w+sCYFw2H3czeD8Qta+99pryJmEbEPUQfebuvddcc436f1gP5md8vvAuQUwAGK1hjMXNBF4LcYjPAmksnEt6n/EZ4pjgM4TQxPkC8YH3gM9Pg/UgjtH4DSIG4ovN02IbTshHbE0wE6wRYgUglBBZwEA7bdq0aL8dQiwFPSWEEBImzC35AUy6SFMgYuRtBiWEMH1DCCFhA2kRAB8J0g/wUiE9gjSUvwoWQroyjJQQW9NWjp+QaANvBbwcaED3yy+/KCM0/BXaW0UI8YSeEkIIIYRYAkZKCCGEEGIJKEoIIYQQYgkoSgghhBBiCbqcKEFJHrpT4jfhMeF5wu8Prym8znLssQ5dTpQQQgghxJpQlBBCCCHEElCUEEIIIcQSUJQQQgghxBJQlBBCCCHEElCUEEIIIcQSUJQQQgghxBJQlBBCCCHEElCUEEIIIcQSUJQQQgghxBJQlBBCCCHEElCUxCjvvvuuvP3222F/DSGEEBIqEkK2JRI0t912m9TW1vp9fvjw4XL88cd36MhCYDQ2Nsrhhx8e8Gvee+89aWpqCuo1hBBCSKigKLEIixcvltdee00uv/xySUtL6/T2DjvssKBnQj700EM7/X8JIYSQjkJREkWuuuoqj8gGRMkVV1wheXl56rHXX39dPvzwQxk2bJh88sknkpqaKmeffbZ8+eWX8sMPP6h1unfvLpMnT5bddtutzf+FbUHsjBo1Sr7++msVoTnggANk6NChnX7N6tWr1ftPSUmRPffcU1atWiWVlZVy9NFHd/IIEUIICSW1dU555D2RvnkiR+/jEKtBUWJhIArmzp0rcXFxcuCBB8qIESNarbNs2TK55ZZb5IQTTpB77rnHb/oG25o3b54kJibK/vvvr4TDlVdeKT/++KNMmDDBZ/qmrddMmjRJrfPLL7/I1KlTZcqUKTJy5Ei58847JT4+XsaPH09RQgghFuO5T0UuedCplrtnikzbwVrChKLE4mzevFmWL18uubm5xmP77ruv+tH861//UoLlggsukCFDhvjdFqIXSBNlZWWpv6dPny4PP/ywPPbYY0G/5oknnlB/X3bZZfJ///d/8uKLL6q/L730UuWFgSghhBBiLRascgkScMsLToqSSIK0RlFRUavHEQ3A3Xy46NWrl/zxxx8h2RaiEGZBopk/f76KWBQXFyvvCFInCxYsaFOU7LPPPoa4ABMnTpQ///yzzf/f1muqqqrUe7jpppuM5/v37+8hmAghhFiH4q3u5W/niPw03ym7jrNOtCSmIyUQJOvXrxc7o/0lZiAC/ve//8k//vEP6devnyQlJakUz9atprPNBxkZGR5/JyQkSENDQ4dfs3HjRvW7Z8+erURZe++FEEJI5Cne5vn3rS855YPbKEoiAgZHX0QiUhIu8N5vvfVW5fc45JBD1GPwjsycOVMiTe/evdXvTZs2yZgxYzzEYHJycsTfDyGEkLbZVOr594c/icxb4ZTxQ6whTGI6UuIrhYJUR2FhoRQUFKjogt1AlKK+vl6lazRPPfVUuxGPcJCenq6qfp599lmV5gGITH311VfKmEsIIcTakRJw20tOefkGihLSASBGTj75ZPWDxmobNmyQWbNmtUqzRIq77rpL+V5gyIXB9YMPPpC+ffvaUvARQkgs09jolC1lruVxg0WKSkVKtom89rXIzac7ZUjf6AuTmI6U2AmU0954440ejdPQ58NXI7Wnn35a3n//fVm0aJGMHj1aHnroIRWtgAnVX/M0X9tCdMPcc8S7eVogr9l5551l4cKF8s477yjBhD4qN9xwg+qfQgghxDqUmKIkA3uJHLOPQ6570ikYKu58xSmPXhZ9UeJwOp3u+qAugN3TN1Y7JvCPQLjoCh38DYF13333ySmnnCJ2hecJjwvPFX5/Yu2aMne5Uyae5hryzzhY5M5zHTLgKKdUVIskJYqses0hffKiK0w4KpNOgbLgXXbZRc455xw5//zzVVM1RE86OmcPIYSQ8JcD53cX6ZbpkPMOc/1d3yByz+vRj1FQlJBOgb4oMLbutNNOKq3z/PPPy6effqq6wBJCCLEOm8yipJsrInLxUQ5JTnI99uh7IqXl0RUm9JSQkJRAn3rqqTyShBBik0hJzxzX7165Djn9QKc8/K5IZY3Ig2+L3DAjam+RkRJCCCGkK1C81R0Fye/mfvzy4xyiW3c98JZTmpqc9knffPHFF3LcccfJtGnT1ORr6JmhqampkX//+9+qRBSVHKgQMdPe84QQQgiJQPrGVCA5sLdDpm7nWt5cJrKlXOyRvvnpp59UX4rrr79exo4dq7wEaFC26667qufvvfdeWbt2rbzwwgtqOnvMKDtw4EBjcrb2nieEEEJIZIyuZvqYZjSBMPF+3pKi5NFHH5XzzjtPdt99d/X3EUccYTyHVueffPKJmpOlT58+6gcTs6GZFkRHe88TQgghJPzdXFGRnOueZ1Vh/nuzj66vlkvfIE2DKewxlT3mXDnooIOUwNDpG0zOVl1drXpUaEaMGCHLly8P6HlCCCGEhH/em7xskfh4z34kedkOj0hJtAg4UlJcXKyavyBl88gjj6i5VpB+QXvzs846S/Wr0POhaDIzM43H23veFxA8Zs+KesMJCWpW3I6iu5yau512ddo7JvPmzZP8/PywTjRoNXie8LjwXOH3J5auKU6nO30Dk6v3+8gxRUpKytDlNfRm10CaxgUsSvSsr5hzpV+/fmoZhle0F4coSU1NVY8hGqKFBwSHblPe3vO+eOaZZ+SJJ57weOyoo45S7c87C7wtVgODP44Nen8Ey99//y15eXnSo0ePkB+TY445Rh3z0047TboaVjxPrACPC48JzxN7fXcqahxS1zBALWel1khhYbHH8856jNH5ann56q1SWBh6t+ugQYNCJ0ow4GVnZ3soHSzrLvWYhA3CZdmyZcYcLFjWb6K9532B3hcnnHBCyCMlOCn69+9vqTbzCxYsUPPVYM6YdevWecwCHAgHHHCA6qiKn1AfEzRCy8nJUe2RuwpWPU+iDY8LjwnPE3t+d5atcy8P6J3a6no+ypSyaYrrLgUF0XG6BixKHA6H8pG89NJLhnH19ddflylTprg2lJCgyoQR2bj11ltVj//PP/9c7r777oCe9wXER2cESFvgpLDSYIOoEI4PoiXvvvuu3zbt8OZgRl74cfSxwcR8tbW16pj+9ttv6jG0ev/9999Vl1Xz5HgQPxAYMBrrCMvWrVtl06ZNSmCiGsrXccHnb6XjFSmsdp5YBR4XHhOeJ/b67mwuQwDBFUTo2b11KqVHN/fzmEk4Wte9oP4rKm969uypxAnSKGPGjPHo5HnppZeqaAgG14suukildSZPnhzw810V+GZQJo3jO2PGDHnyySdbrbNhwwZjht5jjz1WBgwYoMQLwOR3EBVvvfWWXHzxxeqnqalJ9t57b/n22289toPtoxW8Bv6gSy65RP7zn/+oqiqIndmzZ0dgrwkhhESnm6uj1fN5pmZqtjC6AqQUbrrpJjWA4c7ZGxhXUZGDMJUvldXe810V+HIQ9Tj44INl3LhxqindihUrDG8JIhhI7cBUvH79eunWrZuKbujmc4899pgSHxdccIH6CYb777/fmL0SYcXrrrtOCc25c+eGZV8JIYREe94baUX3DETEXYZY24gSjS9BYqY9wREpQTL5zGYpaimBMnCKNDX1dbXUdYTHBd0rR+SPJwLfx6eeekoJAaS4IEQQEXn66afllltuUc+jQR1SMUjtQJAApGROOeWUkLzfuro6WblypRQVFckOO+wgt99+uxI95rQPIYSQGGmcltQgzfUJEpfkHqcSEhzSPdMppeU26uhqNyBI1pdYe7cRoUCZNUTJL7/8YvhBIEoQlYqPj1eGYPwePXp0yP//ww8/LNdcc42KwvTu3dsoE4N3haKEEEJia96bEdXbJP6UP+XL1DgZcd0wGXBKf3G09CxB/xKIEttFSuwCIhatUJGSRomPTxBxRPD/+gHiA2W88IWYqaioUB1wkdJB2TQ8Ipg7COIhmIiWro7SoL+MWRAh3fPxxx8rLwnc2BBAaHDHPi6EEBJ76Zt9tm0UqW+WxvpmWXj537Lu5fUy9q7Rkj0x2+jqWlYp0tDolMSEMA2SXVWU+EqhuPwT69UAHG1fC94Lqm5mzpzZqgfIhRdeqAyvECW77LKLKsuFsfXEE0801kHFjS4dRh8Ys+AAMCWjvFiDlIy5g+6qVauUcEG6CF4V8Omnn4ZtfwkhhEQ3fTOktsLj8bK/yuXHab9IwWkDpE/KYDSBMCpweuVG/n3GtCixOp999pkSA2jb7w2MrdOnT1c+D3RShQEV1Tn4G31eUPqLSQ0ff/xxtT4mSIRo2W677VSFE1JA2AZMs+gRA1GDZURcNBMmTFC9Z9DbZK+99pI333xTCSRCCCGxJ0rinM0yuM4lSpLykyQpJ0kqF1eKNIsUPrlGjk8rkrV5o+W3zB4qhRMNUcISmCgC8yrMqr66sO65556qRPf7779Xf99www3y7LPPys8//yy33XabSuXcc889xvp4bNSoUXLjjTcaJcEwyp555pmq7PfVV19VwgZdeCFSADwj8LMgVYT00cKFC+W9996TnXbayaPTLsQL/CaEEELsm77pV1ctyS2+wZxdusvus3aRETcOl/g0VH6IpFTXy5Vr50lCc3PUzK4Op7fpIMbR5a9WSN9YBR4THhOeK/z+8JoSu9fZ+ganJE91yt7bNspl6xeox0ZcP0yGXIx0jUjNuhr588S/pHy+K4py+rDd5MHb0uWIvSLvKeGoTAghhMQwm1uqaYbUusMfWRPcM/Cl9kuV3D3duZoeDbVRq8ChKCGEEEJimE0t/bqG1LhNrlnjTNMCQ5j0dc+3RlFCCCGEkLBQvE15NYzKm5Q+KZKc5zmvXEorURIdZwcjJYQQQkiMV970qq+R9OZG9XfW+MxW6yCFo8ln+oYQQggh4UrfmPuTZJv8JJrUfp6REvQpiQaMlBBCCCExTPE2p6fJdXxrUZKYkyhxqS5JQE8JIYQQQsKWvmnL5ArQ3Tu1b6pblGyjp4QQQgghIWZTqVOGtkRKEnISJaVPss/1dAontblJakpd/pNIw/QNIYQQEsPUbqiT7CbX3GjdJmSpqIgvUky+krSyWtV0LdJQlBBCCCExTNr68jZNrr7MrnmN0TG7UpREGcxP061bt1Y/b7/9ttgdzICMCQIJIYREB6fTKbklJj9JW6KkxVMCetRHp6srZwmOMphYLycnR2bPnu3xeHp6utiduro6KS+P0qxOhBBCpKxSZFB1eZsmV18N1KLVq4SREguAyZm8IyWJiYnquVWrVslRRx0lffr0kUGDBsk///lPqaysNF67Zs0atf4rr7yiZhXOz8+X119/3ZiF+MADD1Qz/I4bN06uv/56JRTMYJ1DDjlEdt55Z5k8ebI899xzxnOfffaZ8X7w//fZZx+ZNWuWx+uLiork5JNPVu9txIgRaoZizDr8/vvvyyWXXKLev97Ggw8+GOYjSQghxLubq668qU9KkLSB7mhI271KaihKiCf19fWy7777SlNTk3zzzTfy2muvyVdffSUzZszwmHmyrKxMrrnmGvnPf/4jixcvlv/7v/+TOXPmyNSpU5Xg+O2335TY+Pzzz+XCCy80Xvvnn3/KlClTZNSoUfLyyy/Lk08+qf4PZrIEeP3q1avVD7aB7R5wwAGyYsUKYxvnnHOObNmyRT799FP1M3ToULUdrIfUFGbE1Ns488wz+RETQkgE2biiTvIaXTejlX0y/Zpcdft5TbR6lcR0+uaHfX6W+mLPyAC8xBjkV8YXSrgmZU7KT5bdv94l4PV1NEHTs2dPWbJkiYp+bN68WQmKzExXW+AnnnhCdtttNyU+Ro4cabwGAgAiQvPf//5XTjzxRDn33HPV3/3795cHHnhAdt11V/U7OTlZrbPnnnvKHXfcYUyp/eyzzxrbSEhIMN4XfkPQIALy5ptvypVXXqkex/tEdARREnDBBRcYr09NTTWiQIQQQiJP6V8VoguAmwb6T92A+NR4cWYniaOsXomStRQloQWCpHajpyjRNEp0arB9ATFg9pRgIAfz589XaRctSADSLEjtLFy40EOUTJgwwWObv/76q2zdulWlcmB0wg/EGH4QtYCIQPQD6SB/1NbWysyZM+W9996TDRs2SENDg1RXV8uwYcOMdZC6ueKKK9R7RVQHwsj8fgkhhESP6kXlhihJHNm2KAEJvVKkqaxechrrZE5pU8RjFzEdKUHEwhsdKYmPjw9rpCQY/EUTGhsbVbTCDEJvWB/PmUHkwwwEBMSCL9GRlZVlpH60d8UXSAkh5YPIyvDhw5X59oQTTlBpJc3VV18t06ZNkw8++EBFXE466SR56qmn5Oijjw7iCBBCCAkHzuWmcmAfE/H56lVStaRc4kWkagNu6ilKQoavFAoGYp2q0BEJq4JoxksvvaTMqVp0LFiwQP2t0yX+GD9+vPz8889yww03+F0HURisg/SLL+AvOeOMM2Tvvfc2jt3ff/+tjLNmYJDFDzwtEDI33nijEiUQVHgNIYRYia//dMoLnzvln0c4ZNLwcN2eWoPkNS6Ta60jTvqNab+qM7MgRapalhuKalELKpHE2qNyFweeEAinyy+/XJUOFxcXK1/HXnvtJRMnTmzztVdddZWKcsBrUlVVpaIbP/30k4fZFNt955135JFHHlFCB+mef//737Ju3Tr1PCpqPv74Y1Xtg7QN1of/xQwiI6jgQeQG/2fp0qXSr18/w8eC6pySkpKwHB9CCAmWJWuccvBVTnn2E5EL74vO/C6RoqGsQdK31ajlVSmZ0jOvfQHWbZCpOqcEoiSyUJRYGHgzPvzwQxXNQMoFgz0eQ6VMe6B8FymVt956S702NzdXmVOPO+44Yx2kXVDRg/TM2LFjVRUO0lo6EnLXXXepPiPdu3dXr0fVDXwjZo499lhlbs3OzpYePXooAQMzLoC/ZL/99lPihCXBhJBo09jolJNvcUpNi9Vw5QaJacrnu5umLU/Nkvzu7b/GXBacWBp5UeJwwgHZhbBa+gZmUvg/2jOHIpIBweDtMcH+QDhAePjbH0RJ8Fr8+ALbQIQDvhFf28D/xv/F6xExUbNJpnrWumMfsI6vcjNsH71LUlJSWnlfrIrVzhOrwOPCY2Ln8+Tm55xyw1PuIS8xQaTuK0ebZbJ2PiYrH14ti69fopYfGzha3vuzf7uv2fbnNvlpv1/V8uc9+sm9i8dIJIlpo6sdwECNn/bwN5gHUnKblJTU4e17P5eWluZznbYMs3iPiKQQQki0+HOJU2561vMevKFRpLxKJDtDYpLyuW6Ta1mvwKoiU/u5bzi71dRKbZ1TUpIj57uxjoQlhBBCwkBNnVNOvNkpjU0tN1qm+7RoNAiLFGUtoqTB4ZCmfoEpr6QeSdIU5xIh6FWyJcIzhVCUEEIIiWmufswpi9e4lrcbLnLqAbEvShqrGqVqhauOpjA5Q/LyAhvuHXEOqclKiVpXV4oSQgghMUldcZ18fvFy+emZEkyXqyIkL1znkN65jpgXJRWLKkVaOjIsT8mS/CAaazfmuERJRnOjlGxokEhCTwkhhJCYZN61S6Tx7Y3ybxH5IyNXcq8YJaMHpktetttbsnmbxCTVq6uN5bXJ6TIuJ4gX90gVWblVLW5bWSuyR/u+xFBBUUIIISQmWfvVVtFlBJMrt0jcLT/JsupBkjduoJEoKIlRUVKz1l3OW5yUIvndAjerJvZ2F19UrMF22m9PHyooSgghhMQc9aX1klLm2Wejua5Zlt22QjL7bpSJCSNlTkaubC5D1CT2urrWrHc1TQPFiSkB9Sjx1aukZn1ke5XQU0IIISTmKJ/nbhw2q0cfGXTBQHHEu8SHc3213FI4W44qWRWznpJaU6SkJDFVegaRvske6BYlTarVfOSgKCGEEBJzlM11q42ivt1l1H9GyG6zdpHuO7kdn/ttWx+zoqRmnStSUueIk7L4xKCMrrlD3b1KHJspSgghhJBOsXm2O1LSMMDVOCxrdKbs/OGOkj4s3Sh5Ldkae03NnU6n1KxziYmSxBRMLx9U+qbncHfDzKSt7jRQJGCkhBBCSMxRNq/ciBQkD0736MORNtAVCUh0OqWupF5ijYatDdJU1WT4SRLiRboH1tBVkZOfIOXxri7d6RWMlBBCCCEdH5TLG6VxjaskdnVKhvTO97z/Tu1rSk9EYSbccFPTEiXRkZIe3TDdR+BmXswFtLVl+pOsmjpxNkUumsRICSGEkJiiYqFpdtyULI9maSDFVF2CCh3MHhxL1Kw1V96kBpW60VRmuI5RPKJJm1qmVY4AFCWEEEJiMnUDVqRkSp88/yWvefW1UurWMDFBrTlSkpQiPTsgSmqz3cdo68rI+UooSgghhMTs7LgrUjOld67/mXCjMb9LpCpvOtKjRNPU0moebF4euRQXRQkhhJCYjJQ0ikNNRtenlShxD7j5ECXbYtdTUoz0TRDlwBpHT/cxKltNUUIIIYQETVNNk1Qtdc2OuyYlXRri4ltFSpJ7JYuzxWbSo6Em9iIla12REszHtyUhWfrkBd+xNrmPW5RUqlbzkYGREkIIITFDxaIKo1oEJleUwqYkew7KcYlx0tw92d2rJNYiJetdIqI0IVka4+KkoFfw20jr705x1Zla1ocbihJCCCExQ5mpvbwvk6vGke8adLs1NciWEldPj1igqbZJ6ovr3Y3TRKSgZ/Db6dY/WaW/QPMmRkoIIYSQoCk3V96kohy4/fRElckYGlt+khT1e0AHREled4dsSXRFk+K2UJQQQgghQVPWUnkDP8UqHyZXTXp/tyip21Abm+XAiamSkiQdqr7Jy3ZHWhKrG6SxqlEiAdM3hBBCYoLmhmap/NuVvlmflC618Ql+IyXdBrlFSSTTExEtB05KUVESdGgNlrxublECalt8KuGGooQQQkhMULmkUprrW0yuqa7JXvxVnuQMcQ+4kUxPRDp9U9CB1A3IzXKnf9R2KUoIIYSQwCmb6za5rkxxiRJ/kRJzdUnKttoYbTGf0qHKG5CVLlKazEgJIYQQ0mmTK8qBgb/qG/P8NxmVseopSZEBPYNP3QCkfOq6mSIlpu2GE6ZvCCGExJwoWZnadqQksVui1CfEq+WculqpqXPGlKekMi5BquMTO5y+Ac25qT69KuGEooQQQojtQcO08pbZgbemp0plfGKbogSRgKrMFHcDta32FyXOZqfh/dB+kI6mb0B8L1PZdCFFCSGEEBIQVSuqpKnK1QRtdborStItQyTVq5urmfqW9ESys1lK1jTY/kjXbaoTZ4Oz043TNJl5CSriAqoi1GqekRJCCCExMwkf+DteV960/RpnD3ckYEsEZ8KNSOVNUqrExYn07dHx7aFXSVGSK4XTsLFWlVyHG4oSQgghtqfc1F5+cWLbJldNgnkm3MJYECU1xjIiJX3zRBITOmZ09RYl0uSMiNmVooQQQkiMtZdv2+SqSenrFiXVplJau1Kz1rNHSUfay5vJy3bIxqQ04+/q1dUSbihKCCGE2Bqn0+lO3+Qmy7YE15wt/lrMazIL3NUlSE/YnVqvSEln/CS6q+vGRPcxql5FUUIIIYS0Sc2aGmksc83NUj/AFSUBvXPbTl10H+yOlEhJbex1c+3Vue0hfeMZKQl/NImREkIIiaGIQVeehA9s6+nykwTiKckf5hYliaWxIEpq1O8Gh0O2JiRLQQcbp5lbzW/UnhKmbwghhATK8rtWyBeDvpa558+XupK6LnXgKhdXGssbsjKM5fY8JT3z46Q0IUktp5bHjqdkc0KKOB2OkERKtiSmKJED6CkhhBDSLs2NzbL83pXSWNEo61/dIN/u9IMUPrNWNRTrCpgNnmvi0gKOlKSliGxOckVL0mrqpbk+/CWv4aKhvEEayxtD1qNEe0qaHQ4pbvGVIH0T7mgc0zeEEGJzqpZVSXONe0CFv2LhZYvkp+m/eqQ2YhXzJHTLG1ICjpSgq2tFeooxGNba2Oxa49GjxLVPna2+yUgVSU5yp3DQnK6+pF7CCUUJIYTYHLPwSBvsjhSUzS6TH/b9WZ44eJEUF7nuomMR3Vo9ITNBVlckBtTN1XhtVmyUBdd4zA6cKrnZIumpnfOUQLQN6+tldg1zu/mgRMmVV14pU6ZMMX4OPPBAj+dra2vl5ptvlv32208OP/xw+fDDD4N6nhBCSOd6dIy5Y5Ts/MEOkjEiXf3taBbp+/Naeeu8lTF5aDHfiy6Fxcy/GzYHlrrRNOW4RcnWlbUxMztwQSejJJpRA0WKIlgW7GpqHyB1dXVy8cUXywEHHGCoKDP33XefrFq1Sp566ilZvXq1XHPNNTJw4EAZO3ZsQM8TQggJnjJTN9Ps8VmSlJsku83aRa7ef7XsNW+563q92r1OLIF0QnO9y+eQ2DtFajYFlroxyHeLktIVtTESKUmRQSESJaMLRD6LYAVO0OmbpKQkSUtLUz+pqe432tjYKB9//LGcd9550r9/fxVJ2WeffeS9994L6HlCCCEdixRUzC83OpRCkICPf4+TuxoHGpUTKWX2HXADHYwbTVGPQCMlEDKaShu3mq9pSWGFqkeJZlSBV1fXVRZK34AHH3xQpk2bJqeffrr88ssvxuNFRUVSVVUlI0eONB4bPXq0rFixIqDnCSGEBA/C6Y2VTUaUBDQ1OeWqx5yqLBTloSCj0r4DbqAGz+ps941y75zAXp/Wz/2a2vV29pTUGsubVfqmc34Sj/RNBCMlQaVvbr/9dmlqapLq6mr58ssv5ZJLLpHnnntOhg0bJpWVrjrx9HRXHhNkZGQYj7f3vC/q6+vVj8cbTkhQ0ZqO0tzc7PGb8JjwPOH3pzNE+5qybU6ZsZw5PkO9j2c+EVm02u0v6N1QI2mNjVJfVq/MoLF0TKrXugfJrSmu9vI6fRPI/8/umyj1jjhJcjZL46basL3ncB+TmhZfzdb4JKmPi5d++U5pbu58+e7QPiINCfGqn0tOY70SJR3dhzhMW9wOQZ2dycmuDxypm2OPPVZFSr755hslSnQqB4JFCw9ERvTj7T3vi2eeeUaeeOIJj8eOOuooOfroo6WzrF27ttPbiDV4THhMeK7Y7/tT/EOJsVzbq1YWL10j1z/Rx7i8q4G6Zdxe8dtKSRnqHrhj4ZgUL3Lv/8pad4VRQnOJFBYGcFffkOaaUbe+WhwlNcrv6O2XtPoxcTY4pa6ozqMcOKl5oxQWhqZ8t3+PPrJxRZoSJXXF9bJq8SqJSw2+eHfQoEHtrtMpyZyYmKgiJ6BPnz5KtCxfvlwmTJigHsPy4MGDA3reF6eeeqqccMIJIY+U4KSAryUQ1dYV4DHhMeG5Yt/vT3HhZvdd7dQhct/XKVK01fX3wbuKJP+SKlLq+ju5JkcKCgI0W9jkmGwp3+o2/Gb1MJbHj+whBQXtv35kqciviWuUKEmob5a+3ftKYrarrNgux6S6sEYWO5d5NE7beWJv1fwsFIwbIrLxz1QZI9vU33nNeZJZ4J5jKJQELErKyspU1czJJ58s3bp1k++++05+/PFHOemkkwyBMnXqVLXOzJkzZc2aNfLZZ5/JXXfdFdDzvoD46IwAaQucFBQlPCY8T/j9sfM1Bd01y+e7qmqSeiRJdXqK3P6Kfj8it53tkFeXe5a8Do7ge4zEMdGeEkeCQwrr3FGgvj0cEhfXfsQjv5tTGUM1dRvqJbl7sq2OSd1697QC2Bd0qu3R3RGyiM+Ygc2yxuQrqSmsleyx2RJVUZKVlSX9+vWTU045RUpLS1Xk44YbbpDx48cb61x22WVy/fXXK/GRkpKizLA77LBDwM8TQggJnNr1tdJQ2mCYXG99UaSsxaY3Y7rImEEOie/lHnArVsee2dXoUdI3RTZsdQ/CgZYEY34XHV3Q3oysMeGJAkSiAqkkMVX1KAllCgoVOL9GqIFawKIEOwgvB36QsomPj/cpXNCLBOW/eN77oLT3PCGEkI51cnUOzpQH33EtpySJ/Oc01/U1ua+pY6mpUiUWwFw/DdtcPpJUNE7bIkY317SUwMYXpDhQreKrCZldy4EHhKhHiWZUgVcFThgbqHUohuRLkHj7PtoSHO09TwghJLhOru8VZUq9K2giFx8l0i/fdY3N6O8eTBqK7DfgBjoYQ5Rs3BJk4zRYCxIcUmVqNW8uMbZr47SCUIuSgV6t5sNYFkynJyGExEAn11dWZxlRgiuPd9/05eQnSHl8i3GzxH4DbqCDsSM/Vaprg2ucpmnONYkSG/YqqfVuMd8rtDf9mWkOyeyVKNVx8WFvoEZRQgghNo+UxGclyKom18C602iRbpnuQQkTs21OdBk347fWirMpvFPPRxJzVKO2W+CzA3sTZ2o1b25CFi0ayhtl6W3LZcNbG5WZOVBxVhMXLxXxiSGPlIBRAx1GCgcTF4brPKIoIYQQG1K3qc7oTeEYkgnjn1oeghYlfoyccU1OqSt2V2rEUqSkLNXUYj5IUdI9L17KWqJJVRYQJYWPF8ryO1fInLPmydJblrcpTGo31hriTH3ODkfIWsy38pUktqRwGp0eqbNQQlFCCCE2pKxlvhtQ0ceVugFD+nqG7nOzXFPZ29kz0Vb1kaYk2dRiPje49IVZuDWgq2tjdDt+b/vL3aV3xT0rZelM38KkamWV/HzQb9Jc53q/K1JcVUPhiJSMHog5cMJvdqUoIYQQG1JuqrzZkG0SJV6RklyvklfzQB5LkZINjuAn4zOLEqNXSbMrChVNqld6Dvgr/rdSlt3qKUzKF5QrQVLTUp5bmpYiz+cPFdShBJu+CjRS4iFKwmR2pSghhBAbUmaqvFmc5O6rMdhLlGSmiZQme/bhiBV01CcpL0nWl7uHs2AH5bxsh1evkugJN2eT0xjw49Pcla7L714py25zCZPSX7bKL4f8LvXFrjbyGSMz5IaRO0hxUqr064EK19BXt7auwAnPeURRQgghNkR3csXANa86za8oQfuF+u7WGHBDSXNDs/JTeJcDdzRS4hFNiuIxqt1YK831rohI3p65Mvq2kcZzy+9aKXPPmS+/HfmHNJa7+rN0m5wtY1/fQVbVpYQtdQN6dHNIfS4jJYQQQrxo2NZghO2zxmbK8o2uO+NeOSLpqa3vkp151hhwQ0ntxjqVagEpaJzmngIo6EhJj26uTqhWiCZVmVI3aYPTZOCZBTL6Vrcw2fDmRmmuce143t65suPbk2VjvXuunnCYXDU9hqVIk7jOr4oVTN8QQgjxSt2kjs6UolLfURJNYo9kYzCpipH0jW4vD1L7pxqRkuwgurl6RkqSLVEWXG0ykKYNckXABp5VIKNmuoUJ6H1YL5n88naSkJ4ghUXux8MVKQEjBsUZ3hukbwIpVw4Wpm8IIcTGnVxr+5srb3yvn9PNYfQqiZX0jVk4qHlvtnSsHFi3mt9kNnEWhq9jaTCiJL1FlIBBZxfIuHvHSMbwdBnyr8Ey8fHxEpfkGsILN7lfH+rGaf4qcJxVjdKwtaWFcDTmviGEEGItPwnYlGOuvHH4HXThmejZUCtNWxukqbrJw0RpRzxSLPkpRjfXjlSeIFKyLT5JNR9LbW4Km4kzEKpWeKZvzPQ/qZ/68aawyB2xGJAfvveGCpz3IUqq3AIqKScppP+DkRJCCLHpRHxxSQ5ZkZBuPO4vfYNeJR7VJTFQFmyO+FSkpXbY5Kpb88cnOKSoxVdSsyZ8HUvbo6olUoLPNtU0mWJbeEZKwvXOdFlw8BU4lUsrVcVQIFCUEEKIjWisbJSq5a5b1YxRmbJyk8NvjxJNbpZ3yav9fSXmfdiS0vEW8yAuzqGEm5GaCGPH0rZwNrvLgVML0sQRH1gqxuwpCfUMwWb65Ytsywi+gdqa59fJLwf9FtC6FCWEEGIjyhdWiLTcxGdPyJIVG6RdT0ksNlDTnpK41DiP6pM+QXZzNadwisxRgDB1LG2LuqI6o7Im3St10xZril2/87uLpCaHz1OC8vK0ge73VR5gBY650V97UJQQQoiNMF/gs8ZnyYr1ruX0VNegFEgfDrubXVH1oYVVar9U2VDqHog72s0UxygSHUsDSd2YK2/aY8kap1EOHc7KG03+KPcxKl1WE1D0x2zMbg+KEkIIsanJNWNspqxuCd0P7u26k/WFa/6b2EnfNJS6zLogtX+KrFjv7LSnwiVKwt+xNNhy4LZobHTKybc4RVfmTttBws7w4YmyrWXywtoAqpTQd6Wx0vVZBQJFCSGE2AhMwqYpz02Xhsa2UzexmL4xR3oQKVm2zv3c8P4d2yYaqGmja9QiJStM5cABpG9ufUnkt7/d+33tSeFL3fgyu8aV1klTTVPIUjdqm516d4QQYoFQ/vLly+Wxxx6T448/Xs4991ypqnIP3LGG9lIk5SbKqq3urg6IlPgDkZLq+ESpikuIieob80R8aDG/dK1rGdXROVkd95QUJ7k7lkZDlFSvClyU/LnEKTc96wqRYBK+F651BN00rqOipMijp0tNQJVigcI+JYQQ21FRUSEffvihfPnll/LVV19JYWGhx/M77bSTzJgxQ2KN5kb3fC8p/VJl8Ub3c0P6+h+QumciteOKlqTXVapW8xBz/tI9VscsquJ6psi6ks5FSfSkfE2OOHWMejXUSPWqmogfo6oWUeJIcKjW+f6oqXPKiTc7pbElSHHNiSI7jo7M+xzUW6Q4NU2kzN1oLnNkht/1y+a2rBggFCWEEFtRX18vkyZNkhUrVvhdZ8mSJRKL1Jnme0GEwOylaCt9Ex/vkO6ZTjXgDqyrlOa6ZqnfXC/JPdyt1e0aKdlimgF5WOu+YgGDBnMAZleIksYKV8fSUDcH8wcEUHWLKEktSJW4BP+JjGsed8riNa7l7UeIXH9K5IQTZiB29EoVafEyVa6olp5tmVznujxQKb0DO9eYviGE2Iq//vrLQ5AkJyfL1KlT5V//+pfxmHfkJFbw9FKkeJQDt5W+cTdQS46JChzzpIJrne5UwvB+HR+c4SkBHqmJCJYF1xfXS1NVU6v28t58/adT7n3DtZyc5ErbJCZENuKVOdh9jDb85T9VihQYxB3ImuDuPNwWFCWEEFsxb948Y/nKK6+UrVu3qjTOLbfcYjy+Zk3LbWSM4eGl6J8qK1tESVxc+1UnLrNrakzMFmwchziRpTXJoYmUZLt+R6sCJ5By4G0VTplxqzs6dttZDhk1MPIpuPzts6ShJa1V9nPLbJDt+EnQUycQKEoIIbZi/vz5xvL06dMlNdU10OJ3jx49ukykBJPQ6R4lmO8kKbHtwal1q/ka2x+HlF4psnSjIySiRHdC3RilSIlH5c0g36Lk2iecsralUdrek0T+eaREhRHDE2RxqkvFxW2sluo1Ne331KEoIYTEuigZN26cx3MFBQXq94YNG6ShIfQzmEYbc3+RhpwU2VbZ9pw3rapLYqCBGkpQ4YfRPUrM5cDDOmV0FUEH9aLEtIArS8LWo2SIb1Hy/o+u36nJIs9e41Dt8aMBDMVz0t1d6rZ81zJFsxdlc8yRkpZQVDswUkIIsQ0wA2pR0rt3b8nNzfUpSpqbm2XdOtNoFSOYUy5F8akBmVz9RUrsmr7xiBb1c4uSXjkimWkdH6RRZYPjGK2urh7lwINai5LScqdRZbTDSER2olc51T9fZE5GjvH35llbfH5Xy1o6uSb3TJaUXjS6EkJijKKiItmyZYvPKIlZlMRqCkd7KTDfy6oq93wvQ/q0P0DlZjtkS2KyLt6xba8Sc7QovmeqbCrtfOrGPKFhTXyClLV0LI1o+kaXA8c7lF/Im3mmYrPxQySqoB9MYXaW0fcGkRJU2piBH6exzGVyzZ4YmJ8EMFJCCLGlybU9URJrZlfceWohkdo3VVaYvBSBRkrQh6M0wXXHWmtTT4k5wlOW7o78dKZHiUanwbTZtXZj+x1LQ1YOvLKlHLh/isQlxbUjSqLbXwZRpT75cTIv3TXZUv2WBqnARJEmzPPdBOonARQlhJCY8JPEeqQEPTN0ySjKgVducAZcDmyuLtEpnLpN9dJUp+Mm9oyUFMWbe5R0fqDWDeg8UjgR8JVgUNels2l+TK7zVjgtEykBffPgKzGlcL7d4t9PMp6ihBAS46Jk/PjxrZ4fMGBAzIoSjx4l/T17lAQUKWkRJWaza+2GWtu22QermtziIVTpG+DZRj38KZxq03xGaX5Fies3KnHHDpKo07cHfCW5fn0lHSkHBoyUEEJsJ0ri4+Nl1KhRXSpSYu5RghbzuhwYYiM7IwBPScu4sNnD7Gq/FI65lPnv6uSwpG88KnAi0KsEM+lq0n1U3jQ1OWXBKtfy0L4i6anRnx6gXw+RdUlpsrklHVj6y1Zpqm0y0lHlLe3lk/KTJDnAbq6AooQQYgsaGxtl0aJFannYsGGSktJ6bpDu3btLRkZGTIoSs5cisZd7vpdAUjfmSIlHr5J19o2UJHZLkEWbEoKKFgXSqwST20W6V4lHOfCg1qJk+XrMd2Od1A3om+dQYZu/WqIlzTXNsu33bWq5Zk2NNGxrMblOyApq/iCKEkKILcBMwHV1dX79JAAXPx0tgdEVpcGxgtlLsS0tRZzO4AZjHSnxbKBmDVHibHIGvJ5OOSFapMuBISZSkzsfPUC79oKekS8LrmqnHHiehUyu5vQN8PSVlHYqdQMoSgghMVF5o9GiBAKmpKQlnBADmL0UGxwprXwQ7ZGc5FDNwYotlr5Z+9I6+XzgV/LXmXON8L8/6jbVibPBJWDie6XI1orQ+UnMxxMVSnWOuIilb3TljTgwGV+a5U2uOn0D5ppFyazNrTq5Bto0TUNRQgiJicqbWPeVGJESh8iKerewGBxAjxLP+W+slb5Z/WihNFU3yca3i2T2yXP8ChNESZbd7Q4Z1GSGZnZgn74Sh8MwuyIV4d2DI9QYswP3S5H45LbLgSdYRJSg+gZsTUyW0pwMo+KmYVuDR6Qka0JmUNulKCGExETlTaxX4Ljne0mWlcXB9Sgxp3Aq4hOltiUKUBvl9A0Ge3PqouSrzTJ7xpxWpcrN9c0y5+x5svZZd5feTWPdMxAO7x+6lIYuC9aipLmuWWo31nZ6Pxde/resOHq1lP7oOYFdfWm94b9I81N5M7dFlGSmtT/xYqToleuaCBIsyWmJljhFNn+3xRAlSXlJktKntferLShKCCG2EiXp6ekycODALhUpUfO9lNS3qrwJJn1j+EocDmO2YHhKUCkRLeqK6pRB0kzJF5tl9il/GcKksapR/jhhtmx8p0j97UhwyITHxsmi9G7Ga0KdvgEbzRU4qzqXwln9WKESVPUr6+Wv0+epNJSxbXPlzeD0Vq8tq3RKoWvXZdxgCAFreErgv+np6p0mv6W4UzjrXl4vDaUNHTK5AooSQojlqayslJUrV6rlsWPHSpy+ResiosRsSDX3KElOEunTEkYPhLyWcVz7StCMDeH2aGGOkuTs2l3i0+PdwmTGHDV4/3bEn7L56y1Ge/3tX5wkfY/s4zkRX6jTN60aqHXc7FqxuFKW3LzM+LthS4PMu3CBIQbNxyBtcOtIyXzXaW8pP4m32fWH5u7iaJmlGp9dRzq5aihKCCGWZ8GCBQH5SWJVlJjLgVP6opura3lQr+DunH1V4ERzYj5zlKDXob1kh1e3k/i0FmHyeYl8s913RplpQlaC7PjmZMmf5hoJtShBCe+gAMuiA0GnwzwaqHUwUoK009xz56kUkMLhTlMVPrEmoIn45pn9JEOtESXxNrtWOxIkbYI7ctXRyhtAUUIIiRmTq549ODExMabmvzGXAzd0T5Ha+o715nA3UEu2hNnVu2lYzq45MtkkTJprm40GXDt/uKPk7OzKFyDKsLRFlAzsJZLUcpceCjDTcI9u7vlvOlMWvOzOFVI+z1UilD48Xfrd6c61Lf73Uqn4u8LjGKQNbqfyZrBYCm12Bc0T3CkcTTAT8WkoSgghMSVKkNrp169fTEVKzMJhS3Jqq1RDoGCmYFBsigKguiRa+IoS5O6WI5NfcQuT1IJU2eXjnSRrjLuKo2iLSFVN6FM35uO6KTHVmFG5Iw3Utv6+TVbcu9LwwYx/eKxk7pUhBWe5jNiInsC8W7mk0nhNWkGqX5MrGGs1UdLDLQa3DXG3nAdJuYkqqhcsFCWEkJgSJeYUzrZt26S83F2eGAst5tfHmXuUBBch0JPyFbUYXSPVHMwf2k+BQTuln3u/cnfPkd1n7SJj7x4tu325c6u0htlPMjwMogRm18a4OKMlf7CT8jVWNsrc8+aLVjXDrhhipDKGXz9UMka5SmgrFlYakRRUqcSnuoSYprnZaXhKkKLKSrdm+gas7ZYlCZnuDrtZ44M3uQKKEkKIpUGoXosSpGby8tp3dsaar8Ts+1hR7069dDR9YzZxVkWgOZi/z9Xoz1GQKnEJnsNR+pB0GTCjvyTlJLV6rU7dhGp2YG/0cdXHCTM0N5QFbgj++8Ylhl+m2+RsGXyRewa9+JR4mfj4eInz6keSNrh1lGTVRndEyGomV+/0zbpShxKTnfGTAIoSQoil2bhxo2zZsiXgKEksihLtKYHZc9lWl1+mY+kb1++tCcnS1CICaqIUKakvrlfVP/4Mnm2xbK3bZzEsBBPxeaMb0nlElAJM4RR/UWL0U0EKasIj41oJrqzRmTLihmEej/kqB57nYXIVy6Grb8D6EpEe+7lVSvddWuqFg8QdayGEkBhI3cSaKEHjLV0SjHLgNZvcz2Gelo5ESpwOh5RnpUr30iqVmsD/cES4/4VHKWywoiQC6RvgaXatkeyJ7bdMX3LzUmN55E0jfIoNMPCsAlU+u3nWFr+zA89dbja5Wit10ypSUiLS75q+qow7Pi1Bekx1P7l0rVO2VYjsOLr9fWCkhBAS06LE7hU45vleUvulyvqWNhDdMoKfwl57SkBpmrljqbuZV6TwaBoWpCjR6ZukRNdkfOFO3wTqvWkob1Q+EZA5JkMGzPCvmCACxz80TvVnQZVKv+Nb5+I8J+ITy5GR5pBslz1GnZeICA27fKgMPn+gh5/kkXedstM5gTXpY6SEEBJzoiSWWs2bK29gBl0/u3XoPFDSU10DeX2DKwowxDTgpnagUqIzeJTC+ogS+APmz+Xr3RGN+PjQRxB654qkJKFXSXBlwRUL3Kbq7jt0b9foiSkDdv5gR7/Pz2sxuaalBJ+qi6TZtazSlb6BT8jXPpvFVXswUkIIsYUoQanv6NGjA3pN//79Y0iUuI2ozrwUqatvHToPFAwYOoWzNs4cBYi82bW9pmH+WFssxjEIRzmwPk4QAcE2UDNPRNeRHh1mKqudxnQCaC8fDvEVCvR5iN45pT4K3SBUzGXN7UFRQgixLI2NjbJo0SK1PHz4cElJCexuHuv16tUrNkTJWnekpCrLPUh2JFICtChZ2RzdsmCjHDjeIan9W1ee+CNc7eW9QRSmMj5RKuJdCYWqAI4RZsk1l8R2hgWrrJ268Wl2dXeYN9i4RWRLWeDboyghhFiWZcuWSV1dXVCpG29fCap39DbsSK0pUlKa7BZlHYmUmCtwCuM637G0U+XALekbmHfjkuI6ZnIN4ezAfn0lLRPzYUZl79mL/UVK4pIcktnSi6SjzF0ulja5+upVghROZ1I3gKKEEBJTfhJfZtd160wjmY09JUUJKT67aXbE7IqOpXoulo50LO0M9VsapLGisUOVN6jkiESkRJcFG2ZXp2cTO2+wP1XLq9RyxqjMoISWL+aZ28tbOVKS5/CowPGGooQQEjOESpTYOYWjPSWYhXWtqXFahyMlLVkFdCyNy+9Yx9LOUh2icuBwp2+Ah6+kjYhS+YIKJVxC4Scxm1wtL0o8IiXONsVVIDBSQgiJSVESKxU42lOC6pj1pRKy9A1w9mzpWFraIA3lgXcsDWk5sI9J6AIRJahI6dPBYxBM+mZdsrvPSNls/+aIsrllne5mak5v6QgDSp67ZdojfdNWpCTBs4O+XyhKCCGWZcGCBep3enq6DBrkbtXdVSIlEAqN5Y3ucmDTRb/jRlf3AFeXlxZUdUmoqFrpSnMEGylpbHTKyg2u5aF9UZEVvsEasw+junV+mrsz6eZvXY3O2jO5dlaUFBaJlFdZP0rSntG1rt4pf7d89Ua5v45tQlFCCLEkTU1NhpgYOnSoKgnuaqLE7CcxN05LTBDp0a1j2zQ3UKvqFp0KHHM312AiJauLRBqbwp+6AclJDhUFKElKlY0prve47Y8ywwvjTfm8ciPNBk9JZ5hn8aZp3ucTet/4MrouXuP+vALdD4oSQogl2bRpkyoJ9u470pVEiXkivlRTpATNvToaJTCnb0rTzJGS6sinbxyYjC9wUfLzQvfySHd2LuwpnD9TXRPNORudUvrz1lbrNVY1SuUyV2gDVTfxXpPtBcvcFfaovNE9XXQq0Tt94ymuAtsPihJCiCVZu3atsdwRUZKdna1+7Nxq3lztkdg7RTaXdc5PYja6gmJT35dIml2N2YH7pQQ1gL/znds0uf+O4R+stdl1Tkau8djmWZt9m1yb207dPPOJyGWP58q64vb/7/dz3fu53XCxPDqFs7VCpKbO6dPkGuiEghQlhJCYFCXmaAm21dzcdo8Jq6dvKjM63zjNO1KyLiHykZL6rfXSsC34cuDqWqd8+ptrGamrXcdK2NFlwfPSu4uzZbTc/K3JbdxCublp2oTWk/Z99ptTzrhd5O0fM+SSh9r+nzV1Tvlunmu5f77I0DCnqcLZq8Sz10pg26IoIYTErCjRFTj19fVSVFQkdm4xX5ra+cZp3p6SovpESeyWEFFPibnyJi0IP8nnv2PAdi0funtk2q7rSElVfKLU9HcduMrFlVJbVOe/vbxXpKSqxinn3OWOGHz6q8sA6o8f5rnb6O+3gys9YnW8Zwv2LmvGOdfLHWxqE4oSQiwMSgP/+9//ylVXXSXl5T4mlohhQhkpsauvxOwpKYrrfOM0Pbuw9gwjHaQ9HTXra6W5vjmyJtcgIiXm1M3/TYnMQK09JWBtX5evBGz5botPUeJIcEjmaM9Orv951qkMupqqWpHv5vr/n1/84d7PaZOtL0i8z0cdKdlU6pRNpW6Ta6DiiqKEEAvz0UcfyfXXXy+33367HHLIIVJdHfk5SqIFRYnbU5LUI0nWl8eHJFICg2z3luIQzEliCIPmtjuWhiVSEqAoaWh0ygc/uZYz00Smbi8RwTwz75z0HJ+lwcrkurRSLWeMzJD4FPfn9NdSp/zv9dbb/fgXZ5sRIYAxPFL7GY5eJfNNzd8C9ZMAihJCLMyPP/5oLH/33XdyxBFH2Hoel46Kkr59TbesXSRSgqiFThOoxmmmbpmd8ZSYza5bykXSBka2LLjK3DhtiLsxWVsgsgATJThwZ1e5biTIyXKoyBL4qbGbxKe5BMfmWVtUFBNULKr0aXJtanLKWXc5pamlJPaSo0Xi41yv+ehn3/9vU6nT8GHA4JrXzSaREpNIXr/Z2dpPEmDlDaAoIcTCzJ492+PvTz/9VE444QSjVLYriJKePXtKcrK7vXpHRYndKnBqN9Yabcsxi665MVVnIiVmUYIGXckD3KKkKgIN1DxazBcENjvwu99HPnXjncJZuTlOuu3kag5TV1QnVUtdJcBlc3x3cn3wbZE/FruWRw8UueVMke2H1RldaZeZ5vDRfPWne3naZLENnq3mfczdE6DJFVCUEGJRcCemRUlGRoakprou4G+99ZacfvrptqwmCZSGhgY1u29n/CRWjJSgk+ma59ZKfWmLkzGA9vJGN1ezKOlkpMRsdm0wd3WNQKREi5KUPikSnxof0Pfg3e9dy2jSdcDOElF0CgdfN8ek3FYpHF8m1zWbnHLtk+5B+YnLHeq97z3BLfp8RUs+/939mv12sEeURPfN0ZYRnb7RJtf4eJcoCxSKEkIsCma23bzZNRLttttu8s4770hioqt14vPPPy8XXnihEUKONTZs2GDsW2dESX5+viQlJVlClGB/fj92tiy4ZJH8tN8vyljaFhWLXT4FI1LScrGHHyQ1uXMDlrksuDrHHa2oWR3eSElDWYOaIRikDU41SmBRMlte5ftcRrRBD3RTtxPJSo9wpMTkKykd0lqUlGuTa7xDMsdkqs/5vP85parlUJ57mMiu41zv2SxKvH0leN0Xf7jn9YlEyXOoSEp0SH5LN36IZ3iAFq12/T2iv0hKEOcrRQkhNkjdbLfddrL//vvLq6++KvG49RCRhx9+WK699lqJRUJhcgVoTa/LgiFKoini6jbVS/WKamOemV8P/U1qN/gWJps+LpbFNywx/s4Yni4btoQmdePdQG1bUorEtXg0qkIUKalcUik1i2rbTN1og+0Vjzhl+mVOGX+qU0q2tf583jGnbvaIfPRgaF/3/1walyFJeS6RW/pDqWo5X7nElcbJGJmuIj9vznJHQRBBuPUs9+uH9W1QE+yBb+eKVFa79w1zxGxoiYbtOSFyvplQoc/LolJRgqS+oWNt8jskSnD3duCBB8oVV1zh8Xhtba3MnDlTDjjgADn66KNV/juY5wkhbv766y8PUQIOP/xweeaZZ4zHb731VlmxwtTLOUYIlSgxp3AqKipk27ZtEi28m5NBmPxy6O+thMm6V9bL7BlzpLnOlZ7L37+HOCbmGL0rOpu6AbnZ7gGvtMohqQNayoILazot3DZ/t0V+3OsXWX3yGln34nq/5cC68gZ9O/QkdCf91ynNzZ7//53vXL+RHvjHbhJxzKmHhYUiuXu6qnAaK5tk7YvrxNnker9Z411K76Zn3e//wYsdkp3hPtbYBxh1AQbtL00eks9bGsOBaTZK3XhX4MDY+0VLBVGwJtcOi5I777xTevXqJTU1nqG+Bx54QJYsWSKPPPKInHfeeaq/wsKFCwN+nhDiP1KiOemkk+TSSy/1uV6sEA5RAlavbokpRwFz1Ym+8qI89pfD3MJk5cOrZd4FC4yBrs+RvWW75ybKhlL3hT0UkRLzZH4bt7grcJqqm1REpzPpmXnnL1BzxIC/r10slcur/JYDQ4CsNTXb+uw3kZkvuP9eXOhUk7qB3caJ9MxxRFeUrBbJ29Odwln1cKGHnwSN0rCOLoP9vz1ab0+LEvDRz04//UnEdpjFsjk1NSHckZLvv/9elSTusYfn0UY1wIcffijnn3++DBw4UPbaay/ZZ5995L333gvoeUKIJ1psYP6WQYMGeTy3887uK9vSpUtj7tCFUpQMHuy2/q9atUqsECkZe+doQwggpQNhsuiav2Xx9e6UTcGZA2TCI+MkLjHOo3V3KCIl5hl2/y50StpAk9m1sOMpnIVX/O0R+WmqbpY5Z80zmrJ5lAMPTpOSbe7upZobn3HK13+6BrV3Wgyu0ai60SDSgXbvYOEqkdw93P1KzPuaPTFbpS10oAklvb4ahu09SSTFlQGSj39xeUnQ4XXWHNdjSPmM8fy624J+pgZqP8x3Px7W9A0iI/fee69cdtllrZ5DC+eqqioZPXq08RiWly9fHtDzhBDPGXLXr3eFvidNmtTq4jZ8uHuWLkQfY41wiZKVK00dnaIoSnJ2z5Gd3ttBUgvcwmT1Y+6S5WFXDZHRt44UR8tMwJ7lwJ0fnMeY7/5XIWqR2uk5cDa+VyQb3nRVTCVkJUjSgETDCLrs9uWty4EHpamUjSYny13lcvzNTtm42enVxVWihhYJ2ypFtqakStoQr6ZvcSJZYzI9GoaN8zO7L0ysECYAHhL088Dsx9W17iiJHVrLe2OO4DU0uk3ZwYpo16QHAYK0y/Tp06Vfv9YzBFVWupzi6enuZjiZmZnG4+097wvMV4EfjzeckGC46TuCLqOM5XLKYOExsd4x+fNPd7IZosT7fQwZMkRduHCXBVESqfcZqeOiRQmMquhT0pn/h8isBv6bUL/3QI8JyoEVcSjxTZa4pDjZ8d3t5bfD/lReDoVDZNStI6Xg9P7qs9X+DvPMsr1zW/suggUCANUSxVtdKYnU/VM8fB/BHiM0eVtw6SLj75G3DpfK7EopPHWtOBucsuK+VZK7d64RKUnumSRxqXGyusi9H2guBvMn/AhoT/6Pq53yxxJ3CqCgV+f3u6OMLnB7X+avdErfPXIM0zLIGJEhjhSHR2+OsYM836/5PDlw5zj5pGV7H/7klGpTP8R9J9tzfEKExxv0JzGfx/g+h0yU4ML3008/ycsvv+zzed1DAW2wtfBAZEQ/3t7zvoCh74knnvB47KijjlIm2VDeiREeE6udJ998841HpMBXOWufPn1UNOXvv/9WXolI3l2F+7jo/YUg0RGjjqLLqMGiRYvCVhrc1jHBRblyhUuUJPZOlLUbTd1qH+wl667cIA0bGqXnZT1E9m1u9R6XrELKwNUb3tGwUQoLO+770AzpnS/FW1OVMFld7+61UbKwRJIKA79fxb6tvWi9NGx1lVtkTs2Qxh0bJNWRInln50rJg5tVE7jZZ86RxhLXLXRcn3i1j3OXYJ9c6ZD0hBKZeXKtzF/eW4q2JhiCBOw1bpsUFrqblEWanpkYs1yhgB9ml8pRo1vatLYQPyRO7c9vi5DncY1p3ZLWSmFhs8/zZHx/HF9XV7Z3v62V+iZ8d10NAkf09P06qxPX4N4nzaD8ciks3Or+2ysN7YuAz7z58+eri8N+++1nNDeCTwRlip999pm6QKLrIu5Exo8fr9bBsn4T7T3vi1NPPVV1rwx1pAQnBS70gai2rgCPifWOidn7gO+c2axpTn/iO4mqEoh7DOCxcFxQpbdlyxYjyuFr34MBJcFoPoeoLBqydXZ7HTkm9ZvrZXHVMrWcNSzL8z0UiAyZNUSZW+MSfL++zHQnPXlcb+nptjV0mO1HivzcEtyoysd12HXOOUrigjpGa55dK1U/uSMgOzy8vSR0S1DHZOI14+XPv/6S0h+3SmOxuwtxzsju6n9UmLTV9mN6yHbjRF77j8g+F4s0mcblUw7uJgUFJnduhNkDxtOnXMsby3Jk5FmZsv7KjUZ7+d679JaCggGyfIPrb0Shth/X3+95UlAQJ6MKXGXAf61MMXwo44eITB7fuXRltMjxkabZdSLOdc9Zk0MmSg499FAlQDSImMydO1fuuOMO424ExtWnnnpKbrvtNtXSGWIFE4kF8rwvID46I0DaAhcPihIeE6ueJ7ocOC0tTUaOHOnzPeDxL774Qi0vW7ZMevfuHRPHBY3TNKESP/CVzJs3T0WUcGeve71E6piYm5LB4OlzvTbe0obNrtEvMcFVgYJJ9ToL0gu6j/3iogQZ2StZtU9HKinQY161okqW3OgSW2Dc/WMlJS/FSD/EJ8Yrs+73U36SxjK3KEkfnK7+x9pit/IY2Mu1X3tMFLntbKdc/ojrvQ3qLTJxmCOqPgvzsVpUKJKck6yMrWWzXdGbbpOypWSbw+izMm6w/1SFPk8O2qVZiRJzpma/HQJLcViR7AxMltgsFSZL0sShwZ+rAe89RAU8IPoHUQ98sXEHokGZYlNTk6qsOeOMM2TGjBmy0047Bfw8IURULw1tyJwwYYLfAXTEiBExaXYNpcnV2+yKCG9n00EdwbvqJFh09Q3y9qEQJMBc4bFwNSpwXGmH+pJ61RSsPSDu5l24QJURgwEz+kv+vq1vl1P7psq4/43xeEwfgzWbXH/jFDd7Ei49VuTCI1yP3XludAUJyEhzSEEvtzEY+z5ghstbmT40XYkST5Nr+9s8aJfW+zRtsv0Mrv5mC4a26kgVUVBGVzPHH3+8HHPMMR6PdevWTR588EFlTkWaxVvxtfc8IURkzpw5PvuTtCVKYqksOJyiBEDw6S6vkcK76iQYUC66uSx0PUp8ihJU4AxMk62/bDPKgrPGZrW7T1t/da2P6p2RN7krwrzpfVgvKf68RNa/tkEciQ7JnuTaduEm92CWkGBuMuaQ+y/Cj1iGsYNcDd4QCVhbLDLghH6St0euJOW7TMswwLZXeWMGfVey0l2TIoLkJJEpE8TWoNIG0R9ddp6WErzI6rAqQFrFn0kVz7UlONp7npCujL+mad7EallwJERJpKny0V49UHTr8VD1KNF0z3QY0QlU4OhIie422x7miej6HtNHEtLbvscdd98YGXv3aJn8ynaSVpCmGo1taRFbA1r6gFgZ7zJqPSdRfLJrLDOLkkB6cyQmOFS6RjNlfOfnNIo2ZtEcbH8SDZUBIRYWJSgH9gdK8/WNAUVJ4KIkGm35jU6mDjF6kwSKZ4+S0N/9A4iDhh7BNVDTE9GB7AmmGf78gCZwSPH02Nu1E4g2aPR8MFZmzCBHK1FiZl7LaYVMU6Cz4h6yq3ub03e0tyDxTt+MDyBa5AuKEkIsKkrg4xozxjMXbwbRRh0twd0//BKxQDgiJejrEs1IiU7fpPRNkfiU4Ey2nt1cQztwmVM46xOCjJTMcYsSPe9LMOjUDdB+DSvj7cEx09TkNITK0L6Bpy2O31fknENFTpjm+m13th/h3u+9/N9PhcdTQggJPejds3jxYrU8bty4dqvP4CtBFRzK8zHYmn0mdhclEGX5+aGJ66P8VDebi7Qoqd9aLw3bGjtucg1jpMR19+8aYJc0pImOJ1W3M1swjmPZPJcoSe6ZLCm9XD02gkGbXMGAfOtHCVDCiygIyne9IyUrNojU1gductXAR/PIpdbf90A5dHeRJ69wSEaqyO7jGSkhxPagbFV3P2zLTxLLFThalCA9FSrvGaoFdSfqSIsSc+fPtA5V3jjD4inx9knML0mQhIz4gERJ9eoao8Q3e2LwURKwZpPTVukbRD9QnqzLgs3dWuebMoLBiJJYIy7OIacf7JBjpnZcaDF9Q4gN/SSxKkrQ4Awl0aFM3Xj7SjZv3izl5e7Ug5VNruGOlHjMgFvoMCqDatbWSnNjc0B+kqwJHRMldkvfmEVcVY2rEkcTbOUN8Q9FCSE2rLyJ1bLgcPhJoj1bcGfKgVuJkh6hnwFXmxORktAmXHSXbctXYq68ye6gKDGnb/QsvFZnrCkKgooljblHSUerTogLihJCLChKkLbQ0zG0RayVBUdKlEQyhROqxmmYcTUcJaPmGXAdQ90Co/Sn0oiIEuxXZpo9ogtjBvquwNGiJDVZZHCfKLyxGIKihBCLUFdXJwsWLFDLo0aNUi3m2yMrK0t69XLFvilKrClKPCIlBcGJEviLNmwJT+rGuywYlAx0t1XdPGuL3/dUPtfVYCQpP0mSO2ByRbWKLgm2S+rGXwUO+q0sX+9+Pj7eHgLLqlCUEGIRFi5cqKpoAk3deKdwiouLDT+GXYnFSIlRDtwnReLTgisHRv+QuvrwpG589d9YlJglCdmuoswt35eqNI43NWtqjGoiREk60gK+qFSksck+jdM0Iwe42qebIyWLVrsqcrq6yTVUUJQQYlOTayyaXWNNlDSUNUj9Flf/mLTBwTVNC7fJ1Wen0kKR3CmuKYgbtjZI+fzysPtJ7FB5o0lJdsiQlvQM2qkj4uM55w2jJJ2FooQQm5pcNRQlgdGjRw9JT0+PaFdXDz9JR0yuHo3TJCx4VOCsFsnb05TC+XZLm03TAunk2m7lTU97DeQ6hVNTJ7Jqo3flTfTeV6xAUUKIBUXJxIkTu7QoQfv8nBzXHXuoQJpBR0tWr16tZiy3VeVNniPsM+AiFZG7R06bvpLylqZpnSkHtmukxNuDgxROsLMDk7ahKCHEAsBLgsZpYOjQoZKdHfgdaKxU4MBAqUUJUjfhmK5eixK05F+/vsWdGIk5bzoqSsLYOM1XCgcz1pZmpElq/xT1N2YBbqpp8uzk2pK+SeqRJCl9gje5gsIiezVO8zsHzmq3KMnvLtIzx15RHytCUUKIBYDHoabG1RdiwoTg5i8fNGiQaslu914lMOmizX44/CTR8pV4NE6zWIt5v3f/qx2S25LCaa5rVsJEU7uuVhpKXR6Z7PEdM7mCNabJ+ArsJkpM6a5v/nJK8VbXMqMkoYGihBALYB4gzZGPQEhISDAmnFu2bJk0N/vvxNlVTa7Rmpiv0+mbCHhKfM2A6+ErmbXZ9yR8HUzdmNM3iQmILoitGN4fZb+u5a/dGVeKkhBBUUKIBTAbL81388H6Smpra2XNmjViRyIhSqIVKcGkdQnpCR2OlGDwzuuYp7RD/Td0BQ7Y/F1pSCtvzEZXdHLFfCl2IjnJIcP6upbN+p+VN6GBooQQi4kS8918VzK7xpooaaxolPri+g5PxGcWJX3ywjt46xlwdaQkuUeyZI3LNIyt9VvqW5lcOzoRX1mlU8oq7Zm68SXiNEzfhAaKEkIsgHmApCgJnygpKCgwfBDhFiWdnYivts6pmqeF20/ibwZc7SsRp8iWH0o9Ta65iZLS12WGDRbdydWOJld/ogSnlC+hQoKHooQQC0VKkpKSpG/flthwEDBSEhgpKSnG8Q23KOmsn0S3lw+3n8TXDLjwfHj6SrZI7YZaqd9cb/hJOmpyNfcosasoGWvy4IChfV3CjnQeihJiqbLYN954Q37//XfpSuAOVA+QAwcOlHjtoguCWCgLXrduXdgjJeYUTklJiVRUVHRqW7VFdTLnzHmy6b4SaW5sDstEfJGIlHjPgLtglUjOzt0lLslhNFHzaJo2vvMmVzs2TtN4R0WYugkdFCXEMjzxxBNy9NFHy+677y6LFi2SrsKmTZukurq6w6kbkJeXJ927d7d1WbD2lGCSQfyEi1D5SjAvzF9nzJWidzdJ6QtbZeW9q/xHSjpdDuyI+Ay4mKen+46uc6qmsEaK3t8Uosob+/Yo0Qzr5zIfayhKQgdFCbEMs2bNUr/r6+vlf//7n3QVOmtyBQil6xQOBnfd78NO0SIdKQlnlCSUomTVw6tl689b3Z/jXatk6+/bfIuSgS5RcuuLThlybLO8Nav1RHfe/LE4Mo3T2poB1/CViMjGd4qM5eyJHS8FioX0TWKCQ5UGa1h5EzooSohlMKcdXnzxRRVB6Ap0thzYl68E/UrsxObNm1U5s11ESfnCClk6c1mryMncc+apqhtz+gadTxOzEqSmzik3POWUlRtEzrjDKaXl/oVJ8VanPPq+azkpUWTPwGcdCOkMuHl7ukuD9YzBid0TjY6v/vhrmcjvS5NjrsW8mUnDTMvBtRYibUBRQiwBGn6ZRUldXZ08/PDD0hXobOVNLJhdI1EOHCpR0lTXLHPPnSfN9a5BuuDsAZI63jVIV6+ukYVX/y2NVY1SV1TnUXnz92qRxpaO7dsqXVETf9z5ilMZTsFZh6Ak2BHxGXBRgYOISEK2Z3+V7HZMrnOWOWXX80SOuaWXvOkKfvoUJT26iaQm29NTAq450SH7Thb57xkOGdzHvvthNShKiCVAwy99p6yBKNGt12OZUKRvAEVJZETJstuWS8VCV6ONjFEZMvy6odLnpl4Sn+4yKK9/ZYOsvH9Vq8obmEfNPPC2p79Cs6nUKQ+941pOThK5+kRH1GbAdcQ7PBqpBeIneeZjp9S7OtHL7S+7UnOahkan4ZWxc5QEjBrokC/+FyfXnkxBEkooSoglMN/Z67swhPSRxulKogTz2MSKKMFMvN9//73HoGSFSEl+fr6kpaV1SJSU/rJVVj7gUheORIdMfHScxKfES1K/JBl920hjveV3rWxlcl2wyvM41NWLSud4c/vLTiUKwDn/iEyURDPaNK/L4pbGwObS4PY6uSK68tZ37r9nLxX51eRZ37DZ3QXVro3TSHihKCGWYPHixcbyueeeayzD8GrXuVwCRQ+MvXv3NgbLjoAoixZ00RYlpaWlMmnSJNljjz3kzDPPbPczjKQowTHS0RIIp6Ym9yy4bQGvyNzz5qtmYmD41UMla6x7gO5zTG/pfVivVq/T5cDmKe7TU12/n/9MZN4KtzDZuNkpj7zrWk5NFrnqhMjehY/o7/5/SzogSn5Z6FnKDB582xlzfhISPihKiCUwD6InnniiGsy0WPn0008lVqmsrDQMvZ1J3ejGYOhzoo9nIBGKcPHrr7+qWX/BU089JZdcconf94PP+OWXX46YKDEfa1R6bdiwIaDXLLpusSqNBd137iaDLxjUSuyMvXu0pPTxNIEa6ZsWUdItQ+TfM1yDPw7JVY+6j8ttLzml1tWfTM49VKRXbmRFCcyumsVrnEakJ21gqmHaTS1oUVQ+ePPb1p/x69+4UlKtK2+Y9iCtoSghlouUIA2BQUwTy+XB5vRBZypvNCNHjjTEzsaNG8UKKSlw3333yQ033NBqvT/++EOmTJlilANvv/32MmyYqazBIr6STZ8Uy7oX16tleEcmPDRO+S28SeyWKBMeHitiegpG120VTllX4m5SdsHh7kjBJ7+KfDPbKetLnPLYB67H0lJErjg+8oP2CLMoKTSJrXvGSI9peTLu3jF+Ta5I3WhjK3p4HLe3qzFdQ6PIEx/4apwWrr0gdoaihFhKlPTo0UNycnLk4IMPlqFDh6rHvvrqK5kzZ47EIqGqvLGar8RblID//ve/cscddxh/f/PNN7L33nsr7xCYMGGCfPTRRx1uXx5OUVK1vMq4Wo6eOdLoO+KL3Cm5MvLG4eJIcEjfY/ooobJwtfv5sYNclS43n+7ezysedcrMF5zKZwLO/z+RnjmRFyXZGQ7p1eJrXeLOqEneHrmyw6vbS8/p+X5f+/ti97w2U7cXOfegMqPE+NH3ncrkGguN00h4oSghUae8vNy4q9d3+mi1fvHFFxvr3HPPPRKLhKryRqOPn3f0KdIsX77cWL7yyis9llFV9c4778j06dNVRAcgWoLmeT17RmakClaUDL5wkOzy0Y5ScOYA6XdC34DW32/1VJnw8DiP1I153pQTpomMb/nI/1gs8vC7br/J5cdFL7UxssD1u3irtNlLxZs3vnGve+ReIv16NMnBu7j+hs/kvR9io3EaCS8UJSTqmO/ozXf6M2bMMFqnv/LKKwHn/rti4zSriRK9X/C5zJw5U2655RbjufPPP1+OPPJI5ecAiIp99tln0q1bt4i9P/Ox9hXV8QVaro+5bVTAkZz4VPccRubKGz3HTHy8Q247u/W2LjwcPTyiKEpMKRxtdm0P+IXe/Na1nBAvcuhu7oiP2fCq0zcpSa4+JYR4Q1FCoo558DQPqunp6XLOOeeo5YaGBnnooYck1ojF9A0qbfR+YfCPi4uTa665Rq666iqPdcBJJ50kb7/9tqSm+jdPhgNtCI7EbMHePUqQvtFM30lk70nuvzNSRS47NroGUI8KHFMKpy0Q6SkscqducrLcy9qn8u0c9/YQJYlEmo7YD4oSYtlICbjgggskMTFRLT/22GMBl2/aBX2XnpGRofw0nQXpj+zs7KhGStavX6868noLLURMECXRID337LPPGp9vJEEEp2/fvkFFSjoKogi6HLh3rkhutnswxsB8x7kOFV0ASNuYn49m+gYsLgwsffOmaS6fI/cy75/IBf/n/lt/fZm6If6gKCGWjZSAPn36yAEHHKCWt2zZEtWURKhpbGxUfTJ0RCEUd47Yhj6GhYWFxuzDkcQ8yGuzsn5v999/v3zwwQfy5ZdfqqoqRFGihRbAMNqGc56lTaUiW8paR0k0k0c65PsHHfLKjQ657mSJOp5lwcGlbuLjRQ7b3fP5k6e7IkBmWHlD/EFRQqKOFhpJSUkeYXXNrrvu6tH/IlZAGSyESahSN1aZmK8t8y5ECDwkU6dOjXr4fvz48cbyvHnzIpO68WMb2nmMQ46d6pC4uOinNBDFgOcjUE/JX0tFTTIIkIrK8/LDZKU75JTp3v8j+vtJrAlFCYkqSMfogRN31QkJnpN/gZ133tlY/uWXXyRWCHXljVXMrubKm1DuV6hBCXJERImPyhsrA2E0vKV/3fL1rvlq2sLcMO3IPX3v3/mmFA5g+ob4g6KERBWkL3QVhnfqRoOGWjrMH0uRknCJkmibXf2lb6xGqCIlKHetqPEvNjwqbzo+tVFE0eZUzGqMifnaSt288Y1rGV/R/3M1YvY5ed0+27n/Hti6Gz8hCooSElXMg6Y/UQIT6LhxLf0eFiwwelvYnVCXA1slUqL3C71mCgpMrkmLMXr0aEPsdkSULFrtlMOvbZYBR4nsc3lf1dejvfSNecI7KzPSR2dXX8xb4YqmgD0niOR39y/OUP6cly2yyxiR3VxfZ0JaQVFCLNVe3h877bSTUUqK1uSxQKjLgc3bgiCIhijBnbNO3wwYMCAqlTXBVODoc27RokWq7DwQVm90yoyZzTJuhlPe+d712JaKeHn5S9+t1xe2iJLBfUQy0qyfvgEjBzgCMruaG6YdtXfb+7bDKIcUv++QHx92SGKCPY4DiTwUJcSylTex7isxRxQwgIeK5ORkGTRokBGJiuQsy6iQQodeq/tJvH0lSCG2l+rCpHL/vK9Zhp/glOc+heDwfP7Vr1q/Bs3CKmvslbrxngNnScvEfD5TNy1z3cCz/H9T2t8uzM3RNjgTa0NRQizbo8RXpCRWfCW4oGtREo6IghZ4KAlG35BIYRc/SbC+koffccqQ45zywFuuCeZA90xXSkK3isfcLyvWew7guj9JW5U3VmSEaaJmf5GSpWtdP2DK+MjPaExiE4oSYolISa9evYymX/4G2aysLCNSgkHdzpSWloY1omCOOkXS7GqXyptgRQlaolfVuGfwveYkkZWvOuTKExxy/L7u9V77uq1OrvYZtJFm6tejbVHyqene4JBd7bNvxNpQlJCosXXrVikuLm43dQNgSNxxxx3VclFRkaxdG2D/6y5WeeMr6hRJX0m49yucomTu3Ll+1ztiT5dB88IjRFa84pBbzoyTbpmugfiovdzrvfqVp1hesNJ+lTfeKZzScpHN21rfBHz6m9OjXT4hoYCihFg+dROLvpJwVd5EuwLHbumbfv36GZM+thUpQe8OdF29/6K4VmmKgb1Fthtaa6RrFppKgHWkBG3kzT4NO9BWZ9eaOqfM+su13LeHyBibCS5iXShKiOVNrrHoKwlX5U20e5WY0zfhEFuhBqZLHS3BLNRoOe8PzOrrj4N3qm4VLUHTMT2YQ5AkJdorxWGuwPHu7PrdXJFaV3shmb4jJ9cjoYOihFi6R4k/URJLkZJwiJK8vDzJycmJWqQEHiHM8mwHzCmc+fPnd2gbB+1YpZqH6SocVRq9TqS+wZ6pG2CO7Cz2qsD59Fdz6sZeYotYG4oSYvkeJRrMoqvvvmfPnm10grUj4U7fmCfmwxw7kWg4h/+hJ7azQ+omlJ1de3Rrlr0mupbRTGz2UvuaXANJ32iTK9rh7Lt9ZN8XiW0oSkjURQmaWAXap0P7Smpra8M6X0mk0jeIaOiqolBjFnpLly6VcGM3k6uvOXDaMru2x9H7uJdf+dIp880mV+tnsloBrwgqjbzTN4VF7rTUzqPFMPwSEgooSkhUQPdMPYgNHz7c6EDaFXwlEFS6d0g4B+9Im13tKkrGjBljNPTqjNA9fIrL0KpLg9GCXWPH9A3MvbpfycqNInX1LpH12W/udabvSEFCQgtFCYkKq1atMtp6B5K6iaUKHOy77rMSTjNopHuV2K3yRpOWlibDhg1TywsXLpTGxpbuaEGSmy2yv6tqXdaViHzSoplTk0UG9RZbMrJl6qKmJpEVG3z5SaL0xkjMQlFCbFF5Yw61JyUl2TpSEu7Km2j1KrFb4zRfvhJEscz7ESzHTnVHDrTJFeWybVXuWJkR/T0rcFBR9OWfrr8xud52w6P33khsQlFCbNGjxDyvy3bbueZAX7ZsmZprxW5EKs2BKExCQoJaZvomMr6Sf+wmkuLSzLZO3fgzu/68QKSipfp5vx1cKR5CQglFCbFVpMTbV/Lbb6YEt00Id+WNBvPp6DQKjK7hnphP7xemC9DlyF2pAgdkpTvkoF08H7Nj5Y13+kZPzOfZxdW++0WsC0UJsUU5cCz5SiKVvjEfW6Ql1qxpYw76ToLybL19CCG7zQQbKlECjjOlcOxaeaMZ1s8zUmKe7waREkJCDUUJiWr6pm/fvpKRkRHUa61WgVNXVycXX3yxXHTRRR6Cw5umpia599575csvvzRKoXv3Dq8DMlJm19WrVxuRGLv5SUBBQYFkZmaGRJQcuItIRmpspG/SUhxS0Mu1PHe5yF/LXMvwkvTMsZfwJPaAooREHLTy1l6QYFM3YODAgZKfn2+IknCnJdrj5Zdflvvuu0/uv/9+tT/nn3++bNy4sVVkaI899pB//etfKmoB9t13XzXRYDgJtdkV0RCIsFgpB/bVbh77iMkiO0pqskPO/odreYeRIn3yxNZoX4luKw9YdUPCBUUJsXx7eV8DiI6WbNu2TRleo4k5hYQy54cfflgNzFdffbWUlJTI7bffLhMnTpSffvrJWO+CCy6QV155JezvLVS9SlDCjGjQoEGD5PjjjzfKuTXmihU7lQP7M7t2tN285vZzHPL74w759gGH7VJZ3uheJWbYn4SEC4oSEnEWLVrUYT+JFX0lf/3VMl2qiDHfS01Njdx2221qDpirrrrKiC5gwP7uu+/kgQceCDptFc2J+RAJwo/e36eeeiqmIiWh9pWgBHjySIeKmtidkQWe+5CVLrLzmKi9HRLjUJSQiIMGVeZumh3BKr4SNNrSd9VowAVPCbwlupeKTi3hbvmSSy5R5aZTpkyJ2PtDFQzmDOpMpOSjjz6SSy+91OOxm266yWM+HYqS2MU7UoK5bhIT7C+2iDWhKCERxyxKxo4d26Ft7LDDDkZYPJplwYg+aI8IUjTwusDMihLc0047TfUJwT4idXP33Xer7qGRRqdw4HMpLy8P6rUQXMcee6whrrSXBxPv3XPPPa3SNzDv9unTR+yI+VzsTK+SWMNcFgxYCkzCCUUJiTgLFiwwJqPTg1ywYBI7nZpAqN2X+TISzJkzx1ieNGmSRzUHUhwVFRXq/ZnTTZGmoxU4EB4HH3ywERE56qij5JtvvjHmKbrjjjukuLhYCRa0ztd9V8Jt3g0XqL7RqSeco6iWIiK9c0UyTVpat9InJBzY8+pBbEtpaakUFRV1KnWj2X5715zpMF1qoRNNP4lZlGgQOYi20bEjFTiI/hx22GFG75HJkyfLs88+qwTOMcccox6DWPnvf/+rJhfUotCufhJvX0l1dXWb5d1dCZy/WojsOVFkQE+mbkj4oCghtvOTeIsS8OefLRNyRDFSgvSNFQk2UoJKG6SetIG4X79+8v777xupJ3hmtKH30Ucflc8++8x4bayIklCYXWOJ565xyCd3OuTdWyhISHihKCERJZZECQZvHSlBlQ1+rC5K/v7773bXf/XVV41yZYiPDz74wKPJG4yzMO3qKNVll11m+3JgX6KEvhLPJmrwknTLpCghFhIla9eulWuvvVb+8Y9/yKmnnipfffWVx/MI4aInA/LQxx13nHz++edBPU9in1CKEqRLdGokGqJk3bp1Kh1l5SiJbjanoxyzZ88OqNpG8/TTT/vcN1Tj6KqesrKymImUmHuVMFJCiMVFCUK1e++9tzz22GNywgknyI033ugxyDz44IPqb1QfnH766aps0Hxn1t7zXQncYf78888qd92VCKUogTFx+PDhRpUI5l+xkp/EKsCYCk+IbgcPA2tb6LQN/DD/93//5/fY33DDDa0et7soQXM4nZqKxMzKhJBOiBKY2tAaG6Fc/B49erRhMIRTHXlntNhGCBfPQ8C89957AT3f1UDEadddd1VliNr42RXQ50vPnj1V9U1n0SkcCJJIm13NosTKkRJgrv5pq68LpgDQPUe22247NdOwP8466ywPEQLxg6ojO4PKobfffluJ52iZpwnpygQlSsxVBLjjQhmgzsGiB0JVVZUSKuY7YfRrCOT5rsZrr72mfuMYosoBHUBjHbRcx08ooiQaHQGIRgrHXzmwFTE3m2urA65ZsLRXxowGcTNnzjT+HjBggNE0zs7st99+6jqFHjOEkMgS9LcO7bFxJ4FywH/+858yatQo9bjuZWBunY0Qr368ved9gbtf75A8LhSdufDpJlDRnMQNd6PmaeQxEMCj89JLL0WlfDRSx8Q8nwgu+qH4f2Yx8Mcff6i0YKSOiY6U4JxG2D/aEwO2xY47uptLtDWJoVmwoEGd93rex+Xwww+XadOmyRdffKH6mFj5GIQLK1xTrAaPCY+JLwLpYRS0KDnjjDOUSRWToMETolM5yD8D3PFrUx38Eqmprjm823veF88884w88cQTHo/hwnf00UdLZ4FpN1pg7hNfkRNUb6DcMlqE+5h8//33xjL2tbCwsNPbzM3NVUIOlTDw6IRim4EcE5g79f9CH5Bonk+Bgu8qIpYQJejBoZugmZk1a5axjFJgf8fTvL/wimG7/fv3D/nxtxN2OAciDY8Jj4kZ3LyFXJRAROAHfgDcIf3www9KlPTt21dFMJCPHjdunFoXy/pNtPe8LxA9gKE21JESfFFwAY1W50lUbWjQwhuCBIMqJjzD3SlEXySJ1DExe2cw/0uo/Acwu6L/Bn4w8IYihdDeMUFnU3Oaww5eCniY3nrrLZVGxQ2Bd4t/7LOOZkE07rLLLq0id/6Oi91LgTuDFa4pVoPHhMekowQsSjBnBtILEAlo8Q1PCe58dXdHGOJgXEUJ4a233qoGXjRVwnIgz/sCg0u4ctS4eETrAmIuy0QFA3wRutcD0g8wD0ajLXm4j4l5dmAI01D9L5hdIUiQ6sP/gEEz3MfEXC6KFJIdBiOcUxAler4gc08OgGOoy3uxrq9IihW+P1aFx4THhOdJ5wn4qoK8OcQI0ie4y8Xguc8++3ikUi6//HLVnnqvvfaSGTNmKAFjHlzbe76rAO8DQOkh7vLRiAppMd3L5dBDD425MDgiQbocGBO2de/ePWTbjkYTNbuUAwdTgWN+zGyMJYQQy0VKcBcAEYEfCAvtETHTrVs3eeSRR9TzSLN4u9fbe74rYDa5YjDTd6MPPfSQSmchLYBJzi6++GJ55513JFZAb4wtW7aEtPLGXwXOmWeeKZGqvME5HOr9CReIIOF8Q3m+rwoc82Nd8WaBEBJ9OhR/9SVIvJ9vS3C093wsY76TNw+mSFO9+eabRu8OdMuNpVlKQ9k0LdqdXSGqdSoKVUTJycliB2Aw1x1L8XlgBmNfkRLcgJjPTUIIiRRMCkcY86BpTjuAnJwc2XPPPdUyBgyzB8PuhFOUmDu7wusR7s6u5mntrd40zRudlkE67ffffzceh/lV+2RggDWX7hNCSKSgKLGQKAGoeNCgxDVWCKco8e7sav5fXb1pWqC+EpyXurcE/SSEkGhBURIlUaJNrm2Jkp9++klihUiJkkikcOxocm2vsyv9JIQQK0BREkFg9NRVNWaTqxnzfCOxEikxV96glwOquMIpSnR1UyQiJeZZZe3AsGHDjMonRErw2ehlDSMlhJBoQVFiodSNNgHrPhuYF0hXrNgZdPvctm2bWg5XpYo5YhGKSAk6m95yyy2tpq+Hl2Tu3LlqGY3/UFFmJ2Bi1S3nURGlRbKOlEAw6qkjCCEk0lCUWEyUeKdw2po8zS6YZ1sNlyjBYIp27501u8JXgekT0KX4qaeekt13310+//xz43mUbcMUakeTqz9fCRoZbtiwQf2NjsJsikYIiRYUJRYUJWgHromFFE64/SShMruimylmbL7xxhuNtAYEyMEHHyyvv/667f0k/nwlZuHL1A0hJJpQlETJ5Krv6n0RaxU4kRYlHUnh4D0iSvDBBx+ov9H3RM8N09DQoOYoeuyxxzz8JHaNlHjPGGz2k7BpGiEkmlCURAh4QzBfkB7M2ppXBLOz4kfPUWL3JmpmUYJmY1YTJW+88YaKEGDmawAj6EcffSRvv/22nHbaaeoxRE7OOeccefzxx20fKcHMyjC86nmYzLNWM1JCCIkmFCUWS914R0sqKys9PBl2A4O5bgI3cODAsDbl6ojZ9ZVXXlHzN5l9Injt/vvvr7oOQ4RcccUVxvqlpaXGwI6Zr+2KjohgriUIX23czc/Pj/I7I4R0ZShKLC5K7J7CgYkSM0yDcM8RA7OrubMr0i7tcf/99xvLJ554ovz4449qcNYgjXP77berH3+t7e2Ir4gIoySEkGhDURLlOW/8EStN1CLlJ/EWfIgAtGd2RVps/vz5RhTn+eefV/PD+ALRkieffNKoTJk+fbrYGV/eEfpJCCHRhqLEYiZX8504Jumze6QkEuXAZsyCr70mauby3kAiH6effrryYLz22mty4YUXip0ZP358q4k1GSkhhEQbihKLmVw1mHlW3/UvX75cSkpKxI5EK1ISiCjRTdCC6cyK9eBB0YLRrqBrsPlYYX/satwlhMQOFCURAHfXwfhJYqmJmhYliEJEolMouuHqiEc4REksYY6MQCxDCBNCSDRJiOp/7yIEa3L1Z3Y95JBDxKogDYL9REpk5cqV6mfVqlWGIBs8eLBfv0YoyczMlJEjR8rff/+tzK7wlvgbbGOh50hnMHtImLohhFgBihIbiRIrgcqW33//Xb766iv58ssv1ftrq9olkqkB+EogSvB+IEzQFK2tSEl2drYUFBRIVwMid7fddpO1a9fK+eefH+23QwghFCWRFCWIFOAuPlDQB2PAgAGyZs0a1UuisbFR9c6Idonvv/71L/nss8+koqKi3fX79Okj48aNk//85z8SKSBCXnjhBSOF40uUwOeDfdGpGzuX93YUGF1/+OEH1UumK+4/IcR6MFISZtBsC2mMYEyu3tESiJLq6mpVvhptM+LNN98sb775ZqvHhwwZIvvss4+q6kCqBj+IPqSmpkb8PZorcBDNOffcc1ut09X9JGYoSAghVoGixKImV7MoQQkqQIok2qLk22+/Vb8hrlCFMnXqVPWDPh9WQYs/9CHxZ3alKCGEEOvB6pswYx4UOypKrNJEDVGfJUuWGPvy8ssvq94dVhIkANEZPZkeqn8QZWpLlHRFkyshhFgRipIw09nJzjBg6iZX0Ta7msuSzWLJiugUTnNzs/z1119+K28QUYlE/xRCCCHtQ1ESRlD98f3336vlXr16BdTJ1Rs0tdIRFpTZFhcXS7Qwi6Jdd91VrIzZ3OqdwqmvrzcmCcRn4t3ZlBBCSHSgKAlz1Q1m+QV77bVXhw2FVikNNv9vu0RKtNnVzOLFi43yZaZuCCHEOlCUhJFvvvnGWN577707vB0r+EpgGv3111+NUuX+/fuLlUEZsm4F7x0pMTdN6+qVN4QQYiUoSsLIrFmzQiJKdt99d5/bjCQwjOqoj9WjJACCRAsOmHPLysqM51h5Qwgh1oSiJEzAt4DGVDqyMHTo0A5vKz8/X0aPHm2khMrLyyXS2Cl148tXYi7NZuUNIYRYE4qSMAEfgy5F7YyfxDvSgjSKNs9GEnPayC6ixJevBN1LdfqmZ8+e6ocQQog1oCixuJ/E1zaikcLRkRKkRTATrx3wVYGzYcMG1WIe0ORKCCHWgqLE4n4SzZ577ulT8ESCzZs3y7Jly9QyypPtMsU95hnSMxPrSAn9JIQQYl0oSsJAXV2d/Pjjj2oZE+oNGjSo09vMy8tTFSUAzcC2bdsmkcJOTdPMYPJCHdVZvXq1ElesvCGEEOtCURIGUDpbW1sbMj+Jd8QFXUrNnWLDjR1Nrr58JUjh0ORKCCHWhaLEBn6SaPtK7CxKvH0lWpQgBTV8+PAovjNCCCHeUJTYSJTsscceRtQlUr6SxsZG+e2339QyGqahvNmukRLMcLx06VK1jAn7kN4hhBBiHShKQgzSNtqDAS9JQUFByLadk5NjNATDHT9m7Q03CxYskKqqKltGSQD6w2RnZ6vlr776SpUEA1beEEKI9aAoCUOqA0ZX7ScJNTrygsEVd/7hxo79SczExcUZExpqQQLYXp4QQqwHRYlNUje+thmqFM7jjz8uV199taxdu9bWMwMH4ivRUJQQQoj1YFLdZqJkypQp6u4fFTihMLt+9tlncu6556pllMtChHTv3r2VKElJSbFtysPsK9FQlBBCiPVgpCSEoK28nkkXXoZ+/fpJqOnWrZtMmjRJLc+fP19KSko6vK2Ghga5+OKLjb8xcd3RRx+tHgfFxcWyYsUKtYwUiJ511+6RkoEDBxo+E0IIIdaBoiTE/gs9oIfDT+IrAtMZX8mDDz4oixcv9njsyy+/lAsvvFD5L+zaNM0bNLBD8zmNXSM+hBAS61CU2Ch1E0pfyaZNm+Tf//63WkaZ8Y033mhEQh577DG5//77bd2fxAz2z5zCYeqGEEKsCUVJG1RWVsoHH3wgZWVllhIlu+++u8THx6vljvpKrr32WikvL1fLp556qpxyyinK8Kq55JJL5Pnnn48JUQJ23nlnY1lX4xBCCLEWFCVtcPbZZ8s//vEPNedMYWFhuwJGT/o2YsQI6d27t4SLrKwsY2BdtGiRinoEAzqbPv3008a2brnlFrV80kknKbECYKTFjLoAvVbCuT+R4Pzzz5fp06cr8XXggQdG++0QQgjxAUWJH+Cp+Pjjj9UySmWnTp0qGzdu9LlufX29nH766ar7abj9JJ1tOQ+x8c9//tPo2YEUTn5+vvH8TTfdJEceeaTHa+xaCmwGnpJPPvlEnn32WSPKRAghxFpQlPgB0QfzTLyoQpk2bZps2bKlVYTkkEMOkddff139jdblECjhpqO+kpdeesnwiowaNUouuOACj+dRbvzcc895pDhiQZQQQgixPhQlfvj7779bPbZw4UKVAtBeDLR5h1D5/PPP1d+pqany3nvv+WzWFWp22203Y+6WQCMlFRUVcuWVVxp/33vvvZKYmNhqvbS0NHn//fdVmuOggw5SnhNCCCEk3FCU+AFeDc3ll19ueCrgxzj44INl2bJlaoI8XTaLvhcQJ5HyK2RkZBjiB/1FtP+jLWbOnGmkoA499FDZb7/9/K7bp08f+eijj+TDDz+U9PT0EL5zQgghxDcUJQFESpCeQf+O3Nxc9ff333+vUh+InIBevXrJd999p6piIok5hYP31xbwvTz00ENqGaW/d999d9jfHyGEEBIMFCUBiBIIkNGjR6uW7KhWAU1NTer34MGD5YcffpDx48dLpDFHOrQp1x94j0jfgKOOOkqGDBkS9vdHCCGEBANFSTvpG1Rt6G6gMH8ipQHvCECpMAb7aA3wMKDqdukQTLr6xxd43xqknwghhBCrQVHiA1TdFBUVqWVESMwgRYO0DapY0FY+mv07YFLdf//9jfds7sDqT5Sguka/hhBCCLESFCUBpG68GTRokBx//PHKbBptUB3jKxpiBuXMMMPq6Ip5FmBCCCHEKlCUtFN540uUWAmUKGNul7Z8JebHzSKGEEIIsRIUJe1ESrzTN1YD3Vh1afD8+fNlzZo1rdYxR1AoSgghhFgVipIOpG+shlloeEdLqqqqjOZq/fr1k7Fjx0b8/RFCCCGBQFHSRvomMzNT+vbtK3YWJV9//bXU1dUZ6+lUDyGEEGI1KEq8qK6uNmYERpTEDoP4pEmTpGfPnmr5q6++ktraWuM5pm4IIYTYBYoSL1ClomfQtUPqRpf56vb2EFU6XYP90KIkOTlZ9tlnn6i+T0IIIaQtKEpsXHnTXgpnwYIFsm7dOrW81157cQ4bQgghlsZ2ouTTTz8N6/btVHljZt999zVmDUZ0xBwlAay6IYQQYnVsJ0qOPPJIaWhoCNv27VZ5o0G7+SlTpqjllStXqjQURQkhhBA7YTtRghLX2bNnhz19Aw8GOrfaCXM0RLfBByNGjFATBxJCCCFWxnaiBHz77bdh2S4iMMuXLzcG8vj4eLGrKLnrrrukubm51eOEEEKIVbGlKPnuu+/Csl0IEj3Trp1SNxoIKR3dMZcFU5QQQgixA7YUJd9//700NTWFfLt29ZNo0FPFW4CgARxmNiaEEEJiSpSgxPTyyy+XI444Qi666CKZN29eq/THvffeK4cffriccsopRr+MQJ8PlPLycpk7d25Qr6mvr5c33nhDvfdLL71UKisr2ywHtlPljRlvUTJt2jRJSkqK2vshhBBCQi5KMIjffffdqkkXfk+YMEEuuOAC2bRpk7HOQw89JL/99pv897//lWOOOUauu+46VQUS6PPhSOEsXbpUCSnM+3L00UfLu+++K++8847ccsstMRcp0f1IUlNTjb+ZuiGEEBJzoiQ9PV2efvpp2XvvvWXgwIFy2mmnSW5urhEtQTrlvffek3/+858qygDxsueeeyoREMjzoTa7fv7552qAhs8Cps+SkhKP5x955BHZtm2bT1GCDqnDhg0TO5KSkiLTp09Xy+hbcsABB0T7LRFCCCGhFSXwK5jngamoqFBREkQgwMaNG9VjY8aMMdYZN26cEQlp7/lA6d69uxEp0dUl3qCL6cEHH+whXBITE1V0RkcO8F4QudFgW4sXL1bLQ4YMUSXBdgWRrFNPPVVeeOEF6d27d7TfDiGEEBIQrhagQYJuoUh/7LbbbkaaQ3s0MjIyPEyW+vH2nvfnA8GPGfzPDz/8UEpLS5XHZezYsa1ehx4dusEaIh5nnXWWnHTSSdKjRw9ZtmyZfPLJJ0qEwN8Cb0xaWpqsWrVKampq1GuwT/4Ejx0oKCiQJ598Ui0Hsh96HTvvc6jhMeFx4bnC7w+vKaEFWYiwiJLbb79dRUkefvhhj7QBwMCOQV5PDqcfb+95XzzzzDPyxBNPeDzWq1cvYxneEAgbb8GENJPm8ccfV4O0nv0Xpk9ESz744APZvHmz3HnnnTJjxgyPqEqfPn2MmYK7EmvXro32W7AcPCY8LjxX+P3hNSU0BNKQNGhRAn8GIhTwZJgNlRjIkSJBi3MdvcAyBEEgz/sCKYgTTjjB4zF4WHT7dLwP79ejKgfmVrDLLrvIHnvs0eoO+JxzzlGiRAufq6++WrZs2WKss9NOO7X5vmINHBMMvv379w9IyXYFeEx4XHiu8PvDa0rkCUqU3H///fLnn3/Ko48+2ipCgQgEjKvPPfec3HrrrbJhwwZlNv3Pf/4T0PO+wGu8y1l33HFH9b/hCUG/Em+vy8svv2wsI2Xja5BFegbREogbDMavvvqq4ScBEE1dcXDGPnfF/W4LHhMeF54r/P7wmhI5Ah6BioqK5Pnnn5fi4mI57rjjVPUMfszVMyi9RcQB4gProB+JuXFXe88HAipK9GuQQtJREV3ho0UJ1kMJsD+uuuoqY/m2225TURfNyJEjg3pPhBBCCIlgpAQmUfOssxpzxAQlwvBzlJWVqeoVb79Ie88HCkQNzKoAXhCU/YJvvvlGRWAABBP+nz923XVXldpBFY+5AggpDLMZlxBCCCEWi5RgcrqePXu2+tGmVTPZ2dltCo72nm8Ps0/E3EQNJbDm1E17XHPNNa0es2snV0IIIcTu2NJAMHnyZEMMIVKCipuqqip5++23DdGDPiXtsd9++8mkSZM8HrNrJ1dCCCHE7thSlKCKB+kX3Sht9erVqlus7nly1FFHBRSJgUEWlTdmKEoIIYSQ6GBLUeKdwkG05MUXXzT+PvHEEwPeDsy2w4cPN/6mKCGEEEKig21FCcyuGsz+i/JiMGDAAJkyZYoE45W55557VLXOdtttJzvvvHNY3i8hhBBCwtDR1QqgXwkqeOrq6uTjjz82HkeztWB7baBSB31PkBaCSCGEEEJI5LFtpASeEXRe9SaY1I339ihICCGEkOhhW1HincIBSL+wpJcQQgixJzElSgLpTUIIIYQQa2JrUQJTKgyqAD6SY489NtpviRBCCCFdUZSkp6cb0ZHTTjtNevXqFe23RAghhJCuKErAU089JWvWrJHHH3882m+FEEIIIV2xJNjclRWT6BFCCCHE3tg+UkIIIYSQ2ICihBBCCCGWgKKEEEIIIZaAooQQQgghloCihBBCCCGWgKKEEEIIIZaAooQQQgghloCihBBCCCGWgKKEEEIIIZaAooQQQgghloCihBBCCCGWgKKEEEIIIZaAooQQQgghloCihBBCCCGWwOF0Op3RfhOEEEIIIYyUEEIIIcQSUJQQQgghxBJQlBBCCCHEElCUEEIIIcQSUJQQQgghxBJQlBBCCCHEElCUEEIIIcQSUJQQQgghxBIkiE15+eWXZc6cOWp58uTJcvTRR3s839TUJO+9957Mnz9fsrOz5ZhjjpHevXsbz7/44osyb9484+/ExES55ZZbWv2fxsZGmTlzpvTs2VPOPvtssTLfffedfPjhh2q5V69ecskll/hc5/vvv5e4uDj5xz/+IWPGjDGemzVrlnz88cce62Mb2FYgz1uRFStWyGOPPWb8jc8yIcHztP/777/VflVUVMhee+2lfjTLly+Xxx9/3GN9nGs45zTNzc3yySefyO+//y59+/aVE088UVJTU8Wq4Jy+5pprjL9xXg8ZMsRjneLiYnnjjTekqKhIxo0bJ4cffrhx3Orq6uT666/3WH/nnXdW64C//vpLXnnllVb/96yzzpKhQ4eKVfnf//6n9hccfPDBsscee3g8X1NTI6+//ro6p/r16yfHH3+8ZGRkGM/fdddd6rhpsM4///lP4+/q6mp566231DnVrVs3Oeyww2TQoEFiZd5880357bff1PL48ePVuW0GvTdxzZk9e7ZkZmbKUUcdJf379zeex/H6448/PF5z2223qetPIK+3Ir/88ou8/fbbajknJ0euuuqqVuv8/PPP6nqJa8NBBx0kEydO9Hge36F33nlHFi1aJKNHj1b7HR8fbzy/ZMkSeffdd6W2tlb23Xdf2W233aSrYNtICb4g++23nzQ0NKgP1pubbrpJfaFwMtTX18upp54q27ZtM56HIIFYwTbwgw/eFy+88II6Cf/880+xOgUFBWpfIKDwnr159dVXlfAaNmyY5Ofny/nnny8LFiwwnl+9erVUVlYaxwQ/5otue89bEVw08D633357+frrr5VYNYMBFINlVlaWjB07Vm6//XZ1MdBs2bJFFi9e7LHPEB7e59pLL72kBB7E7a233ipWBgOC3pdff/1Vtm7d6vF8aWmpnHDCCer7ssMOO6hBAwOJBscQx3KfffYxtoMLqwbi33y8Bg4cKD/++KOlxSvYdddd1ftdt26dFBYWejyHfT7nnHPUAItjsmzZMjn33HM9zicMRMOHDzf2e5dddvHYxsUXX6xuCvB6DMYnn3yy+l9WBuc09gXnjPkmTnPHHXfIc889JxMmTBCHwyGnnXaahzDDtRkC3Xw+YL1AX29FIDaxHwMGDFDntTfvv/++XHfddeq8x7r/+te/PMYPnDM4d3AubLfddmp/n3jiCeP5lStXyhlnnCHp6enqZgE3EBA4XQXbRkowgOAHg6pZbABcZD/66CMlSnBi6AEVf+PD1owYMcKvGAG4YOAOGHfGP/30k9hBlOAHJz0GG28QHcKF8YADDjDu/J5++ml1h2geUNo6Ju09bzW6d++u3u/atWv9Rtxwx3rmmWca6999991y6KGHGhdPCC9/+4xIHC5MiMqlpaWpx8rLy8XKYIDR++NLQEGE4GJ67bXXqr932mknFTnAd8csLPbee29JTk5u9XqsY14Pd9pY1+oCFtEegM/SG4hXXEM+++wzSUlJUd8hnCMYWLBvGkTQvO+KQVlZmYoGQPDi2AJcu3DzcOSRR4pVGTVqlPpBdAg/ZnD9QOQHogLrgPXr16ubH3OECNExX9+fQF9vNfD54QfnPs4HX9fZ8847T4444ggjMvnkk0+qGyOAqCxulJ966injGmO+ZrzyyisqWnvBBRcYj2FdcwQ3lrFtpKQtcHcLzHe0WNbpHs2XX36pwtBQqd53iwB3h/hyJCUlSSyAO2DzMenTp4/MnTvXY52FCxeqY3L//ffLqlWrWm2jvefteK54nye4c9mwYYPx2ObNm+Xf//63Cs8jRWMGEQOE+TGQ33DDDeoCa/fzxfuYIKqG1I339wdRJUTecJH1N4UWwtRffPGFEjV2BudAbm6uEiQAxwMRSe9jgogZzhWIXYTeNbjrRWR206ZN6m9EeHGc8R208/UE6Qnva4r3Mfn222/VNQNpVBzHYF8fC9cURJmwr0BHGSFU/vOf/6hUkFmwz5s3T90ImMUy0jn4LnUFYlKUQMXi4qFDa7g4IHxmFh4nnXSSukPBh48P/Nhjj1VfEg0iJNjG7rvvLrEC7lj0McEggnAz7uB0CBpKHHfDyF/iLgb5Y0QCNO09b0eQysJx0IOqPj76XMHzV1xxhdpn5Lwvu+wydXenwZ0d7pYh1hCWR0TNynd5gYB9RmQAHggAIYZBVEckcYcIwY50x+DBg+XRRx9VKSxfYEBCBGnHHXcUu393IFQRLQEQrkjhmK8pl19+uey///4qUgIhhu8K7pK1iIGovfnmm9X5gejrIYccoo6hXYEow3dCf2dwjuBcMUeusZ+4tuI6i2OHv7VvJ5DX2/06C7AMQaG/T7hmvPbaa+pvpK0QGTJHLLdt26Y8RxpEbyFocK3uCtg2fdMWEBMYPHDnCpMeTgJ8AcxGIjyOH4C7OOQyEVrFb4TSHnnkEQ+DZCyA3CaOC8LIVVVV6mSHQtfHBakune6aPn26Ci0+//zzcueddwb0vB3B5w2vwHHHHad8JRg8sF+4q9WeFHPoGXc9ODd0aBaCDscRdzxauE2bNk0NWBjc7Qg+W4hymO8gOnB3i7Qdjg/A+WI+JvBOQOAjZN2jRw+PbSGCdOCBBxrGRjsPNDhH4E3DdWPNmjXKpKrPE3P6Rx9DGMkxIO25555KnMAwje3gHME1CUZHLFvZ/NsW+K5AsGNA/eCDD5TYwHUWNywaeI203wjXWZwjEPXwswXyejty0UUXqR/cqCBNg3MEXjOd3sU1A55IrANGjhyp/EWXXnqpGrvw/dJiVos14G3Qj1Vidi/hE8DFEk53GJIweLb1oWKw1aFF3PnipLjnnnsMbwnujPAFgjHLrkyaNMlwfGOAgYETxlV/YEBCZUpHn7cDuAjiTgXHBBcLXBRQjWKu1DKDgQgRNURWIF4QbjZfQHDnhx9z1M1u4Hvy4IMPqvMD+wGzI/wT8Cv5At8vvAbfH7Mowd/wNuFiGwtgEMF1Bf4kDCS4Hvg7JjiPcA7pawpuBJYuXSqff/65cROAMD/OPZgi7Qq8NYgQYt/wXUAqoq07ei1yO/p6OwARpq+zECIYP0pKSgxhjhsbc9oO54mOhKS0nDcbN240nscyHjdHT2IZe9++tAHCgLhAIuwOpYmLAe78ANTrDz/8YKyLECwMZ1rRw5CEUlftFochVldx2BkY63BBxB0dvhTIfyO0qkGuU6cxcIwQgtYGtECetyMYYHCRhGBD2B3GX3P5K+50zd4ARBAwIGmDGvwkZrM1LkQQet4ltnYCIgvpTny2+P6grBODiS4fR8oOF1kNvlvw0XgP0DCb4zX+Bm67gWsE9gUpXQg2VOggIgIQ+cBjGkTKcEOkvx/wlCACYBareI3Vzb/tgWokDJZIQ+E7g4gH2i9ovvrqK2MZEWi0IzBfM9p7vR3BNQAiAylL3Ozihti8T1OmTFHmbx0BwTUG4wu8WwDfOVxn9M0OjNd4zO7RxpiPlOBkh/MZX3x8uLhrwYeNPC1A/hdGPAgT3M2jBAsXVoAPFx/0Aw88oE4EDCr40BFmBlCq5jtlRElwAbF61Qm8MXBp4/3CUIdjgjt77DtAJABeGuwbLqCoGkAO3Hwhve+++9SFF057HDtzb5b2nrciSFMhtaKFBe5KMYDqnjTwR6AiCRdGCBQcG/M+4fW4oKB3Ao4pcsPwBmhwlzd16lS1DspBcS7BM5CXlydWBhE/iDHktZFWgPDAcYBYxfcDhl2kLyGwsI6OGgKEohF+xzHDhRMljDAy6vC0WZTYaYDRvY9w1w7RBfGFtJT2wyDqg2sG7lrhj4ChVYsKlL3eeOONSqzjMbwWIXl9owNxhvMENwGoGsT1CdctvMbK4OYNJa4wteO7gGsKjoeuGEK0Bz4RVFthMD7llFM8ysO/+eYb5TnC9wrpDIh/3c8mkNdbEXz2Dz/8sHrvuKHFMUH0Q6dj8P1BWhhRWFwz4adBpFGDaBtKfHGTjO8bxiecB/pG59hjj1XP47jgXMK5aC4ZjnUcTn+2eYuDEwOCxDuMjIFBgy8+Lpi4s/U1SGAbWAev02V6vsBghYFel3RZFXxJYFA0g4HD3OgLd/QYOLHP+PFGG/ggOOCJMPcUCOR5q4ELP8yWZhAtMpdxQrBgMELu1xwF0aCpGi6ouEDg/PJVXYNzETlx+AOs3o8DwJCrjXcaRND0IIs7PVQB6Pw3hIgZiDMcE1w+cEyQsvJ13HEH7C1WrAq+F9qEqcEAaQ6143PGIAFfiXeUA8cMNwYIw+M88HfNQTgf6VNs2+o+AVz7sE9mMACbox04ZjguOA/03b4Z+G+wHVxjfUXN2nu91cA11LshHM5/c8UMokIQpjh3fDXIw/cG5xtEP6458KWZaWxsVJWR+J5ByFm5GWOosa0oIYQQQkhs0TWSVIQQQgixPBQlhBBCCLEEFCWEEEIIsQQUJYQQQgixBBQlhBBCCLEEFCWEEEIIsQTWLpInhJAgQO8U9AFBB9VYmkyTkK4CRQkhJCDQ4AqdfAGaqWH6dTO69ToIpyhAd2U0ngLokmpuQIa5U9CtWbeDJ4TYC4oSQkjAUzuY211jSgNMvQ7Qg/Gaa65R3TsBuneGSxRgcjs9KzM6xnp3kyWE2BeKEkJIh8AMt1qUYKI1LUj8gSkdEG1BO3bMQ+U9zYE59YK5qLAuZkhF1EO3J8f8KDpKoieJxFw0mJvIe84UCCVf2yCEWBeKEkJI0GDuIwgCzFuCuX4wmZ1+3DyDMMBEbpi8DpOzQYxg7iCkehDluPnmm9WcQ+bUS25urhIQWA9zjGD+HUwqiUnOMFmeeTZeTBiH9A3mHTGLEswpgokVfW2DEGJdWH1DCAkazBKLgR6zC2PCNgz8EBJ6Rl0zmK0bggQTrkG8YCp3TDKGSQEhVnxNLHnGGWfIgw8+KMcdd5yKeCBVhAgLZljVM9SCG264QW699Vb1eKDbIIRYF4oSQkjQHHHEEZKcnCzvvvuuPP300+oxDP7eMyxjJuLPPvtMLcMYi6gGpnaHQVWnfSAgzCByosWNTrlgtlRMEx8oodgGISTyUJQQQoKmW7ducuCBB6op2mGAhQg4+OCDW61XXFysIioAaRlNXl6esQzPh/e2NfHx8cZyMBOah2IbhJDIQ1FCCOkQiIxoDj/8cGU49SYrK8sjamL2mfhahxDStaEoIYR0CJhWTz31VJk2bZocffTRPtfJyckxDKjz5s0zHtfLqMDxrsJpD5hXNToKQwiJDVh9QwjpMOeff36761x33XVqPVTrPPDAAyqi8uGHH6r+IjfeeGPQ/3PkyJEqJQNBAvPq2LFj1U/fvn07uBeEEKtAUUIICYghQ4aoqEhbQBzAUGr2jKDq5o033pBPPvlElfQCiBR4UszrjRkzRqV48vPzjcf69Olj/E+dHoJxFVU1qOiBSXbWrFlqOxAlgW6DEGJNHE46vwghhBBiAegpIYQQQogloCghhBBCiCWgKCGEEEKIJaAoIYQQQogloCghhBBCiCWgKCGEEEKIJaAoIYQQQogloCghhBBCiCWgKCGEEEKIJaAoIYQQQogloCghhBBCiCWgKCGEEEKIWIH/B+T0D0dAu20vAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - } - } - ], - "id": "bc8f520d" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's log this model to MLflow.\n", - "\n", - "Tags can live in two places in MLflow 3:\n", - "\n", - "- **Run tags** (`mlflow.set_tags(...)`) – shown on the run page in the UI. This is also where `autolog()` writes its tags (`model_class`, …).\n", - "- **LoggedModel tags** (`log_model(..., tags=...)`) – attached to the logged model entity itself (open the model from the run's **Outputs** / Models view)." - ], - "id": "35dc864c" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.451366Z", - "iopub.status.busy": "2026-06-24T15:18:47.451297Z", - "iopub.status.idle": "2026-06-24T15:18:47.906785Z", - "shell.execute_reply": "2026-06-24T15:18:47.906380Z" - } - }, - "source": [ - "with mlflow.start_run(run_name=\"exponential-smoothing-baseline\") as run:\n", - " model_info = log_model(\n", - " model=model,\n", - " name=\"exponential-smoothing-model\",\n", - " # alternatively, use mlflow.set_tag(key, value) in the run\n", - " tags={\"model_type\": \"ExponentialSmoothing\", \"dataset\": \"AirPassengers\"},\n", - " )\n", - "\n", - " # log calculated metrics you want\n", - " mlflow.log_metric(\"mape\", mape_score)\n", - " mlflow.log_metric(\"rmse\", rmse_score)\n", - "\n", - " print(f\"Run ID: {run.info.run_id}\")\n", - " print(f\"Model URI: {model_info.model_uri}\")" - ], - "execution_count": 8, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "2026/07/23 18:50:08 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] - }, - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] - } - ], - "id": "61406cd9" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load the Model Back\n", - "\n", - "We can load the model from MLflow using its URI:" - ], - "id": "0728690e" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.907880Z", - "iopub.status.busy": "2026-06-24T15:18:47.907802Z", - "iopub.status.idle": "2026-06-24T15:18:47.914695Z", - "shell.execute_reply": "2026-06-24T15:18:47.914326Z" - } - }, - "source": [ - "loaded_model = load_model(model_info.model_uri)\n", - "\n", - "loaded_predictions = loaded_model.predict(n=len(val))\n", - "\n", - "# verify predictions match\n", - "predictions_match = np.allclose(predictions.values(), loaded_predictions.values())\n", - "print(f\"Loaded model predictions match: {predictions_match}\")" - ], - "execution_count": 9, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Loaded model predictions match: True\n" - ] - } - ], - "id": "cae35ffa" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Automatic Logging with `autolog()`\n", - "\n", - "`autolog()` patches darts models and metrics so that the following are logged automatically, with no extra code needed:\n", - "\n", - "- **`fit()`** – model creation parameters and covariate metadata (and the trained model artifact when ``log_models=True``; default ``False``).\n", - "- **Darts metric functions** – any call made inside an active MLflow run.\n", - "- **`backtest()`** – evaluation metrics under `backtest_*` keys.\n", - "- **`historical_forecasts()`** – patched so its internal per-window `fit()` calls don't each spawn their own logging.\n", - "- **PyTorch-based models** – per-epoch `train_loss` / `val_loss` via MLflow's PyTorch autologging (see the section below for details)." - ], - "id": "6bd4597c" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:47.915629Z", - "iopub.status.busy": "2026-06-24T15:18:47.915566Z", - "iopub.status.idle": "2026-06-24T15:18:50.020337Z", - "shell.execute_reply": "2026-06-24T15:18:50.019951Z" - } - }, - "source": [ - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-autolog\") as run:\n", - " auto_model = LinearRegressionModel(lags=12)\n", - " auto_model.fit(train) # autolog logs params and covariate metadata\n", - "\n", - " auto_predictions = auto_model.predict(n=len(val))\n", - " # these metric calls happen inside the run, so they are logged automatically\n", - " auto_mape = metrics.mape(val, auto_predictions)\n", - " auto_rmse = metrics.rmse(val, auto_predictions)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show logged metrics\n", - "logged = mlflow.tracking.MlflowClient().get_run(run.info.run_id).data.metrics\n", - "print(\"Logged metrics:\", {k: round(v, 4) for k, v in sorted(logged.items())})\n", - "\n", - "# plot\n", - "fig, ax = plt.subplots(figsize=(10, 4))\n", - "train[-36:].plot(label=\"Train\", ax=ax)\n", - "val.plot(label=\"Actual\", ax=ax)\n", - "auto_predictions.plot(\n", - " label=f\"Forecast (MAPE {auto_mape:.1f}%, RMSE {auto_rmse:.1f})\", ax=ax\n", - ")\n", - "ax.set_title(\"Linear Regression — autolog run\")\n", - "ax.legend()\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "execution_count": 10, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Logged metrics: {'mape': 10.742, 'rmse': 51.182}\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - } - } - ], - "id": "5ef7f73a" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Open the MLflow UI\n", - "\n", - "To experiment with the runs yourself, open the **MLflow UI** to explore them interactively. Run the command printed below in a separate terminal, then navigate to `http://localhost:5000`.\n", - "\n", - "The UI lets you:\n", - "- **Compare runs** side-by-side in the Experiments table\n", - "- **Inspect** individual run parameters, metrics, and logged artifacts\n", - "- **Visualize** metrics across runs with built-in charts\n", - "- **Register** models to the Model Registry for versioning" - ], - "id": "f484330f" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:50.021527Z", - "iopub.status.busy": "2026-06-24T15:18:50.021439Z", - "iopub.status.idle": "2026-06-24T15:18:50.023116Z", - "shell.execute_reply": "2026-06-24T15:18:50.022824Z" - } - }, - "source": [ - "print(\"Launch the MLflow UI with this command in your terminal:\\n\")\n", - "print(f\" mlflow ui --backend-store-uri {mlflow.get_tracking_uri()}\\n\")\n", - "print(\"Then open: http://localhost:5000\")" - ], - "execution_count": 11, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Launch the MLflow UI with this command in your terminal:\n", - "\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic/mlflow.db\n", - "\n", - "Then open: http://localhost:5000\n" - ] - } - ], - "id": "1a01cd2f" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> 📸 **Try it:** Open the UI, switch to the `darts-quickstart` experiment, and sort the **Table view** by `mape` to instantly see which model performs best. Click any run name to see its parameters, tags, and logged artifacts.\n", - ">\n", - "![Mlflow Overview](./static/images/mlflow_overview.png)" - ], - "id": "88b0d285" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Per-epoch Metrics with Torch Models\n", - "\n", - "For neural models, `autolog()` enables MLflow's PyTorch autologging, which records `train_loss` and `val_loss` at the end of every epoch.\n", - "\n", - "Pass `torch_metrics` to the model to add extra per-epoch metrics (e.g. MAE, MSE). They will appear prefixed as `train_MAE`, `val_MAE`, etc." - ], - "id": "e2b133bc" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:50.024161Z", - "iopub.status.busy": "2026-06-24T15:18:50.024087Z", - "iopub.status.idle": "2026-06-24T15:18:53.370946Z", - "shell.execute_reply": "2026-06-24T15:18:53.370531Z" - } - }, - "source": [ - "from torchmetrics import MeanAbsoluteError, MeanSquaredError, MetricCollection\n", - "\n", - "# per-epoch train_loss / val_loss are logged via MLflow's PyTorch autologging\n", - "autolog()\n", - "\n", - "with mlflow.start_run(run_name=\"nbeats-epoch-metrics\"):\n", - " nbeats = NBEATSModel(\n", - " input_chunk_length=24,\n", - " output_chunk_length=12,\n", - " n_epochs=10,\n", - " pl_trainer_kwargs={\"accelerator\": \"cpu\"},\n", - " # these are logged per epoch as train_MAE, val_MAE, train_MSE, val_MSE\n", - " torch_metrics=MetricCollection({\n", - " \"MAE\": MeanAbsoluteError(),\n", - " \"MSE\": MeanSquaredError(),\n", - " }),\n", - " random_state=42,\n", - " )\n", - " nbeats.fit(train, val_series=val)\n", - " nbeats_pred = nbeats.predict(n=len(val))\n", - " # metric calls inside the run are logged automatically (keys: mape, rmse)\n", - " nbeats_mape = metrics.mape(val, nbeats_pred)\n", - " nbeats_rmse = metrics.rmse(val, nbeats_pred)\n", - " print(f\"NBEATS MAPE: {nbeats_mape:.2f}%\")\n", - " print(f\"NBEATS RMSE: {nbeats_rmse:.2f}\")\n", - "\n", - "autolog(disable=True)" - ], - "execution_count": 53, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "INFO: GPU available: True (mps), used: False\n", - "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (mps), used: False\n", - "INFO: TPU available: False, using: 0 TPU cores\n", - "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO: HPU available: False, using: 0 HPUs\n", - "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "/Users/jakubchlapek/Desktop/projects/darts/.venv/lib/python3.11/site-packages/pytorch_lightning/trainer/setup.py:177: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", - "\n", - " | Name | Type | Params | Mode \n", - "-------------------------------------------------------------\n", - "0 | criterion | MSELoss | 0 | train\n", - "1 | train_criterion | MSELoss | 0 | train\n", - "2 | val_criterion | MSELoss | 0 | train\n", - "3 | train_metrics | MetricCollection | 0 | train\n", - "4 | val_metrics | MetricCollection | 0 | train\n", - "5 | stacks | ModuleList | 6.2 M | train\n", - "-------------------------------------------------------------\n", - "6.2 M Trainable params\n", - "1.4 K Non-trainable params\n", - "6.2 M Total params\n", - "24.787 Total estimated model params size (MB)\n", - "400 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "33ff56f2bbbb46ddb71bf5ac409bc3c7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Sanity Checking: | | 0/? [00:00 📸 **Try it:** Click on the `nbeats-epoch-metrics` run in the UI, then open the **Model metrics** tab. You'll see `train_loss`, `val_loss`, `train_MAE`, and `val_MAE` plotted as learning curves across epochs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_charts.png)" - ], - "id": "6fcc8f13" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Forecast Metrics\n", - "\n", - "With `log_metrics=True` (the default), `autolog()` patches every darts metric function. Any metric you call **inside an active run** is logged automatically with no extra arguments needed.\n", - "\n", - "The metric key is derived from the result: a scalar is logged under `{metric}` (e.g. calling `darts.metrics.mae(val, pred)` logs `mae`). You can always log a custom-named metric explicitly with `mlflow.log_metric()`.\n", - "\n", - "Logged metric values are only meaningful to compare across runs when the evaluation settings match. Use the same evaluation time frame, forecast horizon, and evaluation start date for every `backtest()` / metric call you intend to compare against one another." - ], - "id": "3f0828c2" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.372445Z", - "iopub.status.busy": "2026-06-24T15:18:53.372367Z", - "iopub.status.idle": "2026-06-24T15:18:53.470125Z", - "shell.execute_reply": "2026-06-24T15:18:53.469722Z" - } - }, - "source": [ - "# log_metrics=True (the default) patches every darts metric so that calls made\n", - "# inside an active run are logged automatically\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"linear-regression-full-metrics\") as run:\n", - " lr_model = LinearRegressionModel(lags=12)\n", - " lr_model.fit(train)\n", - " lr_pred = lr_model.predict(n=len(val))\n", - "\n", - " # each metric called here is auto-logged under its own name: mae, rmse, smape\n", - " metrics.mae(val, lr_pred)\n", - " metrics.rmse(val, lr_pred)\n", - " metrics.smape(val, lr_pred)\n", - " # you can still log a custom-named metric explicitly\n", - " mlflow.log_metric(\"manual_mape\", metrics.mape(val, lr_pred))\n", - " run_id = run.info.run_id\n", - "\n", - "autolog(disable=True)\n", - "\n", - "# show what was logged\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_metrics = client.get_run(run_id).data.metrics\n", - "metric_names = sorted(run_metrics.keys())\n", - "print(f\"All logged metrics ({len(metric_names)}):\")\n", - "for name in metric_names:\n", - " print(f\" {name}: {run_metrics[name]:.4f}\")" - ], - "execution_count": 13, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "All logged metrics (5):\n", - " mae: 46.0220\n", - " manual_mape: 10.7420\n", - " mape: 10.7420\n", - " rmse: 51.1820\n", - " smape: 10.1015\n" - ] - } - ], - "id": "df8e85b6" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Metric Shape and Detailed Logging\n", - "\n", - "The logged key reflects the shape of the metric output, which `autolog()` infers from the metric and its keyword arguments. The general pattern is:\n", - "\n", - "`{metric_name}{component}{quantile_or_label}`\n", - "\n", - "- **Per-component** (`component_reduction=None`) adds the component name, e.g. `mae_`.\n", - "- **Quantile / interval** (`q`, `q_interval`) adds the quantile, e.g. `mql_q0.500`.\n", - "- **Per-label classification** (`label_reduction=None`) adds the class, e.g. `f1_label1`.\n", - "- **Per-timestep forecast metrics** (`time_reduction=None`) use zero-based steps, so the first predicted value is `0`. Backtest calendar-relative steps are negative and end at `-1`, aligning different series lengths on their shared end.\n", - "- **`series_reduction`**, when set on the metric call, aggregates across series inside the metric itself, so the mean-over-series logging described below does not apply.\n", - "\n", - "For `backtest()`, metric keys have a `backtest_` prefix. A time-dependent metric with `reduction=None` keeps its per-window values in the return value, but MLflow charts one value per horizon step: it applies `np.nanmean` over windows for each series, then aggregates across series. The detailed `metrics_per_series.json` table retains every source value with a `window_index`, including for a single-series backtest.\n", - "\n", - "When you score a list of series, the logged value is the mean over series and the full per-series breakdown is appended to the same run-wide table artifact, `metrics_per_series.json`, which you can read back with `mlflow.load_table()`.\n", - "\n", - "Passing `name=` to a metric overrides the `{metric_name}` token in the key while keeping the suffixes (e.g. `mql(..., q=0.5, name=\"foo\")` logs `foo_q0.500`)." - ], - "id": "b08e900a" - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# build a small multi-series example from the univariate AirPassengers data\n", - "series_list = [train, train * 1.2]\n", - "val_list = [val, val * 1.2]\n", - "\n", - "multi_model = LinearRegressionModel(lags=12)\n", - "multi_model.fit(series_list)\n", - "multi_preds = multi_model.predict(n=len(val), series=series_list)\n", - "\n", - "autolog(log_metrics=True)\n", - "\n", - "with mlflow.start_run(run_name=\"metric-shape-and-table\") as run:\n", - " # metric shape: a per-timestep metric (ae) logs one value per horizon step\n", - " # under a single key, charted across MLflow steps\n", - " single_pred = multi_preds[0] # train == series_list[0]\n", - " metrics.ae(val, single_pred)\n", - "\n", - " # multiple series: the logged value is the MEAN over series, and the full\n", - " # per-series breakdown is appended to the run's table artifact\n", - " per_series_mae = metrics.mae(val_list, multi_preds)\n", - "\n", - "autolog(disable=True)\n", - "\n", - "client = mlflow.tracking.MlflowClient()\n", - "run_id = run.info.run_id\n", - "\n", - "# aggregate metrics: mae is the mean over the two series\n", - "logged = client.get_run(run_id).data.metrics\n", - "print(\"Aggregate metrics:\", {k: round(v, 3) for k, v in sorted(logged.items())})\n", - "print(\"Mean MAE over series:\", round(float(np.mean(per_series_mae)), 3))\n", - "\n", - "# load the per-series table artifact\n", - "per_series_df = mlflow.load_table(\n", - " artifact_file=\"metrics_per_series.json\", run_ids=[run_id]\n", - ")\n", - "print(\"\\nPer-series breakdown (metrics_per_series.json):\")\n", - "per_series_df" - ], - "execution_count": 14, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Aggregate metrics: {'ae': 44.196, 'mae': 51.316}\n", - "Mean MAE over series: 51.316\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0305dca7a1b846f19da965d1b74319c5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Downloading artifacts: 0%| | 0/1 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
keyseries_indexstepvalue
0mae0047.458874
1mae1055.172880
\n", - "" - ], - "text/plain": [ - " key series_index step value\n", - "0 mae 0 0 47.458874\n", - "1 mae 1 0 55.172880" - ] - } - } - ], - "id": "ecdbbf29" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Saving and Loading Models Locally\n", - "\n", - "You can also save and load models to/from local paths without MLflow runs." - ], - "id": "8511fc08" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.471252Z", - "iopub.status.busy": "2026-06-24T15:18:53.471178Z", - "iopub.status.idle": "2026-06-24T15:18:53.478682Z", - "shell.execute_reply": "2026-06-24T15:18:53.478330Z" - } - }, - "source": [ - "# Save model to local directory\n", - "local_model_path = os.path.join(tmpdir, \"my_model\")\n", - "save_model(model, path=local_model_path)\n", - "\n", - "print(\"\\nFiles in model directory:\")\n", - "for file in os.listdir(local_model_path):\n", - " print(f\" - {file}\")" - ], - "execution_count": 15, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "2026/07/23 18:50:10 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] - }, - { - "name": "stdout", -"output_type": "stream", - "text": [ - "\n", - "Files in model directory:\n", - " - python_env.yaml\n", - " - requirements.txt\n", - " - MLmodel\n", - " - model.pkl\n", - " - conda.yaml\n" - ] - } - ], - "id": "645ef079" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.479679Z", - "iopub.status.busy": "2026-06-24T15:18:53.479604Z", - "iopub.status.idle": "2026-06-24T15:18:53.484973Z", - "shell.execute_reply": "2026-06-24T15:18:53.484638Z" - } - }, - "source": [ - "# Load model from local directory\n", - "local_loaded_model = load_model(f\"file://{local_model_path}\")\n", - "\n", - "# Test it\n", - "local_predictions = local_loaded_model.predict(n=5)\n", - "print(\"Loaded model successfully!\")\n", - "print(f\"Predictions shape: {local_predictions.values().shape}\")" - ], - "execution_count": 16, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Loaded model successfully!\n", - "Predictions shape: (5, 1)\n" - ] - } - ], - "id": "254ba153" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Querying Experiments\n", - "\n", - "You can programmatically query and compare runs." - ], - "id": "aab0d1e0" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.485914Z", - "iopub.status.busy": "2026-06-24T15:18:53.485859Z", - "iopub.status.idle": "2026-06-24T15:18:53.496380Z", - "shell.execute_reply": "2026-06-24T15:18:53.496048Z" - } - }, - "source": [ - "from mlflow.tracking import MlflowClient\n", - "\n", - "experiment = mlflow.get_experiment_by_name(\"darts-quickstart\")\n", - "\n", - "# get all runs\n", - "client = MlflowClient()\n", - "runs = client.search_runs(\n", - " experiment_ids=[experiment.experiment_id],\n", - " order_by=[\"metrics.mape ASC\"], # Sort by best MAPE\n", - ")\n", - "\n", - "print(f\"Found {len(runs)} runs in experiment '{experiment.name}':\\n\")\n", - "for i, run in enumerate(runs, 1):\n", - " run_name = run.data.tags.get(\"mlflow.runName\", \"Unnamed\")\n", - " mape_val = run.data.metrics.get(\"mape\", \"N/A\")\n", - " print(f\"{i}. {run_name}\")\n", - " print(f\" Run ID: {run.info.run_id}\")\n", - " print(f\" Validation MAPE: {mape_val}\")\n", - " print()" - ], - "execution_count": 17, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Found 5 runs in experiment 'darts-quickstart':\n", - "\n", - "1. exponential-smoothing-baseline\n", - " Run ID: 19ce5c2862014f5a8b27d68cb5f41c34\n", - " Validation MAPE: 7.864181481214469\n", - "\n", - "2. linear-regression-full-metrics\n", - " Run ID: 708095048f274913990375bbbd4310ad\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "3. linear-regression-autolog\n", - " Run ID: 36376b7a94454a13a4acba207459315e\n", - " Validation MAPE: 10.742044444678953\n", - "\n", - "4. nbeats-epoch-metrics\n", - " Run ID: f0d1b0ed9ac34232b5e36fe82a24a0a6\n", - " Validation MAPE: 13.639569217869525\n", - "\n", - "5. metric-shape-and-table\n", - " Run ID: 9be3e9d311b64d45b0204174835537cc\n", - " Validation MAPE: N/A\n", - "\n" - ] - } - ], - "id": "109a9812" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load the Best Model" - ], - "id": "22685423" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.497560Z", - "iopub.status.busy": "2026-06-24T15:18:53.497496Z", - "iopub.status.idle": "2026-06-24T15:18:53.572540Z", - "shell.execute_reply": "2026-06-24T15:18:53.572133Z" - } - }, - "source": [ - "from darts.models.forecasting.forecasting_model import GlobalForecastingModel\n", - "\n", - "if runs:\n", - " best_run = runs[0]\n", - " # the model is logged via MLflow's logged-model API, so resolve its model_id\n", - " # from the run outputs and load it with a models:/ URI\n", - " model_outputs = mlflow.get_run(best_run.info.run_id).outputs.model_outputs\n", - " best_model_uri = f\"models:/{model_outputs[0].model_id}\"\n", - "\n", - " print(f\"Loading best model from run: {best_run.data.tags.get('mlflow.runName')}\")\n", - " print(f\"Model URI: {best_model_uri}\")\n", - "\n", - " best_model = load_model(best_model_uri)\n", - " # global models (e.g. LinearRegression, NBEATS) need the series at predict time\n", - " # because we save with clean=True; local models (e.g. ExponentialSmoothing) don't\n", - " if isinstance(best_model, GlobalForecastingModel):\n", - " best_predictions = best_model.predict(n=len(val), series=train)\n", - " else:\n", - " best_predictions = best_model.predict(n=len(val))\n", - "\n", - " train[-50:].plot(label=\"Training\")\n", - " val.plot(label=\"Actual\")\n", - " best_predictions.plot(label=\"Best Model Forecast\")\n", - " plt.legend()\n", - " plt.title(\"Best Model Predictions\")\n", - " plt.show()" - ], - "execution_count": 18, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Loading best model from run: exponential-smoothing-baseline\n", - "Model URI: models:/m-aa41380f3e4746b8b517c25cf69b23ab\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHECAYAAADmnVpRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoK1JREFUeJztnQd4U2UXx0+6001bSmmBsvcWZIkoiKLi+FRw4MC99544PgXX50IUEffeuFFQFAeisvcus3Tv3eZ7/u/te3OTJm2SZtybnt/z5OlNbpLee3OT93/P+Z/zmiwWi4UYhmEYhmECTEigN4BhGIZhGAawKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYhmEYRhewKGEYxiOWL19OP/30k0ev/eGHH2jFihW6P/J79uyhTz75hMrLy9XHNm3aJB7zZt9JX7wnwxgRE3d0ZRhbfv75Z8rPz1fvh4WFUXp6OvXv359iY2N9eri+++47SkpKolGjRrm1rcnJyXTsscc2WY9B7vPPP6eGhgbq06cPDRo0yGvbetxxx1FRURH9888/br+2b9++NHDgQDEQu/NZREVFUY8ePahfv37kD1599VW6/PLLafv27dSzZ0/x2IMPPkgPPfQQ1dbWinPDVTZs2EBbtmyhs846q8k6T9+TYYINPvsZxo67776b1q1bRyeddJK4j4ECV7K5ubl077330u233+6zY3b11VfT6NGj6YMPPnB5W//66y8xWGdnZ1NCQoLN+l9++YXOPPNMsXzrrbfSU089RUb+LPLy8ujPP/8UAvH9998X4sbf4H/jmIaEuBdofuedd+jxxx93GA3x9D0ZJthgUcIwDkC0QnsVj4HkuuuuozvuuINGjhxJxxxzjG6OW1paGhUWFgohc+WVV9qse/3116lr164iDREsnwUiDogknXHGGUIs+pvp06eLm97fk2GMCMtyhnEBk8lE5557rlh2lq44cOCASL/ghqiFIw4ePCh8GEuXLqVDhw7ZrMPAW1FRQfv37xfLuC1ZsqTFbUN05NRTT6U33njD5vHS0lL69NNP6aKLLmr29RjYv/rqK5EqwWscUV9fLyIU3377rdN9c/dYeArSPqeddhpt3rxZpFUgyHCs8D8BIitffPGFTdoHx/XXX3+lL7/8ktavX+/0vXfs2EFff/01rV271iP/R2VlJf3+++/0zTffiPeSIJq1detWsSw/W9zk8W7uPRGhgwcHxz4rK6vJemwrUnSgqqpKnFs//vij088SxwJ+HmwjjiFSewyjG+ApYRjGyqhRoywZGRlNDsnChQsxYlg+/fRTm8eLioos06ZNs0RGRlrGjh1rOeqooyxRUVGWW2+91dLQ0CCeg7+XX365ePzoo4+2nHDCCZbOnTtbZsyYYamurhbPOfPMMy3R0dGWTp06iWXcbrvttha3tU+fPpZvvvlGbNuWLVvUda+++qolIiLCsnXrVrEO26MlKyvLMmbMGEtsbKxl4sSJlr59+4rl559/3uZ527dvF+sSExMtxx13nFieP3++ZdKkSZYjjjjC7WMBsM3YP08/iyuuuELs0+rVqy1///23WH7jjTcsp5xyimX06NGWHj16WJYvXy6e++yzz1ri4uLEduO4p6SkiP3ev3+/+n61tbWWmTNnWkJDQ8X/xO2MM86wzJ07V7w3joFk1qxZ4jG8RsszzzxjSUhIsHTr1k38n169eom/+fn5Yh32Ga+Tny1uBw4ccPqedXV1lptvvtkSHh5uGT58uDiW+DzPOussS0lJifq8G2+8URxvHIshQ4ZYJk+eLM6hpKQky59//mmzjZ988ol4vH///papU6daBg4caBk2bJhlzZo1LX4WDOMPWJQwjB0YkPDD/fHHH4vbe++9Z7n//vst7dq1s5x77rlisNCCgTo1NdWyceNG9bHff/9dDCYYjMCiRYvEoCMHSoBBGu+tHWAyMzMtZ599tsufiRQl2KaOHTta7rrrLnXduHHjxACWm5vbRJTU19dbBg8eLP7fnj171Mexn3juZ599Ju7jfTGAYUDPzs5WX3vVVVeJ19qLEleORWtFCUQcBvyYmBhLRUWFKkoGDBhg+e2338RzKisrLfv27RPCDOsgLiQFBQViu/HeEoiCkJAQy3fffac+huXevXu7JEpefvll8diTTz5ps62LFy+27N27Vyzfeeed4jmOcPSejzzyiHjsgw8+UB/766+/xH5Pnz7dRpTg+F544YWW4uJi8VhZWZkQHCNHjlSfh88S4uzaa6+1+d8bNmxQjxvDBBoWJQxjBwYrs9msXs3+5z//EVequPp84YUXbJ6LH3MMHC+++GKT43jBBReIgRvMmzdPPA9Ri+bwVJSA22+/XQzgEA3btm0T/w8RFEeiBIMlHluwYIHN+2FQ7NKlixA02ue9//77Ns/DwI5jpBUlrh4Ld0WJViBi8EcEBgIC0RogRQkiHfYgGjV+/Pgmj8vI0ooVK8TxSk5Otpx22mlNnnf66ae3KEogLtPT09Vj5gx3RAneE9uEaJQ9iJ6YTCYR6ZKiBK+F+NMCgYTH8/Ly1M8M9x966KFmt5NhAgkbXRnGBXMlwP1p06aJnDwMrwA+C5nLh4+hUeirPgx4AJDbP/nkk6ldu3aisubss88W5bu4tW/f3mvH/+KLL6Ynn3xS+AlQddOxY0c64YQThOfCntWrV4u/9qXHKEc94ogj6Pvvvxf3V61aJf6OGDHC5nnYl169etk85uqxiIuLc2u/4NOQ1UioMpo4cSK9/PLLTcqbYUDWAm/Ovn37xP7I7QH4e/jwYdV/0qFDB+E/sd9HcOSRR4rXNgf+D7xCF154IXmLvXv3im1yVBqOcwj7sGbNGurSpYvqeRo+fLjN8+Q6HAOUjOMzw3mI0uOVK1fSiSeeKAzbAwYM8Np2M0xrYVHCMC6C/hLdu3enF198URUlGDABzIV//PFHk9egzBMDMgYImBkXLlwonvvWW2+J155zzjn02muvicG2taB3BwZRvB/MlhdccAGFhoY6fG5NTY34GxMT02QdHpPr5d/o6Ogmz8NjKJeWuHosvCEQHWEv8OT27Ny5U5TjOtoe9J9paR9bAiLM2bH0lJY+H1BdXa0+FhER0eQcwmPa7QOLFi2i9957T5h5Z8+eLSrKIEpwfIYOHeq17WcYT2FRwjBugOZp27ZtU++jkZfsAYIr+JZKd9HnBDcMOvPmzaObb75ZXA3feOON6hVva5g5cyZdc8016rIzUCYMUL0CoaUFj8n13bp1Uwd2DOASXKnv2rWLOnfu7NGx8AX2x65Tp04UGRkpIguvvPKK09ch8oUIEfbRHm0FjTNwDPB/UMnizvY1R0ZGhtgmfBb2yMfkZ+MOEKkQq7iBv//+m6ZOnSr648hIF8MEEi4JZhgXQRgcZZ3aMDlKcVNTU0VTLEellQjDyxC/dj2uYmW4PycnR30cYfbi4mKPPxOULSOic8MNNzTb9RRhfFxxv/DCCzZlqBiYUL6KCA5A0zJECyCgtHz00UdUUlJi85irx8JfmM1mmjFjhkj9QEDZg+OOaAP2D8cDzdi0qS4sf/bZZy3+H0QozjvvPBHNsRcmEDyyNBefLXDl88U2QSx8/PHHNqXjiHogdYXUmX26piWwHejAa5/yGjJkiM05yDCBhCMlDOMAhP5lygADLPwQL730EsXHx9Pzzz9vEzlBj4jTTz9dDBLnn3++8Cjg+egtgSgE+ocgbD537lzR8Kt3795icHnzzTdFyuGSSy5R3+/444+nZ599lp555hlxBZ6YmCjaubsKno+BzJWUCFJJuGLGgIztgi/i6aefpqOOOkpEc+RAinQVthHRHTwX0QOIs3HjxtkMcq4eC3+CYwlBAl8JGsuhcyrEBrwy6FsCbw2iHHge9mfMmDEi0gShhuOIaNNjjz3W4v/B54UW8oh6XXvttaLTLP7vhx9+KPqLwEeDzxEdW2+66Sbh9UEkBH+deWwgGCdMmCC2CWkWCBWk5iAg4Plxt/sr+p3AQ4L/iVQNzmWk2ZBusxedDBMoWJQwjB1IPSD0L82V+PFH6gU+Egzi9nn+sWPHipA6rrTRWA3mSYTW58yZI9YBDFRTpkwRAx2alOHqGlfxuEFISGbNmiXSJAirY8BAGqU5UYJt1U4W5wgMuvBPDB482OZxGG4xOMFPgG3CfkF4obOodv4VDMwYzN9++21atmyZ8K1gOxERsf/frhwLgIFRGjGbA/unbYLmTGBh//CZ2YMBH83qIAzQiA6DOQzAEH9I6eDYABxnNCHD/iNSBEGI44KUDgSYds4jRy3h0cAOExQisiKb40GYYFmmvXCsFy9eLJ6DG8Qujgm20dF7Yn+wTfAfwZgKPw6iYDA0Q+xJ8L4QlY5SQHhPGaGBKEQkB1Guf//9l8rKysRngGZy+P8Mowd4Qj6GYRiGYXQBe0oYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFLEoYhmEYhtEFbU6UoGHR7t27HbbBbqvwMeFjwucKf3/4N4V/Z/VAmxMlDMMwDMPoExYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlDMMwDMPoAhYlQcoXX3xBn332mc9fwzAMwzDeIsxr78S4zZw5c6iqqsrp+t69e9N5553n0ZGFwKirq6MzzjjD5dcsWrSI6uvr3XoNwzAMw3gLFiU6YcuWLfThhx/S7bffTtHR0a1+v9NPP93tmZBPO+20Vv9fhmEYhvEUFiUB5K677rKJbECU3HHHHZSSkiIe++ijj+jrr7+mXr160XfffUdms5muvPJKWrJkCf3222/iOe3ataMRI0bQuHHjmv1feC+InX79+tFPP/0kIjQnnngi9ezZs9Wv2bNnj9j+qKgomjBhAu3evZvKyspo+vTprTxCDMMwjDepqrbQS4uIMlKIpk80kd5gUaJjIArWrl1LISEhdNJJJ1GfPn2aPGf79u306KOP0owZM+iZZ55xmr7Be61bt47Cw8PphBNOEMLhzjvvpN9//52GDBniMH3T3GuGDRsmnrNixQqaNGkSjR8/nvr27UtPPvkkhYaG0uDBg1mUMAzD6Iw3vye6Za5FLLeLI5o8Ul/ChEWJzsnLy6MdO3ZQcnKy+thxxx0nbpKbb75ZCJbrrruOevTo4fS9EL1Amig+Pl7cnzJlCs2bN4/mz5/v9msWLFgg7t922230n//8h9555x1x/9ZbbxVeGIgShmEYRl9s2K0IEvDo2xYWJf4EaY3s7OwmjyMagKt5X5GWlkb//POPV94LUQitIJGsX79eRCxycnKEdwSpkw0bNjQrSiZOnKiKCzB06FD6999/m/3/zb2mvLxcbMPDDz+sru/cubONYGIYhmH0Q06hdfmXNUR/rLfQ2EH6iZYEdaQEguTAgQNkZKS/RAtEwP/+9z869dRTqVOnThQRESFSPIWFmrPNAbGxsTb3w8LCqLa21uPXHDp0SPzt0KFDE1HW0rYwDMMw/ienyPb+7Hct9NUcFiV+AYOjI/wRKfEV2PbZs2cLv8cpp5wiHoN35LHHHiN/07FjR/H38OHDNGDAABsxGBkZ6fftYRiGYZrncIHt/a//IFq300KDe+hDmAR1pMRRCgWpjqysLMrMzBTRBaOBKEVNTY1I10gWLlzYYsTDF8TExIiqnzfeeEOkeQAiU0uXLhXGXIZhGEbfkRIw510LvfcAixLGAyBGLrzwQnFDY7WDBw/SsmXLmqRZ/MVTTz0lfC8w5MLg+tVXX1FGRoYhBR/DMEwwU1dnofxiZXlQd6LsAqLcIqIPfyJ65FIL9cgIvDAJ6kiJkUA57axZs2wap6HPh6NGaq+99hp9+eWXtGnTJurfvz+9+OKLIloBE6qz5mmO3gvRDW3PEfvmaa68ZvTo0bRx40b6/PPPhWBCH5UHHnhA9E9hGIZh9EOuJkrSNY3o7Ikmuu9VC2GoePJ9C718W+BFiclisVjrg9oARk/f6O2YwD8C4SIrdHAfAuu5556jiy66iIwKnyd8XPhc4e9PsP2mrN1hoaGXKEP+ZVOJnrzaRF2mWai0giginGj3hyZKTwmsMOFRmWkVKAseM2YMXXXVVXTttdeKpmqInng6Zw/DMAzj+3Lg1HZEiXEmuuZ05X5NLdEzHwU+RsGihGkV6IsCY+uoUaNEWuett96i77//XnSBZRiGYfTDYa0oSVQiIjdNM1FkhPLYy4uICkoCK0zYU8J4pQT64osv5iPJMAxjkEhJhyTlb1qyiS49yULzviAqqySa+xnRAzMDtokcKWEYhmGYtkBOoTUKkppoffz2c00kW3e98KmF6ustxknf/Pjjj3TuuefS5MmTxeRr6JkhqayspAcffFCUiKKSAxUiWlpazzAMwzCMH9I3mgLJrh1NNGm4spxXTJRfQsZI3/zxxx+iL8X9999PAwcOFF4CNCgbO3asWP/ss8/Svn376O233xbT2WNG2a5du6qTs7W0nmEYhmEY/xhdtaRrZjSBMLFfr0tR8vLLL9M111xDRx11lLh/5plnquvQ6vy7774Tc7Kkp6eLGyZmQzMtiI6W1jMMwzAM4/turqhITrbOsyrQ3s9z0PVVd+kbpGkwhT2mssecKyeffLIQGDJ9g8nZKioqRI8KSZ8+fWjHjh0urWcYhmEYxvfz3qQkEIWG2vYjSUkw2URKAoXLkZKcnBzR/AUpm5deeknMtYL0C9qbX3HFFaJfhZwPRRIXF6c+3tJ6R0DwaD0rYoPDwsSsuJ4iu5xqu522dVo6JuvWraPU1FSfTjSoN/g84ePC5wp/f4LpN8VisaZvYHK1344kTaQktxhdXr1vdnWlaZzLokTO+oo5Vzp16iSWYXhFe3GIErPZLB5DNEQKDwgO2aa8pfWOeP3112nBggU2j02bNk20P28t8LboDQz+ODbo/eEumzdvppSUFGrfvr3Xj8nZZ58tjvkll1xCbQ09nid6gI8LHxM+T4z13SmtNFF1bRexHG+upKysHJv1lhqM0alieceeQsrK8r7btVu3bt4TJRjwEhISbJQOlmWXekzCBuGyfft2dQ4WLMuNaGm9I9D7YsaMGV6PlOCk6Ny5s67azG/YsEHMV4M5Y/bv328zC7ArnHjiiaKjKm7ePiZohJaUlCTaI7cV9HqeBBo+LnxM+Dwx5ndn+37rcpeO5ia/5/00KZv6kHaUmRkYp6vLosRkMgkfybvvvqsaVz/66CMaP3688kZhYaJMGJGN2bNnix7/P/zwAz399NMurXcExEdrBEhz4KTQ02CDqBCOD6IlX3zxhdM27fDmYEZe+HHkscHEfFVVVeKYrly5UjyGVu9///236LKqnRwP4gcCA0ZjGWEpLCykw4cPC4GJaihHxwWfv56Ol7/Q23miF/i48DHh88RY3528YgQQlCBCh3ZNUyntE63rMZNwoH733PqvqLzp0KGDECdIowwYMMCmk+ett94qoiEYXG+88UaR1hkxYoTL69sq8M2gTBrHd+bMmfTqq682ec7BgwfVGXrPOecc6tKlixAvAJPfQVR8+umndNNNN4lbfX09HXvssfTLL7/YvA/eH63gJfAH3XLLLfTQQw+JqiqInVWrVvlhrxmGYZjAdHM1NVmfommmZgijK0BK4eGHHxYDGK6c7YFxFRU5CFM5UlktrW+rwJeDqMfUqVNp0KBBoindzp07VW8JIhhI7cBUfODAAUpMTBTRDdl8bv78+UJ8XHfddeLmDs8//7w6eyXCivfdd58QmmvXrvXJvjIMwzCBnveGmtAuFhFxxRBrGFEicSRItLQkOPwlSEZc3kDZjSVQKhai+voMpaWuyTcu6LQkon8WuL6PCxcuFEIAKS4IEUREXnvtNXr00UfFejSoQyoGqR0IEoCUzEUXXeSV7a2urqZdu3ZRdnY2jRw5kh5//HEherRpH4ZhGCZIGqdF1FJDTRiFRFjHqbAwE7WLs1BBiYE6uhoNCJIDufrebUQoUGYNUbJixQrVDwJRgqhUaGioMATjb//+/b3+/+fNm0f33HOPiMJ07NhRLRODd4VFCcMwTHDNe9OnoohCL/qXlphDqM99vajLRZ3J1NizBP1LIEoMFykxCohYNEFESuooNDSMyOTH/+sEiA+U8cIXoqW0tFR0wEVKB2XT8Ihg7iCIB3ciWrI6SoL+MlpBhHTPt99+K7wkcGNDAKHBHfdxYRiGCb70zcSiQ0Q1DVRX00Abb99M+987QAOf6k8JQxPUrq7FZUS1dRYKD/PRINlWRYmjFIrinzggBuBA+1qwLai6eeyxx5r0ALn++uuF4RWiZMyYMaIsF8bW888/X30OKm5k6TD6wGgFB4ApGeXFEqRktB10d+/eLYQL0kXwqoDvv//eZ/vLMAzDBDZ906Oq1Obx4tUl9PvkFZR5SRdKj+qOJhBqBU5asv+3M6hFid5ZvHixEANo228PjK1TpkwRPg90UoUBFdU5uI8+Lyj9xaSGr7zying+JkiEaBk+fLiocEIKCO8B0yx6xEDUYBkRF8mQIUNE7xn0NjnmmGPok08+EQKJYRiGCT5REmJpoO7ViiiJSI2giKQIKttSRtRAlPXqXjovOpv2pfSnlXHtRQonEKKES2ACCMyrMKs66sI6YcIEUaK7fPlycf+BBx6gN954g/7880+aM2eOSOU888wz6vPxWL9+/WjWrFlqSTCMspdffrko+/3ggw+EsEEXXogUAM8I/CxIFSF9tHHjRlq0aBGNGjXKptMuxAv8JgzDMIxx0zedqisostE3mDSmHR21bAz1mdWbQqNR+UEUVVFDd+5bR2ENDQEzu5os9qaDIEeWv+ohfaMX+JjwMeFzhb8//JsSvL+zNbUWipxkoWOLDtFtBzaIx/rc34t63IR0DVHl/kr69/zVVLJeiaJc2msczZ0TQ2ce439PCY/KDMMwDBPE5DVW0/SosoY/4odYZ+AzdzJT8gRrrqZ9bVXAKnBYlDAMwzBMEHO4sV9Xj0qryTV+kGZaYAiTDOt8ayxKGIZhGIbxCTlFwquhVt5EpUdRZIrtvHJRTURJYJwdHClhGIZhmCCvvEmrqaSYhjpxP35wXJPnIIUjSeX0DcMwDMMwvkrfaPuTJGj8JBJzJ9tICfqUBAKOlDAMwzBMEJNTZLE1uQ5uKkrCk8IpxKxIAvaUMAzDMAzjs/RNcyZXgO7e5gyzVZQUsaeEYRiGYRgvc7jAQj0bIyVhSeEUlR7p8HkyhWNuqKfKAsV/4m84fcMwDMMwQUzVwWpKqFfmRkscEi+iIo6I0vhKoourRNM1f8OihPE7Dz30EJ111lluveaOO+6gGTNm+GybGIZhgpXoAyXNmlwdmV1T6gJjdmVREmAwP01iYqJ6Qwvik08+mVasWOHV/3PLLbeIeXaaA5PxYRvOOOOMJuswYzHWjR07ttXbgnl7ysrK3HpNRUUFlZeXu3wc5e2zzz4jo4OZpDHRIsMwjLtgJpnkXI2fpDlR0ugpAe1rAtPVlWcJDjAYoJOSkmjVqlXifkFBgRAHkydPpl27djmcrM8TWhrU5bZghuFvvvmG9u/fT506dVLXvfzyyxQTE0MlJQGapcnN4yjBNhud6upq3R53hmH0TXEZUbeKkmZNro4aqAWqVwlHSnQAJmeSV/bdu3enu+66S0QSNmxQJk6SfPHFFzRu3DhKS0ujkSNH0iuvvCJUsGT9+vU0depU6ty5Mw0dOpSeeOIJdbZgXG1/+eWX6v/55ZdfHG4LRNAJJ5wgZiSWrF27lrZt2+YwgjJv3jwaPHgwdejQQcxq/MMPPzR5zuzZs6lHjx7Uu3dvuvLKK8WsxPa0tG/uHkd5Cw8PF+t2795N06ZNo/T0dOrWrRvdcMMNNtGavXv3iue///77Yj+wHRBncjbnk046ScyUPGjQILr//vuFUNCC5+DY4/0R1XjzzTfVdYsXL1a3B+snTpxIy5Yts3l9dnY2XXjhhWLb+vTpI2Z6xnHCZ4YoF7ZfvsfcuXPdOi4Mw7Ttbq49GitvaiLCKLqrNRrSfK+SShYlDFFdXR29++67FBcXJwZAyQcffCAG9Ntuu01EA+bMmUOPPPIIvfTSS+pzTj31VDH4//777/Tee+9RcXExff/993TrrbcKP8aJJ55Ie/bsETcIAGdceumlQsRIUYDUzTnnnNMk6oDHIaDuu+8+WrlypUg7YfCGiJFg+5588kn63//+JwRLu3bthJDR4sq+tYaamho67rjjhED7+eef6cMPP6SlS5fSzJkzbWbwxPG65557hOdl06ZNdPzxx9OaNWto0qRJdMopp4h9hNjAflx//fXqa//9918aP3489evXT4iN1157TfwfzAgK8Hp53PEe//nPf8RnsXPnTvU9rrrqKsrPzxefF249e/YUxxfPg6hEWk++x+WXX+6V48IwTPBzaGc1pdQpF1Fl6XFOTa6y/bwkUL1Kgjp989vEP6kmx/aKFsMsBqddoVnkq0mZI1Ij6aifxrj8fHkVDHD1HhsbKwbOlJQU9Tm4OsdAjQEN4Iobjz3//PN0zTXXUFVVlRiwzjvvPOrSpYt4DgYzdZsiIkTUQP6f5oC4wCCJAXbMmDFCJH333Xf0+eef2zwP7w/BM336dHH/7rvvFoMxRAUiDuDxxx8XJtXTTjtN3Me6b7/91uZ9Wto3T44jQPRm69atYlvy8vKEoIDYAwsWLBDCbMuWLdS3b1+bfYKIgEhBpAL3zz//fLr66qvFekShXnjhBeGtwV+ku/773//ShAkThPiSaCNNYWFh6nbhLwQNIiCffPIJ3XnnneJxbCeiI4iSgOuuu059vdlsVqNADMMw7lCwupRkAXB9V+epGxBqDiVLQgSZimuEKNnHosS7QJBUHbIVJZI6CkwNtiNwFSy9EBgIIQIw0C9fvlykYXAFvWPHDjG440oeEQzcEAGAwAJRUVHiNWeeeaYwtB577LF09NFHCzHiLhhEkUrAFf/BgweFSBg1apSNKIF4chRxQcTgo48+Up+DaAGEjRbcl1EEV/bNk+MIMJDLtBaiTlKQgNGjRwuRtnHjRhtRMmTIEJv3RGSjsLBQ7JPcNmwXbth/iAg8B+kgZ0Awwie0aNEicTxra2uFx6dXr17qc3C8cQywrYjqQBhpt5dhGMYTKjaVqKIkvG/zogSEpUVRfXENJdVV05qCer/HLoI6UoKIhT0yUhIaGurTSIk7aK+C8RcpkXfeeUd4BxDCxyAGkFKB2NCiDcUhDfLjjz8KD8ONN95IRUVFYiAcMWKE2/twySWX0LBhw8QVPJYdpZmkgNGC+3Kd/Itjbf8ciav75grOognYDvvtxHvj+XIbJYh8aMH2QSw4Eh3x8coXHFEV6V1xBMQWUj6IrMBXgzQY0mkQXhJEmWBu/uqrr4QX6IILLqCFCxeqUSiGYRhPsOzQlAM7mIjPUa+S8q0lhF/t8oO4qGdR4jUcpVAwgOAqHVfV8kpaj2BwxNW0TEOkpqaqfgRnYKCFDwK3p59+WqRh8BfpCwzK2HdXQQQAhk38T2n41ILBH9sEP8UxxxyjPv7PP/+oKQg8B8ZZ+DJgHpWsXr1aHdBd3bfWgO1B9AnmVCk6YCLGfbmtzkCE5c8//6QHHnigxec4Aymtyy67TBVd+Bw2b94sjLNaIB5xg6cFQmbWrFlClLj72TEM0zw//Wuht3+w0A1nmmhYb19dnuqDyL2KybXKFEKdBrRcjRiXGUWyTrM2uwo1jORP9Dsqt1Ew+CDigYEbplEpNjBIPffcc0Jg4AobqRFcVcN7AVDCCx8IqmSQYsjJybEp64UXAuvsq0aaY8mSJSK94qwsGVUhTz31lBAiiD7BB4PIzM0336w+B/4J+ErWrVsnohIwr2oHcFf2rbXAEwIBevvtt4vSYRwbbBfEFNJjzQHPB6Ic8JagpBrb98cff9iYTfG+SG1h35CqQbrnwQcfFMcfoKIGPhrsF4Qmng//ixZERlDBg2OE/4PPSvvZoTonNzfXK8eDYdoyW/daaOpdFnrjO6LrnwvM/C7+ora4lmKKKsXy7qg46pDSsgBL7KapzsmFKPEvLEp0gLbcMzo6WoTyn3nmGTGYSpCOQdTj3nvvFeF/DFjwfKAqBuCqG+kWVODgPVCFgwEXV9sAPhO8LiEhodmSYC3wqTTna4DJFYMp/A94Lu7Pnz9fmD61gzpKjBEBQOUNBm/7zqwt7VtrwT58/fXXQgwhQoP3x2OoUGoJlO9CIH366afitcnJyWKfzj33XPU5SLtAkEFYwaSM6AtSVjISAuGGPiPYf7weVTfwjWjBvsLcis8HIhACBmZcgOOL6BfECZcEM4zn1NVZ6MJHLVTZeG2262BwH82S9db2CzvM8ZTaruXXaMuCwwv8L0pMFnebQRgcvaVvcGWNmwSCoiVzKp6PNIQzz4U2TWEPPBK4EsfgKX0W8pgglYKIhzMhgv+L19uvxymECAS23RmIAGB7MVjjffB/HDU2c7ZveH9sp7NmaM62zdGxwTbYe0zw3hAOEB44LxydJ4iS4LX2Hhn77YBAc/a/8X/xekRMxKycZtueAdgHPMfRZysrgvD+zj7ftvb90QN8TIxzTB5500IPLLQOeeFhRNVLTW7714xyTHbN20Nb7t8qlud37U+L/u3c4muK/i2iP47/Syz/0L4TPbtlAPmToDa6GgEMMM4GseZe0xzNDVjNlQXjfZv7sjjbVnyhmxMkQCsCmtt+Z+vsB29Xt83VY+NKya0rlUzNbYP2fzs7Xs0ZZrGNiKQwDOM+/2610MNv2F6D19YRlZQTJcQG5xEtWWs1uRanuVbNZ+5k/a1NrKyiqmoLRUX6z3ejHwnLMAzDMD6gstpC5z9iobrGLgORmuuLQDQI8xfFjaKk1mSi+k6uKa+I9hFUH6KIEPQqyffzDBcsShiGYZig5u75FtqyV1ke3pvo4hODX5TUlddR+U6ljiYrMpZSUlwb7k0hJqqMjwpYV1cWJQzDMExQUp1TTT/ctIP+eD0X5jcRIXn7PhN1TDYFvSgp3VRG1NhJYEdUPKW60RC6LkkRJbENdZR7UOkl5S/YU8IwDMMEJevu3Up1nx2iB9FDKTaZku/oR/27xlBKgtVbkldEQUnFHqXPFdgXGUODktx4cXsz0a5CsVi0q4roaPc7g3sKixKGYRgmKNm3tJCk9XxEWT6FPPoHba/oRimDuqqJgtwgFSWV+6xVnTkRUZSa6LpZNbyj1bBfuhfv03J7em/BooRhGIYJOmoKaiiq2LbPRkN1A22fs5PiMg7R0LC+tCY2mfKKETUJvq6ulQeUpmkgJzzKpR4ljnqVVB7wb68S9pQwDMMwQUfJOmvjsGXt06nbdV3JFKqID8uBCno0axVNy90dtJ6SKk2kJDfcTB3cSN8kdLWKknrRat5/sChhGIZhgo7itVa1kZ3Rjvo91IfGLRtD7UZZHZ/HFx0IWlFSuV+JlFSbQqg4NNwto2tyT2uvElMeixKGYRiGaRV5q6yRktouSuOw+P5xNPrrIymmV4xa8ppbGHxNzS3osr1fERO54VHocOlW+qZDb2ujx4hCaxrIH3CkhGEYhgk6iteVqJGCyO4xNn04orsqkYBwi4Wqc2so2KgtrKX68nrVTxIWStTOtYaugqTUMCoJVbpLx5RypIRhGIZhPB+US+qobq9SErsnKpY6ptpef5szNOmJAMyE62sqG6MkMlLSPhHTVLhu5sXUIYWNU2bEV1aTpd5/0SSOlDAMwzBBRelGzey4UfE2zdJAlKa6BBU6mD04mKjcp628MbuVupGUxSrHKBTRpMON0yr7ARYlDMMwTFCmbsDOqDhKT3Fe8ppSU0UFVg0TFFRpIyURUdTBA1FSlWA9RoW7/OcrYVHCMAzDBO3suDvNcdQx2flMuIGY38VflTee9CiR1De2mgd5O/yX4mJRwjAMwwRlpKSOTGIyuvQmosQ64KZClBQFr6ckB+kbN8qBJaYO1mNUvIdFCcMwDMO4TX1lPZVvU2bH3RsVQ7UhoU0iJZFpkWRptJm0r60MvkjJPiVSgvn48sMiKT3F/Y61kelWUVImWs37B46UMAzDMEFD6aZStVoEJleUwkZF2g7KIeEh1NAu0tqrJNgiJQcUEVEQFkl1ISGUmeb+e0R3tqa4qjUt630NixKGYRgmaCjWtJd3ZHKVmFKVQTexvpbyc5WeHsFAfVU91eTUWBunEVFmB/ffJ7FzpEh/gYbDHClhGIZhGLcp0VbemFEO3HJ6olxjDA0uP0mU+NvFA1GS0s5E+eFKNCkkn0UJwzAMw7hNcWPlDfwUux2YXCUxna2ipPpgVXCWA4ebKSqCPKq+SUmwRlrCK2qprryO/AGnbxiGYZigoKG2gco2K+mbAxExVBUa5jRSktjNKkr8mZ7wazlwRJSIkqBDq7ukJFpFCahq9Kn4GhYlDMMwTFBQtrWMGmoaTa5mZbIXZ5UnST2sA64/0xP+Tt9kepC6Acnx1vSPeF8WJQzDMAzjOsVrrSbXXVGKKHEWKdFWl0QVVQVpi/kojypvQHwMUUEkR0oYhmEYptUmV5QDA2fVN9r5b2LLgtVTEkVdOrifugFI+VQnaiIlmvf1JZy+YRiGYYJOlOwyNx8pCU8Mp5qwULGcVF1FldWWoPKUlIWEUUVouMfpG9CQbHboVfElLEoYhmEYw4OGaSWNswMXxpipLDS8WVGCSEB5XJS1gVqh8UWJpcGiej+kH8TT9A0ITdOUTWexKGEYhmEYlyjfWU715UoTtD0xSpQkMZbIbNfNVUtNY3oi0tJAuXtrDX+kqw9Xk6XW0urGaZK4lDARcQHlfmo1z5EShmEYJmgm4QObQ2XlTfOvsbS3RgLy/TgTrl8qbyLMFBJClNHe8/dDr5LsCCWFU3uoSpRc+xoWJQzDMIzhKdG0l98S3rzJVRKmnQk3KxhESaW6jEhJRgpReJhnRld7UUL1Fr+YXVmUMAzDMEHWXr55k6skKsMqSio0pbRGpXKfbY8ST9rLa0lJMNGhiGj1fsWeCvI1LEoYhmEYQ2OxWKzpm+RIKgpT5mxx1mJeEpdprS5BesLoVNlFSlrjJ5FdXQ+FW49RxW4WJQzDMAzTLJV7K6muWJmbpaaLEiUBHZObT120626NlFBuVfB1c01r3fshfWMbKfF9NIkjJQzDMEEUMWjLk/CBog6Kn8QVT0lqL6soCS8IBlFSKf7WmkxUGBZJmR42TtO2mj8kPSWcvmEYhmFcZcdTO+nHbj/R2mvXU3VudZs6cGVbytTlg/Gx6nJLnpIOqSFUEBYhls0lweMpyQuLIovJ5JVISX54lBA5gD0lDMMwTIs01DXQjmd3UV1pHR344CD9Muo3ynp9n2go1hbQGjz3hkS7HCmJjiLKi1CiJdGVNdRQ4/uSV19RW1JLdSV1XutRIj0lDSYT5TT6SpC+8XU0jtM3DMMwBqd8ezk1VFoHVPgrNt62if6Y8pdNaiNY0U5Ct6M2yuVICbq6lsZEqYNhlYHNrpU2PUqUfWpt9U2smSgywprCQXO6mtwa8iUsShiGYQyOVnhEd7dGCopXFdNvx/1JC6Zuopxs5So6GJGt1cPiwmhPabhL3VzV18YHR1lwpc3swGZKTiCKMbfOUwLR1ivDzuzq43bzbomSO++8k8aPH6/eTjrpJJv1VVVV9Mgjj9Dxxx9PZ5xxBn399ddurWcYhmFa16NjwBP9aPRXIym2T4y4b2ogyvhzH316za6gPLSY70WWwmLm34N5rqVuJPVJVlFSuKsqaGYHzmxllETSrytRth/LgpWm9i5SXV1NN910E5144omqitLy3HPP0e7du2nhwoW0Z88euueee6hr1640cOBAl9YzDMMw7lOs6WaaMDieIpIjaNyyMXT3CXvomHU7lN/rPdbnBBNIJzTUKD6H8I5RVHnYtdSNSqpVlBTsrAqSSEkUdfOSKOmfSbTYjxU4bqdvIiIiKDo6WtzMZuuG1tXV0bfffkvXXHMNde7cWURSJk6cSIsWLXJpPcMwDONZpKB0fYnaoRSCBHz7dwg9VddVrZyIKjbugOvqYFyniXq4GimBkJGUGbjVfGVjCstbPUok/TLturru1lH6BsydO5cmT55Ml156Ka1YsUJ9PDs7m8rLy6lv377qY/3796edO3e6tJ5hGIZxH4TT68rq1SgJqK+30F3zLaIsFOWhILbMuAOuqwbPigTrhXLHJNdeH93J+pqqA0b2lFSpy3kifdM6P4lN+saPkRK30jePP/441dfXU0VFBS1ZsoRuueUWevPNN6lXr15UVqbUicfEKHlMEBsbqz7e0npH1NTUiJvNBoeFiWiNpzQ0NNj8ZfiY8HnC35/WEOjflKI1xepy3OBYsR2vf0e0aY/VX9CxtpKi6+qoprhGmEGD6ZhU7LMOkoVRSnt5mb5x5f8nZIRTjSmEIiwNVHe4ymfb7OtjUtnoqykMjaCakFDqlGqhhobWl+/2TCeqDQsV/VyS6mqEKPF0H0IwbXELuHV2RkYqHzhSN+ecc46IlPz8889ClMhUDgSLFB6IjMjHW1rviNdff50WLFhg89i0adNo+vTp1Fr27dvX6vcINviY8DHhc8V435+c33LV5aq0KtqybS/dvyBd/XkXA3XjuL1z5S6K6mkduIPhmORssu7/riprhVFYQy5lZblwVV8brcyoW1NBptxK4Xe090vq/ZhYai1UnV1tUw4c0XCIsrK8U77buX06HdoZLURJdU4N7d6ym0LM7hfvduvWrcXntEoyh4eHi8gJSE9PF6Jlx44dNGTIEPEYlrt37+7SekdcfPHFNGPGDK9HSnBSwNfiimprC/Ax4WPC54pxvz85WXnWq9pJPei5n6Iou1C5P3UsUeQKM1GBcj+yMokyM100WxjkmOSXFFoNv/Ht1eXBfdtTZmbLr+9bQPRX+F4hSsJqGiijXQaFJyhlxUY5JhVZlbTFst2mcdrooR1F8zNvMKgH0aF/zTSAisT9lIYUisu0zjHkTVwWJcXFxaJq5sILL6TExET69ddf6ffff6cLLrhAFSiTJk0Sz3nsscdo7969tHjxYnrqqadcWu8IiI/WCJDmwEnBooSPCZ8n/P0x8m8KumuWrFeqaiLaR1BFTBQ9/r7cHqI5V5rogx22Ja/d/biN/jgm0lNiCjNRVrU1CpTR3kQhIS1HPFITLcIYKqk+WEOR7SINdUyqD1inFcC+oFNt+3Ymr0V8BnRtoL0aX0llVhUlDEyggIqS+Ph46tSpE1100UVUUFAgIh8PPPAADR48WH3ObbfdRvfff78QH1FRUcIMO3LkSJfXMwzDMK5TdaCKagtqVZPr7HeIihttejOnEA3oZqLQNOuAW7on+Myuao+SjCg6WGgdhF0tCcb8LjK6IL0Z8QN8EwXwRwVSbrhZ9CjxZgoKFTh/+amBmsuiBDsILwduSNmEhoY6FC7oRYLyX6y3PygtrWcYhmE86+Rq6R5Hcz9XlqMiiB66RPl9jczQdCzVVKoEA5jrp7ZI8ZGY0Tgtn9RurtFRro0vSHGgWsVREzKjlgN38VKPEkm/TLsKHB82UPMohuRIkNj7PpoTHC2tZxiGYdzr5LooO45qlKAJ3TSNqFOq8hsb29k6mNRmG2/AdXUwhig5lO9m4zRYC8JMVK5pNa8tMTZq47RMb4uSrnat5n1YFsxOT4ZhmCDo5Pr+nng1SnDnedaLvqTUMCoJbTRu5hpvwHV1MDalmqmiyr3GaZKGZI0oMWCvkir7FvNp3r3oj4s2UVxaOFWEhPq8gRqLEoZhGINHSkLjw2h3vTKwjupPlBhnHZQwMVteuGLcDC2sIku9b6ee9yfaqEZVouuzA9sTomk1r21CFihqS+po25wddPDTQ8LM7Ko4qwwJpdLQcK9HSkC/riY1hYOJC311HrEoYRiGMSDVh6vV3hSmHnEw/onlHmhR4sTIGVJvoeoca6VGMEVKis2aFvNuipJ2KaFU3BhNKteBKMl6JYt2PLmT1lyxjrY9uqNZYVJ1qEoVZ+JzNpm81mK+ia8kvDGFU2exSZ15ExYlDMMwBqS4cb4bUJqupG5Ajwzb0H1yvDKVvZE9E81VH0lyIzUt5pPdS19ohVsturrWBbbjd9Fqa5fenc/som2PORYm5bvK6c+TV1JDtbK9O6OUqiFfREr6d8UcOL43u7IoYRiGMSAlmsqbgwkaUWIXKUm2K3nVDuTBFCk5aHJ/Mj6tKFF7lTQoUahAUrHLdsDf+b9dtH22rTAp2VAiBEllY3luQXQUvZXak1CH4m76ytVIiY0o8ZHZlUUJwzCMASnWVN5sibD21ehuJ0riookKIm37cAQLMuoTkRJBB0qsw5m7g3JKgsmuV0nghJul3qIO+KHR1krXHU/vou1zFGFSsKKQVpzyN9XkKG3kY/vG0gN9R1JOhJk6tUeFq/erW5tW4PjmPGJRwjAMY0BkJ1cMXOsqop2KErRfqGmnjwHXmzTUNgg/hX05sKeREptoUgCPUdWhKmqoUSIiKROSqf+cvuq6HU/torVXraeVZ/1DdSVKf5bEEQk08KORtLs6ymepG9A+0UQ1yRwpYRiGYeyoLapVw/bxA+NoxyHlyjgtiSjG3PQq2ZKijwHXm1QdqhapFhCFxmnWKYDcjpS0T1Q6oeohmlSuSd1Ed4+mrpdnUv/ZVmFy8JND1FCp7HjKscl05Gcj6FCNda4eX5hcJe17RVE9KedX6U5O3zAMwzB2qRtz/zjKLnAcJZGEt49UB5PyIEnfyPbywNzZrEZKEtzo5mobKYnURVlwhcZAGt1NiYB1vSKT+j1mFSag4+lpNOK94RQWE0ZZ2dbHfRUpAX26hajeG6RvXClXdhdO3zAMwxi4k2tVZ23ljePnJyWa1F4lwZK+0QoHMe9NvmflwLLV/GGtiTPLdx1L3RElMY2iBHS7MpMGPTuAYnvHUI+bu9PQVwZTSIQyhGcdtr7e243TnFXgWMrrqLawsYVwIOa+YRiGYfTlJwGHk7SVNyangy48Ex1qq6i+sJbqK+ptTJRGxCbFkhqldnP1pPIEkZKi0AjRfMzcUO8zE6crlO+0Td9o6XxBJ3GzJyvbGrHokuq7bUMFzpcQJeVWARWRFOHV/8GREoZhGINOxBcSYaKdYTHq487SN+hVYlNdEgRlwdqIT2m02WOTq2zNHxpmouxGX0nlXt91LG2J8sZICT5bs2YyxeawjZT4astkWbD7FThl28pExZArsChhGIYxEHVldVS+Q7lUje0XR7sOm5z2KJEkx9uXvBrfV6Ldh/woz1vMg5AQkxBuamrChx1Lm8PSYC0HNmdGkynUtVSM1lPi7RmCtXRKJSqKdb+B2t639tOKk1e69FwWJQzDMAaiZGMpUeNFfMKQeNp5kFr0lARjAzXpKQkxh9hUn6S72c1Vm8LJ1kYBfNSxtDmqs6vVypoYu9RNc+zNUf6mtiMyR/rOU4Ly8uiu1u0qcbECR9voryVYlDAMwxgI7Q98/OB42nlAWY4xK4OSK304jG52RdWHFFbmTmY6WGAdiD3tZopj5I+Opa6kbrSVNy2xda9FLYf2ZeWNJLWf9RgVbK90KfqjNWa3BIsShmEYg5pcYwfG0Z7G0H33jsqVrCOU+W+CJ31TW6CYdYG5cxTtPGBptadCESW+71jqbjlwc9TVWejCRy0kK3MnjySf07t3OBU1Tl5Y5UKVEvqu1JUpn5UrsChhGIYxEJiETVKSHEO1dc2nboIxfaON9CBSsn2/dV3vzp69JxqoSaNrwCIlOzXlwC6kb2a/S7Rys3W/773Ad6kbR2bXkIJqqq+s91rqRrxnq7aOYRhGB6H8HTt20Pz58+m8886jq6++msrLrQN3sCG9FBHJ4bS70NrVAZESZyBSUhEaTuUhYUFRfaOdiA8t5rftU5ZRHZ0U77mnJCfC2rE0EKKkYrfrouTfrRZ6+A0lRIJJ+N6+1+R20zhPRUm2TU+XSpcqxVyF+5QwDGM4SktL6euvv6YlS5bQ0qVLKSsry2b9qFGjaObMmRRsNNRZ53uJ6mSmLYes63pkOB+Q2sUhtaNES2Kqy0SreYg5Z+kevaMVVSEdomh/buuiJHJSvnpTiDhGabWVVLG70u/HqLxRlJjCTKJ1vjMqqy10/iMWqmsMUtxzPtGR/f2znd06EuWYo4mKrY3m4vrGOn1+8drGJ7oIixKGYQxFTU0NDRs2jHbu3On0OVu3bqVgpFoz3wsiBFovRXPpm9BQE7WLs4gBt2t1GTVUN1BNXg1Ftre2VjdqpCRfMwNyr6Z9xVwGDeYAzK4QJXWlSsdSbzcHcwYEUEWjKDFnmikkzHki455XLLRlr7J8RB+i+y/yn3DCDMSmNDNRo5epbGcFdWjO5LpW8UBFdXTtXOP0DcMwhmL16tU2giQyMpImTZpEN998s/qYfeQkWLD1UkTZlAM3l76xNlCLDIoKHO2kgvss1lRC706eD87wlACb1IQfy4Jrcmqovry+SXt5e37610LPfqwsR0YoaZvwMP9GvOK6W4/RwdXOU6VIgUHcgfgh1s7DzcGihGEYQ7Fu3Tp1+c4776TCwkKRxnn00UfVx/fubbyMDDJsvBSdzbSrUZSEhLRcdaKYXc1BMVuwehxCiLZVRnonUpKg/A1UBY4r5cBFpRaaOdsaHZtzhYn6dfV/Ci71iHiqbUxrFf/ZOBtkC34S9NRxBRYlDMMYivXr16vLU6ZMIbNZGWjxt3379m0mUoJJ6GSPEsx3EhHe/ODUtNV8peGPQ1RaFG07ZPKKKJGdUA8FKFJiU3nTzbEouXeBhfY1Nko7dhjRDWdRQOjTO4y2mBUVF3Kogir2VrbcU4dFCcMwwS5KBg0aZLMuMzNT/D148CDV1np/BtNAo+0vUpsURUVlzc9506S6JAgaqKEEFX4Y2aNEWw7cq1VGVyJ0UM8Oj3a5ssRnPUp6OBYlX/6u/DVHEr1xj0m0xw8EMBSvibF2qcv/tXGKZjuK12gjJY2hqBbgSAnDMIYBZkApSjp27EjJyckORUlDQwPt368ZrYIEbcolO9TsksnVWaTEqOkbm2hRJ6soSUsiiov2fJBGlQ2OY6C6utqUA3drKkoKSixqldHIvojsBK5yqnMq0ZrYJPV+3rJ8h9/V4sZOrpEdIikqjY2uDMMEGdnZ2ZSfn+8wSqIVJcGawpFeCsz3srvcOt9Lj/SWB6jkBBPlh0fK4h3D9irRRotCO5jpcEHrUzfaCQ0rQ8OouLFjqV/TN7IcONQk/EL2rNMUmw3uQQEF/WCyEuLVvjeIlKDSRgv8OHXFisk1YahrfhLAkRKGYQxpcm1JlASb2RVXnlJImDPMtFPjpXA1UoI+HAVhyhVrlUE9JdoIT3GMNfLTmh4lEpkGk2bXqkMtdyz1WjnwrsZy4M5RFBIR0oIoCWx/GUSV0lNDaF2MMtlSTX4tlWKiSA3a+W5c9ZMAFiUMwwSFnyTYIyXomSFLRlEOvOugxeVyYG11iUzhVB+uofpqGTcxZqQkO1Tbo6T1A7VsQGeTwvGDrwSDuiydjXZicl2306KbSAnISIGvRJPC+SXfuZ9kMIsShmGCXJQMHjy4yfouXboErSix6VHS2bZHiUuRkkZRojW7Vh2sMmybfbC73ioevJW+AbZt1H2fwqnQzGcU7VSUKH9RiTuwGwWcjPbwlSQ79ZV4Ug4MOFLCMIzhREloaCj169evTUVKtD1K0GJelgNDbCTEuuApaRwX8mzMrsZL4WhLmTdXRPokfWNTgeOHXiWYSVcS46Dypr7eQht2K8s9M4hizIGfHqBTe6L9EdGU15gOLFhRSPVV9Wo6qqSxvXxEagRFutjNFbAoYRjGENTV1dGmTZvEcq9evSgqquncIO3ataPY2NigFCVaL0V4mnW+F1dSN9pIiU2vkv3GjZSEJ4bRpsNhbkWLXOlVgsnt/N2rxKYcuFtTUbLjAOa70U/qBmSkmETYZnVjtKShsoGK/i4Sy5V7K6m2qNHkOiTerfmDWJQwDGMIMBNwdXW1Uz8JwI+fjJbA6IrS4GBB66Uoio4ii8W9wVhGSmwbqOlDlFjqLS4/T6acEC2S5cAQE+bI1kcP0K49s4P/y4LLWygHXqcjk6s2fQNsfSUFrUrdABYlDMMEReWNRIoSCJjc3MZwQhCg9VIcNEU18UG0RGSESTQHy9FZ+mbfu/vph65LafXla9XwvzOqD1eTpVYRMKFpUVRY6j0/ifZ4okKp2hTit/SNrLwhEybji9a9yVWmb8BarShZltekk6urTdMkLEoYhgmKyptg95WokRIT0c4aq7Do7kKPEtv5b/SVvtnzchbVV9TToc+yadWFa5wKE0RJtj9tDRlUxnlndmCHvhKTSTW7IhVh34PD26izA3eKotDI5suBh+hElKD6BhSGR1JBUqxacVNbVGsTKYkfEufW+7IoYRgmKCpvgr0CxzrfSyTtynGvR4k2hVMaGk5VjVGAqgCnbzDYa1MXuUvzaNXMNU1KlRtqGmjNleto3xvWLr2HB1pnIOzd2XspDVkWLEVJQ3UDVR2qavV+brx9M+2cvocKfredwK6moEb1X0Q7qbxZ2yhK4qJbnnjRX6QlKxNBgq1JjdESC1Her/mqKIlIiaCo9Kber+ZgUcIwjKFESUxMDHXt2rVNRUrEfC+5NU0qb9xJ36i+EpNJnS0YnhJUSgSK6uxqYZDUkvtjHq26aLUqTOrK6+ifGavo0OfZ4r4pzERD5g+iTTGJ6mu8nb4Bh7QVOLtbl8LZMz9LCKqaXTW0+tJ1Ig2lvre28qZ7TJPXFpdZKEvZdRrUHUJAH54S+G86KL3TaGWUNYWz/70DVFtQ65HJFbAoYRhG95SVldGuXbvE8sCBAylEXqK1EVGiNaRqe5RERhClN4bRXSGlcRyXvhI0Y0O4PVBooyRJY9tRaEyoVZjMXCMG75Vn/kt5P+Wr7fWPeGcYZZyVbjsRn7fTN00aqHludi3dUkZbH9mu3q/Nr6V1129QxaD2GER3bxopWa+c9rryk9ibXX9raEemxlmq8dl50slVwqKEYRjds2HDBpf8JMEqSrTlwFEZ6OaqLHdLc+/K2VEFTiAn5tNGCdJOS6ORHwyn0OhGYfJDLv08/Fe1zDQsPoyO/GQEpU5WRkIpSlDC283FsmhXkOkwmwZqHkZKkHZae/U6kQISmKxpqqwFe12aiG+d1k/SUx9REnuza4UpjKKHWCNXnlbeABYlDMMEjclVzh4cHh4eVPPfaMuBa9tFUVWNZ705rA3UInVhdrVvGpY0NolGaIRJQ1WD2oBr9NdHUtJoJV+AKMO2RlHSNY0oovEq3RtgpuH2idb5b1pTFrz9yZ1Usk4pEYrpHUOdnrTm2rY8uI1KN5faHIPo7i1U3nQnXSHNrqBhiDWFI3FnIj4JixKGYYJKlCC106lTp6CKlGiFQ36kuUmqwVUwUzDI0UQBUF0SKBxFCZLHJdGI963CxJxppjHfjqL4AdYqjux8ovJK76dutMf1cLhZnVHZkwZqhX8X0c5nd6k+mMHzBlLcMbGUeYVixEb0BObdsq1l6muiM81OTa5goN5ESXurGCzqYW05DyKSw0VUz11YlDAME1SiRJvCKSoqopISa3liMLSYPxCi7VHiXoRATsqX3Wh09VdzMGdIPwUG7ahO1v1KPiqJjlo2hgY+3Z/GLRndJK2h9ZP09oEogdm1LiREbcnv7qR8dWV1tPaa9SRVTa87eqipjN7396TYfkoJbenGMjWSgiqVULMixCQNDRbVU4IUVXyMPtM3YF9iPIXFWTvsxg923+QKWJQwDKNrEKqXogSpmZSUlp2dweYr0fo+dtZYUy+epm+0Js5yPzQHc/a5qv05Ms0UEmY7HMX0iKEuMztTRFJEk9fK1I23Zge2Rx5XeZwwQ3NtseuG4M2ztqp+mcQRCdT9RusMeqFRoTT0lcEUYtePJLp70yjJ7kPWiJDeTK726Zv9BSYhJlvjJwEsShiG0TWHDh2i/Px8l6MkwShKpKcEZs/thYpfxrP0jfK3MCyS6htFQGWAIiU1OTWi+seZwbM5tu+z+ix6eWEiPntkQzqbiJKLKZycH3PVfipIQQ15aVATwRXfP476PNDL5jFH5cDrbEyupDtk9Q04kEvU/nirSmk3prFe2E2ssRaGYZggSN0EmyhB4y1ZEoxy4L2HreswT4snkRKLyUQl8WZqV1AuUhP4HyY/97+wKYV1V5T4IX0DbM2ulZQwtOWW6Vsf2aYu9324j0OxAbpekSnKZ/OW5TudHXjtDq3JVV+pmyaRklyiTvdkiDLu0Ogwaj/JunLbPgsVlRId2b/lfeBICcMwQS1KjF6Bo53vxdzJTAca20Akxro/hb30lICCaG3HUmszL39h0zTMTVEi0zcR4cpkfL5O37jqvaktqRM+ERA3IJa6zHSumCACB784SPRnQZVKp/Oa5uJsJ+Ij3REbbaIExR4jzktEhHrd3pO6X9vVxk/y0hcWGnWVa036OFLCMEzQiZJgajWvrbyBGfTAqqahc1eJMSsDeU2tEgXooRlwzR5USrQGm1JYB1ECZ8D8ueOANaIRGur9CELHZKKoCPQqca8suHSD1VTdbmS7Fo2emDJg9FdHOl2/rtHkGh3lfqrOn2bX4jIlfQOfkKN91oqrluBICcMwhhAlKPXt37+/S6/p3LlzEIkSqxHVkhJF1TVNQ+euggFDpnD2hWijAP43u7bUNMwZ+3JIPQa+KAeWxwkiwN0GatqJ6Dzp0aGlrMKiTieA9vK+EF/eQJ6H6J1T4KDQDUJFW9bcEixKGIbRLXV1dbRp0yax3Lt3b4qKcu1qHs9LS0sLDlGyzxopKY+3DpKeREqAFCW7GgJbFqyWA4eayNy5aeWJM3zVXt4eRGHKQsOpNFRJKJS7cIwwS662JLY1bNit79SNQ7OrtcO8yqF8ovxi19+PRQnDMLpl+/btVF1d7Vbqxt5Xguod+R5GpEoTKSmItIoyTyIl2gqcrJDWdyxtVTlwY/oG5t2QiBDPTK5enB3Yqa+kcWI+zKhsP3uxs0hJSISJ4hp7kXjK2h2ka5Oro14lSOG0JnUDWJQwDBNUfhJHZtf9+zUjmYE9JdlhUQ67aXpidkXHUjkXiycdS1tDTX4t1ZXWeVR5g0oOf0RKZFmwana12Daxswf7U76jXCzH9otzS2g5Yp22vbyeIyUpJpsKHHtYlDAMEzR4S5QYOYUjPSWYhXWfpnGax5GSxqwCOpaGpHrWsbS1VHipHNjX6Rtg4ytpJqJUsqFUCBdv+Em0JlfdixKbSImlWXHlChwpYRgmKEVJsFTgSE8JqmMOFJDX0jfA0qGxY2lBLdWWuN6x1KvlwA4moXNFlKAiJd3DY+BO+mZ/pLXPSPEq5+aI4rXFre5mqk1vyQgDSp4T44yRvmkuUhJm20HfKSxKGIbRLRs2bBB/Y2JiqFs3a6vuthIpgVCoK6mzlgNrfvQ9N7paB7jqlGi3qku8RfkuJc3hbqSkrs5Cuw4qyz0zUJHlu8Easw+junV9tLUzad4vSqOzlkyurRUlWdlEJeX6j5K0ZHStrrHQ5savXj/r17FZWJQwDKNL6uvrVTHRs2dPURLc1kSJ1k+ibZwWHkbUPtGz99Q2UCtPDEwFjrabqzuRkj3ZRHX1vk/dgMgIk4gC5EaY6VCUso1F/xSrXhh7StaVqGk2eEpawzqdN02zP5/Q+8aR0XXLXuvn5ep+sChhGEaXHD58WJQE2/cdaUuiRDsRn1kTKUFzL0+jBNr0TUG0NlJS4f/0jQmT8bkuSv7caF3ua83O+TyF869ZmWjOUmehgj8LmzyvrryOyrYroQ1U3YTaTbbnLmt3GqPyRvZ0kalE+/SNrbhybT9YlDAMo0v27dunLnsiShISEsTNyK3mtdUe4R2jKK+4dX4SrdEV5Gj6vvjT7KrODtwpyq0B/PNfrabJE470/WAtza5rYpPVx/KW5Tk2uTY0n7p5/Tui215Jpv05Lf/f5Wut+zm8N+kemcIpLCWqrLY4NLm6OqEgixKGYYJSlGijJXivhobme0zoPX1TFtv6xmn2kZL9Yf6PlNQU1lBtkfvlwBVVFvp+pbKM1NXYgeRzZFnwuph2ZGkcLfN+0biNGynRNk0b0nTSvsUrLXTZ40Sf/R5Lt7zY/P+srLbQr+uU5c6pRD19nKbyZa8S214rrr0XixKGYYJWlMgKnJqaGsrOziYjt5gvMLe+cZq9pyS7JpzCE8P86inRVt5Eu+En+eFvDNjK8mlH+aftuoyUlIeGU2Vn5cCVbSmjquxq5+3l7SIl5ZUWuuopa8Tg+78UA6gzfltnbaN//EglPaJ37GcLti9rxjmXZg02NQuLEobRMSgN/O9//0t33XUXlZQ4mFgiiPFmpMSovhKtpyQ7pPWN0+TswtIzjHSQ9HRUHqiihpoG/5pc3YiUaFM3/xnvn4FaekrAvgzFVwLyf813KEpMYSaK62/byfWhNyzCoCspryL6da3z//njP9b9nDxC/4LE/nyUkZLDBRY6XGA1uboqrliUMIyO+eabb+j++++nxx9/nE455RSqqPD/HCWBgkWJ1VMS0T6CDpSEeiVSAoNsu8biEMxJogqDhuY7lvokUuKiKKmts9BXfyjLcdFEk44gv6CdmXdNTJLD0mBhct1WJpZj+8ZSaJT1c1q9zUL/+6jp+367wtJsRAhgDPfXfvqiV8l6TfM3V/0kgEUJw+iY33//XV3+9ddf6cwzzzT0PC6eipKMDM0laxuJlCBqIdMEonGapltmazwlWrNrfglRdFf/lgWXaxun9bA2JmsORBZgogQnjVbKdf1BUrxJRJbAH3WJFBqtCI68ZfkiiglKN5U5NLnW11voiqcsVN9YEnvLdKLQEOU13/zp+P8dLrCoPgwYXFMSDRIp0YjkA3mWpn4SFytvAIsShtExq1atsrn//fff04wZM9RS2bYgSjp06ECRkdb26p6KEqNV4FQdqlLblmMWXW1jqtZESrSiBA26IrtYRUm5Hxqo2bSYz3RtduAvlvs/dWOfwtmVF0KJo5TmMNXZ1VS+TSkBLl7juJPr3M+I/tmiLPfvSvTo5URH9KpWu9Ju18zhI1n6r3V58ggyDLat5h3M3eOiyRWwKGEYnYIrMSlKYmNjyWxWfsA//fRTuvTSSw1ZTeIqtbW1Ynbf1vhJ9BgpQSfTvW/uo5qCRiejC+3l1W6uWlHSykiJ1uxaq+3q6odIiRQlUelRFGoOdel78MVyZRlNuk4cTX5FpnDwdTMNS26SwnFkct172EL3vmodlBfcbhLbfuwQq+hzFC354W/ra44faYwoieybIy0jMn0jTa6hoYoocxUWJQyjUzCzbV6eMhKNGzeOPv/8cwoPV1onvvXWW3T99derIeRg4+DBg+q+tUaUpKamUkREhC5ECfbn73NW0YZbNtEfx68QxtLmKN2i+BTUSEnjjz38IObI1g1Y2rLgiiRrtKJyj28jJbXFtWKGYBDd3ayWwKJktqTc8bmMaIMc6CYNJ4qP8XOkROMrKejRVJSUSJNrqIniBsSJz/ma/1movPFQXn060dhByjZrRYm9rwSv+/Ef67w+/ih59hYR4SZKbezGD/EMD9CmPcr9Pp2Jotw4X1mUMIwBUjfDhw+nE044gT744AMKxaUHEc2bN4/uvfdeCka8YXIFaE0vy4IhSgIp4qoP11DFzgp1npm/TltJVQcdC5PD3+bQlge2qvdje8fQwXzvpG7sG6gVRURRSKNHo9xLkZKyrWVUuamq2dSNNNje8ZKFptxmocEXWyi3qOnn87k2dXO0/6MHPTOs/3NbSCxFpCgit+C3AtFyvmyrksaJ7RsjIj+fLLNGQRBBmH2F9fW9MmrFBHvgl7VEZRXWfcMcMQcbo2EThvjPN+Mt5HmZXUBCkNTUetYm3yNRgqu3k046ie644w6bx6uqquixxx6jE088kaZPny7y3+6sZxjGyurVq21ECTjjjDPo9ddfVx+fPXs27dyp6eUcJHhLlGhTOKWlpVRUVESBwr45GYTJitP+biJM9r9/gFbNXEMN1Up6LvWE9mQamqT2rmht6gYkJ1gHvIJyE5m7NJYFZ1W2Wrjl/ZpPvx+zgvZcuJf2v3PAaTmwrLxB3w45Cd0F/7VQQ4Pt///8V+Uv0gOnjiO/o009bMwiSp6gVOHUldXTvnf2k6Ve2d74wYrSe/gN6/bPvclECbHWY419gFEXYNBeovGQ/NDYGA5MNlDqxr4CB8beHxsriNw1uXosSp588klKS0ujykrbUN8LL7xAW7dupZdeeomuueYa0V9h48aNLq9nGMZ5pERywQUX0K233urwecGCL0QJ2LOnMaYcALRVJ/KXF+WxK063CpNd8/bQuus2qANd+lkdafibQ+lggfWH3RuREu1kfofyrRU49RX1IqLTmvTMums3iDliwOZ7t1DZjnKn5cAQIPs0zbYWryR67G3r/S1ZFjGpGxg3iKhDkimwomQPUcoEawpn97wsGz8JGqXhObIM9j9HN30/KUrAN39anPQnIcOhFcva1NQQX0dKli9fLkoSjz7a9mijGuDrr7+ma6+9lrp27UrHHHMMTZw4kRYtWuTSeoZhbJFiA/O3dOvWzWbd6NHWX7Zt27YF3aHzpijp3t1q/d+9ezfpIVIy8Mn+qhBASgfCZNM9m2nL/daUTeblXWjIS4MoJDzEpnW3NyIl2hl2N2dZKLqrxuya5XkKZ+Mdm20iP/UVDbTminVqUzabcuDu0ZRbZO1eKpn1uoV++lcZ1D5vNLgGoupGgkgH2r2DjbuJko+29ivR7mvC0ASRtpCBJpT0OmoYduwwoiglA0TfrlC8JOjwumyN8hhSPgNsv+6GoJOmgdpv662P+zR9g8jIs88+S7fddluTdWjhXF5eTv3791cfw/KOHTtcWs8wjO0MuQcOKKHvYcOGNflx693bOksXoo/Bhq9Eya5dmo5OARQlSUcl0ahFI8mcaRUme+ZbS5Z73dWD+s/uS6bGmYBty4FbPzgP0F7970bUwtzqOXAOLcqmg58oFVNh8WEU0SVcNYJuf3xH03LgbtEiZSNJirdWuZz3iIUO5VnsurhSwJAioaiMqDDKTNE97Jq+hRDFD4izaRg2yMnsvjCxQpgAeEjQzwOzH1dUWaMkRmgtb482gldbZzVluyuilUkPXARplylTplCnTk1nCCorU5ziMTHWZjhxcXHq4y2tdwTmq8DNZoPDwlQ3vSfIMspgLqd0Fz4m+jsm//5rTTZDlNhvR48ePcQPF66yIEr8tZ3+Oi5SlMCoij4lrfl/iMxK4L/x9ra7ekxQDiwIQYlvJIVEhNCRXxxBK0//V3g5BCaifrP7UualncVnK/0d2pllOyY39V24CwQAqiVyCpWUhPmEKBvfh7vHCE3eNty6Sb3fd3ZvKksoo6yL95Gl1kI7n9tNyccmq5GSyA4RFGIOoT3Z1v1AczGYP+FHQHvyU++20D9brSmAzLTW77en9M+0el/W77JQxtFJqmkZxPaJJVOUyaY3x8ButturPU9OGh1C3zW+39d/WKhC0w/xuBHGHJ8Q4bEH/Um05zG+z14TJfjh++OPP+i9995zuF72UEAbbCk8EBmRj7e03hEw9C1YsMDmsWnTpgmTrDevxBg+Jno7T37++WebSIGjctb09HQRTdm8ebPwSvjz6srXx0XuLwSJjBh5iiyjBps2bfJZaXBzxwQ/ymU7FVES3jGc9h3SdKudm0b77zxItQfrqMNt7YmOa2iyjVt3I2Wg9IY31R6irCzPfR+SHh1TKafQLITJnhprr43cjbkUkeX69Sr2bd+NB6i2UCm3iJsUS3VH1pLZFEUpVyZT7tw80QRu1eVrqC5XuYQOSQ8V+7h2K/ZJSYfEhOXSYxdW0fodHSm7MEwVJOCYQUWUlWVtUuZvOsRhzFJCAb+tKqBp/RvbtDYS2iNE7M/KTcjzKGNaYsQ+yspqcHieDO6M46t0Zfvilyqqqcd3V2kQ2KeD49fpnZBa6z5JuqWWUFZWofW+XRraES6feevXrxc/Dscff7za3Ag+EZQpLl68WPxAousirkQGDx4snoNluREtrXfExRdfLLpXejtSgpMCP/SuqLa2AB8T/R0TrfcB3zmtWVOb/sR3ElUlEPcYwIPhuKBKLz8/X41yONp3d0BJMJrPISqLhmytfT9PjklNXg1tKd8uluN7xdtuQyZRj2U9hLk1JMzx64s1V9IjBnWkDlZbg8cc0Zfoz8bgRnkqfoeVc86UG+LWMdr7xj4q/8MaARk57wgKSwwTx2ToPYPp39WrqeD3QqrLsXYhTurbTvyPUo22OmJAexo+iOjDh4gm3kRUrxmXL5qaSJmZGneunzkaxtOFyvKh4iTqe0UcHbjzkNpevuOYjpSZ2YV2HFTuIwp1xKDOTs+TzMwQ6peplAGv3hWl+lAG9yAaMbh16cpAkeQgTTN2KM5121mTvSZKTjvtNCFAJIiYrF27lp544gn1agTG1YULF9KcOXNES2eIFUwk5sp6R0B8tEaANAd+PFiU8DHR63kiy4Gjo6Opb9++DrcBj//4449iefv27dSxY8egOC5onCbxlviBr2TdunUiooQre9nrxV/HRNuUDAZPh89rZpMO5imjX3iYUoGCSfVaC9ILso/9luww6psWKdqnI5Xk6jEv31lOW2cpYgsMen4gRaVEqemH0PBQYdZdPv4Pqiu2ipKY7jHif+zLsSqPrmnKfh09lGjOlRa6/SVl27p1JBrayxRQn4X2WG3KIopMihTG1uJVSvQmcVgC5RaZ1D4rg7o7T1XI8+TkMQ1ClGgzNcePdC3FoUcSYjFZYgOVaixJQ3u6f666vPcQFfCAyBuiHvhi4wpEgjLF+vp6UVlz2WWX0cyZM2nUqFEur2cYhkQvDWnIHDJkiNMBtE+fPkFpdvWmydXe7IoIb2vTQZ5gX3XiLrL6Bnl7bwgSoK3w2LgHFThK2qEmt0Y0BWsJiLt1128QZcSgy8zOlHpc08tlc4aZBv1vgM1j8hjsPazcxymu9STceg7R9Wcqjz15dWAFCYiNNlFmmtUYjH3vMlPxVsb0jBGixNbk2vJ7njym6T5NHmE8g6uz2YKhrTypInLL6KrlvPPOo7PPPtvmscTERJo7d64wpyLNYq/4WlrPMAzRmjVrHPYnaU6UBFNZsC9FCYDgk11e/YV91Yk7oFw0r9h7PUocihJU4HSNpsIVRWpZcPzA+Bb3qfAv5fmo3un7sLUizJ6Op6dRzg+5dODDg2QKN1HCMOW9sw5bB7OwMG2TMRM9fyNupBsGdlMavCESsC+HqMuMTpRydDJFpCqmZRhgW6q80YK+K/ExyqSIIDKCaPwQMjSotEH0R5adR0e5L7I8VgVIqzgzqWJdc4KjpfUM05Zx1jTNnmAtC/aHKPE35Q7aq7uKbD3urR4lknZxJjU6gQocGSmR3WZbQjsRXcbZ6RQW0/w17qDnBtDAp/vTiPeHU3RmtGg0lt8otro09gHRM/Zl1HJOotBIZSzTihJXenOEh5lEukYyfnDr5zQKNFrR7G5/EgkrA4bRsShBObAzUJovLwxYlLguSgLRll/tZGoitTeJq9j2KPH+1T+AOKht714DNTkRHUgYopnhzwloAocUT/tjlZ1AtEEi54PRMwO6mZqIEi3rGk8rZJpcnRX3lLHW95xypLEFiX36ZrAL0SJHsChhGJ2KEvi4BgywzcVrQbRRRktw9Q+/RDDgi0gJ+roEMlIi0zdRGVEUGuWeyda2m6t3By5tCudAmJuRkjVWUSLnfXEHmboB0q+hZ+w9OFrq6y2qUOmZ4Xra4rzjiK46jWjGZOWv0Tmij3W/j3F+PeUbTwnDMN4HvXu2bNkilgcNGtRi9Rl8JaiCQ3k+Blutz8ToogSiLDXVO3F9lJ/KZnP+FiU1hTVUW1TnucnVh5ES5epfGWC31kaTjCdVtDBbMI5j8TpFlER2iKSoNKXHhjtIkyvokqr/KAFKeBEFQfmufaRk50GiqhrXTa4S+GheulX/++4qpx1F9OodJoo1Ex01mCMlDGN4ULYqux825ycJ5gocKUqQnvKW9wzVgrITtb9FibbzZ7RHlTcWn3hK7H0S63PDKCw21CVRUrGnUi3xTRjqfpQE7D1sMVT6BtEPlCfLsmBtt9b1moygO6Ik2AgJMdGlU0109iTPhRanbxjGgH6SYBUlaHCGkmhvpm7sfSV5eXlUUmJNPejZ5OrrSInNDLhZJrUyqHJfFTXUNbjkJ4kf4pkoMVr6RiviyiuVShyJu5U3jHNYlDCMAStvgrUs2Bd+kkDPFtyacuAmoqS992fAleZEpCSkCRfdZZvzlWgrbxI8FCXa9I2chVfvDNREQVCxJNH2KPG06oRRYFHCMDoUJUhbyOkYmiPYyoL9JUr8mcLxVuM0zLjqi5JR7Qy4pp5WgVHwR4FfRAn2Ky7aGNGFAV0dV+BIUWKOJOqeHoANCyJYlDCMTqiurqYNGzaI5X79+okW8y0RHx9PaWlK7JtFiT5FiU2kJNM9UQJ/0cF836Ru7MuCQW5Xa1vVvGX5TrepZK3SYCQiNYIiPTC5olpFlgQbJXXjrAIH/VZ2HLCuDw01hsDSKyxKGEYnbNy4UVTRuJq6sU/h5OTkqH4MoxKMkRK1HDg9ikKj3SsHRv+Q6hrfpG4c9d/YFB5PYQlKUWb+8gKRxrGncm+lWk2EKIknLeCzC4jq6o3TOE3St4vSPl0bKdm0R6nIaesmV2/BooRhDGpyDUaza7CJktriWqrJV/rHRHd3r2mar02uDjuVZhElj1emIK4trKWS9SU+95MYofJGEhVpoh6N6Rm0U0fEx3bOG46StBYWJQxjUJOrhEWJa7Rv355iYmL82tXVxk/iicnVpnEa+QSbCpw9RCkTNCmcX/KbbZrmSifXFitvOhhrIJcpnMpqot2H7CtvArddwQKLEobRoSgZOnRomxYlaJ+flKRcsXsLpBlktGTPnj1ixnJDVd6kmHw+Ay5SEclHJzXrKylpbJrWmnJgo0ZK7D04SOG4Ozsw0zwsShhGB8BLgsZpoGfPnpSQ4PoVaLBU4MBAKUUJUje+mK5eihK05D9woNGd6I85bzwVJT5snOYohYMZawtio8ncOUrcxyzA9ZX1tp1cG9M3Ee0jKCrdfZMryMo2VuM0p3Pg7LGKktR2RB2SjBX10SMsShhGB8DjUFmp9IUYMsS9+cu7desmWrIbvVcJTLpos+8LP0mgfCU2jdN01mLe6dX/HhMlN6ZwGqobhDCRVO2votoCxSOTMNgzkyvYq5mML9NookST7vp5tYVyCpVljpJ4BxYlDKMDtAOkNvLhCmFhYeqEc9u3b6eGBuedONuqyTVQE/O1On3jB0+JoxlwbXwly/IcT8LnYepGm74JD0N0gQxF784o+1WWf7JmXFmUeAkWJQyjA7TGS+3VvLu+kqqqKtq7dy8ZEX+IkkBFSjBpXVhMmMeREgzeKZ55Sj3qvyErcEDerwVerbzRGl3RyRXzpRiJyAgT9cpQlrX6nytvvAOLEobRmSjRXs23JbNrsImSutI6qsmp8XgiPq0oSU/x7eAtZ8CVkZLI9pEUPyhONbbW5Nc0Mbl6OhFfcZmFisuMmbpxJOIknL7xDixKGEYHaAdIFiW+EyWZmZmqD8LXoqS1E/FVVVtE8zRf+0mczYArfSVkIcr/rcDW5JocTlEZihnWXWQnVyOaXJ2JEpxSjoQK4z4sShhGR5GSiIgIyshojA27AUdKXCMqKko9vr4WJa31k8j28r72kziaAReeD1tfST5VHayimrwa1U/iqclV26PEqKJkoMaDA3pmKMKOaT0sShhdlcV+/PHH9Pfff1NbAlegcoDs2rUrhUoXnRsEQ1nw/v37fR4p0aZwcnNzqbS0tFXvVZVdTWsuX0eHn8ulhroGn0zE549Iif0MuBt2EyWNbkchESa1iZpN07TBrTe5GrFxmsQ+KsKpG+/BooTRDQsWLKDp06fTUUcdRZs2baK2wuHDh6miosLj1A1ISUmhdu3aGbosWHpKMMkgbr7CW74SzAuz+rK1lP3FYSp4u5B2PbvbeaSk1eXAJr/PgIt5etodqZxTlVmVlP3lYS9V3hi3R4mkVyfFfCxhUeI9WJQwumHZsmXib01NDf3vf/+jtkJrTa4AoXSZwsHgLvt9GClaJCMlvoySeFOU7J63hwr/LLR+jk/tpsK/ixyLkq6KKJn9joV6nNNAny5rOtGdPf9s8U/jtOZmwFV9JUR06PNsdTlhqOelQMGQvgkPM4nSYAlX3ngPFiWMbtCmHd555x0RQWgLtLYc2JGvBP1KjEReXp4oZzaKKCnZWErbHtveJHKy9qp1oupGm75B59Pw+DCqrLbQAwsttOsg0WVPWKigxLkwySm00MtfKssR4UQTXJ91wKsz4KZMsJYGyxmDw9uFqx1fnbF6O9Hf2yKDrsW8lmG9NMvutRZimoFFCaML0PBLK0qqq6tp3rx51BZobeVNMJhd/VEO7C1RUl/dQGuvXkcNNcognXllFzIPVgbpij2VtPHuzVRXXkfV2dU2lTeb9xDVNXZsLypToibOePJ9izCcgitOQUmwye8z4KICBxGRsATb/ioJLZhc12y30NhriM5+NI0+UYKfDkVJ+0Qic6QxPSXgnvNNdNwIov9eZqLu6cbdD73BooTRBWj4Ja+UJRAlsvV6MOON9A1gUeIfUbJ9zg4q3ag02ojtF0u97+tJ6Q+nUWiMYlA+8P5B2vX87iaVNzCPannhM1t/heRwgYVe/FxZjowguvt8U8BmwDWFmmwaqbniJ3n9WwvVKJ3o6fH3lNScpLbOonpljBwlAf26mujH/4XQvReyIPEmLEoYXaC9spdXYQjpI43TlkQJ5rEJFlGCmXiXL19uMyjpIVKSmppK0dHRHomSghWFtOsFRV2Ywk009OVBFBoVShGdIqj/nL7q83Y8tauJyXXDbtvjUF1DIp1jz+PvWYQoAFed6p8oiaS/Zl6XLY2NgbWlwS11ckV05dNfrfdXbSP6S+NZP5hn7YJq1MZpjG9hUcLogi1btqjLV199tboMw6tR53JxFTkwduzYUR0sPQFRFinoAi1KCgoKaNiwYXT00UfT5Zdf3uJn6E9RgmMkoyUQTvX11llwmwNekbXXrBfNxEDvu3tS/EDrAJ1+dkfqeHpak9fJcmDtFPcxZuXvW4uJ1u20CpNDeRZ66Qtl2RxJdNcM/16F9+ls/X9bPRAlKzbaljKDuZ9Zgs5PwvgOFiWMLtAOoueff74YzKRY+f777ylYKSsrUw29rUndyMZg6HMij6crEQpf8ddff4lZf8HChQvplltucbo9+Izfe+89v4kS7bFGpdfBgwddes2m+7aI0ljQbnQidb+uWxOxM/Dp/hSVbmsCVdM3jaIkMZbowZnK4I9DctfL1uMy510LVSn9yejq04jSkv0rSmB2lWzZa1EjPdFdzapp15zZqKgc8MkvTT/jj35WUlJNK2847cE0hUUJo7tICdIQGMQkwVwerE0ftKbyRtK3b19V7Bw6dIj0kJICzz33HD3wwANNnvfPP//Q+PHj1XLgI444gnr10pQ16MRXcvi7HNr/zgGxDO/IkBcHCb+FPeGJ4TRk3kAizSoYXYtKLbQ/19qk7LozrJGC7/4i+nmVhQ7kWmj+V8pj0VFEd5zn/0G7j1aUZGnE1jMDqP3kFBr07ACnJlekbqSxFT08zj1WaUxXW0e04CtHjdN8tReMkWFRwuhKlLRv356SkpJo6tSp1LNnT/HY0qVLac2aNRSMeKvyRm++EntRAv773//SE088od7/+eef6dhjjxXeITBkyBD65ptvPG5f7ktRUr6jXP217P9YX7XviCOSxydT31m9yRRmooyz04VQ2bjHun5gN6XS5ZFLrft5x8sWeuxti/CZgGv/Q9Qhyf+iJCHWRGmNvtat1owapRydTCM/OII6TEl1+tq/t1jntZl0BNHVJxerJcYvf2kRJtdgaJzG+BYWJUzAKSkpUa/q5ZU+Wq3fdNNN6nOeeeYZCka8VXkjkcfPPvrkb3bs2KEu33nnnTbLqKr6/PPPacqUKSKiAxAtQfO8Dh38M1K5K0q6X9+NxnxzJGVe3oU6zchw6fnH75lEQ+YNskndaOdNmTGZaHDjR/7PFqJ5X1j9JrefG7jURt9M5W9OITXbS8Wej3+2PvesY4g6ta+nqWOU+/CZLPotOBqnMb6FRQkTcLRX9Nor/ZkzZ6qt099//32Xc/9tsXGa3kSJ3C/4XB577DF69NFH1XXXXnstnXXWWcLPARAVW7x4MSUmJvpt+7TH2lFUxxFouT5gTj+XIzmhZuscRtrKGznHTGioieZc2fS9rj8DPTwCKEo0KRxpdm0J+IU++UVZDgslOm2cNeKjNbzK9E1UhNKnhGHsYVHCBBzt4KkdVGNiYuiqq64Sy7W1tfTiiy9SsBGM6RtU2sj9wuAfEhJC99xzD9111102zwEXXHABffbZZ2Q2OzdP+gJpCPbHbMH2PUqQvpFMGUV07DDr/Vgz0W3nBNYAalOBo0nhNAciPVnZ1tRNUrx1WfpUflljfT9ESfyRpmOMB4sSRreREnDddddReHi4WJ4/f77L5ZtGQV6lx8bGCj9Na0H6IyEhIaCRkgMHDoiOvPZCCxETREkkSM+98cYb6ufrTxDBycjIcCtS4imIIshy4I7JRMkJ1sEYA/MTV5tEdAEgbaNdH8j0DdiS5Vr65hPNXD5nHaPdP6Lr/mO9L7++nLphnMGihNFtpASkp6fTiSeeKJbz8/MDmpLwNnV1daJPhowoeOPKEe8hj2FWVpY6+7A/0Q7y0qwst+3555+nr776ipYsWSKqqhBFCRRSAMNo68t5lg4XEOUXN42SSEb0NdHyuSZ6f5aJ7ruQAo5tWbB7qZvQUKLTj7Jdf+EUJQKkhStvGGewKGECjhQaERERNmF1ydixY236XwQLKIOFMPFW6kYvE/M1Z96FCIGHZNKkSQEP3w8ePFhdXrdunX9SN05sQ6MHmOicSSYKCQl8SgNRDHg+XPWUrN5GYpJBgFRUip0fJj7GRBdNsf8fgd9PRp+wKGECCtIxcuDEVXVYmO3kX2D06NHq8ooVKyhY8HbljV7MrtrKG2/ul7dBCbJfRImDyhs9A2HUu7F/3Y4Dynw1zaFtmHbWBMf7d60mhQM4fcM4g0UJE1CQvpBVGPapGwkaaskwfzBFSnwlSgJtdnWWvtEb3oqUoNy1tNK52LCpvPF8aiO/Is2pmNUYE/M1l7r5+GdlGV/R/yiNmB1OXjdxuPV+16bd+BlGwKKECSjaQdOZKIEJdNCgxn4PGzaovS2MjrfLgfUSKZH7hV4zmZka16TO6N+/vyp2PRElm/ZY6Ix7G6jLNKKJt2eIvh4tpW+0E97pmb4OOrs6Yt1OJZoCJgwhSm3nXJyh/DklgWjMAKJxyteZYZrAooTRVXt5Z4waNUotJUVr8mDA2+XA2veCIAiEKMGVs0zfdOnSJSCVNe5U4MhzbtOmTaLs3BX2HLLQzMcaaNBMC32+XHksvzSU3lviuPX6xkZR0j2dKDZa/+kb0LeLySWzq7Zh2rRjm9+3kf1MlPOliX6fZ6LwMGMcB8b/sChhdFt5E+y+Em1EAQO4t4iMjKRu3bqpkSh/zrKMCil06NW7n8TeV4IUYkupLkwqd8NzDdR7hoXe/B6Cw3b9B0ubvgbNwsoqjZW6sZ8DZ2vjxHwOUzeNc93As/yf8S2/L8zNgTY4M/qGRQmj2x4ljiIlweIrwQ+6FCW+iChIgYeSYPQN8RdG8ZO46yuZ97mFepxroRc+VSaYA+3ilJSEbBWPuV92HrAdwGV/kuYqb/RIH81Ezc4iJdv2KTcwfrD/ZzRmghMWJYwuIiVpaWlq0y9ng2x8fLwaKcGgbmQKCgp8GlHQRp38aXY1SuWNu6IELdHLK60z+N5zAdGuD0x05wwTnXec9Xkf/tRcJ1fjDNpIM3Vq37wo+V5zbXDKWOPsG6NvWJQwAaOwsJBycnJaTN0AGBKPPPJIsZydnU379rnY/7qNVd44ijr501fi6/3ypShZu3at0+edOUExaF5/JtHO90306OUhlBinDMTTjrE+74OltmJ5wy7jVd7Yp3AKSojyippeBHy/0mLTLp9hvAGLEkb3qZtg9JX4qvIm0BU4RkvfdOrUSZ30sblICXp3oOvq8zeGNElTdO1INLxnlZqu2agpAZaRErSR1/o0jEBznV0rqy20bLWynNGeaIDBBBejX1iUMLo3uQajr8RXlTeB7lWiTd/4Qmx5G5guZbQEs1Cj5bwzMKuvM6aOqmgSLUHTMTmYQ5BEhBsrxaGtwLHv7PrrWqIqpb0QTTmSJ9djvAeLEkbXPUqciZJgipT4QpSkpKRQUlJSwCIl8AhhlmcjoE3hrF+/3qP3OPnIctE8TFbhiNLo/UQ1tcZM3QBtZGeLXQXO939pUzfGEluMvmFRwui+R4kEs+jKq+9Vq1apnWCNiK/TN9qJ+TDHjj8azuF/yIntjJC68WZn1/aJDXTMUGUZzcRWbTOuydWV9I00uaIdznFH+He7mOCGRQkTcFGCJlau9umQvpKqqiqfzlfir/QNIhqyqsjbaIXetm3byNcYzeTqaA6c5syuLTF9onX5/SUWWq81ueo/k9UEeEVQaWSfvsnKtqalRvcn1fDLMN6ARQkTENA9Uw5ivXv3VjuQtgVfCQSV7B3iy8Hb32ZXo4qSAQMGqA29WiN0zxivGFplaTBasEuMmL6BuVf2K9l1iKi6RhFZi1danzPlSBYkjHdhUcIEhN27d6ttvV1J3QRTBQ72XfZZ8aUZ1N+9SoxWeSOJjo6mXr16ieWNGzdSXV1jdzQ3SU4gOkGpWqf9uUTfNWpmcyRRt45kSPo2Tl1UX0+086AjP0mANowJWliUMIaovNGG2iMiIgwdKfF15U2gepUYrXGaI18Jolja/XCXcyZZIwfS5Ipy2eYqd/RMn862FTioKFryr3Ifk+sN7x24bWOCExYljCF6lGjndRk+XJkDffv27WKuFaPhrzQHojBhYWFimdM3/vGVnDqOKErRzIZO3Tgzu/65gai0sfr5+JFKiodhvAmLEsZQkRJ7X8nKlZoEt0HwdeWNBPPpyDQKjK6+nphP7hemC5DlyG2pAgfEx5jo5DG2jxmx8sY+fSMn5rPt4mrc/WL0C4sSxhDlwMHkK/FX+kZ7bJGW2Lu3mTnoWwnKs+X7QwgZbSZYb4kScK4mhWPUyhtJr062kRLtfDeIlDCMt2FRwgQ0fZORkUGxsbFuvVZvFTjV1dV000030Y033mgjOOypr6+nZ599lpYsWaKWQnfs6FsHpL/Mrnv27FEjMUbzk4DMzEyKi4vziig5aQxRrDk40jfRUSbKTFOW1+4gWr1dWYaXpEOSsYQnYwxYlDB+B628pRfE3dQN6Nq1K6WmpqqixNdpiZZ477336LnnnqPnn39e7M+1115Lhw4dahIZOvroo+nmm28WUQtw3HHHiYkGfYm3za6IhkCEBUs5sKN289hHTBbpKeZIE115qrI8si9RegoZGukrkW3lAVfdML6CRQmj+/byjgYQGS0pKioShtdAok0hocx53rx5YmC+++67KTc3lx5//HEaOnQo/fHHH+rzrrvuOnr//fd9vm3e6lWCEmZEg7p160bnnXeeWs4t0VasGKkc2JnZ1dN285LHrzLR36+Y6JcXTIZLZdkje5Vo4f4kjK9gUcL4nU2bNnnsJ9Gjr2T16sbpUonU+V4qKytpzpw5Yg6Yu+66S40uYMD+9ddf6YUXXnA7bRXIifkQCcJN7u/ChQuDKlLibV8JSoBH9DWJqInR6Ztpuw/xMUSjBwRsc5ggh0UJ43fQoErbTdMT9OIrQaMteVWNBlzwlMBbInupyNQSrpZvueUWUW46fvx4v20fqmAwZ1BrIiXffPMN3XrrrTaPPfzwwzbz6bAoCV7sIyWY6yY8zPhii9EnLEoYv6MVJQMHDvToPUaOHKmGxQNZFozog/SIIEUDrwvMrCjBveSSS0SfEOwjUjdPP/206B7qb2QKBz6XkpISt14LwXXOOeeo4kp6eTDx3jPPPNMkfQPzbnp6OhkR7bnYml4lwYa2LBhwKTDjS1iUMH5nw4YN6mR0cpBzF0xiJ1MTCLU7Ml/6gzVr1qjLw4YNs6nmQIqjtLRUbJ823eRvPK3AgfCYOnWqGhGZNm0a/fzzz+o8RU888QTl5OQIwYLW+bLviq/Nu74C1Tcy9YRzFNVSDFHHZKI4jZaWrfQZxhcY89eDMSwFBQWUnZ3dqtSN5IgjlDnTYbqUQieQfhKtKJEgchBoo6MnFTiI/px++ulq75ERI0bQG2+8IQTO2WefLR6DWPnvf/8rJheUotCofhJ7X0lFRUWz5d1tCZy/UohMGErUpQOnbhjfwaKEMZyfxF6UgH//bZyQI4CREqRv9Ii7kRJU2iD1JA3EnTp1oi+//FJNPcEzIw29L7/8Mi1evFh9bbCIEm+YXYOJN+8x0XdPmuiLR1mQML6FRQnjV4JJlGDwlpESVNngpndRsnnz5haf/8EHH6jlyhAfX331lU2TNxhnYdqVUarbbrvN8OXAjkQJ+0psm6jBS5IYx6KE0ZEo2bdvH91777106qmn0sUXX0xLly61WY8QLnoyIA997rnn0g8//ODWeib48aYoQbpEpkYCIUr2798v0lF6jpLIZnMyyrFq1SqXqm0kr732msN9QzWOrOopLi4OmkiJtlcJR0oYRueiBKHaY489lubPn08zZsygWbNm2Qwyc+fOFfdRfXDppZeKskHtlVlL69sSuML8888/Re66LeFNUQJjYu/evdUqEcy/oic/iV6AMRWeENkOHgbW5pBpG/hh/vOf/zg99g888ECTx40uStAcTqam/DGzMsMwrRAlMLWhNTZCufjbv39/1WAIpzryzmixjRAu1kPALFq0yKX1bQ1EnMaOHSvKEKXxsy0gz5cOHTqI6pvWIlM4ECT+NrtqRYmeIyVAW/3TXF8XTAEge44MHz5czDTsjCuuuMJGhED8oOrIyKBy6LPPPhPiOVDmaYZpy7glSrRVBLjiQhmgzMGiB0J5ebkQKtorYfRrcGV9W+PDDz8Uf3EMUeWADqDBDlqu4+aNKIlERgACkcJxVg6sR7TN5prrgKsVLC2VMaNB3GOPPabe79Kli9o0zsgcf/zx4ncKPWYYhvEvbn/r0B4bVxIoB7zhhhuoX79+4nHZy0DbOhshXvl4S+sdgatf+5A8fiha88Mnm0AFchI3XI1qp5HHQACPzrvvvhuQ8lF/HRPtfCL40ffG/9OKgX/++UekBf11TGSkBOc0wv6BnhiwOY480tpcorlJDLWCBQ3q7J9nf1zOOOMMmjx5Mv3444+ij4mej4Gv0MNvit7gY8LHxBGu9DByW5RcdtllwqSKSdDgCZGpHOSfAa74pakOfgmzWZnDu6X1jnj99ddpwYIFNo/hh2/69OnUWmDaDRSY+8RR5ATVGyi3DBS+PibLly9Xl7GvWVlZrX7P5ORkIeRQCQOPjjfe05VjAnOn/F/oAxLI88lV8F1FxBKiBD04ZBM0LcuWLVOXUQrs7Hhq9xdeMbxv586dvX78jYQRzgF/w8eEj4kWXLx5XZRAROAGPwCukH777TchSjIyMkQEA/noQYMGiediWW5ES+sdgegBDLXejpTgi4If0EB1nkTVhgQtvCFIMKhiwjNcnUL0+RN/HROtdwbzv3jLfwCzK/pv4IaB1xsphJaOCTqbatMcRvBSwMP06aefijQqLgjsW/xjn2U0C6JxzJgxTSJ3zo6L0UuBW4MeflP0Bh8TPiae4rIowZwZSC9AJKDFNzwluPKV3R1hiINxFSWEs2fPFgMvmiph2ZX1jsDg4qscNX48AvUDoi3LRAUDfBGy1wPSDzAPBqItua+PiXZ2YAhTb/0vmF0hSJDqw/+AQdPXx0RbLooUkhEGI5xTECVyviBtTw6AYyjLe/FcR5EUPXx/9AofEz4mfJ60Hpd/VZA3hxhB+gRXuRg8J06caJNKuf3220V76mOOOYZmzpwpBIx2cG1pfVsB3geA0kNc5aMRFdJispfLaaedFnRhcESCZDkwJmxr166d1947EE3UjFIO7E4FjvYxrTGWYRhGd5ESXAVAROAGYSE9IloSExPppZdeEuuRZrF3r7e0vi2gNbliMJNXoy+++KJIZyEtgEnObrrpJvr8888pWEBvjPz8fK9W3jirwLn88svJX5U3OIe9vT++AhEknG8oz3dUgaN9rC1eLDAME3g8ir86EiT265sTHC2tD2a0V/LawRRpqk8++UTt3YFuucE0S6k3m6YFurMrRLVMRaGKKDIykowADOayYyk+D8xg7ChSggsQ7bnJMAzjLzgp7Ge0g6Y27QCSkpJowoQJYhkDhtaDYXR8KUq0nV3h9fB1Z1fttPZ6b5pmj0zLIJ32999/q4/D/Cp9MjDAakv3GYZh/AWLEh2JEoCKBwlKXIMFX4oS+86u2v/V1pumueorwXkpe0uwn4RhmEDBoiRAokSaXJsTJX/88QcFC/4SJf5I4RjR5NpSZ1f2kzAMowdYlPgRGD1lVY3W5KpFO99IsERKtJU36OWAKi5fihJZ3eSPSIl2Vlkj0KtXL7XyCZESfDZyWcKREoZhAgWLEh2lbqQJWPbZwLxAsmLFyKDbZ1FRkVj2VaWKNmLhjUgJOps++uijTaavh5dk7dq1YhmN/1BRZiRgYpUt51ERJUWyjJRAMMqpIxiGYfwNixKdiRL7FE5zk6cZBe1sq74SJRhM0e69tWZX+CowfQK6FC9cuJCOOuoo+uGHH9T1KNuGKdSIJldnvhI0Mjx48KC4j47C3BSNYZhAwaJEh6IE7cAlwZDC8bWfxFtmV3QzxYzNs2bNUtMaECBTp06ljz76yPB+Eme+Eq3w5dQNwzCBhEVJgEyu8qreEcFWgeNvUeJJCgfbiCjBV199Je6j74mcG6a2tlbMUTR//nwbP4lRIyX2MwZr/STcNI1hmEDCosRPwBuC+YLkYNbcvCKYnRU3OUeJ0ZuoaUUJmo3pTZR8/PHHIkKAma8BjKDffPMNffbZZ3TJJZeIxxA5ueqqq+iVV14xfKQEMyvD8CrnYdLOWs2REoZhAgmLEp2lbuyjJWVlZTaeDKOBwVw2gevatatPm3J5YnZ9//33xfxNWp8IXnvCCSeIrsMQIXfccYf6/IKCAnVgx8zXRkVGRDDXEoSvNO6mpqYGeMsYhmnLsCjRuSgxegoHJkrMMA18PUcMzK7azq5Iu7TE888/ry6ff/759Pvvv4vBWYI0zuOPPy5uzlrbGxFHERGOkjAME2hYlAR4zhtnBEsTNX/5SewFHyIALZldkRZbv369GsV56623xPwwjkC05NVXX1UrU6ZMmUJGxpF3hP0kDMMEGhYlOjO5aq/EMUmf0SMl/igH1qIVfC01UdOW97oS+bj00kuFB+PDDz+k66+/nozM4MGDm0ysyZEShmECDYsSnZlcJZh5Vl7179ixg3Jzc8mIBCpS4oookU3Q3OnMiufBgyIFo1FB12DtscL+GNW4yzBM8MCixA/g6todP0kwNVGTogRRCH90CkU3XBnx8IUoCSa0kRGIZQhhhmGYQBIW0P/eRnDX5OrM7HrKKaeQXkEaBPuJlMiuXbvEbffu3aog6969u1O/hjeJi4ujvn370ubNm4XZFd4SZ4NtMPQcaQ1aDwmnbhiG0QMsSgwkSvQEKlv+/vtvWrp0KS1ZskRsX3PVLv5MDcBXAlGC7YEwQVO05iIlCQkJlJmZSW0NiNxx48bRvn376Nprrw305jAMw7Ao8acoQaQAV/Gugj4YXbp0ob1794peEnV1daJ3RqBLfG+++WZavHgxlZaWtvj89PR0GjRoED300EPkLyBC3n77bTWF40iUwOeDfZGpGyOX93oKjK6//fab6CXTFvefYRj9wZESH4NmW0hjuGNytY+WQJRUVFSI8tVAmxEfeeQR+uSTT5o83qNHD5o4caKo6kCqBjdEH8xms9+3UVuBg2jO1Vdf3eQ5bd1PooUFCcMweoFFiU5NrlpRghJUgBRJoEXJL7/8Iv5CXKEKZdKkSeKGPh96QYo/9CFxZnZlUcIwDKM/uPrGx2gHRU9FiV6aqCHqs3XrVnVf3nvvPdG7Q0+CBCA6IyfTQ/UPokzNiZK2aHJlGIbRIyxKfExrJzvDgCmbXAXa7KotS9aKJT0iUzgNDQ20evVqp5U3iKj4o38KwzAM0zIsSnwIqj+WL18ultPS0lzq5GoPmlrJCAvKbHNycihQaEXR2LFjSc9oza32KZyamhp1kkB8JvadTRmGYZjAwKLEx1U3mOUXHHPMMR4bCvVSGqz930aJlEizq5YtW7ao5cucumEYhtEPLEp8yM8//6wuH3vssR6/jx58JTCN/vXXX2qpcufOnUnPoAxZtoK3j5Rom6a19cobhmEYPcGixIcsW7bMK6LkqKOOcvie/gSGURn10XuUBECQSMEBc25xcbG6jitvGIZh9AmLEh8B3wIaU8nIQs+ePT1+r9TUVOrfv7+aEiopKSF/Y6TUjSNfibY0mytvGIZh9AmLEh8BH4MsRW2Nn8Q+0oI0ijTP+hNt2sgoosSRrwTdS2X6pkOHDuLGMAzD6AMWJTr3kzh6j0CkcGSkBGkRzMRrBBxV4Bw8eFC0mAdscmUYhtEXLEp07ieRTJgwwaHg8Qd5eXm0fft2sYzyZKNMcY95huTMxDJSwn4ShmEY/cKixAdUV1fT77//LpYxoV63bt1a/Z4pKSmiogSgGVhRURH5CyM1TdOCyQtlVGfPnj1CXHHlDcMwjH5hUeIDUDpbVVXlNT+JfcQFXUq1nWJ9jRFNro58JUjhsMmVYRhGv7AoMYCfJNC+EiOLEntfiRQlSEH17t07gFvGMAzD2MOixECi5Oijj1ajLv7yldTV1dHKlSvFMhqmobzZqJESzHC8bds2sYwJ+5DeYRiGYfQDixIvg7SN9GDAS5KZmem1905KSlIbguGKH7P2+poNGzZQeXm5IaMkAP1hEhISxPLSpUtFSTDgyhuGYRj9waLEB6kOGF2ln8TbyMgLBldc+fsaI/Yn0RISEqJOaCgFCeD28gzDMPqDRYlBUjeO3tNbKZxXXnmF7r77btq3b5+hZwZ2xVciYVHCMAyjPzipbjBRMn78eHH1jwocb5hdFy9eTFdffbVYRrksREi7du2aiJKoqCjDpjy0vhIJixKGYRj9wZESL4K28nImXXgZOnXqRN4mMTGRhg0bJpbXr19Pubm5Hr9XbW0t3XTTTep9TFw3ffp08TjIycmhnTt3imWkQOSsu0aPlHTt2lX1mTAMwzD6gUWJl/0XckD3hZ/EUQSmNb6SuXPn0pYtW2weW7JkCV1//fXCf2HUpmn2oIEdms9JjBrxYRiGCXZYlBgodeNNX8nhw4fpwQcfFMsoM541a5YaCZk/fz49//zzhu5PogX7p03hcOqGYRhGn7AoaYaysjL66quvqLi4WFei5KijjqLQ0FCx7Kmv5N5776WSkhKxfPHFF9NFF10kDK+SW265hd56662gECVg9OjR6rKsxmEYhmH0BYuSZrjyyivp1FNPFXPOZGVltShg5KRvffr0oY4dO5KviI+PVwfWTZs2iaiHO6Cz6Wuvvaa+16OPPiqWL7jgAiFWAIy0mFEXoNeKL/fHH1x77bU0ZcoUIb5OOumkQG8OwzAM4wAWJU6Ap+Lbb78VyyiVnTRpEh06dMjhc2tqaujSSy8V3U997Sdpbct5iI0bbrhB7dmBFE5qaqq6/uGHH6azzjrL5jVGLQXWAk/Jd999R2+88YYaZWIYhmH0BYsSJyD6oJ2JF1UokydPpvz8/CYRklNOOYU++ugjcR+tyyFQfI2nvpJ3331X9Yr069ePrrvuOpv1KDd+8803bVIcwSBKGIZhGP3DosQJmzdvbvLYxo0bRQpAejHQ5h1C5YcffhD3zWYzLVq0yGGzLm8zbtw4de4WVyMlpaWldOedd6r3n332WQoPD2/yvOjoaPryyy9FmuPkk08WnhOGYRiG8TUsSpwAr4bk9ttvVz0V8GNMnTqVtm/fLibIk2Wz6HsBceIvv0JsbKwqftBfRPo/muOxxx5TU1CnnXYaHX/88U6fm56eTt988w19/fXXFBMT48UtZxiGYRjHsChxIVKC9Az6dyQnJ4v7y5cvF6kPRE5AWloa/frrr6Iqxp9oUzjYvuaA7+XFF18Uyyj9ffrpp32+fQzDMAzjDixKXBAlECD9+/cXLdlRrQLq6+vF3+7du9Nvv/1GgwcPJn+jjXRIU64zsI1I34Bp06ZRjx49fL59DMMwDOMOLEpaSN+gakN2A4X5EykNeEcASoUx2AdqgIcBVbZLh2CS1T+OwHZLkH5iGIZhGL3BosQBqLrJzs4Wy4iQaEGKBmkbVLGgrXwg+3fApHrCCSeo26ztwOpMlKC6Rr6GYRiGYfQEixIXUjf2dOvWjc477zxhNg00qI5xFA3RgnJmmGFldEU7CzDDMAzD6AUWJS1U3jgSJXoCJcqY26U5X4n2ca2IYRiGYRg9waKkhUiJffpGb6AbqywNXr9+Pe3du7fJc7QRFBYlDMMwjF5hUeJB+kZvaIWGfbSkvLxcba7WqVMnGjhwoN+3j2EYhmFcgUVJM+mbuLg4ysjIICOLkp9++omqq6vV58lUD8MwDMPoDRYldlRUVKgzAiNKYoRBfNiwYdShQwexvHTpUqqqqlLXceqGYRiGMQosSuxAlYqcQdcIqRtZ5ivb20NUyXQN9kOKksjISJo4cWJAt5NhGIZhmoNFiYErb1pK4WzYsIH2798vlo855hiew4ZhGIbRNYYTJd9//71P399IlTdajjvuOHXWYERHtFESwFU3DMMwjN4xnCg566yzqLa21mfvb7TKGwnazY8fP14s79q1S6ShWJQwDMMwRsJwogQlrqtWrfJ5+gYeDHRuNRLaaIhsgw/69OkjJg5kGIZhGD1jOFECfvnlF5+8LyIwO3bsUAfy0NBQMqooeeqpp6ihoaHJ4wzDMAyjVwwpSn799VefvC8EiZxp10ipGwmElIzuaMuCWZQwDMMwRsCQomT58uVUX1/v9fc1qp9Egp4q9gIEDeAwszHDMAzDBJUoQYnp7bffTmeeeSbdeOONtG7duibpj2effZbOOOMMuuiii9R+Ga6ud5WSkhJau3atW6+pqamhjz/+WGz7rbfeSmVlZc2WAxup8kaLvSiZPHkyRUREBGx7GIZhGMbrogSD+NNPPy2adOHvkCFD6LrrrqPDhw+rz3nxxRdp5cqV9N///pfOPvtsuu+++0QViKvrfZHC2bZtmxBSmPdl+vTp9MUXX9Dnn39Ojz76aNBFSmQ/ErPZrN7n1A3DMAwTdKIkJiaGXnvtNTr22GOpa9eudMkll1BycrIaLUE6ZdGiRXTDDTeIKAPEy4QJE4QIcGW9t82uP/zwgxig4bOA6TM3N9dm/UsvvURFRUUORQk6pPbq1YuMSFRUFE2ZMkUso2/JiSeeGOhNYhiGYRjvihL4FbTzwJSWloooCSIQ4NChQ+KxAQMGqM8ZNGiQGglpab2rtGvXTo2UyOoSe9DFdOrUqTbCJTw8XERnZOQA24LIjQTvtWXLFrHco0cPURJsVBDJuvjii+ntt9+mjh07BnpzGIZhGMYllBagboJuoUh/jBs3Tk1zSI9GbGysjclSPt7Semc+ENy04H9+/fXXVFBQIDwuAwcObPI69OiQDdYQ8bjiiivoggsuoPbt29P27dvpu+++EyIE/hZ4Y6Kjo2n37t1UWVkpXoN9ciZ4jEBmZia9+uqrYtmV/ZDPMfI+exs+Jnxc+Fzh7w//pngXZCF8Ikoef/xxESWZN2+eTdoAYGDHIC8nh5OPt7TeEa+//jotWLDA5rG0tDR1Gd4QCBt7wYQ0k+SVV14Rg7Sc/RemT0RLvvrqK8rLy6Mnn3ySZs6caRNVSU9PV2cKbkvs27cv0JugO/iY8HHhc4W/P/yb4h1caUjqtiiBPwMRCngytIZKDORIkaDFuYxeYBmCwJX1jkAKYsaMGTaPwcMi26djO+xfj6ocmFvBmDFj6Oijj25yBXzVVVcJUSKFz9133035+fnqc0aNGtXsdgUbOCYYfDt37uySkm0L8DHh48LnCn9/+DfF/7glSp5//nn6999/6eWXX24SoUAEAsbVN998k2bPnk0HDx4UZtOHHnrIpfWOwGvsy1mPPPJI8b/hCUG/Enuvy3vvvacuI2XjaJBFegbREogbDMYffPCB6icBEE1tcXDGPrfF/W4OPiZ8XPhc4e8P/6b4D5dHoOzsbHrrrbcoJyeHzj33XFE9g5u2egalt4g4QHzgOehHom3c1dJ6V0BFiXwNUkgyKiIrfKQowfNQAuyMu+66S12eM2eOiLpI+vbt69Y2MQzDMAzjx0gJTKLaWWcl2ogJSoTh5yguLhbVK/Z+kZbWuwpEDcyqAF4QlP2Cn3/+WURgAAQT/p8zxo4dK1I7qOLRVgAhhaE14zIMwzAMo7NICSan69ChQ5ObNK1qSUhIaFZwtLS+JbQ+EW0TNZTAalM3LXHPPfc0ecyonVwZhmEYxugY0kAwYsQIVQwhUoKKm/Lycvrss89U0YM+JS1x/PHH07Bhw2weM2onV4ZhGIYxOoYUJajiQfpFNkrbs2eP6BYre55MmzbNpUgMDLKovNHCooRhGIZhAoMhRYl9CgfRknfeeUe9f/7557v8PjDb9u7dW73PooRhGIZhAoNhRQnMrhLM/ovyYtClSxcaP348ueOVeeaZZ0S1zvDhw2n06NE+2V6GYRiGYXzQ0VUPoF8JKniqq6vp22+/VR9HszV3e22gUgd9T5AWgkhhGIZhGMb/GDZSAs8IOq/a407qxv79WJAwDMMwTOAwrCixT+EApF+4pJdhGIZhjElQiRJXepMwDMMwDKNPDC1KYEqFQRXAR3LOOecEepMYhmEYhmmLoiQmJkaNjlxyySWUlpYW6E1iGIZhGKYtihKwcOFC2rt3L73yyiuB3hSGYRiGYdpiSbC2Kysm0WMYhmEYxtgYPlLCMAzDMExwwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdwKKEYRiGYRhdYLJYLJZAbwTDMAzDMAxHShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QUsShiGYRiG0QVhZFDee+89WrNmjVgeMWIETZ8+3WZ9fX09LVq0iNavX08JCQl09tlnU8eOHdX177zzDq1bt069Hx4eTo8++miT/1NXV0ePPfYYdejQga688krSM7/++it9/fXXYjktLY1uueUWh89Zvnw5hYSE0KmnnkoDBgxQ1y1btoy+/fZbm+fjPfBerqzXIzt37qT58+er9/FZhoXZnvabN28W+1VaWkrHHHOMuEl27NhBr7zyis3zca7hnJM0NDTQd999R3///TdlZGTQ+eefT2azmfQKzul77rlHvY/zukePHjbPycnJoY8//piys7Np0KBBdMYZZ6jHrbq6mu6//36b548ePVo8B6xevZref//9Jv/3iiuuoJ49e5Je+d///if2F0ydOpWOPvpom/WVlZX00UcfiXOqU6dOdN5551FsbKy6/qmnnhLHTYLn3HDDDer9iooK+vTTT8U5lZiYSKeffjp169aN9Mwnn3xCK1euFMuDBw8W57YW9N7Eb86qVasoLi6Opk2bRp07d1bX43j9888/Nq+ZM2eO+P1x5fV6ZMWKFfTZZ5+J5aSkJLrrrruaPOfPP/8Uv5f4bTj55JNp6NChNuvxHfr8889p06ZN1L9/f7HfoaGh6vqtW7fSF198QVVVVXTcccfRuHHjqK1g2EgJviDHH3881dbWig/Wnocfflh8oXAy1NTU0MUXX0xFRUXqeggSiBW8B2744B3x9ttvi5Pw33//Jb2TmZkp9gUCCttszwcffCCEV69evSg1NZWuvfZa2rBhg7p+z549VFZWph4T3LQ/ui2t1yP40cB2HnHEEfTTTz8JsaoFAygGy/j4eBo4cCA9/vjj4sdAkp+fT1u2bLHZZwgP+3Pt3XffFQIP4nb27NmkZzAgyH3566+/qLCw0GZ9QUEBzZgxQ3xfRo4cKQYNDCQSHEMcy4kTJ6rvgx9WCcS/9nh17dqVfv/9d12LVzB27Fixvfv376esrCybddjnq666SgywOCbbt2+nq6++2uZ8wkDUu3dvdb/HjBlj8x433XSTuCjA6zEYX3jhheJ/6Rmc09gXnDPaizjJE088QW+++SYNGTKETCYTXXLJJTbCDL/NEOja8wHPc/X1egRiE/vRpUsXcV7b8+WXX9J9990nzns89+abb7YZP3DO4NzBuTB8+HCxvwsWLFDX79q1iy677DKKiYkRFwu4gIDAaSsYNlKCAQQ3DKpasQHwI/vNN98IUYITQw6ouI8PW9KnTx+nYgTgBwNXwLgy/uOPP8gIogQ3nPQYbOxBdAg/jCeeeKJ65ffaa6+JK0TtgNLcMWlpvd5o166d2N59+/Y5jbjhivXyyy9Xn//000/Taaedpv54Qng522dE4vDDhKhcdHS0eKykpIT0DAYYuT+OBBRECH5M7733XnF/1KhRInKA745WWBx77LEUGRnZ5PV4jvZ5uNLGc/UuYBHtAfgs7YF4xW/I4sWLKSoqSnyHcI5gYMG+SRBBs78qBsXFxSIaAMGLYwvw24WLh7POOov0Sr9+/cQN0SHctOD3A5EfiAo8Bxw4cEBc/GgjRIiOOfr+uPp6vYHPDzec+zgfHP3OXnPNNXTmmWeqkclXX31VXBgBRGVxobxw4UL1N0b7m/H++++LaO11112nPobnaiO4wYxhIyXNgatboL2ixbJM90iWLFkiwtBQqfZXiwBXh/hyREREUDCAK2DtMUlPT6e1a9faPGfjxo3imDz//PO0e/fuJu/R0nojniv25wmuXA4ePKg+lpeXRw8++KAIzyNFowURA4T5MZA/8MAD4gfW6OeL/TFBVA2pG/vvD6JKiLzhR9bZFFoIU//4449C1BgZnAPJyclCkAAcD0Qk7Y8JImY4VyB2EXqX4KoXkdnDhw+L+4jw4jjjO2jk3xOkJ+x/U+yPyS+//CJ+M5BGxXF09/XB8JuCKBP2FcgoI4TKQw89JFJBWsG+bt06cSGgFctI5+C71BYISlECFYsfDxlaw48Dwmda4XHBBReIKxR8+PjAzznnHPElkSBCgvc46qijKFjAFYs8JhhEEG7GFZwMQUOJ42oY+UtcxSB/jEiApKX1RgSpLBwHOajK4yPPFay/4447xD4j533bbbeJqzsJruxwtQyxhrA8Imp6vspzBewzIgPwQAAIMQyiMiKJK0QIdqQ7unfvTi+//LJIYTkCAxIiSEceeSQZ/bsDoYpoCYBwRQpH+5ty++230wknnCAiJRBi+K7gKlmKGIjaRx55RJwfiL6ecsop4hgaFYgyfCfkdwbnCM4VbeQa+4nfVvzO4tjhvvTtuPJ6o//OAixDUMjvE34zPvzwQ3EfaStEhrQRy6KiIuE5kiB6C0GD3+q2gGHTN80BMYHBA1euMOnhJMAXQGskwuO4AVzFIZeJ0Cr+IpT20ksv2RgkgwHkNnFcEEYuLy8XJzsUujwuSHXJdNeUKVNEaPGtt96iJ5980qX1RgSfN7wC5557rvCVYPDAfuGqVnpStKFnXPXg3JChWQg6HEdc8UjhNnnyZDFgYXA3IvhsIcphvoPowNUt0nY4PgDni/aYwDsBgY+Qdfv27W3eCxGkk046STU2GnmgwTkCbxp+N/bu3StMqvI80aZ/5DGEkRwD0oQJE4Q4gWEa74NzBL9JMDpiWc/m3+bAdwWCHQPqV199JcQGfmdxwSKB10j6jfA7i3MEoh5+Nldeb0RuvPFGccOFCtI0OEfgNZPpXfxmwBOJ54C+ffsKf9Gtt94qxi58v6SYlWIN2Bv0g5Wg3Uv4BPBjCac7DEkYPJv7UDHYytAirnxxUjzzzDOqtwRXRvgCwZhlVIYNG6Y6vjHAwMAJ46ozMCChMsXT9UYAP4K4UsExwY8FfhRQjaKt1NKCgQgRNURWIF4Qbtb+gODKDzdt1M1o4Hsyd+5ccX5gP2B2hH8CfiVH4PuF1+D7oxUluA9vE35sgwEMIvhdgT8JAwl+D5wdE5xHOIfkbwouBLZt20Y//PCDehGAMD/OPZgijQq8NYgQYt/wXUAqorkreilyPX29EYAIk7+zECIYP3Jzc1VhjgsbbdoO54mMhEQ1njeHDh1S12MZj2ujJ8GMsS9fmgFhQPxAIuwOpYkfA1z5AajX3377TX0uQrAwnElFD0MSSl2lWxyGWFnFYWRgrMMPIq7o8KVA/huhVQlynTKNgWOEELQ0oLmy3ohggMGPJAQbwu4w/mrLX3Glq/UGIIKAAUka1OAn0Zqt8UMEoWdfYmskILKQ7sRni+8PyjoxmMjycaTs8CMrwXcLPhr7ARpmc7zG2cBtNPAbgX1BSheCDRU6iIgARD7wmASRMlwQye8HPCWIAGjFKl6jd/NvS6AaCYMl0lD4ziDigfYLkqVLl6rLiECjHYH2N6Ol1xsR/AZAZCBliYtdXBBr92n8+PHC/C0jIPiNwfgC7xbAdw6/M/JiB8ZrPGb0aGPQR0pwssP5jC8+PlxcteDDRp4WIP8LIx6ECa7mUYKFH1aADxcf9AsvvCBOBAwq+NARZgZQqtorZURJ8AOi96oTeGPg0sb2wlCHY4Ire+w7QCQAXhrsG35AUTWAHLj2h/S5554TP7xw2uPYaXuztLRejyBNhdSKFBa4KsUAKnvSwB+BiiT8MEKg4Nho9wmvxw8KeifgmCI3DG+ABFd5kyZNEs9BOSjOJXgGUlJSSM8g4gcxhrw20goQHjgOEKv4fsCwi/QlBBaeI6OGAKFohN9xzPDDiRJGGBlleForSow0wMjeR7hqh+iC+EJaSvphEPXBbwauWuGPgKFVigqUvc6aNUuIdTyG1yIkLy90IM5wnuAiAFWD+H3C7xZeo2dw8YYSV5ja8V3AbwqOh6wYQrQHPhFUW2Ewvuiii2zKw3/++WfhOcL3CukMiH/Zz8aV1+sRfPbz5s0T244LWhwTRD9kOgbfH6SFEYXFbyb8NIg0ShBtQ4kvLpLxfcP4hPNAXuicc845Yj2OC84lnIvakuFgx2RxZpvXOTgxIEjsw8gYGCT44uMHE1e2jgYJvAeeg9fJMj1HYLDCQC9LuvQKviQwKGrBwKFt9IUregyc2Gfc7JEGPggOeCK0PQVcWa838MMPs6UWRIu0ZZwQLBiMkPvVRkEkaKqGH1T8QOD8clRdg3MROXH4A/TejwPAkCuNdxJE0OQgiys9VAHI/DeEiBaIMxwT/HzgmCBl5ei44wrYXqzoFXwvpAlTggFSG2rH54xBAr4S+ygHjhkuDBCGx3ng7DcH4XykT/HeevcJ4LcP+6QFA7A22oFjhuOC80Be7WuB/wbvg99YR1Gzll6vN/Abat8QDue/tmIGUSEIU5w7jhrk4XuD8w2iH7858KVpqaurE5WR+J5ByOm5GaO3MawoYRiGYRgmuGgbSSqGYRiGYXQPixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXQBixKGYRiGYXSBvovkGYZh3AC9U9AHBB1Ug2kyTYZpK7AoYRjGJdDgCp18AZqpYfp1LbL1OvClKEB3ZTSeAuiSqm1AhrlT0K1ZtoNnGMZYsChhGMblqR207a4xpQGmXgfowXjPPfeI7p0A3Tt9JQowuZ2clRkdY+27yTIMY1xYlDAM4xGY4VaKEky0JgWJMzClA6ItaMeOeajspznQpl4wFxWeixlSEfWQ7ckxP4qMkshJIjEXDeYmsp8zBULJ0XswDKNfWJQwDOM2mPsIggDzlmCuH0xmJx/XziAMMJEbJq/D5GwQI5g7CKkeRDkeeeQRMeeQNvWSnJwsBASehzlGMP8OJpXEJGeYLE87Gy8mjEP6BvOOaEUJ5hTBxIqO3oNhGP3C1TcMw7gNZonFQI/ZhTFhGwZ+CAk5o64WzNYNQYIJ1yBeMJU7JhnDpIAQK44mlrzsssto7ty5dO6554qIB1JFiLBghlU5Qy144IEHaPbs2eJxV9+DYRj9wqKEYRi3OfPMMykyMpK++OILeu2118RjGPztZ1jGTMSLFy8WyzDGIqqBqd1hUJVpHwgILYicSHEjUy6YLRXTxLuKN96DYRj/w6KEYRi3SUxMpJNOOklM0Q4DLETA1KlTmzwvJydHRFQA0jKSlJQUdRmeD/v3loSGhqrL7kxo7o33YBjG/7AoYRjGIxAZkZxxxhnCcGpPfHy8TdRE6zNx9ByGYdo2LEoYhvEImFYvvvhimjx5Mk2fPt3hc5KSklQD6rp169TH5TIqcOyrcFoC5lWJjMIwDBMccPUNwzAec+2117b4nPvuu088D9U6L7zwgoiofP3116K/yKxZs9z+n3379hUpGQgSmFcHDhwobhkZGR7uBcMweoFFCcMwLtGjRw8RFWkOiAMYSrWeEVTdfPzxx/Tdd9+Jkl4AkQJPivZ5AwYMECme1NRU9bH09HT1f8r0EIyrqKpBRQ9MssuWLRPvA1Hi6nswDKNPTBZ2fjEMwzAMowPYU8IwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwjC5gUcIwDMMwDOmB/wO4yGlRd4tdywAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - } - } - ], - "id": "7b09db6a" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Model Registry\n", - "\n", - "After comparing runs in the UI you can promote your best model to the **MLflow Model Registry** for versioning and lifecycle management (Staging → Production → Archived)." - ], - "id": "6f1ec89e" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-22T08:27:04.144511Z", - "iopub.status.busy": "2026-07-22T08:27:04.144439Z", - "iopub.status.idle": "2026-07-22T08:27:04.166315Z", - "shell.execute_reply": "2026-07-22T08:27:04.165897Z" - } - }, - "source": [ - "# register the best model (from the \"Load the Best Model\" section above)\n", - "result = mlflow.register_model(\n", - " model_uri=best_model_uri,\n", - " name=\"darts-air-passengers\",\n", - ")\n", - "print(f\"Registered version: {result.version}\")" - ], - "execution_count": 60, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Registered version: 1\n" - ] - }, - { - "name": "stdout", -"output_type": "stream", - "text": [ - "Successfully registered model 'darts-air-passengers'.\n", - "Created version '1' of model 'darts-air-passengers'.\n" - ] - } - ], - "id": "7c854bc4" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The registry is accessible in the MLflow UI under the **Models** tab, where you can add descriptions, set aliases, and compare versions side-by-side.\n", - "\n", - "> 📸 **Try it:** After running the cells above, open the Models tab in the UI and register one of the runs.\n", - ">\n", - "![Mlflow Charts](./static/images/mlflow_models.png)" - ], - "id": "da6cc83a" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Important Note: Custom Flavor\n", - "\n", - "Since Darts uses a custom MLflow flavor on its' side it's important to import the methods accordingly.\n", - "\n", - "**Always use:**\n", - "```python\n", - "from darts.utils.mlflow import load_model\n", - "model = load_model(model_uri)\n", - "```\n", - "\n", - "**Instead of:**\n", - "```python\n", - "import mlflow\n", - "model = mlflow.pyfunc.load_model(model_uri) # Will fail!\n", - "```\n", - "\n", - "This custom flavor is necessary to properly handle:\n", - "- TimeSeries objects\n", - "- Darts-specific model parameters\n", - "- Covariate handling (past, future, static)\n", - "- PyTorch model state preservation" - ], - "id": "7af49ea9" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Cleanup" - ], - "id": "40621b13" - }, - { - "cell_type": "code", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-24T15:18:53.573724Z", - "iopub.status.busy": "2026-06-24T15:18:53.573637Z", - "iopub.status.idle": "2026-06-24T15:18:53.575115Z", - "shell.execute_reply": "2026-06-24T15:18:53.574817Z" - } - }, - "source": [ - "# Uncomment to cleanup\n", - "# import shutil\n", - "# shutil.rmtree(tmpdir)\n", - "# print(f\"Cleaned up temporary directory: {tmpdir}\")\n", - "\n", - "print(f\"To cleanup manually, delete: {tmpdir}\")" - ], - "execution_count": 19, - "outputs": [ - { - "name": "stdout", -"output_type": "stream", - "text": [ - "To cleanup manually, delete: /var/folders/yr/3703qwtj56lcw6n91xm6tq_r0000gn/T/tmpw5bcp0ic\n" - ] - } - ], - "id": "51fc7c4a" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Final Remarks" - ], - "id": "ca40afc1" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Currently none of the model serving capabilities are implemented for Darts. While an API was provided (`input_example` and `signature` parameters for the `.log_model` and `.load_model`) to keep in line with MLflow API conventions, they are currently widely unsupported." - ], - "id": "c4c86a23" - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv (3.11.9)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "01ac1053789e45fab75e2cde894b417a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "02cefe41f8814ddf9de26418b26783c3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "03569ea4478d4d74b0ae4c5416c40d6d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "055bae1119db45caa5b6cd91921c76d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_11dbeaae3ae640c3995e784abfda15c2", - "IPY_MODEL_4787d389023845a8ae398eb5d1155ab1", - "IPY_MODEL_cb3cebaf14cc445a8055d1aac2f0d05c" - ], - "layout": "IPY_MODEL_30a18f8c59754940a9785cd152a67daa", - "tabbable": null, - "tooltip": null - } - }, - "05d25d3b3bd9497f86849702e5a19515": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "071709416bab4673a582978e2e3592a3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "07e8c0b16c2d430ea8bb6798e9b4f103": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_580c0814097844e186ef642094968d3a", - "placeholder": "​", - "style": "IPY_MODEL_ce45f3190357423a9563bfae253f2f16", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "0deaf695a8544725ac4904ff7388f489": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_32e9a01e1a2b4914989eda6f6832f989", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_20cca542fe2a4e19846e2e1cb07dd165", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "11dbeaae3ae640c3995e784abfda15c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_97b2d3e5a7e847739b237fc9c5cdc3a9", - "placeholder": "​", - "style": "IPY_MODEL_dc6cccb142db43b7ac9849983a154a20", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "12524abe09304f9bb20bd9978ac2a44d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_dcb0a4350297443aa61691406923fb81", - "placeholder": "​", - "style": "IPY_MODEL_e53d8d156b1c4db6aff2ba8395bf5415", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 189.90it/s]" - } - }, - "13af542c17d64851a3ef54ce9610bb99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "153af823c040405dbc075bf50a28ff17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "16656416b10a43c8b81c6c4b2a02ec0b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "16ce59abc5bb4ffe978736017f60e21a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_07e8c0b16c2d430ea8bb6798e9b4f103", - "IPY_MODEL_f6f12cd135674388b0fc72167a0308eb", - "IPY_MODEL_81e281800a094e34b2e43021bea6fd11" - ], - "layout": "IPY_MODEL_8d829381b5034ed9807b86d514b1fdbb", - "tabbable": null, - "tooltip": null - } - }, - "19382158e51343918122512753ca25c7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "20cca542fe2a4e19846e2e1cb07dd165": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "252a64f9c6d440e2a3d3c3f62f44d764": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f299c926a6a64a769d3db2e71725f8af", - "placeholder": "​", - "style": "IPY_MODEL_7d599e5710f4485a8f7580c7efca3bc3", - "tabbable": null, - "tooltip": null, - "value": " 3/3 [00:00<00:00, 19.89it/s, train_loss=768.0, val_loss=2.64e+3, val_MAE=39.40, val_MSE=2.64e+3, train_MAE=26.60, train_MSE=1.08e+3]" - } - }, - "27e25633e2a549dcbfafe1129839043d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b154733d72e4e468c339683e83c30a7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b197d3911154085bb86f0dbba2c8b98": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2c4ee939558d44a4a3bc9040a940693f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_71c1aa3663804753bf3a75a227412072", - "placeholder": "​", - "style": "IPY_MODEL_7e0ad83f116b4933a35870525656df5d", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 199.01it/s]" - } - }, - "2e727ab68ed64ee98bfb9d81f1e39c1d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f69737793cc648bd9aadfc0dd4b16569", - "IPY_MODEL_579cbbe7cfb34e429bffd11ec774ba50", - "IPY_MODEL_fe40606eebe6464db0b7f86e5abe1997" - ], - "layout": "IPY_MODEL_c2906f9d5f47471ca6bf44d8754f8d30", - "tabbable": null, - "tooltip": null - } - }, - "2ec00b06939145ec95930e3c1490efcc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce49dfd502074696aefcfa2cff18e4f2", - "placeholder": "​", - "style": "IPY_MODEL_19382158e51343918122512753ca25c7", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "30a18f8c59754940a9785cd152a67daa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "32e9a01e1a2b4914989eda6f6832f989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "331f7f90d7d049a6adc72c260c06570e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4be51ee5aeac4ddf87ec0ca3ceb7b2cb", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_153af823c040405dbc075bf50a28ff17", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "33a28231831d473aa27d32e1c15a8989": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "35778f5ef201497d8d453772f80a7978": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "366e2af2827540728d29bfa6d931dbdb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_2ec00b06939145ec95930e3c1490efcc", - "IPY_MODEL_fb7ccdb37f844e989de3f7a0b12b8924", - "IPY_MODEL_d04931a3bb0c47329cdd67701a7be0ad" - ], - "layout": "IPY_MODEL_f286ebc675c549678f70419f668a7baa", - "tabbable": null, - "tooltip": null - } - }, - "3799be676aea4d12b87992115e4b90ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "3a36a442c4a94ab585d8522e57f45c34": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8f2ac8fd36964f11bd556782c96b0f72", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_35778f5ef201497d8d453772f80a7978", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3b44dec6a3354f7ebc4117e7d7f50b1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e742e68a86474f0db17ccb64db4264c9", - "placeholder": "​", - "style": "IPY_MODEL_cd4d74958b704246a2cb2462a784d502", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "3c3d34b732664135a79031e8bc9e2984": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6eb691aae3a44a25b1e7471929151f47", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_b676b1571a00427587827caac8158c14", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "3cde338fcaf548de8e8216a98e66f9bc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c325a187e8a54e639300ff5a29640f03", - "placeholder": "​", - "style": "IPY_MODEL_b4e804d6e4b44314a8847c2f5be857d4", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 195.74it/s]" - } - }, - "3dddd89019c849f0872e9a9700e14ad0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_425a21a3b7604c8cb49871c1b2850f68", - "placeholder": "​", - "style": "IPY_MODEL_e09f041d857346029cbba27fb36f009e", - "tabbable": null, - "tooltip": null, - "value": "Predicting DataLoader 0: 100%" - } - }, - "40b8f5c6c7844bd0bb071f043f97a639": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "40df96a9f08440a893ffe9d57d176e1f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41e23a2458044b888fb76fd882428b39": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "42360fe280a14e44831c8e62f6ad249e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "425a21a3b7604c8cb49871c1b2850f68": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4297b4158e4f43da9226bfc00272f9c5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "43eab5ba00014d7ba62f97acd9e93eba": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "44c3cc7783594142a19ffad035eea9d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_27e25633e2a549dcbfafe1129839043d", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4f10caf0abca4aa59053c4cb374ea3d6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "4787d389023845a8ae398eb5d1155ab1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b154733d72e4e468c339683e83c30a7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_859b368a8a6d4500960a6e2285f4c016", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "480afa5d41c145d0ac88e2adaca7b1e6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_eeb45b37592a4a599da1857d3444382e", - "IPY_MODEL_44c3cc7783594142a19ffad035eea9d0", - "IPY_MODEL_3cde338fcaf548de8e8216a98e66f9bc" - ], - "layout": "IPY_MODEL_d4b49fabdd4543959d64e4e1c60dc360", - "tabbable": null, - "tooltip": null - } - }, - "4b3f0ca06bf54eb9bab4e081dabcf139": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4be51ee5aeac4ddf87ec0ca3ceb7b2cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4f10caf0abca4aa59053c4cb374ea3d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "50e4f1e4cd994abeae53d0f84b6afd44": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "522af0834c254f0eb2fe7c9efa74c5f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "54aad655289741b59d3c83b8508e68b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b23efdc3bb5747af96dd5e539a14b5c8", - "IPY_MODEL_3c3d34b732664135a79031e8bc9e2984", - "IPY_MODEL_12524abe09304f9bb20bd9978ac2a44d" - ], - "layout": "IPY_MODEL_13af542c17d64851a3ef54ce9610bb99", - "tabbable": null, - "tooltip": null - } - }, - "55e102413ba54377b2fd1995b98c7858": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "579cbbe7cfb34e429bffd11ec774ba50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e6dfb5d14dfe4a1193e551f414ea393e", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_522af0834c254f0eb2fe7c9efa74c5f6", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "57cd2f911c6840da87c1d6c8a78521e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "57db1d3f28d347878d9f48d0ceef5589": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3b44dec6a3354f7ebc4117e7d7f50b1b", - "IPY_MODEL_0deaf695a8544725ac4904ff7388f489", - "IPY_MODEL_e12d00f1e1b94e749f22904d3cec2445" - ], - "layout": "IPY_MODEL_b4d7ddbd507e4e1681cc0888680abb5b", - "tabbable": null, - "tooltip": null - } - }, - "580c0814097844e186ef642094968d3a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "590ebae9a3664214be16b105941c7ee3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "59413112366944be8e0d6600880dc1a4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5dcf47d8b9c0420898fe491a81bab8af": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3dddd89019c849f0872e9a9700e14ad0", - "IPY_MODEL_331f7f90d7d049a6adc72c260c06570e", - "IPY_MODEL_9b933a5d5aa14741904151b4ea7e3f50" - ], - "layout": "IPY_MODEL_cc7d97d8845d46ff9d946020b1b8e4cb", - "tabbable": null, - "tooltip": null - } - }, - "61734f2b95c34e13971fd65cd7da2e1b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "641b5ae5b9e7475db63a31e67b13b601": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "642a06d187834b96af41b74a25d13e1a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6da83aee80314ceb9ace5fa0c4c76529": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9e33a121da334db899669d702f9d54ce", - "IPY_MODEL_7adbf399ea5e4a7c990cdff60674b593", - "IPY_MODEL_252a64f9c6d440e2a3d3c3f62f44d764" - ], - "layout": "IPY_MODEL_41e23a2458044b888fb76fd882428b39", - "tabbable": null, - "tooltip": null - } - }, - "6dad7db23e9e4397bfb93655cd8b08b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e794979a2793408791ee570d3af6f371", - "IPY_MODEL_b35ce184b43b48daaa39ccef748eeac6", - "IPY_MODEL_fb53a4348865461783df6d1e5b16386b" - ], - "layout": "IPY_MODEL_f03f6404137144b8b600f8131c78ac63", - "tabbable": null, - "tooltip": null - } - }, - "6eb691aae3a44a25b1e7471929151f47": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "71c1aa3663804753bf3a75a227412072": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "72125343cca3416fbd3f012232e63ae5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "761dbbe1bf4e4804a3649858898b78e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7adbf399ea5e4a7c990cdff60674b593": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_42360fe280a14e44831c8e62f6ad249e", - "max": 3, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_f60411b259344a9e9a892d9552ecdabf", - "tabbable": null, - "tooltip": null, - "value": 3 - } - }, - "7d599e5710f4485a8f7580c7efca3bc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e0ad83f116b4933a35870525656df5d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "81e281800a094e34b2e43021bea6fd11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_590ebae9a3664214be16b105941c7ee3", - "placeholder": "​", - "style": "IPY_MODEL_02cefe41f8814ddf9de26418b26783c3", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 174.77it/s]" - } - }, - "859b368a8a6d4500960a6e2285f4c016": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "86bfcc40b08440af98f64a732df1ea5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8766872fa61844458d70112fcf44bdb3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8825c219393f4040890a639a17210bc5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "89dc0773756b4b7b93cce8e6cfe47202": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_924315df026a41fb97d7cc8488bb8503", - "placeholder": "​", - "style": "IPY_MODEL_86bfcc40b08440af98f64a732df1ea5f", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 100.83it/s]" - } - }, - "8d829381b5034ed9807b86d514b1fdbb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "8e6984bd5a00425bb9071deba84f4cea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8f2ac8fd36964f11bd556782c96b0f72": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "924315df026a41fb97d7cc8488bb8503": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "95daeef1bd3e4f77b883d3d71fcd1fac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_be1dd700617141cf9517ee7ef1153746", - "placeholder": "​", - "style": "IPY_MODEL_59413112366944be8e0d6600880dc1a4", - "tabbable": null, - "tooltip": null, - "value": "Sanity Checking DataLoader 0: 100%" - } - }, - "97b2d3e5a7e847739b237fc9c5cdc3a9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9914744ed44845fd9d00727c7da93d32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9a20b5d724584e289863cf63a4c13259", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_05d25d3b3bd9497f86849702e5a19515", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "9a20b5d724584e289863cf63a4c13259": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b1dd53c1fdd45dabf3660e9e0be1310": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_c255e442c01446699af3179f14eb8fc3", - "IPY_MODEL_3a36a442c4a94ab585d8522e57f45c34", - "IPY_MODEL_2c4ee939558d44a4a3bc9040a940693f" - ], - "layout": "IPY_MODEL_c7c373a0b1c14b809041651ffcdd4559", - "tabbable": null, - "tooltip": null - } - }, - "9b8b6898ef244336989227f5469a2d11": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9b933a5d5aa14741904151b4ea7e3f50": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c99d9a52749b40628b8d148c64e75e88", - "placeholder": "​", - "style": "IPY_MODEL_761dbbe1bf4e4804a3649858898b78e9", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 88.28it/s]" - } - }, - "9e33a121da334db899669d702f9d54ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_642a06d187834b96af41b74a25d13e1a", - "placeholder": "​", - "style": "IPY_MODEL_40df96a9f08440a893ffe9d57d176e1f", - "tabbable": null, - "tooltip": null, - "value": "Epoch 9: 100%" - } - }, - "9fd5c0e984d04e4aa0e106ec89434720": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "a30948d8cfd6491484d6b63591b65a84": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a5f3118f4f9040ebbdb1a7acae012087": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b1dc954934944e92914a1c129d8c7dcd": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b23efdc3bb5747af96dd5e539a14b5c8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3799be676aea4d12b87992115e4b90ee", - "placeholder": "​", - "style": "IPY_MODEL_8766872fa61844458d70112fcf44bdb3", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "b35ce184b43b48daaa39ccef748eeac6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c198ffce01de4b7294649c1619b5b7e6", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_03569ea4478d4d74b0ae4c5416c40d6d", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "b4d7ddbd507e4e1681cc0888680abb5b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "b4e804d6e4b44314a8847c2f5be857d4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b6625b52007b4434a7804cfd824452cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_95daeef1bd3e4f77b883d3d71fcd1fac", - "IPY_MODEL_9914744ed44845fd9d00727c7da93d32", - "IPY_MODEL_89dc0773756b4b7b93cce8e6cfe47202" - ], - "layout": "IPY_MODEL_e7198635809b4f56bd1a30b6cbe661cf", - "tabbable": null, - "tooltip": null - } - }, - "b676b1571a00427587827caac8158c14": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "be1dd700617141cf9517ee7ef1153746": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c198ffce01de4b7294649c1619b5b7e6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c255e442c01446699af3179f14eb8fc3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ce97bb2d961e4dc9bf44a646cb3d3aff", - "placeholder": "​", - "style": "IPY_MODEL_4297b4158e4f43da9226bfc00272f9c5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "c2906f9d5f47471ca6bf44d8754f8d30": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c325a187e8a54e639300ff5a29640f03": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c60add7b277344feaad65a884c7fbf37": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c7c373a0b1c14b809041651ffcdd4559": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c99d9a52749b40628b8d148c64e75e88": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cb3cebaf14cc445a8055d1aac2f0d05c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_071709416bab4673a582978e2e3592a3", - "placeholder": "​", - "style": "IPY_MODEL_fffac86b0934453d88f52df4b9ac6dd6", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 180.77it/s]" - } - }, - "cc7d97d8845d46ff9d946020b1b8e4cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "cd4d74958b704246a2cb2462a784d502": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce45f3190357423a9563bfae253f2f16": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce49dfd502074696aefcfa2cff18e4f2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ce97bb2d961e4dc9bf44a646cb3d3aff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d04931a3bb0c47329cdd67701a7be0ad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_50e4f1e4cd994abeae53d0f84b6afd44", - "placeholder": "​", - "style": "IPY_MODEL_a30948d8cfd6491484d6b63591b65a84", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 192.16it/s]" - } - }, - "d473da3081af4d4a810014019cd40b29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_dcced12e0ae04e32a811f60680db24f2", - "IPY_MODEL_d9fc58b33d2645488a8c53af72f21e7a", - "IPY_MODEL_fe3a78bc7ec842b08aac1b4e0fe1ed29" - ], - "layout": "IPY_MODEL_9fd5c0e984d04e4aa0e106ec89434720", - "tabbable": null, - "tooltip": null - } - }, - "d4b49fabdd4543959d64e4e1c60dc360": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "d9fc58b33d2645488a8c53af72f21e7a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_72125343cca3416fbd3f012232e63ae5", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_e19ea3de3e554c50a7300a7214c773f2", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "da4c6178632b4cfe96d2a9504cc3173b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dc6cccb142db43b7ac9849983a154a20": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dcb0a4350297443aa61691406923fb81": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dcced12e0ae04e32a811f60680db24f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_43eab5ba00014d7ba62f97acd9e93eba", - "placeholder": "​", - "style": "IPY_MODEL_55e102413ba54377b2fd1995b98c7858", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "e09f041d857346029cbba27fb36f009e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e12d00f1e1b94e749f22904d3cec2445": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_641b5ae5b9e7475db63a31e67b13b601", - "placeholder": "​", - "style": "IPY_MODEL_40b8f5c6c7844bd0bb071f043f97a639", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 186.36it/s]" - } - }, - "e19ea3de3e554c50a7300a7214c773f2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e53d8d156b1c4db6aff2ba8395bf5415": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e6dfb5d14dfe4a1193e551f414ea393e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e7198635809b4f56bd1a30b6cbe661cf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "e742e68a86474f0db17ccb64db4264c9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e794979a2793408791ee570d3af6f371": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_33a28231831d473aa27d32e1c15a8989", - "placeholder": "​", - "style": "IPY_MODEL_61734f2b95c34e13971fd65cd7da2e1b", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "ed4968eb8435434db1604e34ee657413": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "eeb45b37592a4a599da1857d3444382e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b1dc954934944e92914a1c129d8c7dcd", - "placeholder": "​", - "style": "IPY_MODEL_8e6984bd5a00425bb9071deba84f4cea", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f03f6404137144b8b600f8131c78ac63": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f286ebc675c549678f70419f668a7baa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "f299c926a6a64a769d3db2e71725f8af": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "f60411b259344a9e9a892d9552ecdabf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f609670bc6b840ed9f8698af8c7615a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f69737793cc648bd9aadfc0dd4b16569": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9b8b6898ef244336989227f5469a2d11", - "placeholder": "​", - "style": "IPY_MODEL_8825c219393f4040890a639a17210bc5", - "tabbable": null, - "tooltip": null, - "value": "Validation DataLoader 0: 100%" - } - }, - "f6f12cd135674388b0fc72167a0308eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_01ac1053789e45fab75e2cde894b417a", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_ed4968eb8435434db1604e34ee657413", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fb53a4348865461783df6d1e5b16386b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a5f3118f4f9040ebbdb1a7acae012087", - "placeholder": "​", - "style": "IPY_MODEL_f609670bc6b840ed9f8698af8c7615a0", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.28it/s]" - } - }, - "fb7ccdb37f844e989de3f7a0b12b8924": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4b3f0ca06bf54eb9bab4e081dabcf139", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c60add7b277344feaad65a884c7fbf37", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "fe3a78bc7ec842b08aac1b4e0fe1ed29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_da4c6178632b4cfe96d2a9504cc3173b", - "placeholder": "​", - "style": "IPY_MODEL_57cd2f911c6840da87c1d6c8a78521e5", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 191.93it/s]" - } - }, - "fe40606eebe6464db0b7f86e5abe1997": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b197d3911154085bb86f0dbba2c8b98", - "placeholder": "​", - "style": "IPY_MODEL_16656416b10a43c8b81c6c4b2a02ec0b", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 177.56it/s]" - } - }, - "fffac86b0934453d88f52df4b9ac6dd6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/static/images/mlflow_charts.png b/examples/static/images/mlflow_charts.png deleted file mode 100644 index cdf6da63563dae8fa55cbdf11538a36117557f86..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 357183 zcmbTecUTi$w>})2G!YaL1?f#eK%@ys7XcAbdJjnNozRO2s7R42HK-Kni1Zc^r8jAz z2c(yfP!nptiO=(%bFT0AkGx!0$dJsQ*|W;M?zPt5ym|IinTmpe0t5n4sj58G1c4}9 zKp>J*vJ1c`m!%5(L7@Y@6eADvTCFW#!``+X{bCkPsk!9G$UXr zC%75>@BL_7a+)7v> zl1r4Iec{*qBpj|#%olk{!MNmms{M5F_ci-~uLy3LWYTR#P^U&lOUnUY$x)E=dMAge;DA2Xip;%1q zR;7RWs<@elv5cs<>#V~KcV{1iwAG-TaA|=DBR3K zIfbsgP=C!qC*d|vBvue^(AX)@Sa(mCE{f}i`&SW8xsuoQ=wemU&x>mQ-=>*H<}`e`)z%Wi=NL2|`@ zcbo-#qM6G(hyWKp`uVJOneA*6%^ zjJM3yNwws~;wrtwJ=>(bH15)XBsz&-%-wIf7^AX|djH+w<}Ko21wV!C7m424*I4MVwne%02-20O@4uWEZ>xu%!g=fJ7 z)D_?x0+#F-t}o5Kb8OG%5_)}I2WYMMpf_h+J8|TuO4g=1g|eP47N6Jtj=JK|Wc0 zu7;Oy(|j^GYA&5e#7x;OFFWz_)!?^C^!v1fG-pNLLgV0cma4Kf#lvN){fkg2M*Tpk zoQlQy4S(yU7dGXz;}XR;96*kn*T-I0y-?QnvHdB%33dzn_VeI4fygVOEVWESH%T?z zqr@X+m&Xg-?DMF3-D*)isV`CO-nX3zV{8Y_w?oa3!?&uVzC}ra3URSVy9c~^IM~Z_ zLzp`y4%D)u4+bL!z;)#opp#VsS@KAjd-YAM!!OX>ruj!r)9hu}(Qpv#=0)tm4G^sv zfus2YffgnoqF@^0?{ZgPlXjWi+moRz^^o{*$vTWA`+DNbBr~QjAfp!VXH*9-iLwbq z!f5B{U73xE^;-FB{Ulq32Z?4wV#!{{(MW!Oc#%fy2ZfuQG0mmlQN(PQRqn*U%VA4> zef2r}xA);Hw<{P5xQ_ zIrEkEr{O^b&&%~U`IUwvV`<&E``el3DK7n_b!C&Gf<_6p@uBS-nPtPl?WlQaEInbS z*+W-WpUc=++s5<&>@FX)C;BUPY<6zOiWFrOJqvq?k0K6v&5m3Zm+oiv0dw10p*va5y^GCb*FVc zDk>@uDvjvtRBze?qTQoU8Eizi>>Bge1~=^<81kyC8aaUbPT(WkychyfO zP@*X!C_X6V>}f*5T22@Is$KtZ@klYeG3PKt-dta(_FdOIg-16QSQiLC8%2GxD)~8l z#kOy>a741$%cMvzy+Hbr)MF_P|I`C#q{pO&r;6m5q`V}1rjq28*VFX}W-p#la>w4b z6tLVf%d+-fzvAWOd00PDpIh(mHRb8Q=ecLRe`Vi#RcD>)*M^z-9fxbsq#nao$(H)| zqr2aIh#{|hehgjq;t+`TDU#JhfWgJ!PcRK!;Tb7WwS1g>Oe=5Lg)pgz+K)}<@8&(* z`XchF8kE;#_Ly(qG`P3Z(us(E#^L{2|FglPsc6G!zi9P$itnu28Q*CzK+?;foTyi* zkEPudUAt$Mc9iz`2|SHiIIw%n!egRt)BWJKcWml=gD6#XnBkeT(%0YmRt6jte@p6!$2 z4=Dl%0tzXQQ}`^_EW$ea8K>?agcpSsjeC9Dpc2oU@~Qdh%Bsn*I>A7u;L5VC{i%g_7PU?IgNH(zxWiy^M|_eG$qQ z$`$G)FDXwhPbUuv>kAVOa|rWSm{zb3ze&yYDk8F!qN!henetHdBmdN6pi$*1Q^z#B`|siCiG;&)Cp*?AAEM(Qey_lEDySAbzGyMc$8z#ie`ni5y= zS6?o-T+gK{ouHyZJ%=&@<5ROftmwYOgoD~xv#Ge%Ox-qW&y-PN=;^p3%m z9Bv({EcazcHbtfl>UVbq)=Fd6$Jez)nMFk#qP@$$C^;lmnfPmBjHelEYrgh>b)J$L zYaTi^gSq2|S%!ley;)D>dgS|C>!HO#lRmF~zvM6%Kn)PXaifF3K1`1X-QRRoOMnc2 zgk}cKjyjGR`#wZwL z$gI8TbC|++!nacP$kYjz?22sPAK73Me<+?c-P?5d8}kw&JDV1q?%J>zGnQG=@CZ_L zR(@;&j`Z(%?;naWM0L!-_T{j16N*3EG%}-@f3YMdmT4YjY0M=*roWH`o*meZoq==R$HfTXND8gm$L~?OB38pr=(bzsRs0 z&_4{!Ln_b7n(yDJfVE_*F-;G5c(%>-d4Ud4pcaO8VNHV9c|7Qg0f)+67YhScYTG0n!lE^Tn$83`FK!!nVp{n@oA{B_hnP>q8 z{QcHSU)5S&9mES9lYxi{7(gVz5drX$Az=KU<3|LyKtz8&Cj@~a?Lfr;p7RuV$N$6u zFZ`H)-ihKPK%~H5SAdsKHsOEHrfkV3`p+>*DexUgUQ1C`6?oUOaJRB@_ONyF6ds#U z0X`siRWa}Yfv$1kUj(X}oM_i2^>0E zd788OI5|3dNcu>#|2abvIL3c0$j=0 z&fvBY2i+BWvqglwKdv#pG|Ghb@rn#wl73}*%DJSJb!-K z@z!fIf*ci;mw#YC>W<9^f5_I>Oalah`fhXfUD{*0H&qyw$~A!7Kbl2w?=#-}WH?SE z2O=Q;FMg@GhH?_3$J3+d&3`h6|;0XBv$G+Ejyq*|MU>SMds=0DY;tkImI!~MRO%Iwvo1q zo&fu$;QDL)OlWwY@sBpQ_^%2boYy8p>q+7rS!Fosz!>u7TLf6YH`o6dSGiFO=d8oo z)QpZxRANBW!;9xL7_(T~*D~YHQlwy<1o0fEmOh+O0q~eKh3sZ~RC8QI*_!T^!KF*v zZ_X)5{||Cz@1%2tEqNBVHi{@TKr*kQnD7z|eMUfQQg$d*9k4B`({{h#ebD9Bd0;j`hF;lI`wjdb}4n@u3A*9{=muS(`hPG|uImS;nm&Tj*o|HlscSw0g zq#_6af0Ty-$j-B`FH>~grElzh=%e1(UH~Pv~a#iH8Nar)Of0cG(ikh37+bYfZ z&HoXFrIl5xJ=)GXIVbJb$rfj$xQAxE#F$IxYjovj@sLMt#5>e7dOOsTJZMg;CYSWn zV#pH=UZkO~u8@_TFjs*2m#nNbH8ta(saXr16QIgh$Skd`9~=7B*RchQV$-T;bF0Z( ziXLWEDW_fr*b zt>4IfMrZfmmi}%K6FoBJr(2=}R5$I|Gp}$?)rEvm0IE~9H(W2JX)Gai;rp&dFgs_w z*G8#08^5#T?z;}fQLGg?@Zjb=xNzAX3K1eXNB;j>^Xws&1YGLP1$<043oTzqnO-+N zcKD7~QXJ|+S%Qo zoS2wsqBFPO%}tB|JgBL;(#3)ZJx@2C#&S%80-o(-Z3m*az6w(SR!2tT8Vd3644;PtZc((-(_ed>^k0acpDoUj5M>}C z(a?rU3*`Z^;6RPKE^ywhUykzx*oX|qzLR(I064!SE6lH>l^;C-ES11mAoaL@`hUaj)u&BWldQ$I@_Jon_)xv&~UC`4fknx%xLvpyj3A)3e_ zz%EfgCG+(po>RO(E)NQ|rXedh+ag3a&o$Vku?8evrK1yVv#%uvto>YeO=G|+B{j8( zNDw6g)4oE9TfTZDxiw>?Mlu&x*d0l_h}q(4o8btNJ0UUti7^qL0&a(*Xqj?ttnOnW zL~p}w9-Y&EY(L1UgJyFORYy{Ea}MZFR4q2%EV^n^-#XBSfm}uOBkRL4@uJ{P0J*kf zE{9-l+5SNkED_pp-2^waf8!e9b_hr6aLRK!upBV~Rg3>TM2HQWTnv)6UsSmvYH!)8 z$&$WTI|H{!F?D|r&k}}|_NE@E_NIP@dMNgjvlNle_=tl$$<3vH5znZk{EFi$bIF9^CLW zRDqff2b)NL*@(G14PRgwgQPRA$e6%z!@*SI{eks$o?zUnKBQNc)QR|t(j59%N2j@R zv{UucwAWOhx=+a zZzWlfiKMjb*G$hEr&Pf0hCq!aJ6p~+de?*WmLLg!HLaL+6DaXqCN1=wHaw_F*g%BN zJM!101Yn4|tf3Hj_AG$&7FE^8wLX2O{MI9M_x5C&ks9%w=t+sZC+^zqSEWg_CO;uK zY_0gHV3RcE8)45Ou z!@&H3y37$ZMt8QhyhI!NkQPlkcRD)3vClJkq&T*qfSO#JJhGcQ0|973pYkfB`_lO) z4aCuDLIZ9G1hOp*F%3QY(^I{=^iox_0SddMuTtlv^K^T1!t(N++ie2io!$)Jxt=dv2=CtRJhr7TyiG2mNipn$=^ z!H1C6B9J8U3mXKZ}c`4FsJkIWLdF2I5h6S4`gDxuzi zk_;hmvxZgKdBY<{=R1JoF6I$V^F57zviWb&Eyh zQBg+&|4C5TlP_mml~~6!0TH5GG}i%zG%OgW|dB zFlH#4ai$Oi-AjBhdBkF5*{~NMwKNnZNKxmlNQm@%q1Z0&1(LaC%k1va;Qfi}ZLI%q zb<|!Tcp!lqRXa9SR`ik0i>kGO|G}5i(|NW-G$;Ve;B{#RNDn%K*1^9rz9AQE8n;Dg zY)k%~IYtH&K7%AQF_MLZ&pVMd=N(BAV1ER@Exvd@;@+g1twTE3Mzrg(+@I7F9Ax!l z1)fL;e6U#m+O{Y&GO~vwbA!4?+30k}99vW)E&^h)3!HED3kJyyNjOUfun(q@u#?Pi z?32!H%zuvkI`eHdkZ;vhc)xD2!L+~XlmI(34vdj`S{4(%APe}J#$};#?%(%3K94OKbuj%-h2V~0e~?hun)*|#T|2V z?IuK8=CbX-s%}H+w4oxIM8~{gvKIA~#$>bMvtGALk%VYbC_?}w7$Aq=UBUy;8QA5r z4M@mZH2fN`Vc$V!lw%Z*VeLQ=_P5;j(2?%Ca2$8$x2lh7EE#+5R~}xYMIH)T9PzwoH-nTzUmg{$d0a zr*7h*#f^)a`mM6xMfv$dFD>WGB`wU&KN&)(VUGqUzjv%wiGo;|EvaS28{HdAO;);P zS8uu;&ae28+OiHl{ztbBQ%{P~4W->WftZ>C5GsrQywNJohmd$K{T7Jj_7CPW3gYk; zQ6J_?CIAPA06osKm4M2U<~F9jmtC%`&IUDJfNxM%kdn+*4ZxJ@S#Z}U$tt=3!9hQl z`FTtdLV)&E3of=XQ?o94Gtz>1ZXu-e>N(&KkClV(fEg{&0HHHe1{kBRvyyc@;v zjCxY!q?FC428cJR1|mzUH4c1b8!<4yfXZE9Mon)ZqAy?W%44=405j3`rqOfU#5kgAU{^H4*vU4Cf?C*`j1L zAug5xOo5nh-(lWUcoo^dA*EN;0xay2%$I$LDuiv+f3G=Oz66fKov6qkWFJFTMj_JT zF&e~%>HipP6D*tN`F(K(%8Bp*b8eFU(MB`=&}lo*!j zDsx$pLIaLra%{KiyZ^Is=>SI&haJ+j(-k5k5sd$PI#zAY{fl9{COf94}IIanJpYXWL+hVxDC19$|l$;$=>1b#d` z8tZiQxXpU5l3+ga1Rgf0NQ=TE?8X$}e|YqlzCp$(x97TY}U1YS^b zYJ*G*9!1~0!7gUAH63?~&Ww0R%~IqMJ^)Qjntu9hf7g}> z?Hu#)XryrGj6V$>fR*qI5?MI};3{;Cljim+bAjyYtO#-0R51iWAvygd5P$*lw4U?j zYawzO#8(7>63?-HvYiOFWOU%vNQ7?qbioct(l-8ibZ9L^1tjAJrQ$oU-?0K60D0c$ z2TLpgrHd?{PdjZ1(QG$2S<96v9#YgRuWJ|+6QbW7JL=y!rwJ321Ms5xrb43#=0N9z zt9I_@*92;fuqZJ?vQ6{<#PI|27M`td=2qv#FB(ockct3TiL{N!b%OuIq_ZDQ2x)N; zbfUS&av2j>*nMwe8=3#+nCxIMX~~m`-N}#13>hUBK%3IwIE7(Vef%^jzJ#w2s^gZL zpn5J3G=u_Exs{cAVOC97Fb*h`bA3C$dwj!_VH6Rjy{c$70FeEe^o6ahdgL;9eQy?H z2r8hZV8|S?kW<*GeN6^pLVGCW6esuCull0Q?j?VfQ+kbN)k5Cxml0xLT%fzS7acBX zxHQKMoPAiom1_@$WhIgqd4Y+}?edb6QLg1~%|Q=UlGV@49d73#gUyLJ#_z*l`1K;b z1M+v04QjpsbuLMD^1hAJw$ZpCUU6-h(st3b#j2bxuVh~4xLCpS|Xf2=D=Lj~L5VZ?{`BjUoqLrwUY2CbxM@ZK;k zKPM+=bef$2tGoNYujWaa0*I8eYH`}YIeq;s&q-Ov_6B}=b$LFr2{m7$7V z*}u#CAVhHdDBqu4l22s zQZmv63dGPEoJ&&TY4B3s-}}EWhiG(lie7NaHHPXb8T@b%y$^yWTF$n4$7jSlBf{4U zyI*^dGO0Z6yNiX3PzRX`rp@?f?@1h_92{+| zJW1vUYs4NKp3trj1jYM$FOj5g1Yk~99v)vh9C%YTGcv$6=H>SH{b_!FIZ$&h6a-fW z?A!233qaTjN@pYq(YMzohU{QkIWuz{ihI?9$NFNu{sxoOGLI!U{WGX?1p~I~|iKW>xQjaA*ynE7enrim8Z!=P7aMhPOJMDpuUkvquo|n$MBO&Z80hDs!f~_ z>juHX(9!CbRY)?d!%{=6O6&UJ?Bx=lnZuA_&Z&T-n#|>zx5c^*4EMd40q28_~m7Ol&$0AZqT05soJTg^q@3a2W#O zN`R#D04Mf=o7R}t1ACL=hppl^^@a3w2Lh%yAkptmn1}3ss1D`9&q{lOt~u$m8__p8 z3{Xm#c~4ipseal$%U4OC{oJ_zTe611@zB1$ zZY9-v;AD*Go0l|t(-4&?UA|GKggZ>qPQK=2a&#gUD{121fLz$O`|PtzA&f~6#r#73 zVC4K3C^%8QNVGAtBxU1=3MsW3rZ4Ns-mVGnT|rDZjy1M6e%_vJ&$|1xomuv2o<=(F zFc`{EW~aFPMhxVVmF(LeT)lFw_)I~!`M6wMBbGxTxp9^w*L8;7KClJInAI$LQY{oa9zBt=Fj!Sh;w-wU(kVorm)-hVH)fZ4NK(Id<%n zTFe~jeB|*U<&nVq;lJj$wn6|V^FJC02S$V@UvvEkF^P2G2?Ck&VRBJ)As{9+b+XqH1yA zTHA^|y_z1EF&{$4?Vdy`PS!`zp`IlEj#g7VVys^%`@-b86)|9X zkL^SY`O%Bp6Xx~nqRR)$43`Wb2&Lf);V73{p`+ZeKJb&>OZyUA_KfSZb@t80Y1^;i zWmF}evw&utYGoEfTx=3j9Trx~#swK_ogpP?P-Dd4F>`QcrbZizZ}uoE(HZQZF&yGi z_Bq&^XvH}TJ;1~#Bg}THTHP?!x}tj4()K;l=Qs*n+f|fRX6{I31+OZ>?U77WppkKG zryVnnuy@(=TklSs#VS!3Y(YW0DK4EY!_HnNRWb`ERA=!$Wyt^zOl*kgkjWf@8ebp( zR+>Nhxoj}@YTnCDI=24Fq#y&LIXNw`^zikJ1+EepCqb%o-|9I{_u6jVbJ5(eja6Zbjq6Zb~sVFRRqm`z2d5yPayt zyHrW^AKq@&+ud)dub9^5gy_JlC=Syw(8TyY#N)T*4lCYMdi6|x%}n6h0|$fcgRp9* z9RED@H=sZ z6)zTKwI`__C=BgNPEDB{ZsB~rCof+O(HPiZ4~#j@)jK?$5=YSomO5{g4+vEsHElV3 z3F?8nq#p}b4}2MZ?RJpn=U7Lsy^%syITY+}m{-Z@`3e)m5A}}KzKR+&Zz$~6Q`2-W zym%8QHQ<6&##O+iTLLJ*k6)@9ZO=r0T5*Yc>=EqjLEuvZ+fO&ptUcf}+6F_Tn`!MP zkelZ8uMo|S-hK3hPs(Bn?(n(icPxD?Xd43(SmB-e$2cwLYD|v6hD=a<1I&kbZpLyd zIf!#ACFquwl=ufhOHVPn`GK7v#)sGec|`;pB-$rHY~SNe2SX~+U)liR(KM_e#Fcep zT400<83DZ?{AaEA3(`5!5u`#Z!&TEWM1w+G3wOx$?rXIi^|I3vS07Nb6C#XLqo_tt zujfbuT4Qd3`@HIgRpOSD?e^vm*t)=&JeG+Do$SC-$uDRPsVDFKAw$MC)Fpl{@dZa` z2Ay}Q{4mTO;Yg#yEe`HQY1zeE-AKp=yn9iH&Wf$$^USuMFg5l5`ps0NfBNH1xc_i? ztXt@=k8TJgsdoPpv%>!TcCTQw)PjLr* zq`mZ)#lm~xm{%KIMT#!BC+Z(1H|c7%BB%y!CXsUCW`K8Q4L=Lf^?XiibbCIaTZyC8y=kQL^cySN9lor8pvT~hpTIG z2!Xh?Ou?{rgtcHU>ic?XY(vlEVpN>CJO`utp)o_9$Wwgq{wrV3{)t~ic3qnO5kA}- z;=?^tY34WqcAB{@7rqMBucaHt@rG|)8&i1lv?rd;X2$LqDEC%fi1b?YX5ns%IV(V# z$RKCa3TLecSV9m$R#M?NhS>a&4O^#bNnhV+>NuOus^8u%_>?q}{$c|%ROYC&!LBuN zVx%?yz;@&QCNb@z%uiVa0laJeCskt4N=7j$O-K2L@&|@Io9kZ$K`d(z;AKgRqyW{J8AaSH zKkN~oW)lRtAo^DN=xKUWgxH<7veG#~We&E5x$S-b+$nUSX$BqK)cS36fVlDefV{nSOP>bME5=6AeLGN;uGa4iGcL3o15 zW>M(Y3y+dCGgnvE`i0jCT%Vo9QIb`RqZP}iu=Hu4+!A}4y_-}YqNu`3u(C|if?>Qn{%WplNB3^vq;~4rk+zHMScEJHjJOFTX-0cBm$Z}U zBQHklfzCE;N-JbJ*b>q+og*_`f(~E~%_?8jn^WDRAos^0o$0KXqVxO&-1Hf={<`!r z$PQE}jb3F&;hQ^eSmzW__1EA}H$edd9D+$=O$TLknpE&jZ?tc`Ec!0(C;p`H0TX)n z`%UURw4Y>^DkuHj4Igz1;hyGzPSU8M$w)QXJ!&dDIMCT^m1yQgpCwdj9#(U)bRJl- zs7}OCohc5jj2AhgrE-KFZRTNRqODu^v<{o{_oUVy`Fr*qYfOd&jz4QiPn&pjA@huM z%6T0WQ0YKnn14`r*9W_;G=R93WTiAe<1KreOWp6Lo12Q4n|QfdU&?{RmT{9@AzzP4 z&FMRCP#O5cpsQ#4EC(0AlqLP_(2tnpp5|qt3p+3?k=} zF8kJmLE9e&#R2hSf5ibnx5NDXNfYV^Mw3)B6=N{|ug!|HKiq6-LSl*7|60JC&jI;j zzI1f;;Z;I)8DNFd9aWfjpa6K-K$15Rbs1d8C?&4(dZov`huia5=l(EJ&DOx4j*d`ht11|_*)c`hN^+gzwo z@u2bk>8SPq*V7&ghQ9-B04~x@fO5jO1P^&&1nYBrMhjnUq`FvV^4- z)S8uU1p&wHf%tUJZJd0_4yWa)=K~5FTnjEIa4Q)prJHIK4^BD+%Bgt zievcDbI;v!uApX8@a5{jrnul~*pzL?^jAN>5niw9X9wMDw zGR3x{b{2w~)M{%(PNq&Yr|d~>UvODR3zhz^W)R2PYgqO!RWSx6dP<}3G{EfJKj+1tuFMKK z)q(=zqAz?MfL>jNPUJl-Hvy>;s64qm$@QPwKk%S-X^;Xhx+P$vRqf+2J7UDCO#HXT;@ zK}4NkcmF6fDyD0FP){!v3cDwPOD&sS)@y03s1h)xR$7hDUfs( z@bU=}oU{(PVc#4`I?n=WKQpQlao=CRXwU__$yIPSX>ebS45_X^5svVZ1L}u~?~G}g zVPhV%Crgan#xe-qvO3z(vPk_j3-q;sr_SpM(Za#~c~TnP(-V<*XB(;ko|ilD6;|ng zw3On-BFn*Lq^I`yQT5_J!`dk~5fe=rD8OR&qe)N9;b(~~wce~q+ZhGBDI5)>GZ;JVHG4m}d}3oy zRHQeBM@}rfb zC$=Jk5dEKJ`HqC=oR%r6W-isW93So-K}7dfnm_qO9^O+!VM*rtrUCjjzY%2xD}buq zark}nuf={v9uPbG1ClX(qqOohUhF?j@M5nwq`C!}#Q6_74_>a{aGFX9e!-grvptGU zjA@GjXc;_oBJ+Yu3ems;Z?pq6!bZH;SH7E~Mg>M|Pq^EYKg0JkJ$cRCzp2$`)_lrA z1{>)JKKSaSe8eXztT9P-gC9v6d!R5kjQs^t1|A8hr@}mVOqF7eC=CgRT?q|VC zbaXM)VeEHN5R&Tk$B!Rz0vtR(NrPU%R_FGC{Ip~2GaxYKXNoowHhSk-S0$B_Lir@P zRZzTL4zLR&RqTgx-?oNKjF?P|avDnT$$SVbVo`4(W3j$z;N8hqUj4~!ZsP~vH-;Z| zB_~;Lt$i903h*GnMnhq|>DL;s`HlM=NUq=0stf#p#6!90|T|E_S+=u%3fr$c9)KH_7XDzK3Euj6Vh&_Ru5)q~;!>^U7q`%x0G@dkEmR%enM(S(1CNBuKHpxx-Z876?_+Hm&UE zO!^Dp8{_PwI&`xi+eP+fwZ854T^+Ta?X#ZkZhxYOsk27fEt~xE7Z3+~ekr_F5ZglJzW|LRRDtNeoK?MjRp?|}HvWFX3W904JF*-+ghI!_;>)n~AKN4U44arA6c zWYkMxIeMFkA~o#KmZQHDk8P!#0#IW6R*?fioDF@pVVS7+`c`b*tS#m;Ilh{{uQB-9 z#s%oUCNoXdOvs*D$Rmr39oNKN%lE{CyL)=9x_*}}P30oSy$7+j$3w#R7DJwss;xNB za7`53wAEMb98OPYYU^J|UVVpesK2<1PmgA*jPyV{$}l5@M1TRu1uQn z=xx?jg{z0n58!rPDyFqfW38mngKbNz78>z6Ih?4yBSQ27cLx9QB?Ka-?8}!pb;hwN z(d8;(f4d?scvO163qfxIw|#Rg1;)&+U_R{by!*jl0VZv-YGY z;U`a}7alNP1XsPNJJ~?R`gMG=TU@MuFFbJk(Q|9E?-JZK(A~Wvv#b=@e-H)Rq=!#< zjFp)1Ysj9JYwPGtoSqS>hnzO1fsU8e8JD&rw_>etH?(thCBboqB70@&{SDUpkEfjB zA3qzP41*{4*CcW7a3@VuQ|H)idZ1NH1I80(1Cw-6KtMFDe|1idT;B2aFgvT*| zRSbMo=&YF1a&RyZ8CO-L*F`z-;C70sTQpTRoGwHbTh3v%C&V+kyLG(aqQuv7TtjXX z48Cw_qC+t!TqziXR0*U?{o75I_)8g2=={UJj*21sT z%^OG~Lb3SfME~+6up*2Nfou#Fc$ygbP$!4%+$1DXjj+=Bsu-#XNUiM> z27oKy4uAsshjEA)-vU!R+=A8D^M3Cf+@cgXEAT}9Qmb~J;Ea{_0k5{2_yb6CWo@Pg zX0Yph2$MzJxF7KppZ~fM3hb4Bs}%z_>7=>?%WeL;=!Rz^BDr!eN#_!B9BQ`Qe;4Gd z<@cL7{q!t}VAf`9{-_cSY~HZ4>RE!HJdRIDuo`Zs+WFB&{jlj3Uuhjs0&-sjK(!MF z4Pr+(E_6hvoGLSM0^82q2atx_SyX_?Uf1AxPGhM$NM^RX_pfu5e{-2_T9r=F$&D4$ zTY;n(@j!E|?4rl_5w^V^Rk4>I?pAl)PBNFUNSboi`)b#Jyz1oi7pyzN%i*&r+zWQr z)KoSgbEq=wgUkgsTtC=zz2Pz4bubP_HJiMRiX!azh2PftLjWi>N`^VmhQ!V!2>*4D z^&ij6E+Dyb4}?373g({i+q+nY0XBXa+;xd*lt$_p(Md0wU6hI@Z;53LPTrLI4e}rL zg$CUjesWiKlAmANq_lp!#v2Q)6pP2$JfVKz1)V?cxlP+&-H{crCvO0AR-d~siOh8Ix(X7#gXvQaV%ovtG1li6wzsY?5mX zbn;Od_*YahZawoe|M_1468)yZOEo=s*k?#hq zOr-nsM*^(O>4nY-1Z>>&+n4fZ%;`R5iOGpSDkD4u8@2uR*LbFCToRPe0`%r?uHaUA zhCb`LFjfZdm0^fuKH>{5wtup(JAivMyX9q^cR#%P?Km0&Y*y28H()nkF^3}y)T*uh zOjTPFTwF?}b!(97;MPWook=xZfoL8Z6BT(2WPMsk;AERFJ|p9fRc6~;H|0jrcL!(r4h4U}V+#!r9v0W|u$bYR zir;qnS5>2b&r6eIWg|qd-N>syrV<^Ukv(4I@Li}%v7cElKYi2+C8*(`T7wA3Z~}Ki51PAA8mvrJ z>!t_K^-n!%nB3a^f9OUk9+A(Zt>3rf?h;_D50Q(<^tdOL_VrUDn^_qdo8C^?)4F_U z99>U}U*L_@)KBK#HPZXowhHh4$2E-G!f60^%77$|b3CowXi@$)n{;D1-?yzD>J@sC zp}uSeQSMxVhibo$%3oi#Y!2tGVCXH4q8>dxJvBeS2&R0b4Nge4QsKd$wQVAQe76Dc z-Mp{Xy61ZUn%9wX-+?xY_0Z7J;)w7-%531Vn!SA?B$(k9qQdv{lS9n#r=+pAn*a4z zrzGVwcL;XAB~TCqL-VDcpz;Yj0#JJ%maFBbgt6g}p!>T_z607Nko3}(O%&L%Xbgv0 zqPGM*Z7U8lQR1(mg*+v+OGsG(mKo*L>YE15-!N$2OOFfshZs@d;c*>Lj2wC$|JKz0 zJs^cAo*#N`e^Ch*ST?TFw_7js6lP&nq>SgIJ<+0A`TUVoyh`jr6t_U&8Al))xt z!L^~1NTzRg3w~PrfpvCzaNkR$_^{Ic2d5W-i7=wNFP?KEgW81Tj3F+CjMk=q6vBh= z*P(!GWnTKPHcQZ=Qp?$aD`ltRyDEY!z?IU;q32#WeG%w!S;#G11+HW^Km%k$O^k4E z5X|O*(H7ykOg~f_SUGx;q1Ob?6ZhWVb*}T{+rH=hx*1~}S5`#+k=%_(09NDjaYfC=9b6YC?dmpJ&WpZvm4NvSR_ zFMJ(=AZQv7O8k#1eZYN>d&dE zhUYXE7fTBDRQ{Q)cKCHtl zC}>~3;llpU9{-3K5bF81>aMWj4&+0ekp-2^)&oTBmMp)tijJ->0lKzMnxBvFTW!8} zCEp)^h{NoE3tvRdfz@B6_=<ZqW_hw#I4yV=^oA;UoIps%km4wLF>?_bL9ho8QS_+t~Dc$&OACG?VI4 zVT0ba@Y}W8jCJ`-z(1%CxW51NnuPsv$HEg%vOxX(z`d)#KP;)rBvCVFf@>lQ`Mu)d zcnR|6Vcjn4b3HvCVC>3nTJ_|L+S8{ABit#1XKP4$Moi8#qv)!v!%DExP$T+hwO$9V49EQ z=;%TKdln7F;jk*x1`onNo}oq~?GAS+aaqu)=!x7*BzsJ3Dy?g6S^o1CXkD4oyB#3K z1g5Ek>KPh_78g`)Zq^_ndz)XI)<%%na&H*>##59FV^>?UzJjT3-E0uKw%Ef7o;7 zq!sN%+mmoN;VCuRt--es=mu+AdFGalJ4Lm?Iy=Dsh=Gfm0Wi%35eYo+h?e|WgfV}E zk1Codu37YPN8dJTz&|j)0-2f?As7I!_oqr%M;HWw9hrbh9J1dzq8~hplC*vUi#1Od z*N{7zYcs}cx?cL5P@44CbWN-gx{3b5 zGHM^yBZ*3*_xgzAFaEp1*fIoW>@=8keG5DOqsQMi-+c;#lzR2f+yRcywLfvC7bk>e zQ#%BP-@s+}Id}yGDy}h#GP||0o0CGul00;@pVI{E*&y5dOkR(yz&xS~HeNWu@U=kA zC3(i@zp10OVic()zl{eTTldHHK=wxdpO?B65kDT$!WU{BD4P$&?yjd`heBhLlT94z zebEgTtp1zdaewePE(qA8QQClXImbeEsK0%WKnYQaI;fdwunzY!pKjtjMv==_8&wOc z%8~!+)2_oClnlSMj#z{Tqt30@YJ@L=3TSQQZ=15Ko5(zbcNW9W;X=;dSQh8dRSE`O zGc!)GE>)6{lIL1oqehUXXhv+@L2tG@_)DDf+V=7idq_!ZvDt-a#He{ zZ0O3>mW_8WDSpt?(yDqJX;_`*JKe=2z8(Pntq45VJt1WYOz1JqfZB|c;0-n(6hod=ks699~T?1<+N}nS_oi?uaYq|NdSXl0?2mQOYwj%lz)##d=b18*{98##|FXGnx!T-DFIRra> z{_wwCUPkVFN5L+_M<*_CW17S;B@%#%x}dMy;9@N7IZzflq%)QNPO#(cxX;PU%WJ>C z*ul&$IcfB^@%@}(sS$Wuw%&91Cptvwm+;os*JlF^a?a^L2-?_!(`61Lci26)fi$Zp zYHNC(c_fZxy2^oDQgX7~ehd(BQmcXFBqR*^0KCyA6Y2#vYjFRrTVi6d@3$xk1xRuC zjd6{bKHr+Rvr@iP6shn6{2j-sCDpvB)ZRov@t!CaX~z0uYnIX|S>L0|jhSlL8qyPH zZ>Fz5b_Z=@Zk|>NMj|l1#o=rIABfE_sSdVRnx@NKvT0~&9=nB0r0sEgmJ@L81}SiKyYdic#L{mbePLuSzU z2_y%YqO0q)Xy>#Ak=$??;KRQbo5Al7&*z^-%N#sh`<p9!yopi{V9Zb?x zMHKJk;K04^5DMiFWp@4WeeDI`ao*$zKRR%B=d9hd6T()W`y-oBBKAaw zsd{vy)^~7UO-)VXlV_96ZVkK(p6=WHgT2?B>zn_iRbtm?6;`L#Wk%*hFk>OY9)G67 zx<96a6>3T+WWFiCS(T2Rkk8RbPCC{PLT+C);pILvFtBbiONS`T&Fl+(%F3EUD&N~) zie28U7>L0tUrqe@vG>#Yxa0u>ezK?L-9K|2M{nUiQr(&NK2GRzQcEd4o;VnLT#8PD zTz|B+-Gqjmt}aGzm}Wz~7t*z`iU&y0Wp%$F`}~3$^i9Ko?8z3`=`$K~+)#z6dH3#- z_j#)4QZ%%lBUgy*qvV-w-NIh_)5{BN6F92gWA)tB7UJ7hY=rJ`Kp5RcC5Xv+yl1(^Vddc71zptv?dFVD+K0kBc z!l&z(YdeF@6O#RqYgmQ@@L5HsMWGk)qsw6ErEd`A$anHMK=u z2D6|E##{=d=ruX-?ue`otYznpi_;}1wJ~O_PlANFbA!Ak-SX#Q%@;RppsqyerEcp| zv_{gM^pkBcld!N?OUd>EfBwr>hyj6N}(I>Yc?+ zo~FVG(Gl$V_eX-*U90k8y$q_Ub+VRd1`%bahQo0mqz1+8B^m}7vAFFmxO&3{oqWEw zX>94&)EO+&FDf6Kz1(eq$?A8o|9y5`bE%N#eS~~#3V6HaOV*^D_n&Wbjhr_wpx|Yh z&Jsl z$VLe(QbI>1iz%Z=cbz31q6&QY;kzq)>;^d84Sa zIxNb#R5Ik zJ>m7(hTroppTTUHtTVec71a9eD$$Qgat;5mN%J>w!p=H=rkqwiDQ(^>cfS|E{%TU( zX@&=IneQlO8uk}~da3p1^V6PmwtR`Q&617FH&1FOpytJnFu=3KLKCqBe5w-?dBm^5 zwY$*Q>qVvGjK+q8$BBk!0@Q362bkOXy4P0KWw+Rbnc>8>x|Q{!rH({%W7L-?Bmh^T z@es>>2sxb_)rE6I8?i_EiftDg1rr0kVAn7A7iFO}jw-;bcu&l_wjO#QJx^XU@;F&)h0d4XGaw*dSpLB|mI$%KjQW`UmmtGDC=vGQf(M6@r zF(U&q{LarE&T0gAi2nuq{tJi)c)c@xLCq3NBueI|+t_bq2!5RgF^^ow9+C8ZFcYVpyz(sC9M ziBTk59j`_RHb0ibtY*)$kyx6=efnGArb`UVE7#>U2-C$?{a1mJ$%aq~Grs5lp9n`^Wx@*Gi+ zWx1H)c(9tiG#^GCM5#2Jr#~8TuPKUi?qs426y)KYl%2ejKkf|OrX|B9gRDOlw8(iOD=AsU_pE5E|u z88N>sJy@R<`Pn<<0l&OBcMUtGAijWAVNFmL(zyAM|24}>(tWXcW%2dq?&2dsN&l(Q zCSg)wuHll{3tXk-cQOvvqbG6ugXAi8%zoGMUCsy!_aMP4L6g4XUwjx2;#uy;KkUwPp`y?}r zs(UC~B~++mdn2iG_;6j!;f}n#h4NK4)?M=3Z2p+R5SGt8mv;JF)a52RUp@`xLvnPru$ohY!vJ%gEw%OR-rqJ94n&!@A_*MJWuV+&Zd%x%{rc}G&m}Q}FYAC_$D7n>7ii+>nfXbKH3(Rm&Y3CBJ z?(6C5E#bWYf+g-m?DLECrgKnqmi;sc!^PgjeFyKI-kR8fdCt>kW$(iE$cKNuBl4Xm zc&wzort>Z6_7jq4K0>!O!mmAff|lJ$Jq|Xq_Oy{mejWQ}PI5x&2pB!Th1fecyA(mk z@f-Fpxm3TIRejYFIbi~KI~QNb$TL_}{V8JI|BaekvwKXR&oDPrF;pAg>|d3uYirBn zu{Lf7p3RM9%Gb$J^?B9UGQTM4h8iNi9^T})9B#@+L-WKU?3zRNr)$}#GG!jq;*271 zQ%q6I%Q;2ra&GN4qZtYW*^ZQKa_Wob=^0EYZ4c9#rhy;dIYPU}#va`9S4tVEAV|v& z4knzf*3{G#g>Ez3&(wZ*QeWGt8g&@dHmW@1x7cWwg(h9C7P>Z8k$BPgu~tf=W~DD_ z$OPQ1P-Ql+uf>J4TE6SFT?@78IY@P^jZlkzf zvmD8TJ(JTcjbBa*MFS)iNLn>7vBzxsFyjzG(^?+6SLDl1r&p-)@bJn@FZSD$!9(vOk6AyryPY&x z+HkY(W)7W5?7?afx$uFM&km~ENHJ2Ue3TOd5rhamiG0U*Nv z^}kA-8Twc=NpYYl>9t{H3nHC`T-Oj|SC*;4ek{37Gxl+|J@w>Pv37LCu0stET3INJNYDJ=exHWPI$-g!d7b=b2-1d1i6nkW#RXmYe^(wf&DdX5`)25zqUoW zXKjM=LD2N3%vxrg`6iI_WO^bVts&F#P8x$J<3Tbc%hT1iFR$m7M=Hf?sPlz`FmvpR zYb`&5l5ARNeLc5+XEH2c&yvBb9g}YE)5~-LmvgPrw#$Y3^{4Am6%``bI$wHkZ+k<_ z6_6xJSDpXGWZvlUZpT=159IahZ=~sO#mROHxt&fNW%Xe?O0sv()e;2b^&8`9(;<7` zpK-2L*bEHSh*T@yE1v5KdM|LZK_6?$?FJ*nyC0=@oUc0(-=~j4RCXOIBD+fh-_xT-g8JO&-Y!v z_jW%4=H8QwzXOaI8!b^(i49z}R16JYUzXImH@LOwq_Xw8wx1FAft8;&8lua2EXX-P zz+6GIhU0su=KS0*>_8W#vrt>an-)5=`omi#@4shYSzU@gJMBJ)_Bcq1yq>C(1=ord$QgFffY-=fKo+zzuj_LSVK&=eJHT-_IZC zucoMOJi9Mhy1vDc{pyL)z~cMqy_<$UsCKuy0#r|+A7-9x{K~G&>F;4LYF*knilQPW z@Y92i5*8Yoo3AVFv0yk5^0Y=HlgV4y$EgC}m7TLqj>!EI&L^sA-RnMb<}8B4MJxb3$2rR?1_qo?-SXIX7hqU!SR$Aq&P} zg{fK4to#dONbpU{9wwd>WiqD~{GCh8K9%h5=!o)k5lMFS#wm5U&UqeRmMe|)MTyIY#G;Vt$w>wclP2rP2kj)Teit*6qvcj=*^;J_ za^GC27xK8jI50mJmr=QxaS?OO`AXJ;Ml>axGwdb_YwRDU!?hgDgXSqfRPjPu=w>&x zgo2w57cr_gRmHT*d{&)kZlaVPE=ye%-72A3R%dW-Dns;gHzvopsB;D#Ed>Y}i@%O$ zVr31jY*4>Yf$7&QOHR+vM*x?`q%nV7quF%kv$)c%xV}F${p9YKb92nj;+wOTX)uMv zedFpoAoSXrLMY{oFa8G~Zj3t#q&ukYXrU!ANy1A5Wz{ zOep2C@ievmXjFQOkA3no%aaAk@o2K9V^r5Om0`xSMYXUu4qKqc0_R%S zMgV6?`7M!R4<}fs%02j%R8;tjT>Zs7+!UOctgWqeutSeA6zV-nt zg!g}!f-U;GhcT>FOcyaTy^IPLx_BGd^W%|EmaWS!>i&rF5)&14^Ko;5+F&Hx3_QBF zu*p)|YxNohqs(JU@XQXAeu3$vGnvt1`&Fwvz@b>Er>RHK2^i$sHM7e4eVCb<`8e*s zw`Oy&Uv5?J0ud&V&t#X^@Q;lsZz?zrg_560{Lov>yR*|r@;;J(c0cyEdR2wZ#kgq> zWlFM7IN{~{;^%cbZoY?eYOQW^hU@pYB}nZa`?UrQlW~BM$6?%SGj(p=?CQ+}#R;KzwF8)G}jcM(>GOjeoKU z_~x9!0L%c!C_A1d^5W5Cd4%nw2q*=Qy0!Ml{tg;oRVyQ}N|Cz95&I_;yG3SRySSKjYWmDln= zmt_Z+NCGHo$cJ@K^iAjUC*jS;_i0xEPPhx=~TF%vPzycZrPfs68F@s_hILw*s zMAOpobaC|*-yxu0(zor3irUhvR%ghT`~@fx1Ueo0Ko&I+|L%TqGYzC(j;{wOjlb57 z)6+qsm7C)^ki6?#Ax6cX-v~gDSAHxW~WU7`&YOe`;ex$iS&vVVy-K={?X z0iZ_5W}yfCI9Q={DWst0rRFV)744aY?-UJso4PV=u4MKWDJ=pdXpAvww`M&4H}S!IJOmu?o~~=ca&AO zvj3L#Js!>D}k%NkERC1zMi%ndyyI$WDI5sMjF?#4JyRV9*h zN3n2TG%{2(Ap5=!^P`MGA?(Aa6aoMLegWpCeJ(wXxUvEZeT5 zKefKEm?c2MGd6lV!&5qea89LJ{1JvS^4?6`$@}C_?HZBo`_kIa;U1^5Y;Q>ZGIR$7 zIFjE2fv3?_K(hmIa@ffLuqPKhTr&%5tf(NbtF2$@%C3Y9RXGklc540MQG#%SwVzY& z9A{V13(|Te+7%SUrKK6nVRtCQML+}b0g|8IJQbm>hQHlPy2@+_GmZxU`B;qEvUgN{ zx10YnULPQqEp2b7p|Cfdv~S{h$+hzf!S6iU;pqI488^@FX0~!m(vVH-e(jH+#&{s1DBbrIAHIzc6z7i1j*-tfw40$OKlP%Vi+(HF8{>jb$BCoqvW`;*N z=Xl)o4rYduOKi}8S^+x=ga+n!&$h*8qPJ^r%8F3~TSviPNni~(x$jIb zsxbzyv&%m*O}~*2&YAQ9T};}fwcB=@mk(9{r&yM6VX^) z{?9{)*T0CUb2A}aE9X@sv>zGK;T7O~DwJV-!kr5^!6$#5pkIPHLeBdFj%SLOMzAqc zeBA(r%_rC)niUEqrCwO{k}$CQ#S)Od)1F+pdyI5zN_eG08C#^RbP3$9IKt0i9y^^b z>8~o1g3u2RD~-^0QJB8ufLT&=3b4@o{$Qdy)=b2 z+#}dok6oIBBnn1rhrZn^(43V5PH-z=?okUx7v;R7K(Sb>gy^N#;#&BfatatX-kF$9B1>bFefu#D7bFp*D91mDd#chj`n&IhCK(Mn#8TR0 zokn&98o-RGwi1aKvOqY8pL|TshTPtCj5MIZ^KwYZ^I@yL86a_J-j^a4(VQ%)=6^=C zKJ5c)w(6l<;ALLd9ynwLKHmiZnYce zT~z>T3?i*-sI8BHIxQ`2?zJ>tsny0=M0ktiGfOFr;Q81aFL|d`X@A7~Gr{>XJzNHcJQh-9%Var0c8Z|JxghrRL#$ZKk`UhjR;Q1qwlp+X0@^ruXY?2GT?!GtaNTrxG?5NE|CkqTZ9V6-+@iTJgV(eJAeL z@w?uUDUw0Df0O-Wr3JF3Rsjga_O>p0n{1}d#c3#ASh85$dyvd$F}{{$pHfOzsmDRYRL^S3G4>mH zCpccj0Y%xjfms?ESVdX&h)(bZi4_{=DFm6{IkYjraFh5S9=g|i@IU%$J>=kWF>d7k z?hD~x1|^=yc(9!Y*IMt2=3D^Y@kCIy6=?vXaBA?beu6D9eLK06#9NW8z{yd_Q1O`|$gBN%T+wbw}j*{!-rK6D;`p zJBhLJ5_2Vh1Qs@ScoX(&qOwvn+r_Fy z@5A}w$Do2J1E7podpzo#_;`skGSk z_I5dK=nZG}0Wt8iM{hpXKD}ckVVxRv!w1#G>pxA|vj5e`dmr32yWS!5!gBGNpPjq~ z-xk_op3XbHJ$`v#hv=d|bvo`ETlz7<*U6uHA8PXPcl_*!hK5GX3D@F56=&`i%nv>x zAR8KopGpSO59<$^))UfKClckbOVqRF_4}vv7K00%YGaB%SoR=bBmgznYUJ)asWLl0 zp5C$4y6y^tBHcW3m}zrLZDFmY2<^vId9YyBo1vf1Qf76oA*@?t)3zxj5cB%rM~sLH zZLU;V&!{um-EZZ#2lneL@5pcGpFI~;(9cdada%<9unmA@D|-?Hkvl!8aMw(!D5$ob z$G4xVEErn%-lqrdFP02+)m5;t$_{QLw4Z3sw$?rg<31b8V}ll}kNGY$@kzcYCY(M$ z*j9>#V|2h#Xo!bWWroH{P{^6KBRCVKesMFx499PRe3lz3j!&U?y1>hqUU zt(TJn-mrrPCfYM+hF*2x@=)(*#J57Jm{eaWM~jn%bYEGZ3T2n1DG&u<=|VtJP-|1( zd!CI4jWYJVH>bXH#_m>L6MN^cc8FLuwQ-nSEfP$2^ro7)yz|}iFL}Te6K9H`@ z

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 z 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�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%0AAc>C-@`QlRu=QXI&5U`J8G2A|uyh%M&oQMtvoL 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�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

owr|GTcd1H9tatKScrpg40d^Bi6>!Vgsjj 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 z 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 literal 0 HcmV?d00001 diff --git a/examples/static/images/mlflow_experiments_overview.png b/examples/static/images/mlflow_experiments_overview.png new file mode 100644 index 0000000000000000000000000000000000000000..fa426acb0a5a8a266a76b5536338715fab4d1f86 GIT binary patch literal 219488 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

AYV7d0YIne}{bCY#w%X7wiaba+qhL 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%0DSkk!ocV%g3X2k?i1S@m_mO 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 Xk$YG-iu^!Z1o&86?y(?k^N9K{X+wC4 literal 0 HcmV?d00001 diff --git a/examples/static/images/mlflow_model_registry.png b/examples/static/images/mlflow_model_registry.png new file mode 100644 index 0000000000000000000000000000000000000000..d344fbedb18b4e0e36992a152b9f24307b990609 GIT binary patch literal 148435 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�f*LU(>E2cAx`3$d4kEr3d{Vcv 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 SOTg=X($diVrAY13lm7>W06ks+ literal 0 HcmV?d00001 diff --git a/examples/static/images/mlflow_models.png b/examples/static/images/mlflow_models.png deleted file mode 100644 index 6c935b91cd7a0c4a01cd0347cfbc599905cdd4bc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 361032 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≶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%0A`rh5fZ%X) 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 B*b)E$ diff --git a/examples/static/images/mlflow_models_overview.png b/examples/static/images/mlflow_models_overview.png new file mode 100644 index 0000000000000000000000000000000000000000..5dfc795405a110e3c7c24820a2329fcacbc42d6d GIT binary patch literal 186819 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

-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 bGuZm+oLY@pJZuM;pL@6UZWaB_D)_$ukTDV3 literal 0 HcmV?d00001 diff --git a/examples/static/images/mlflow_overview.png b/examples/static/images/mlflow_overview.png deleted file mode 100644 index 2d923379e249c34de6eeadab80264c789609d338..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 332549 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

@Z_W6B?Q>to=c{V6>yc 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 EAGvpN^8f$< diff --git a/examples/static/images/mlflow_run_detail.png b/examples/static/images/mlflow_run_detail.png new file mode 100644 index 0000000000000000000000000000000000000000..2038443e1be65eee31b1fa45e6755719460d924b GIT binary patch literal 429667 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�*zc4=R+>qliMf1Qe$*;V};k>u9kF>`h)@prOyiB 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%0AKla=dWh{dir=6T;s1=?xane9OH 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 R_z&>!!a2y<{4-W}{}10F7<>Q# literal 0 HcmV?d00001 From fe01a223a04644b98477e083eb037221d202e316 Mon Sep 17 00:00:00 2001 From: dennisbader Date: Thu, 3 Sep 2026 17:40:44 +0200 Subject: [PATCH 150/154] finalize notebook --- CHANGELOG.md | 2 +- darts/utils/mlflow.py | 61 +- docs/source/examples.rst | 10 + examples/29-MLflow-examples.ipynb | 4054 ++++++++++++++++++++++++++++- 4 files changed, 4054 insertions(+), 73 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e68c1cc30f..c23e9b95c3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,7 +15,7 @@ but cannot always guarantee backwards compatibility. Changes that may **break co - Added `save_model()`, `load_model()`, and `log_model()` to persist and reload Darts models as MLflow models, including model and covariate metadata. - Added `autolog()` for model parameters, series/covariate metadata, optional model artifacts, PyTorch epoch metrics, and backtest metrics. Nested historical-forecast fits are suppressed. - Darts metrics are logged with shape-aware keys; multi-series and window-level backtest details are available in `metrics_per_series.json`. - - Added a new notebook for [MLflow quickstart](https://unit8co.github.io/darts/examples/29-MLflow-quickstart.html) with detailed usage examples. + - Added a new notebook for [MLflow quickstart](https://unit8co.github.io/darts/examples/29-MLflow-examples.html) with detailed usage examples. - Note: model serving and deployment (MLflow's `pyfunc` flavor, model signatures, and input examples) are not yet supported. - Added support for per-timestep (non-aggregated) encoder and decoder variable importances in `TFTExplainer`, exposed as `TimeSeries` via `TFTExplainabilityResult.get_encoder_importance_over_time()` and `get_decoder_importance_over_time()`. [#3170](https://github.com/unit8co/darts/pull/3170) by [exactml](https://github.com/exactml). - Calling `TFTModel.fit_from_dataset()` on a dataset that does not have future covariates now raises an informative exception. [#3149](https://github.com/unit8co/darts/pull/3149) by [YOON KIWOONG](https://github.com/kiwoongyoon). diff --git a/darts/utils/mlflow.py b/darts/utils/mlflow.py index 470d13bdf4..7b7f1e6694 100644 --- a/darts/utils/mlflow.py +++ b/darts/utils/mlflow.py @@ -8,7 +8,7 @@ and logging any Darts ``ForecastingModel`` (statistical, ML-based, and PyTorch-based) to MLflow, as well as automatic logging via ``autolog()``. -See the `MLflow quickstart example `_ +See the `MLflow quickstart example `_ for an end-to-end walkthrough. .. dropdown:: Here's a quick start example @@ -30,9 +30,16 @@ # use a permanent location for real use cases tmpdir = tempfile.mkdtemp() mlflow_db = os.path.join(tmpdir, "mlflow.db") + artifact_root = os.path.join(tmpdir, "mlruns") mlflow.set_tracking_uri(f"sqlite:///{mlflow_db}") - mlflow.set_experiment("darts-quickstart") + # SQLite stores run metadata; artifacts default to ./mlruns unless we set a location + mlflow.set_experiment( + experiment_id=mlflow.create_experiment( + "darts-quickstart", + artifact_location=artifact_root, + ) + ) # load series and create train and val splits series = AirPassengersDataset().load() @@ -110,9 +117,9 @@ ``"mae_target0_q0_500"``), where each part is included only when the corresponding axis is present: - - ``metric_name`` – the metric function name, or the ``name`` metric + - ``metric_name`` - the metric function name, or the ``name`` metric keyword argument when provided (e.g., ``"mae"``). - - ``component`` – the component name: e.g., ``"_target0"`` when + - ``component`` - the component name: e.g., ``"_target0"`` when ``component_reduction=None``. - ``quantile_or_label``: @@ -206,7 +213,7 @@ import pandas as pd import yaml from mlflow.entities import LoggedModel -from mlflow.models import Model, ModelInputExample, ModelSignature +from mlflow.models import Model, ModelSignature from mlflow.models.model import MLMODEL_FILE_NAME from mlflow.models.utils import _save_example from mlflow.tracking.artifact_utils import _download_artifact_from_uri @@ -284,7 +291,7 @@ def save_model( code_paths: list[str] | None = None, mlflow_model: Model | None = None, signature: ModelSignature | None = None, - input_example: ModelInputExample | None = None, + input_example: Any | None = None, pip_requirements: list[str] | None = None, extra_pip_requirements: list[str] | None = None, metadata: dict[str, Any] | None = None, @@ -329,7 +336,7 @@ def save_model( Notes ----- - Signature and input_example params are currently not supported, as they + ``signature`` and ``input_example`` params are currently not supported, as they are used to support serving and input validation in the MLflow pyfunc flavor, which is not implemented for Darts models. They are accepted as params for simplifying potential future extensibility, and to keep in line with MLflow API @@ -850,10 +857,10 @@ def _mlflow_metric_callback(func, result, args, kwargs) -> None: where: - - ``metric_name`` – the metric function name, or the ``name`` keyword + - ``metric_name`` - the metric function name, or the ``name`` keyword argument when provided (it overrides only this token). - - ``component`` – ``_{component_name}`` when ``component_reduction=None``. - - ``quantile_or_label`` – quantile/interval/label suffix (e.g. ``_q0.500``, + - ``component`` - ``_{component_name}`` when ``component_reduction=None``. + - ``quantile_or_label`` - quantile/interval/label suffix (e.g. ``_q0.500``, ``_qi0.800``, ``_label1``) when applicable. When the input is a ``Sequence[TimeSeries]`` with more than one series, the @@ -1124,7 +1131,7 @@ def _log_series_info( def _is_torch_model(model) -> bool: - """Check if a model is a `TorchForecastingModel`. + """Check if a model is a ``TorchForecastingModel``. Parameters ---------- @@ -1288,36 +1295,36 @@ def _log_metric_results( ---------------- Each per-series result is reshaped to ``(W, T, C, M)``: - - ``W`` – backtest windows (``1`` for standalone, or when windows were + - ``W`` - backtest windows (``1`` for standalone, or when windows were aggregated before scoring). - - ``T`` – timesteps (``1`` when ``time_reduction`` is set). - - ``C`` – sub-metrics per component (components × quantiles / intervals / + - ``T`` - timesteps (``1`` when ``time_reduction`` is set). + - ``C`` - sub-metrics per component (components * quantiles / intervals / labels; ``1`` when ``component_reduction`` is set). - - ``M`` – number of metrics when several are logged at once. + - ``M`` - number of metrics when several are logged at once. Axis sizes are inferred from each metric's signature and the corresponding ``metric_kwargs``. Kwargs that affect output dimensions (both modes unless noted): - - ``time_reduction`` – collapses the time axis (``T=1``). - - ``component_reduction`` – collapses the component axis (``C=1``). - - ``q`` / ``q_interval`` – one sub-metric per quantile / interval. - - ``labels`` – when ``label_reduction=None``, one sub-metric per label; + - ``time_reduction`` - collapses the time axis (``T=1``). + - ``component_reduction`` - collapses the component axis (``C=1``). + - ``q`` / ``q_interval`` - one sub-metric per quantile / interval. + - ``labels`` - when ``label_reduction=None``, one sub-metric per label; otherwise ``labels`` only restricts which classes are scored. - - ``label_reduction`` – collapses label outputs to a scalar per component. - - ``series_reduction`` – collapses the series axis inside the metric, so + - ``label_reduction`` - collapses label outputs to a scalar per component. + - ``series_reduction`` - collapses the series axis inside the metric, so the caller's ``result`` is already aggregated and treated as a single series (``W=1`` for backtest regardless of ``reduction``). Backtest-only kwargs: - - ``reduction=None`` – no aggregation across windows → one value per + - ``reduction=None`` - no aggregation across windows → one value per window (``W > 1``). - - ``last_points_only`` – concatenates all windows into one ``TimeSeries`` + - ``last_points_only`` - concatenates all windows into one ``TimeSeries`` before scoring, so there is effectively one window regardless of ``reduction``. - - ``forecast_horizon`` / ``historical_forecasts`` – set the time-axis + - ``forecast_horizon`` / ``historical_forecasts`` - set the time-axis length for time-dependent metrics when windows are preserved. MLflow keys and steps @@ -1596,10 +1603,10 @@ def _infer_metric_axes( tuple ``(has_time_axis, has_comp_axis, axis_labels)`` where - - ``has_time_axis`` – ``True`` when ``time_reduction`` is ``None`` (i.e. a + - ``has_time_axis`` - ``True`` when ``time_reduction`` is ``None`` (i.e. a per-timestep axis is present in the output). - - ``has_comp_axis`` – ``True`` when components are expanded (not collapsed to a scalar). - - ``axis_labels`` – one key suffix per quantile/interval/label entry. + - ``has_comp_axis`` - ``True`` when components are expanded (not collapsed to a scalar). + - ``axis_labels`` - one key suffix per quantile/interval/label entry. Raises ------ diff --git a/docs/source/examples.rst b/docs/source/examples.rst index ddba7e8713..5aae3ae484 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -256,6 +256,16 @@ Explainability example notebook showcasing the use of Darts' explainability modu examples/28-Explainability-examples.ipynb +MLflow Integration +================== + +MLflow integration example notebook: + +.. toctree:: + :maxdepth: 1 + + examples/29-MLflow-examples.ipynb + Kalman Filter Model =================== diff --git a/examples/29-MLflow-examples.ipynb b/examples/29-MLflow-examples.ipynb index 7ffa551156..30a177f907 100644 --- a/examples/29-MLflow-examples.ipynb +++ b/examples/29-MLflow-examples.ipynb @@ -36,13 +36,3910 @@ "execution_count": 2, "id": "11bca7fd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import os\n", "import tempfile\n", "import warnings\n", "\n", "import mlflow\n", + "import plotly\n", "from mlflow import MlflowClient\n", "\n", "import darts.metrics as metrics\n", @@ -54,10 +3951,9 @@ "\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", "set_option(\"plotting.use_darts_style\", True)\n", + "plotly.offline.init_notebook_mode()\n", "\n", "PLOTLY_KWARGS = dict(\n", - " width=800,\n", - " height=400,\n", " legend=dict(yanchor=\"top\", y=0.99, xanchor=\"left\", x=0.01),\n", ")" ] @@ -69,7 +3965,7 @@ "source": [ "## 1. MLflow setup\n", "\n", - "Point MLflow at a tracking backend and create an experiment. We use a temporary SQLite database so this notebook runs self-contained; in production, set `tracking_uri` to your team's MLflow server or local database." + "Point MLflow at a tracking backend and create an experiment. We use a temporary directory so this notebook runs self-contained: run metadata goes to a SQLite database, and artifacts (models, JSON files) are stored alongside it. In production, set `tracking_uri` to your team's MLflow server or local database." ] }, { @@ -82,33 +3978,38 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026/09/03 16:10:25 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", - "2026/09/03 16:10:25 INFO mlflow.store.db.utils: Updating database tables\n", - "2026/09/03 16:10:26 INFO mlflow.tracking.fluent: Experiment with name 'darts-mlflow-examples' does not exist. Creating a new experiment.\n" + "2026/09/03 17:38:23 INFO mlflow.store.db.utils: Creating initial MLflow database tables...\n", + "2026/09/03 17:38:23 INFO mlflow.store.db.utils: Updating database tables\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Tracking URI: sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmps5wn0e4a/mlflow.db\n", + "Tracking URI: sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmp35vve02p/mlflow.db\n", "Experiment: darts-mlflow-examples\n", "\n", "To explore runs in the UI:\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmps5wn0e4a/mlflow.db\n" + " mlflow ui --backend-store-uri sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmp35vve02p/mlflow.db\n" ] } ], "source": [ "tmpdir = tempfile.mkdtemp()\n", "mlflow_db = os.path.join(tmpdir, \"mlflow.db\")\n", + "artifact_root = os.path.join(tmpdir, \"mlruns\")\n", "\n", "EXPERIMENT_NAME = \"darts-mlflow-examples\"\n", "mlflow.set_tracking_uri(f\"sqlite:///{mlflow_db}\")\n", - "mlflow.set_experiment(EXPERIMENT_NAME)\n", + "mlflow.set_experiment(\n", + " experiment_id=mlflow.create_experiment(\n", + " EXPERIMENT_NAME,\n", + " artifact_location=artifact_root,\n", + " )\n", + ")\n", "\n", "print(f\"Tracking URI: {mlflow.get_tracking_uri()}\")\n", - "print(f\"Experiment: {mlflow.get_experiment_by_name('darts-mlflow-examples').name}\")\n", + "print(f\"Experiment: {mlflow.get_experiment_by_name(EXPERIMENT_NAME).name}\")\n", "print(\n", " f\"\\nTo explore runs in the UI:\\n mlflow ui --backend-store-uri sqlite:///{mlflow_db}\"\n", ")" @@ -318,7 +4219,6 @@ "yref": "y domain" } ], - "height": 400, "hovermode": "x unified", "legend": { "x": 0.01, @@ -411,14 +4311,40 @@ "title": { "text": "Air Passengers" }, - "width": 800, "xaxis": { "title": { "text": "Month" } } } - } + }, + "text/html": [ + "

" + ] }, "metadata": {}, "output_type": "display_data" @@ -554,7 +4480,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026/09/03 16:10:29 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + "2026/09/03 17:38:25 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { @@ -810,7 +4736,6 @@ } ], "layout": { - "height": 400, "hovermode": "x unified", "legend": { "x": 0.01, @@ -888,14 +4813,40 @@ "title": { "text": "Historical forecasts — linear_regression" }, - "width": 800, "xaxis": { "title": { "text": "Month" } } } - } + }, + "text/html": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -904,7 +4855,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026/09/03 16:10:29 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" + "2026/09/03 17:38:25 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n", + "2026/09/03 17:38:25 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" ] }, { @@ -912,20 +4864,7 @@ "output_type": "stream", "text": [ "Finished run: linear_regression\n", - "Finished run: random_forest\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026/09/03 16:10:29 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Finished run: random_forest\n", "Finished run: linear_regression_lags24\n" ] } @@ -984,7 +4923,7 @@ "text": [ "\n", "To explore runs in the UI:\n", - " mlflow ui --backend-store-uri sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmps5wn0e4a/mlflow.db\n" + " mlflow ui --backend-store-uri sqlite:////var/folders/4h/l09drklx06g8022q7khgyxyr0000gn/T/tmp35vve02p/mlflow.db\n" ] } ], @@ -1087,19 +5026,19 @@ " \n", " \n", " 0\n", - " fb3ad151ba8c4192bb82857a5e255994\n", + " b887a1aef1904bc69e4c39e9049c1420\n", " linear_regression\n", " 18.870433\n", " \n", " \n", " 1\n", - " 41484b2e9f794a3a96ee6f89f4d789e4\n", + " 40f92ba313d44527ad0b252ca68217ef\n", " linear_regression_lags24\n", " 24.509846\n", " \n", " \n", " 2\n", - " 2302431c94a348d09dcd46bbc10dcdab\n", + " ba40cdb96e5b40289919ca4c1b205dce\n", " random_forest\n", " 77.316667\n", " \n", @@ -1109,9 +5048,9 @@ ], "text/plain": [ " run_id tags.mlflow.runName \\\n", - "0 fb3ad151ba8c4192bb82857a5e255994 linear_regression \n", - "1 41484b2e9f794a3a96ee6f89f4d789e4 linear_regression_lags24 \n", - "2 2302431c94a348d09dcd46bbc10dcdab random_forest \n", + "0 b887a1aef1904bc69e4c39e9049c1420 linear_regression \n", + "1 40f92ba313d44527ad0b252ca68217ef linear_regression_lags24 \n", + "2 ba40cdb96e5b40289919ca4c1b205dce random_forest \n", "\n", " metrics.backtest_agg_mae \n", "0 18.870433 \n", @@ -1127,7 +5066,7 @@ "output_type": "stream", "text": [ "\n", - "Best run by backtest_agg_mae: linear_regression (fb3ad151ba8c4192bb82857a5e255994)\n" + "Best run by backtest_agg_mae: linear_regression (b887a1aef1904bc69e4c39e9049c1420)\n" ] } ], @@ -1166,7 +5105,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Best model URI: models:/m-d142c7979f29495d90aa74b3e91638e0\n", + "Best model URI: models:/m-4f23e6ce02f144cdb164b78ab5dc2dc6\n", "Aliases set: @champion\n" ] }, @@ -1432,7 +5371,6 @@ } ], "layout": { - "height": 400, "hovermode": "x unified", "legend": { "x": 0.01, @@ -1510,14 +5448,40 @@ "title": { "text": "Production inference — darts-air-passengers-forecaster@champion" }, - "width": 800, "xaxis": { "title": { "text": "Month" } } } - } + }, + "text/html": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" From b8ba85f037e7cf6892f1869e62e48ce7dd5e59dc Mon Sep 17 00:00:00 2001 From: dennisbader Date: Fri, 4 Sep 2026 11:19:58 +0200 Subject: [PATCH 151/154] udpate notebook --- examples/29-MLflow-examples.ipynb | 1432 ++++++++++++----------------- 1 file changed, 578 insertions(+), 854 deletions(-) diff --git a/examples/29-MLflow-examples.ipynb b/examples/29-MLflow-examples.ipynb index 30a177f907..f8ba551244 100644 --- a/examples/29-MLflow-examples.ipynb +++ b/examples/29-MLflow-examples.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "11bca7fd", "metadata": {}, "outputs": [ @@ -45,7 +45,7 @@ " if (window.MathJax && window.MathJax.Hub && window.MathJax.Hub.Config) {window.MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}\n", " \n", "

U2q)qg?;wnx8kJ~4wx&zOWiDuxz^Gb#3x}-Xi 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