autogluon.timeseries 1.2.1b20250224__py3-none-any.whl → 1.4.1b20251215__py3-none-any.whl

autogluon/timeseries/models/ensemble/greedy_ensemble.py

@@ -1,170 +0,0 @@
-import copy
-import logging
-import pprint
-from typing import Dict, List, Optional
-
-import numpy as np
-
-import autogluon.core as ag
-from autogluon.core.models.greedy_ensemble.ensemble_selection import EnsembleSelection
-from autogluon.timeseries import TimeSeriesDataFrame
-from autogluon.timeseries.metrics import TimeSeriesScorer
-from autogluon.timeseries.models.ensemble import AbstractTimeSeriesEnsembleModel
-from autogluon.timeseries.utils.datetime import get_seasonality
-
-logger = logging.getLogger(__name__)
-
-
-class TimeSeriesEnsembleSelection(EnsembleSelection):
-    def __init__(
-        self,
-        ensemble_size: int,
-        metric: TimeSeriesScorer,
-        problem_type: str = ag.constants.QUANTILE,
-        sorted_initialization: bool = False,
-        bagging: bool = False,
-        tie_breaker: str = "random",
-        random_state: np.random.RandomState = None,
-        prediction_length: int = 1,
-        target: str = "target",
-        eval_metric_seasonal_period: Optional[int] = None,
-        **kwargs,
-    ):
-        super().__init__(
-            ensemble_size=ensemble_size,
-            metric=metric,
-            problem_type=problem_type,
-            sorted_initialization=sorted_initialization,
-            bagging=bagging,
-            tie_breaker=tie_breaker,
-            random_state=random_state,
-            **kwargs,
-        )
-        self.prediction_length = prediction_length
-        self.target = target
-        self.eval_metric_seasonal_period = eval_metric_seasonal_period
-
-    def _fit(
-        self,
-        predictions: List[List[TimeSeriesDataFrame]],  # first dim: model, second dim: val window index
-        labels: List[TimeSeriesDataFrame],
-        time_limit: Optional[int] = None,
-        sample_weight=None,
-    ):
-        # Stack predictions for each model into a 3d tensor of shape [num_val_windows, num_rows, num_cols]
-        stacked_predictions = [np.stack(preds) for preds in predictions]
-
-        self.dummy_pred_per_window = []
-        self.scorer_per_window = []
-        self.data_future_per_window = []
-
-        for window_idx, data in enumerate(labels):
-            dummy_pred = copy.deepcopy(predictions[0][window_idx])
-            # This should never happen; sanity check to make sure that all predictions have the same index
-            assert all(dummy_pred.index.equals(pred[window_idx].index) for pred in predictions)
-
-            self.dummy_pred_per_window.append(dummy_pred)
-
-            scorer = copy.deepcopy(self.metric)
-            # Split the observed time series once to avoid repeated computations inside the evaluator
-            data_past = data.slice_by_timestep(None, -self.prediction_length)
-            data_future = data.slice_by_timestep(-self.prediction_length, None)
-            scorer.save_past_metrics(data_past, target=self.target, seasonal_period=self.eval_metric_seasonal_period)
-            self.scorer_per_window.append(scorer)
-            self.data_future_per_window.append(data_future)
-
-        super()._fit(
-            predictions=stacked_predictions,
-            labels=data_future,
-            time_limit=time_limit,
-        )
-        self.dummy_pred_per_window = None
-        self.evaluator_per_window = None
-        self.data_future_per_window = None
-
-    def _calculate_regret(self, y_true, y_pred_proba, metric=None, sample_weight=None):  # noqa
-        # Compute average score across all validation windows
-        total_score = 0.0
-        for window_idx, data_future in enumerate(self.data_future_per_window):
-            dummy_pred = self.dummy_pred_per_window[window_idx]
-            dummy_pred[list(dummy_pred.columns)] = y_pred_proba[window_idx]
-            # We use scorer.compute_metric instead of scorer.score to avoid repeated calls to scorer.save_past_metrics
-            metric_value = self.scorer_per_window[window_idx].compute_metric(
-                data_future, dummy_pred, target=self.target
-            )
-            total_score += metric.sign * metric_value
-        avg_score = total_score / len(self.data_future_per_window)
-        # score: higher is better, regret: lower is better, so we flip the sign
-        return -avg_score
-
-
-class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
-    """Constructs a weighted ensemble using the greedy Ensemble Selection algorithm."""
-
-    def __init__(self, name: str, ensemble_size: int = 100, **kwargs):
-        super().__init__(name=name, **kwargs)
-        self.ensemble_size = ensemble_size
-        self.model_to_weight: Dict[str, float] = {}
-
-    def _fit_ensemble(
-        self,
-        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
-        data_per_window: List[TimeSeriesDataFrame],
-        time_limit: Optional[int] = None,
-        **kwargs,
-    ):
-        if self.eval_metric_seasonal_period is None:
-            self.eval_metric_seasonal_period = get_seasonality(self.freq)
-        ensemble_selection = TimeSeriesEnsembleSelection(
-            ensemble_size=self.ensemble_size,
-            metric=self.eval_metric,
-            prediction_length=self.prediction_length,
-            target=self.target,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
-        )
-        ensemble_selection.fit(
-            predictions=list(predictions_per_window.values()),
-            labels=data_per_window,
-            time_limit=time_limit,
-        )
-        self.model_to_weight = {}
-        for model_name, weight in zip(predictions_per_window.keys(), ensemble_selection.weights_):
-            if weight != 0:
-                self.model_to_weight[model_name] = weight
-
-        weights_for_printing = {model: round(weight, 2) for model, weight in self.model_to_weight.items()}
-        logger.info(f"\tEnsemble weights: {pprint.pformat(weights_for_printing, width=200)}")
-
-    @property
-    def model_names(self) -> List[str]:
-        return list(self.model_to_weight.keys())
-
-    @property
-    def model_weights(self) -> np.ndarray:
-        return np.array(list(self.model_to_weight.values()), dtype=np.float64)
-
-    def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
-        if set(data.keys()) != set(self.model_names):
-            raise ValueError(
-                f"Set of models given for prediction in {self.name} differ from those provided during initialization."
-            )
-        for model_name, model_pred in data.items():
-            if model_pred is None:
-                raise RuntimeError(f"{self.name} cannot predict because base model {model_name} failed.")
-
-        # Make sure that all predictions have same shape
-        assert len(set(pred.shape for pred in data.values())) == 1
-
-        return sum(data[model_name] * weight for model_name, weight in self.model_to_weight.items())
-
-    def get_info(self) -> dict:
-        info = super().get_info()
-        info["model_weights"] = self.model_to_weight
-        return info
-
-    def remap_base_models(self, model_refit_map: Dict[str, str]) -> None:
-        updated_weights = {}
-        for model, weight in self.model_to_weight.items():
-            model_full_name = model_refit_map.get(model, model)
-            updated_weights[model_full_name] = weight
-        self.model_to_weight = updated_weights

autogluon/timeseries/models/presets.py

@@ -1,360 +0,0 @@
-import copy
-import logging
-import re
-from collections import defaultdict
-from typing import Any, Dict, List, Optional, Type, Union
-
-from autogluon.common import space
-from autogluon.core import constants
-from autogluon.timeseries.metrics import TimeSeriesScorer
-from autogluon.timeseries.utils.features import CovariateMetadata
-
-from . import (
-    ADIDAModel,
-    ARIMAModel,
-    AutoARIMAModel,
-    AutoCESModel,
-    AutoETSModel,
-    AverageModel,
-    ChronosModel,
-    CrostonModel,
-    DeepARModel,
-    DirectTabularModel,
-    DLinearModel,
-    DynamicOptimizedThetaModel,
-    ETSModel,
-    IMAPAModel,
-    NaiveModel,
-    NPTSModel,
-    PatchTSTModel,
-    RecursiveTabularModel,
-    SeasonalAverageModel,
-    SeasonalNaiveModel,
-    SimpleFeedForwardModel,
-    TemporalFusionTransformerModel,
-    ThetaModel,
-    TiDEModel,
-    WaveNetModel,
-    ZeroModel,
-)
-from .abstract import AbstractTimeSeriesModel
-from .multi_window.multi_window_model import MultiWindowBacktestingModel
-
-logger = logging.getLogger(__name__)
-
-ModelHyperparameters = Dict[str, Any]
-
-# define the model zoo with their aliases
-MODEL_TYPES = dict(
-    SimpleFeedForward=SimpleFeedForwardModel,
-    DeepAR=DeepARModel,
-    DLinear=DLinearModel,
-    PatchTST=PatchTSTModel,
-    TemporalFusionTransformer=TemporalFusionTransformerModel,
-    TiDE=TiDEModel,
-    WaveNet=WaveNetModel,
-    RecursiveTabular=RecursiveTabularModel,
-    DirectTabular=DirectTabularModel,
-    Average=AverageModel,
-    SeasonalAverage=SeasonalAverageModel,
-    Naive=NaiveModel,
-    SeasonalNaive=SeasonalNaiveModel,
-    Zero=ZeroModel,
-    AutoETS=AutoETSModel,
-    AutoCES=AutoCESModel,
-    AutoARIMA=AutoARIMAModel,
-    DynamicOptimizedTheta=DynamicOptimizedThetaModel,
-    NPTS=NPTSModel,
-    Theta=ThetaModel,
-    ETS=ETSModel,
-    ARIMA=ARIMAModel,
-    ADIDA=ADIDAModel,
-    Croston=CrostonModel,
-    CrostonSBA=CrostonModel,  # Alias for backward compatibility
-    IMAPA=IMAPAModel,
-    Chronos=ChronosModel,
-)
-
-DEFAULT_MODEL_NAMES = {v: k for k, v in MODEL_TYPES.items()}
-DEFAULT_MODEL_PRIORITY = dict(
-    Naive=100,
-    SeasonalNaive=100,
-    Average=100,
-    SeasonalAverage=100,
-    Zero=100,
-    RecursiveTabular=90,
-    DirectTabular=85,
-    # All local models are grouped together to make sure that joblib parallel pool is reused
-    NPTS=80,
-    ETS=80,
-    CrostonSBA=80,  # Alias for backward compatibility
-    Croston=80,
-    Theta=75,
-    DynamicOptimizedTheta=75,
-    AutoETS=70,
-    AutoARIMA=60,
-    Chronos=55,
-    # Models that can early stop are trained at the end
-    TemporalFusionTransformer=45,
-    DeepAR=40,
-    TiDE=30,
-    PatchTST=30,
-    # Models below are not included in any presets
-    WaveNet=25,
-    AutoCES=10,
-    ARIMA=10,
-    ADIDA=10,
-    IMAPA=10,
-    SimpleFeedForward=10,
-)
-DEFAULT_CUSTOM_MODEL_PRIORITY = 0
-
-VALID_AG_ARGS_KEYS = {
-    "name",
-    "name_prefix",
-    "name_suffix",
-}
-
-
-def get_default_hps(key):
-    default_model_hps = {
-        "very_light": {
-            "Naive": {},
-            "SeasonalNaive": {},
-            "ETS": {},
-            "Theta": {},
-            "RecursiveTabular": {"max_num_samples": 100_000},
-            "DirectTabular": {"max_num_samples": 100_000},
-        },
-        "light": {
-            "Naive": {},
-            "SeasonalNaive": {},
-            "ETS": {},
-            "Theta": {},
-            "RecursiveTabular": {},
-            "DirectTabular": {},
-            "TemporalFusionTransformer": {},
-            "Chronos": {"model_path": "bolt_small"},
-        },
-        "light_inference": {
-            "SeasonalNaive": {},
-            "DirectTabular": {},
-            "RecursiveTabular": {},
-            "TemporalFusionTransformer": {},
-            "PatchTST": {},
-        },
-        "default": {
-            "SeasonalNaive": {},
-            "AutoETS": {},
-            "NPTS": {},
-            "DynamicOptimizedTheta": {},
-            "RecursiveTabular": {},
-            "DirectTabular": {},
-            "TemporalFusionTransformer": {},
-            "PatchTST": {},
-            "DeepAR": {},
-            "Chronos": [
-                {
-                    "ag_args": {"name_suffix": "ZeroShot"},
-                    "model_path": "bolt_base",
-                },
-                {
-                    "ag_args": {"name_suffix": "FineTuned"},
-                    "model_path": "bolt_small",
-                    "fine_tune": True,
-                    "target_scaler": "standard",
-                    "covariate_regressor": {"model_name": "CAT", "model_hyperparameters": {"iterations": 1_000}},
-                },
-            ],
-            "TiDE": {
-                "encoder_hidden_dim": 256,
-                "decoder_hidden_dim": 256,
-                "temporal_hidden_dim": 64,
-                "num_batches_per_epoch": 100,
-                "lr": 1e-4,
-            },
-        },
-    }
-    return default_model_hps[key]
-
-
-def get_preset_models(
-    freq: Optional[str],
-    prediction_length: int,
-    path: str,
-    eval_metric: Union[str, TimeSeriesScorer],
-    eval_metric_seasonal_period: Optional[int],
-    hyperparameters: Union[str, Dict, None],
-    hyperparameter_tune: bool,
-    metadata: CovariateMetadata,
-    all_assigned_names: List[str],
-    excluded_model_types: Optional[List[str]],
-    multi_window: bool = False,
-    **kwargs,
-):
-    """
-    Create a list of models according to hyperparameters. If hyperparamaters=None,
-    will create models according to presets.
-    """
-    models = []
-    if hyperparameters is None:
-        hp_string = "default"
-        hyperparameters = copy.deepcopy(get_default_hps(hp_string))
-    elif isinstance(hyperparameters, str):
-        hyperparameters = copy.deepcopy(get_default_hps(hyperparameters))
-    elif isinstance(hyperparameters, dict):
-        hyperparameters = copy.deepcopy(hyperparameters)
-    else:
-        raise ValueError(
-            f"hyperparameters must be a dict, a string or None (received {type(hyperparameters)}). "
-            f"Please see the documentation for TimeSeriesPredictor.fit"
-        )
-    hyperparameters = check_and_clean_hyperparameters(hyperparameters, must_contain_searchspace=hyperparameter_tune)
-
-    excluded_models = set()
-    if excluded_model_types is not None and len(excluded_model_types) > 0:
-        if not isinstance(excluded_model_types, list):
-            raise ValueError(f"`excluded_model_types` must be a list, received {type(excluded_model_types)}")
-        logger.info(f"Excluded model types: {excluded_model_types}")
-        for model in excluded_model_types:
-            if not isinstance(model, str):
-                raise ValueError(f"Each entry in `excluded_model_types` must be a string, received {type(model)}")
-            excluded_models.add(normalize_model_type_name(model))
-
-    all_assigned_names = set(all_assigned_names)
-
-    model_priority_list = sorted(hyperparameters.keys(), key=lambda x: DEFAULT_MODEL_PRIORITY.get(x, 0), reverse=True)
-
-    for model in model_priority_list:
-        if isinstance(model, str):
-            if model not in MODEL_TYPES:
-                raise ValueError(f"Model {model} is not supported. Available models: {sorted(MODEL_TYPES)}")
-            if model in excluded_models:
-                logger.info(
-                    f"\tFound '{model}' model in `hyperparameters`, but '{model}' "
-                    "is present in `excluded_model_types` and will be removed."
-                )
-                continue
-            if "mxnet" in model.lower():
-                logger.info(f"\tMXNet model '{model}' given in `hyperparameters` is deprecated and won't be trained. ")
-                continue
-            model_type = MODEL_TYPES[model]
-        elif isinstance(model, type):
-            if not issubclass(model, AbstractTimeSeriesModel):
-                raise ValueError(f"Custom model type {model} must inherit from `AbstractTimeSeriesModel`.")
-            model_type = model
-        else:
-            raise ValueError(
-                f"Keys of the `hyperparameters` dictionary must be strings or types, received {type(model)}."
-            )
-
-        for model_hps in hyperparameters[model]:
-            ag_args = model_hps.pop(constants.AG_ARGS, {})
-            for key in ag_args:
-                if key not in VALID_AG_ARGS_KEYS:
-                    raise ValueError(
-                        f"Model {model_type} received unknown ag_args key: {key} (valid keys {VALID_AG_ARGS_KEYS})"
-                    )
-            model_name_base = get_model_name(ag_args, model_type)
-
-            model_type_kwargs = dict(
-                name=model_name_base,
-                path=path,
-                freq=freq,
-                prediction_length=prediction_length,
-                eval_metric=eval_metric,
-                eval_metric_seasonal_period=eval_metric_seasonal_period,
-                metadata=metadata,
-                hyperparameters=model_hps,
-                **kwargs,
-            )
-
-            # add models while preventing name collisions
-            model = model_type(**model_type_kwargs)
-
-            model_type_kwargs.pop("name", None)
-            increment = 1
-            while model.name in all_assigned_names:
-                increment += 1
-                model = model_type(name=f"{model_name_base}_{increment}", **model_type_kwargs)
-
-            if multi_window:
-                model = MultiWindowBacktestingModel(model_base=model, name=model.name, **model_type_kwargs)
-
-            all_assigned_names.add(model.name)
-            models.append(model)
-
-    return models
-
-
-def normalize_model_type_name(model_name: str) -> str:
-    """Remove 'Model' suffix from the end of the string, if it's present."""
-    if model_name.endswith("Model"):
-        model_name = model_name[: -len("Model")]
-    return model_name
-
-
-def check_and_clean_hyperparameters(
-    hyperparameters: Dict[str, Union[ModelHyperparameters, List[ModelHyperparameters]]],
-    must_contain_searchspace: bool,
-) -> Dict[str, List[ModelHyperparameters]]:
-    """Convert the hyperparameters dictionary to a unified format:
-    - Remove 'Model' suffix from model names, if present
-    - Make sure that each value in the hyperparameters dict is a list with model configurations
-    - Checks if hyperparameters contain searchspaces
-    """
-    hyperparameters_clean = defaultdict(list)
-    for key, value in hyperparameters.items():
-        # Handle model names ending with "Model", e.g., "DeepARModel" is mapped to "DeepAR"
-        if isinstance(key, str):
-            key = normalize_model_type_name(key)
-        if not isinstance(value, list):
-            value = [value]
-        hyperparameters_clean[key].extend(value)
-
-    if must_contain_searchspace:
-        verify_contains_at_least_one_searchspace(hyperparameters_clean)
-    else:
-        verify_contains_no_searchspaces(hyperparameters_clean)
-
-    return dict(hyperparameters_clean)
-
-
-def get_model_name(ag_args: Dict[str, Any], model_type: Type[AbstractTimeSeriesModel]) -> str:
-    name = ag_args.get("name")
-    if name is None:
-        name_stem = re.sub(r"Model$", "", model_type.__name__)
-        name_prefix = ag_args.get("name_prefix", "")
-        name_suffix = ag_args.get("name_suffix", "")
-        name = name_prefix + name_stem + name_suffix
-    return name
-
-
-def contains_searchspace(model_hyperparameters: ModelHyperparameters) -> bool:
-    for hp_value in model_hyperparameters.values():
-        if isinstance(hp_value, space.Space):
-            return True
-    return False
-
-
-def verify_contains_at_least_one_searchspace(hyperparameters: Dict[str, List[ModelHyperparameters]]):
-    for model, model_hps_list in hyperparameters.items():
-        for model_hps in model_hps_list:
-            if contains_searchspace(model_hps):
-                return
-
-    raise ValueError(
-        "Hyperparameter tuning specified, but no model contains a hyperparameter search space. "
-        "Please disable hyperparameter tuning with `hyperparameter_tune_kwargs=None` or provide a search space "
-        "for at least one model."
-    )
-
-
-def verify_contains_no_searchspaces(hyperparameters: Dict[str, List[ModelHyperparameters]]):
-    for model, model_hps_list in hyperparameters.items():
-        for model_hps in model_hps_list:
-            if contains_searchspace(model_hps):
-                raise ValueError(
-                    f"Hyperparameter tuning not specified, so hyperparameters must have fixed values. "
-                    f"However, for model {model} hyperparameters {model_hps} contain a search space."
-                )

autogluon.timeseries-1.2.1b20250224-py3.9-nspkg.pth

@@ -1 +0,0 @@
-import sys, types, os;has_mfs = sys.version_info > (3, 5);p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('autogluon',));importlib = has_mfs and __import__('importlib.util');has_mfs and __import__('importlib.machinery');m = has_mfs and sys.modules.setdefault('autogluon', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('autogluon', [os.path.dirname(p)])));m = m or sys.modules.setdefault('autogluon', types.ModuleType('autogluon'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)

autogluon.timeseries-1.2.1b20250224.dist-info/RECORD

@@ -1,68 +0,0 @@
-autogluon.timeseries-1.2.1b20250224-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
-autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
-autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
-autogluon/timeseries/learner.py,sha256=PDAHFlos6q5JukwRE86tKoH0zxYf3nLzy7qfD_a5NYY,13849
-autogluon/timeseries/predictor.py,sha256=HTE8a_R_9U0z-KlxyoELm-64BXNRzFu3mIEbTabQNEc,85171
-autogluon/timeseries/regressor.py,sha256=dIXttb0SOGS8IAwZOMANNDc796spN0LMysGUvuKgskU,9623
-autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
-autogluon/timeseries/trainer.py,sha256=L9FT5qERcqlWTgH9IgE6QsO0aBNj2nivRKF2Oy4UJOk,57250
-autogluon/timeseries/version.py,sha256=wvpihE7pNO9z8UVRsqZkNCn6OXTvBuhtKEB6VMhlhxM,91
-autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
-autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
-autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=SodnGhEA2V-hnfYHuAkH8rK4hQlLH8K5Tb6dsGapvPM,47161
-autogluon/timeseries/metrics/__init__.py,sha256=dJCrZ2cHwqhqNctwQjwG-FHgGUmzIFT-D0z72f4RAVM,2104
-autogluon/timeseries/metrics/abstract.py,sha256=8IWEHU8Xt14sivmsX3iXASXCzn9fA0w9FLSca2zYvjI,8190
-autogluon/timeseries/metrics/point.py,sha256=g7L8jVUKc5YVjETZ-B7syK9nZswfKxLFlkN-rTbJdlg,15777
-autogluon/timeseries/metrics/quantile.py,sha256=eemdLbo3y2wstnVkuA-f55YXywctUmSW1EhIW4BsoH4,3965
-autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhxm1-S20s0,910
-autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
-autogluon/timeseries/models/presets.py,sha256=GezDk-p591Mlhm5UTIjKKJqQE2mnWw9rdsDYKen4zJo,12478
-autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=tfFAu-NQ1UVDh9nxMKNkixzZoJw98Dxs4WSsXCSu9i4,43885
-autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
-autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=H2UlpnJcIIEi_swYn9AJUPFGT4qwFSmzZ7yvC3I2pUU,33039
-autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=XVoy8KpvoeX38lHHAXq4Be9LCxKjxZ36SOFeSAICRFM,2524
-autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=Fn3Vu_Q0PCtEUbtNgLp1xIblg7dOdpFlF3W5kLHgruI,63
-autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
-autogluon/timeseries/models/chronos/model.py,sha256=ijupqg4S6kRxdJWanNt6bnyPoGAaJluUHHmZpyQrfDE,31211
-autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=N-YZH9BGBoi99r5cznJe1zEEjwjIg7cOYIHZkKuJq44,247
-autogluon/timeseries/models/chronos/pipeline/base.py,sha256=14OAKHmio6LmO4mVom2mPGB0CvIrOjMGJzb-MVSAq-s,5596
-autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=uFJLsSb2WQiSrmDZ0g2mO-lhTFUlq7vplGRBXZ9_VBk,22591
-autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=2MJuik-YFgONZ3X2DciAph5So6ABys5ppQhBC81gLyk,20083
-autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=dtDX5Pyu95bGv7qmqgfUc1iYowWPY84dnGN0uyqyHyQ,13131
-autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
-autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=OM8S0mUSSlnzNh2GNxM-xFGgXVVecXj50aKtC945ioc,3405
-autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=UPEmNx-RSuqCXS7V093NEid_AwwEigM6AXMcZtof8vg,7230
-autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
-autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=brf2lIMHH4a_AETwyOcOBVPWqWhLxr8iolJ3Z5AR8MA,30621
-autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/models/gluonts/torch/models.py,sha256=xlhblFM4DG_GQVj_4dxqWntLh1fPMyRF63eXPs_Z098,25672
-autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=CYDvOXs7ZNzyz75gMOAKI1socB_qGep51FSPfzXMopA,11948
-autogluon/timeseries/models/local/naive.py,sha256=iwRcFMFmJKPWPbD9TWaIUS51oav69F_VAp6-jb_5SUE,7249
-autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
-autogluon/timeseries/models/local/statsforecast.py,sha256=s3Byp7WAUy0Rnfl1qYMSIm44MKD9t8E732xuNLk_aao,32615
-autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
-autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=kVHAGNQC8ahEmAgnnLa38hcbxMFC_Tl1lHFJMos2G8w,11985
-autogluon/timeseries/transforms/__init__.py,sha256=Stym_998LZQgKPuFN4_w1AcJFh4_AeaQLXgXLzv53kY,299
-autogluon/timeseries/transforms/covariate_scaler.py,sha256=Xa1qBKAMt8TRDEeTcc4Gtym1iXt2_Yat8gwQQV6lIFs,7013
-autogluon/timeseries/transforms/target_scaler.py,sha256=R-PhcaXTTRkl4bkguSy7p2QU7Grv2-ew3QsNT4NJv-I,5382
-autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/utils/features.py,sha256=FYgcv_i5fFfxGOW86GLLrLanmaIpA2OXoMwUwvPsdkI,22443
-autogluon/timeseries/utils/forecast.py,sha256=kMeP2KxrlX5Gk31D2BesuVIc0F4hEahvAcFpJHgcWG4,2082
-autogluon/timeseries/utils/warning_filters.py,sha256=FyXvYW_ylULcZP4R9xNBxojKtvadW3uygXwHK_xHq5g,2522
-autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
-autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbjy4DJ_YYOGuu9x4,1341
-autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
-autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
-autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.2.1b20250224.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250224.dist-info/METADATA,sha256=11lBa7naRjQBmasccuaxeYIuELnFuL4uO1hbqcW-sZc,12684
-autogluon.timeseries-1.2.1b20250224.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250224.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250224.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250224.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250224.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250224.dist-info/RECORD,,