autogluon.timeseries 1.0.1b20240327__tar.gz → 1.0.1b20240329__tar.gz

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.0.1b20240327
+Version: 1.0.1b20240329
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/learner.py

@@ -1,7 +1,7 @@
 import logging
 import reprlib
 import time
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, List, Literal, Optional, Type, Union
 
 import pandas as pd
 
@@ -228,5 +228,32 @@ class TimeSeriesLearner(AbstractLearner):
         learner_info.pop("random_state", None)
         return learner_info
 
+    def persist_trainer(
+        self, models: Union[Literal["all", "best"], List[str]] = "all", with_ancestors: bool = False
+    ) -> List[str]:
+        """Loads models and trainer in memory so that they don't have to be
+        loaded during predictions
+
+        Returns
+        -------
+        list_of_models : List[str]
+            List of models persisted in memory
+        """
+        self.trainer = self.load_trainer()
+        return self.trainer.persist(models, with_ancestors=with_ancestors)
+
+    def unpersist_trainer(self) -> List[str]:
+        """Unloads models and trainer from memory. Models will have to be reloaded from disk
+        when predicting.
+
+        Returns
+        -------
+        list_of_models : List[str]
+            List of models removed from memory
+        """
+        unpersisted_models = self.load_trainer().unpersist()
+        self.trainer = None
+        return unpersisted_models
+
     def refit_full(self, model: str = "all") -> Dict[str, str]:
         return self.load_trainer().refit_full(model=model)

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -415,6 +415,13 @@ class AbstractTimeSeriesModel(AbstractModel):
         hpo_executor.register_resources(self, k_fold=1, **kwargs)
         return self._hyperparameter_tune(hpo_executor=hpo_executor, **kwargs)
 
+    def persist(self) -> "AbstractTimeSeriesModel":
+        """Ask the model to persist its assets in memory, i.e., to predict with low latency. In practice
+        this is used for pretrained models that have to lazy-load model parameters to device memory at
+        prediction time.
+        """
+        return self
+
     def _hyperparameter_tune(
         self,
         train_data: TimeSeriesDataFrame,

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/models/chronos/model.py

@@ -18,11 +18,29 @@ logger = logging.getLogger(__name__)
 MODEL_CONFIGS = {
     "amazon/chronos-t5-tiny": {
         "num_gpus": 0,  # minimum number of required GPUs
+        "default_torch_dtype": "auto",
+        "default_batch_size": 16,
+    },
+    "amazon/chronos-t5-mini": {
+        "num_gpus": 0,
+        "default_torch_dtype": "auto",
+        "default_batch_size": 16,
+    },
+    "amazon/chronos-t5-small": {
+        "num_gpus": 1,
+        "default_torch_dtype": "bfloat16",
+        "default_batch_size": 16,
+    },
+    "amazon/chronos-t5-base": {
+        "num_gpus": 1,
+        "default_torch_dtype": "bfloat16",
+        "default_batch_size": 16,
+    },
+    "amazon/chronos-t5-large": {
+        "num_gpus": 1,
+        "default_torch_dtype": "bfloat16",
+        "default_batch_size": 8,
     },
-    "amazon/chronos-t5-mini": {"num_gpus": 0},
-    "amazon/chronos-t5-small": {"num_gpus": 1},
-    "amazon/chronos-t5-base": {"num_gpus": 1},
-    "amazon/chronos-t5-large": {"num_gpus": 1},
 }
 
 
@@ -124,7 +142,6 @@ class ChronosModel(AbstractTimeSeriesModel):
 
     # default number of samples for prediction
     default_num_samples: int = 20
-    default_batch_size: int = 16
     default_model_path = "amazon/chronos-t5-small"
     maximum_context_length = 512
 
@@ -149,7 +166,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         self.device = hyperparameters.get("device")
 
         # if the model requires a GPU, set the torch dtype to bfloat16
-        self.torch_dtype = hyperparameters.get("torch_dtype", "auto" if self.min_num_gpus == 0 else "bfloat16")
+        self.torch_dtype = hyperparameters.get("torch_dtype", self.default_torch_dtype)
 
         self.data_loader_num_workers = hyperparameters.get("data_loader_num_workers", 0)
         self.optimization_strategy: Optional[Literal["onnx", "openvino"]] = hyperparameters.get(
@@ -200,8 +217,32 @@ class ChronosModel(AbstractTimeSeriesModel):
         return torch.cuda.is_available()
 
     @property
-    def min_num_gpus(self):
-        return MODEL_CONFIGS.get(self.model_path, {}).get("num_gpus", 0)
+    def ag_default_config(self) -> Dict[str, Any]:
+        """The default configuration of the model used by AutoGluon if the model is one of those
+        defined in MODEL_CONFIGS. For now, these are ``amazon/chronos-t5-*`` family of models.
+        """
+        return MODEL_CONFIGS.get(self.model_path, {})
+
+    @property
+    def min_num_gpus(self) -> int:
+        """Minimum number of GPUs required for the model. For models not defined in AutoGluon,
+        this value defaults to 0.
+        """
+        return self.ag_default_config.get("num_gpus", 0)
+
+    @property
+    def default_batch_size(self) -> int:
+        """Default batch size used for the model. For models not defined in AutoGluon, this value
+        defaults to 8.
+        """
+        return self.ag_default_config.get("default_batch_size", 8)
+
+    @property
+    def default_torch_dtype(self) -> Any:
+        """Default torch data type used for the model. For models not defined in AutoGluon, this value
+        defaults to "auto".
+        """
+        return self.ag_default_config.get("default_torch_dtype", "auto")
 
     def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
         minimum_resources = {"num_cpus": 1}
@@ -211,7 +252,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         return minimum_resources
 
     def load_model_pipeline(self, context_length: Optional[int] = None):
-        from .chronos import OptimizedChronosPipeline
+        from .pipeline import OptimizedChronosPipeline
 
         gpu_available = self._is_gpu_available()
 
@@ -234,6 +275,10 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         self.model_pipeline = pipeline
 
+    def persist(self) -> "ChronosModel":
+        self.load_model_pipeline(context_length=self.context_length or self.maximum_context_length)
+        return self
+
     def _fit(
         self,
         train_data: TimeSeriesDataFrame,
@@ -283,8 +328,9 @@ class ChronosModel(AbstractTimeSeriesModel):
         with warning_filter(all_warnings=True):
             import torch
 
-            # load model pipeline to device memory
-            self.load_model_pipeline(context_length=context_length)
+            if self.model_pipeline is None:
+                # load model pipeline to device memory
+                self.load_model_pipeline(context_length=context_length)
 
             self.model_pipeline.model.eval()
             with torch.inference_mode():

autogluon.timeseries-1.0.1b20240327/src/autogluon/timeseries/models/chronos/chronos.py → autogluon.timeseries-1.0.1b20240329/src/autogluon/timeseries/models/chronos/pipeline.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # Original Source: https://github.com/amazon-science/chronos-forecasting
-# Author: Lorenzo Stella <stellalo@amazon.com>
+# Authors: Lorenzo Stella <stellalo@amazon.com>, Abdul Fatir Ansari <ansarnd@amazon.com>
 
 import logging
 import warnings
@@ -18,6 +18,9 @@ from autogluon.timeseries.utils.warning_filters import set_loggers_level
 logger = logging.getLogger(__name__)
 
 
+__all__ = ["ChronosConfig", "ChronosPipeline", "OptimizedChronosPipeline"]
+
+
 @dataclass
 class ChronosConfig:
     """
@@ -81,14 +84,14 @@ class ChronosTokenizer:
             A boolean tensor, same shape as ``token_ids``, indicating
             which input observations are not ``torch.nan`` (i.e. not
             missing nor padding).
-        decoding_context
+        tokenizer_state
             An object that will be passed to ``output_transform``.
             Contains the relevant context to decode output samples into
             real values, such as location and scale parameters.
         """
         raise NotImplementedError()
 
-    def output_transform(self, samples: torch.Tensor, decoding_context: Any) -> torch.Tensor:
+    def output_transform(self, samples: torch.Tensor, tokenizer_state: Any) -> torch.Tensor:
         """
         Turn a batch of sample token IDs into real values.
 
@@ -97,7 +100,7 @@ class ChronosTokenizer:
         samples
             A tensor of integers, shaped (batch_size, num_samples, time_length),
             containing token IDs of sample trajectories.
-        decoding_context
+        tokenizer_state
             An object returned by ``input_transform`` containing
             relevant context to decode samples, such as location and scale.
             The nature of this depends on the specific tokenizer.
@@ -132,13 +135,6 @@ class MeanScaleUniformBins(ChronosTokenizer):
 
         if length > self.config.context_length:
             context = context[..., -self.config.context_length :]
-        elif length < self.config.context_length:
-            padding_size = (
-                *context.shape[:-1],
-                self.config.context_length - length,
-            )
-            padding = torch.full(size=padding_size, fill_value=torch.nan)
-            context = torch.concat((padding, context), dim=-1)
 
         attention_mask = ~torch.isnan(context)
         scale = torch.nansum(torch.abs(context) * attention_mask, dim=-1) / torch.nansum(attention_mask, dim=-1)
@@ -191,7 +187,36 @@ class ChronosPretrainedModel(nn.Module):
         super().__init__()
         self.config = config
         self.model = model
-        self.device = model.device
+
+    @property
+    def device(self):
+        return self.model.device
+
+    def encode(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+    ):
+        """
+        Extract the encoder embedding for the given token sequences.
+
+        Parameters
+        ----------
+        input_ids
+            Tensor of indices of input sequence tokens in the vocabulary
+            with shape (batch_size, sequence_length).
+        attention_mask
+            A mask tensor of the same shape as input_ids to avoid attending
+            on padding or missing tokens.
+
+        Returns
+        -------
+        embedding
+            A tensor of encoder embeddings with shape
+            (batch_size, sequence_length, d_model).
+        """
+        assert self.config.model_type == "seq2seq", "Encoder embeddings are only supported for encoder-decoder models"
+        return self.model.encoder(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state
 
     def forward(
         self,
@@ -288,6 +313,48 @@ class ChronosPipeline:
         self.tokenizer = tokenizer
         self.model = model
 
+    def _prepare_and_validate_context(self, context: Union[torch.Tensor, List[torch.Tensor]]):
+        if isinstance(context, list):
+            context = left_pad_and_stack_1D(context)
+        assert isinstance(context, torch.Tensor)
+        if context.ndim == 1:
+            context = context.unsqueeze(0)
+        assert context.ndim == 2
+
+        return context
+
+    @torch.no_grad()
+    def embed(self, context: Union[torch.Tensor, List[torch.Tensor]]) -> Tuple[torch.Tensor, Any]:
+        """
+        Get encoder embeddings for the given time series.
+
+        Parameters
+        ----------
+        context
+            Input series. This is either a 1D tensor, or a list
+            of 1D tensors, or a 2D tensor whose first dimension
+            is batch. In the latter case, use left-padding with
+            ``torch.nan`` to align series of different lengths.
+
+        Returns
+        -------
+        embeddings, tokenizer_state
+            A tuple of two tensors: the encoder embeddings and the tokenizer_state,
+            e.g., the scale of the time series in the case of mean scaling.
+            The encoder embeddings are shaped (batch_size, context_length, d_model)
+            or (batch_size, context_length + 1, d_model), where context_length
+            is the size of the context along the time axis if a 2D tensor was provided
+            or the length of the longest time series, if a list of 1D tensors was
+            provided, and the extra 1 is for EOS.
+        """
+        context = self._prepare_and_validate_context(context=context)
+        token_ids, attention_mask, tokenizer_state = self.tokenizer.input_transform(context)
+        embeddings = self.model.encode(
+            input_ids=token_ids.to(self.model.device),
+            attention_mask=attention_mask.to(self.model.device),
+        ).cpu()
+        return embeddings, tokenizer_state
+
     def predict(
         self,
         context: Union[torch.Tensor, List[torch.Tensor]],
@@ -335,13 +402,7 @@ class ChronosPipeline:
             Tensor of sample forecasts, of shape
             (batch_size, num_samples, prediction_length).
         """
-        if isinstance(context, list):
-            context = left_pad_and_stack_1D(context)
-        assert isinstance(context, torch.Tensor)
-        if context.ndim == 1:
-            context = context.unsqueeze(0)
-        assert context.ndim == 2
-
+        context = self._prepare_and_validate_context(context=context)
         if prediction_length is None:
             prediction_length = self.model.config.prediction_length
 

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -212,6 +212,11 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
             most_recent_model.save()
         return save_path
 
+    def persist(self):
+        if self.most_recent_model is None:
+            raise ValueError(f"{self.name} must be fit before persisting")
+        self.most_recent_model.persist()
+
     @classmethod
     def load(
         cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/predictor.py

@@ -5,7 +5,7 @@ import os
 import pprint
 import time
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Type, Union
 
 import numpy as np
 import pandas as pd
@@ -983,6 +983,47 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
                 return self._trainer.model_best
         return self._trainer.get_model_best()
 
+    def persist(
+        self, models: Union[Literal["all", "best"], List[str]] = "best", with_ancestors: bool = True
+    ) -> List[str]:
+        """Persist models in memory for reduced inference latency. This is particularly important if the models are being used for online
+        inference where low latency is critical. If models are not persisted in memory, they are loaded from disk every time they are
+        asked to make predictions. This is especially cumbersome for large deep learning based models which have to be loaded into
+        accelerator (e.g., GPU) memory each time.
+
+        Parameters
+        ----------
+        models : list of str or str, default = 'best'
+            Model names of models to persist.
+            If 'best' then the model with the highest validation score is persisted (this is the model used for prediction by default).
+            If 'all' then all models are persisted. Valid models are listed in this `predictor` by calling `predictor.model_names()`.
+        with_ancestors : bool, default = True
+            If True, all ancestor models of the provided models will also be persisted.
+            If False, ensemble models will not have the models they depend on persisted unless those models were specified in `models`.
+            This will slow down inference as the ancestor models will still need to be loaded from disk for each predict call.
+            Only relevant for ensemble models.
+
+        Returns
+        -------
+        list_of_models : List[str]
+            List of persisted model names.
+        """
+        return self._learner.persist_trainer(models=models, with_ancestors=with_ancestors)
+
+    def unpersist(self) -> List[str]:
+        """Unpersist models in memory for reduced memory usage. If models are not persisted in memory, they are loaded from
+        disk every time they are asked to make predictions.
+
+        Note: Another way to reset the predictor and unpersist models is to reload the predictor from disk
+        via `predictor = TimeSeriesPredictor.load(predictor.path)`.
+
+        Returns
+        -------
+        list_of_models : List[str]
+            List of unpersisted model names.
+        """
+        return self._learner.unpersist_trainer()
+
     def leaderboard(
         self,
         data: Optional[Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]] = None,

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/trainer/abstract_trainer.py

@@ -5,7 +5,7 @@ import time
 import traceback
 from collections import defaultdict
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Type, Union
 
 import networkx as nx
 import numpy as np
@@ -71,21 +71,6 @@ class SimpleAbstractTrainer:
             results[model] = self.model_graph.nodes[model][attribute]
         return results
 
-    def get_model_best(self) -> str:
-        """Return the name of the best model by model performance on the validation set."""
-        models = self.get_model_names()
-        if not models:
-            raise ValueError("Trainer has no fit models that can predict.")
-        if len(models) == 1:
-            return models[0]
-        model_performances = self.get_models_attribute_dict(attribute="val_score")
-        performances_list = [(m, model_performances[m]) for m in models if model_performances[m] is not None]
-
-        if not performances_list:
-            raise ValueError("No fitted models have validation scores computed.")
-
-        return max(performances_list, key=lambda i: i[1])[0]
-
     def get_model_attribute(self, model: Union[str, AbstractModel], attribute: str):
         """Get a member attribute for given model from the `model_graph`."""
         if not isinstance(model, str):
@@ -174,9 +159,12 @@ class SimpleAbstractTrainer:
         raise NotImplementedError
 
     # FIXME: Copy pasted from Tabular
-    def get_minimum_model_set(self, model: Union[str, AbstractTimeSeriesModel], include_self: bool = True) -> list:
+    def get_minimum_model_set(
+        self, model: Union[str, AbstractTimeSeriesModel], include_self: bool = True
+    ) -> List[str]:
         """Gets the minimum set of models that the provided model depends on, including itself.
-        Returns a list of model names"""
+        Returns a list of model names
+        """
         if not isinstance(model, str):
             model = model.name
         minimum_model_set = list(nx.bfs_tree(self.model_graph, model, reverse=True))
@@ -219,6 +207,9 @@ class SimpleAbstractTrainer:
         save_json.save(path=os.path.join(self.path, self.trainer_info_json_name), obj=info)
         return info
 
+    def get_model_best(self, *args, **kwargs) -> AbstractModel:
+        raise NotImplementedError
+
     def get_info(self, include_model_info: bool = False) -> Dict[str, Any]:
         num_models_trained = len(self.get_model_names())
         if self.model_best is not None:
@@ -389,6 +380,29 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
 
         return levels
 
+    def get_model_best(self) -> str:
+        """Return the name of the best model by model performance on the validation set."""
+        models = self.get_model_names()
+        if not models:
+            raise ValueError("Trainer has no fit models that can predict.")
+        if len(models) == 1:
+            return models[0]
+        model_performances = self.get_models_attribute_dict(attribute="val_score")
+        model_levels = self._get_model_levels()
+        model_name_score_level_list = [
+            (m, model_performances[m], model_levels.get(m, 0)) for m in models if model_performances[m] is not None
+        ]
+
+        if not model_name_score_level_list:
+            raise ValueError("No fitted models have validation scores computed.")
+
+        # rank models in terms of validation score. if two models have the same validation score,
+        # rank them by their level in the model graph (lower level models are preferred).
+        return max(
+            model_name_score_level_list,
+            key=lambda mns: (mns[1], -mns[2]),  # (score, -level)
+        )[0]
+
     def get_model_names(self, level: Optional[int] = None, **kwargs) -> List[str]:
         """Get model names that are registered in the model graph"""
         if level is not None:
@@ -797,6 +811,44 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
 
         return df[explicit_column_order]
 
+    def persist(
+        self, model_names: Union[Literal["all", "best"], List[str]] = "all", with_ancestors: bool = False, **kwargs
+    ) -> List[str]:
+        if model_names == "all":
+            model_names = self.get_model_names()
+        elif model_names == "best":
+            model_names = [self.get_model_best()]
+        if not isinstance(model_names, list):
+            raise ValueError(f"model_names must be a list of model names. Invalid value: {model_names}")
+
+        if with_ancestors:
+            models_with_ancestors = set()
+            for model_name in model_names:
+                models_with_ancestors = models_with_ancestors.union(self.get_minimum_model_set(model_name))
+            model_names = list(models_with_ancestors)
+
+        model_names_already_persisted = [model_name for model_name in model_names if model_name in self.models]
+        model_names = [model_name for model_name in model_names if model_name not in model_names_already_persisted]
+
+        for model_name in model_names:
+            model = self.load_model(model_name)
+            model.persist()
+            self.models[model.name] = model
+
+        return model_names
+
+    def unpersist(self, model_names: Union[Literal["all"], List[str]] = "all") -> List[str]:
+        if model_names == "all":
+            model_names = list(self.models.keys())
+        if not isinstance(model_names, list):
+            raise ValueError(f"model_names must be a list of model names. Invalid value: {model_names}")
+        unpersisted_models = []
+        for model in model_names:
+            if model in self.models:
+                self.models.pop(model)
+                unpersisted_models.append(model)
+        return unpersisted_models
+
     def _get_model_for_prediction(self, model: Optional[Union[str, AbstractTimeSeriesModel]] = None) -> str:
         """Given an optional identifier or model object, return the name of the model with which to predict.
 

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.0.1b20240327'
+__version__ = '1.0.1b20240329'
 __lite__ = False

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon.timeseries.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.0.1b20240327
+Version: 1.0.1b20240329
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon.timeseries.egg-info/SOURCES.txt

@@ -30,8 +30,8 @@ src/autogluon/timeseries/models/autogluon_tabular/__init__.py
 src/autogluon/timeseries/models/autogluon_tabular/mlforecast.py
 src/autogluon/timeseries/models/autogluon_tabular/utils.py
 src/autogluon/timeseries/models/chronos/__init__.py
-src/autogluon/timeseries/models/chronos/chronos.py
 src/autogluon/timeseries/models/chronos/model.py
+src/autogluon/timeseries/models/chronos/pipeline.py
 src/autogluon/timeseries/models/ensemble/__init__.py
 src/autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py
 src/autogluon/timeseries/models/ensemble/greedy_ensemble.py

{autogluon.timeseries-1.0.1b20240327 → autogluon.timeseries-1.0.1b20240329}/src/autogluon.timeseries.egg-info/requires.txt

@@ -16,13 +16,13 @@ utilsforecast<0.0.11,>=0.0.10
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.0.1b20240327
-autogluon.common==1.0.1b20240327
-autogluon.tabular[catboost,lightgbm,xgboost]==1.0.1b20240327
+autogluon.core[raytune]==1.0.1b20240329
+autogluon.common==1.0.1b20240329
+autogluon.tabular[catboost,lightgbm,xgboost]==1.0.1b20240329
 
 [all]
-optimum[nncf,openvino]<1.18,>=1.17
 optimum[onnxruntime]<1.18,>=1.17
+optimum[nncf,openvino]<1.18,>=1.17
 
 [chronos-onnx]
 optimum[onnxruntime]<1.18,>=1.17