autogluon.timeseries 1.4.1b20250830__py3-none-any.whl → 1.4.1b20251116__py3-none-any.whl

autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py

@@ -1,530 +0,0 @@
-# Implements Chronos with T5 architecture but with patched inputs instead of
-# per-time-step tokenization. a.k.a. Chronos-Bolt
-
-# Authors: Abdul Fatir Ansari <ansarnd@amazon.com>, Lorenzo Stella <stellalo@amazon.com>, Caner Turkmen <atturkm@amazon.com>
-
-import copy
-import logging
-import warnings
-from dataclasses import dataclass, fields
-from typing import Optional, Union
-
-import torch
-import torch.nn as nn
-from transformers import AutoConfig
-from transformers.models.t5.modeling_t5 import (
-    ACT2FN,
-    T5Config,
-    T5LayerNorm,
-    T5PreTrainedModel,
-    T5Stack,
-)
-from transformers.utils import ModelOutput
-
-from .base import BaseChronosPipeline, ForecastType
-
-logger = logging.getLogger("autogluon.timeseries.models.chronos")
-
-
-@dataclass
-class ChronosBoltConfig:
-    context_length: int
-    prediction_length: int
-    input_patch_size: int
-    input_patch_stride: int
-    quantiles: list[float]
-    use_reg_token: bool = False
-
-
-@dataclass
-class ChronosBoltOutput(ModelOutput):
-    loss: Optional[torch.Tensor] = None
-    quantile_preds: Optional[torch.Tensor] = None
-    attentions: Optional[torch.Tensor] = None
-    cross_attentions: Optional[torch.Tensor] = None
-
-
-class Patch(nn.Module):
-    def __init__(self, patch_size: int, patch_stride: int) -> None:
-        super().__init__()
-        self.patch_size = patch_size
-        self.patch_stride = patch_stride
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        length = x.shape[-1]
-
-        if length % self.patch_size != 0:
-            padding_size = (
-                *x.shape[:-1],
-                self.patch_size - (length % self.patch_size),
-            )
-            padding = torch.full(size=padding_size, fill_value=torch.nan, dtype=x.dtype, device=x.device)
-            x = torch.concat((padding, x), dim=-1)
-
-        x = x.unfold(dimension=-1, size=self.patch_size, step=self.patch_stride)
-        return x
-
-
-class InstanceNorm(nn.Module):
-    """
-    See, also, RevIN. Apply standardization along the last dimension.
-    """
-
-    def __init__(self, eps: float = 1e-5) -> None:
-        super().__init__()
-        self.eps = eps
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        loc_scale: Optional[tuple[torch.Tensor, torch.Tensor]] = None,
-    ) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
-        if loc_scale is None:
-            loc = torch.nan_to_num(torch.nanmean(x, dim=-1, keepdim=True), nan=0.0)
-            scale = torch.nan_to_num((x - loc).square().nanmean(dim=-1, keepdim=True).sqrt(), nan=1.0)
-            scale = torch.where(scale == 0, self.eps, scale)
-        else:
-            loc, scale = loc_scale
-
-        return (x - loc) / scale, (loc, scale)
-
-    def inverse(self, x: torch.Tensor, loc_scale: tuple[torch.Tensor, torch.Tensor]) -> torch.Tensor:
-        loc, scale = loc_scale
-        return x * scale + loc
-
-
-class ResidualBlock(nn.Module):
-    def __init__(
-        self,
-        in_dim: int,
-        h_dim: int,
-        out_dim: int,
-        act_fn_name: str,
-        dropout_p: float = 0.0,
-        use_layer_norm: bool = False,
-    ) -> None:
-        super().__init__()
-
-        self.dropout = nn.Dropout(dropout_p)
-        self.hidden_layer = nn.Linear(in_dim, h_dim)
-        self.act = ACT2FN[act_fn_name]
-        self.output_layer = nn.Linear(h_dim, out_dim)
-        self.residual_layer = nn.Linear(in_dim, out_dim)
-
-        self.use_layer_norm = use_layer_norm
-        if use_layer_norm:
-            self.layer_norm = T5LayerNorm(out_dim)
-
-    def forward(self, x: torch.Tensor):
-        hid = self.act(self.hidden_layer(x))
-        out = self.dropout(self.output_layer(hid))
-        res = self.residual_layer(x)
-
-        out = out + res
-
-        if self.use_layer_norm:
-            return self.layer_norm(out)
-        return out
-
-
-class ChronosBoltModelForForecasting(T5PreTrainedModel):
-    _keys_to_ignore_on_load_missing = [
-        r"input_patch_embedding\.",
-        r"output_patch_embedding\.",
-    ]
-    _keys_to_ignore_on_load_unexpected = [r"lm_head.weight"]
-    _tied_weights_keys = ["encoder.embed_tokens.weight", "decoder.embed_tokens.weight"]
-
-    def __init__(self, config: T5Config):
-        assert hasattr(config, "chronos_config"), "Not a Chronos config file"
-
-        super().__init__(config)
-        self.model_dim = config.d_model
-
-        # TODO: remove filtering eventually, added for backward compatibility
-        config_fields = {f.name for f in fields(ChronosBoltConfig)}
-        self.chronos_config = ChronosBoltConfig(
-            **{k: v for k, v in config.chronos_config.items() if k in config_fields}
-        )
-
-        # Only decoder_start_id (and optionally REG token)
-        if self.chronos_config.use_reg_token:
-            config.reg_token_id = 1
-
-        config.vocab_size = 2 if self.chronos_config.use_reg_token else 1
-        self.shared = nn.Embedding(config.vocab_size, config.d_model)
-
-        # Input patch embedding layer
-        self.input_patch_embedding = ResidualBlock(
-            in_dim=self.chronos_config.input_patch_size * 2,
-            h_dim=config.d_ff,
-            out_dim=config.d_model,
-            act_fn_name=config.dense_act_fn,
-            dropout_p=config.dropout_rate,
-        )
-
-        # patching layer
-        self.patch = Patch(
-            patch_size=self.chronos_config.input_patch_size,
-            patch_stride=self.chronos_config.input_patch_stride,
-        )
-
-        # instance normalization, also referred to as "scaling" in Chronos and GluonTS
-        self.instance_norm = InstanceNorm()
-
-        encoder_config = copy.deepcopy(config)
-        encoder_config.is_decoder = False
-        encoder_config.use_cache = False
-        encoder_config.is_encoder_decoder = False
-        self.encoder = T5Stack(encoder_config, self.shared)
-
-        self._init_decoder(config)
-
-        self.num_quantiles = len(self.chronos_config.quantiles)
-        quantiles = torch.tensor(self.chronos_config.quantiles, dtype=self.dtype)
-        self.register_buffer("quantiles", quantiles, persistent=False)
-
-        self.output_patch_embedding = ResidualBlock(
-            in_dim=config.d_model,
-            h_dim=config.d_ff,
-            out_dim=self.num_quantiles * self.chronos_config.prediction_length,
-            act_fn_name=config.dense_act_fn,
-            dropout_p=config.dropout_rate,
-        )
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-        # Model parallel
-        self.model_parallel = False
-        self.device_map = None
-
-    def _init_weights(self, module):
-        super()._init_weights(module)
-        """Initialize the weights"""
-        factor = self.config.initializer_factor
-        if isinstance(module, (self.__class__)):
-            module.shared.weight.data.normal_(mean=0.0, std=factor * 1.0)
-        elif isinstance(module, ResidualBlock):
-            module.hidden_layer.weight.data.normal_(
-                mean=0.0,
-                std=factor * ((self.chronos_config.input_patch_size * 2) ** -0.5),
-            )
-            if hasattr(module.hidden_layer, "bias") and module.hidden_layer.bias is not None:
-                module.hidden_layer.bias.data.zero_()
-
-            module.residual_layer.weight.data.normal_(
-                mean=0.0,
-                std=factor * ((self.chronos_config.input_patch_size * 2) ** -0.5),
-            )
-            if hasattr(module.residual_layer, "bias") and module.residual_layer.bias is not None:
-                module.residual_layer.bias.data.zero_()
-
-            module.output_layer.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
-            if hasattr(module.output_layer, "bias") and module.output_layer.bias is not None:
-                module.output_layer.bias.data.zero_()
-
-    def forward(
-        self,
-        context: torch.Tensor,
-        mask: Optional[torch.Tensor] = None,
-        target: Optional[torch.Tensor] = None,
-        target_mask: Optional[torch.Tensor] = None,
-    ) -> ChronosBoltOutput:
-        mask = mask.to(context.dtype) if mask is not None else torch.isnan(context).logical_not().to(context.dtype)
-
-        batch_size, _ = context.shape
-        if context.shape[-1] > self.chronos_config.context_length:
-            context = context[..., -self.chronos_config.context_length :]
-            mask = mask[..., -self.chronos_config.context_length :]
-
-        # scaling
-        context, loc_scale = self.instance_norm(context)
-
-        # the scaling op above is done in 32-bit precision,
-        # then the context is moved to model's dtype
-        context = context.to(self.dtype)
-        mask = mask.to(self.dtype)
-
-        # patching
-        patched_context = self.patch(context)
-        patched_mask = torch.nan_to_num(self.patch(mask), nan=0.0)
-        patched_context[~(patched_mask > 0)] = 0.0
-        # concat context and mask along patch dim
-        patched_context = torch.cat([patched_context, patched_mask], dim=-1)
-
-        # attention_mask = 1 if at least one item in the patch is observed
-        attention_mask = patched_mask.sum(dim=-1) > 0  # (batch_size, patched_seq_length)
-
-        input_embeds = self.input_patch_embedding(patched_context)
-
-        if self.chronos_config.use_reg_token:
-            # Append [REG]
-            reg_input_ids = torch.full(
-                (batch_size, 1),
-                self.config.reg_token_id,
-                device=input_embeds.device,
-            )
-            reg_embeds = self.shared(reg_input_ids)
-            input_embeds = torch.cat([input_embeds, reg_embeds], dim=-2)
-            attention_mask = torch.cat([attention_mask, torch.ones_like(reg_input_ids)], dim=-1)
-
-        encoder_outputs = self.encoder(
-            attention_mask=attention_mask,
-            inputs_embeds=input_embeds,
-        )
-        hidden_states = encoder_outputs[0]
-
-        sequence_output = self.decode(input_embeds, attention_mask, hidden_states)
-
-        quantile_preds_shape = (
-            batch_size,
-            self.num_quantiles,
-            self.chronos_config.prediction_length,
-        )
-        quantile_preds = self.output_patch_embedding(sequence_output).view(*quantile_preds_shape)
-
-        loss = None
-        if target is not None:
-            # normalize target
-            target, _ = self.instance_norm(target, loc_scale)
-            target = target.unsqueeze(1)  # type: ignore
-            assert self.chronos_config.prediction_length >= target.shape[-1]
-
-            target = target.to(quantile_preds.device)
-            target_mask = (
-                target_mask.unsqueeze(1).to(quantile_preds.device) if target_mask is not None else ~torch.isnan(target)
-            )
-            target[~target_mask] = 0.0
-
-            # pad target and target_mask if they are shorter than model's prediction_length
-            if self.chronos_config.prediction_length > target.shape[-1]:
-                padding_shape = (*target.shape[:-1], self.chronos_config.prediction_length - target.shape[-1])
-                target = torch.cat([target, torch.zeros(padding_shape).to(target)], dim=-1)
-                target_mask = torch.cat([target_mask, torch.zeros(padding_shape).to(target_mask)], dim=-1)
-
-            loss = (
-                2
-                * torch.abs(
-                    (target - quantile_preds)
-                    * ((target <= quantile_preds).float() - self.quantiles.view(1, self.num_quantiles, 1))
-                )
-                * target_mask.float()
-            )
-            loss = loss.mean(dim=-2)  # Mean over prediction horizon
-            loss = loss.sum(dim=-1)  # Sum over quantile levels
-            loss = loss.mean()  # Mean over batch
-
-        # Unscale predictions
-        quantile_preds = self.instance_norm.inverse(
-            quantile_preds.view(batch_size, -1),
-            loc_scale,
-        ).view(*quantile_preds_shape)
-
-        return ChronosBoltOutput(
-            loss=loss,
-            quantile_preds=quantile_preds,
-        )
-
-    def _init_decoder(self, config):
-        decoder_config = copy.deepcopy(config)
-        decoder_config.is_decoder = True
-        decoder_config.is_encoder_decoder = False
-        decoder_config.num_layers = config.num_decoder_layers
-        self.decoder = T5Stack(decoder_config, self.shared)
-
-    def decode(
-        self,
-        input_embeds,
-        attention_mask,
-        hidden_states,
-        output_attentions=False,
-    ):
-        """
-        Parameters
-        ----------
-        input_embeds
-            Patched and embedded inputs. Shape (batch_size, patched_context_length, d_model)
-        attention_mask
-            Attention mask for the patched context. Shape (batch_size, patched_context_length), type: torch.int64
-        hidden_states
-            Hidden states returned by the encoder. Shape (batch_size, patched_context_length, d_model)
-
-        Returns
-        -------
-        last_hidden_state
-            Last hidden state returned by the decoder, of shape (batch_size, 1, d_model)
-        """
-        batch_size = input_embeds.shape[0]
-        decoder_input_ids = torch.full(
-            (batch_size, 1),
-            self.config.decoder_start_token_id,
-            device=input_embeds.device,
-        )
-        decoder_outputs = self.decoder(
-            input_ids=decoder_input_ids,
-            encoder_hidden_states=hidden_states,
-            encoder_attention_mask=attention_mask,
-            output_attentions=output_attentions,
-            return_dict=True,
-        )
-
-        return decoder_outputs.last_hidden_state  # sequence_outputs, b x 1 x d_model
-
-
-class ChronosBoltPipeline(BaseChronosPipeline):
-    forecast_type: ForecastType = ForecastType.QUANTILES
-    default_context_length: int = 2048
-    # register this class name with this alias for backward compatibility
-    _aliases = ["PatchedT5Pipeline"]
-
-    def __init__(self, model: ChronosBoltModelForForecasting):
-        super().__init__(inner_model=model)
-        self.model = model
-        self.model_context_length: int = self.model.config.chronos_config["context_length"]
-        self.model_prediction_length: int = self.model.config.chronos_config["prediction_length"]
-
-    @property
-    def quantiles(self) -> list[float]:
-        return self.model.config.chronos_config["quantiles"]
-
-    def predict(  # type: ignore[override]
-        self,
-        context: Union[torch.Tensor, list[torch.Tensor]],
-        prediction_length: Optional[int] = None,
-        limit_prediction_length: bool = False,
-    ):
-        context_tensor = self._prepare_and_validate_context(context=context)
-
-        if prediction_length is None:
-            prediction_length = self.model_prediction_length
-
-        if prediction_length > self.model_prediction_length:
-            msg = (
-                f"We recommend keeping prediction length <= {self.model_prediction_length}. "
-                "The quality of longer predictions may degrade since the model is not optimized for it. "
-            )
-            if limit_prediction_length:
-                msg += "You can turn off this check by setting `limit_prediction_length=False`."
-                raise ValueError(msg)
-            warnings.warn(msg)
-
-        predictions = []
-        remaining = prediction_length
-
-        # We truncate the context here because otherwise batches with very long
-        # context could take up large amounts of GPU memory unnecessarily.
-        if context_tensor.shape[-1] > self.model_context_length:
-            context_tensor = context_tensor[..., -self.model_context_length :]
-
-        context_tensor = context_tensor.to(device=self.model.device, dtype=torch.float32)
-        # First block prediction
-        with torch.no_grad():
-            prediction: torch.Tensor = self.model(context=context_tensor).quantile_preds.to(context_tensor)
-
-            predictions.append(prediction)
-            remaining -= prediction.shape[-1]
-
-        # NOTE: The following heuristic for better prediction intervals with long-horizon forecasts
-        # uses all quantiles generated by the model for the first `model_prediction_length` steps,
-        # concatenating each quantile with the context and generating the next `model_prediction_length` steps.
-        # The `num_quantiles * num_quantiles` "samples" thus generated are then reduced to `num_quantiles`
-        # by computing empirical quantiles. Note that this option scales the batch size by `num_quantiles`
-        # when the `prediction_length` is greater than `model_prediction_length`.
-
-        if remaining > 0:
-            # Expand the context along quantile axis
-            context_tensor = context_tensor.unsqueeze(1).repeat(1, len(self.quantiles), 1)
-
-        quantile_tensor = torch.tensor(self.quantiles, device=context_tensor.device)
-        while remaining > 0:
-            # Append the prediction to context
-            context_tensor = torch.cat([context_tensor, prediction], dim=-1)[..., -self.model_context_length :]
-            (batch_size, n_quantiles, context_length) = context_tensor.shape
-
-            with torch.no_grad():
-                # Reshape (batch, n_quantiles, context_length) -> (batch * n_quantiles, context_length)
-                prediction = self.model(
-                    context=context_tensor.reshape(batch_size * n_quantiles, context_length)
-                ).quantile_preds.to(context_tensor)
-            # Reshape predictions from (batch * n_quantiles, n_quantiles, model_prediction_length) to (batch, n_quantiles * n_quantiles, model_prediction_length)
-            prediction = prediction.reshape(batch_size, n_quantiles * n_quantiles, -1)
-            # Reduce `n_quantiles * n_quantiles` to n_quantiles and transpose back to (batch_size, n_quantiles, model_prediction_length)
-            prediction = torch.quantile(prediction, q=quantile_tensor, dim=1).transpose(0, 1)
-
-            predictions.append(prediction)
-            remaining -= prediction.shape[-1]
-
-        return torch.cat(predictions, dim=-1)[..., :prediction_length]
-
-    def predict_quantiles(
-        self, context: torch.Tensor, prediction_length: int, quantile_levels: list[float], **kwargs
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        # shape (batch_size, prediction_length, len(training_quantile_levels))
-        predictions = (
-            self.predict(
-                context,
-                prediction_length=prediction_length,
-            )
-            .detach()
-            .cpu()
-            .swapaxes(1, 2)
-        )
-
-        training_quantile_levels = self.quantiles
-
-        if set(quantile_levels).issubset(set(training_quantile_levels)):
-            # no need to perform intra/extrapolation
-            quantiles = predictions[..., [training_quantile_levels.index(q) for q in quantile_levels]]
-        else:
-            # we rely on torch for interpolating quantiles if quantiles that
-            # Chronos Bolt was trained on were not provided
-            if min(quantile_levels) < min(training_quantile_levels) or max(quantile_levels) > max(
-                training_quantile_levels
-            ):
-                logger.warning(
-                    f"\tQuantiles to be predicted ({quantile_levels}) are not within the range of "
-                    f"quantiles that Chronos-Bolt was trained on ({training_quantile_levels}). "
-                    "Quantile predictions will be set to the minimum/maximum levels at which Chronos-Bolt "
-                    "was trained on. This may significantly affect the quality of the predictions."
-                )
-
-            # TODO: this is a hack that assumes the model's quantiles during training (training_quantile_levels)
-            # made up an equidistant grid along the quantile dimension. i.e., they were (0.1, 0.2, ..., 0.9).
-            # While this holds for official Chronos-Bolt models, this may not be true in the future, and this
-            # function may have to be revised.
-            augmented_predictions = torch.cat(
-                [predictions[..., [0]], predictions, predictions[..., [-1]]],
-                dim=-1,
-            )
-            quantiles = torch.quantile(
-                augmented_predictions, q=torch.tensor(quantile_levels, dtype=augmented_predictions.dtype), dim=-1
-            ).permute(1, 2, 0)
-        mean = predictions[:, :, training_quantile_levels.index(0.5)]
-        return quantiles, mean
-
-    @classmethod
-    def from_pretrained(cls, *args, **kwargs):
-        """
-        Load the model, either from a local path or from the HuggingFace Hub.
-        Supports the same arguments as ``AutoConfig`` and ``AutoModel``
-        from ``transformers``.
-        """
-        config = AutoConfig.from_pretrained(*args, **kwargs)
-        assert hasattr(config, "chronos_config"), "Not a Chronos config file"
-
-        context_length = kwargs.pop("context_length", None)
-        if context_length is not None:
-            config.chronos_config["context_length"] = context_length
-
-        architecture = config.architectures[0]
-        class_ = globals().get(architecture)
-
-        # TODO: remove this once all models carry the correct architecture names in their configuration
-        # and raise an error instead.
-        if class_ is None:
-            logger.warning(f"Unknown architecture: {architecture}, defaulting to ChronosBoltModelForForecasting")
-            class_ = ChronosBoltModelForForecasting
-
-        model = class_.from_pretrained(*args, **kwargs)
-        return cls(model=model)

autogluon.timeseries-1.4.1b20250830-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.4.1b20250830.dist-info/RECORD

@@ -1,75 +0,0 @@
-autogluon.timeseries-1.4.1b20250830-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=eQrqFVOmL-2JC85LgCMkbyoLpKS02Dilg1T8RUeS_LI,13887
-autogluon/timeseries/predictor.py,sha256=7X4YsWYa3Xk2RI1Irf2O-c3-I82Zqhg-cgj8cj_4AoA,88427
-autogluon/timeseries/regressor.py,sha256=lc8Qr3-8v4oxajtCnV3sxpUaW6vxXXJOA6Kr-qVne4k,11926
-autogluon/timeseries/splitter.py,sha256=8ACkuCXeUhQGUx4jz_Vv17q814WrHJQeKvq2v4-oE6s,3158
-autogluon/timeseries/version.py,sha256=1LLPRzXVZj4uays1y13gP-npP7vnQKZjr7gnSOkOTuo,91
-autogluon/timeseries/configs/__init__.py,sha256=wiLBwxZkDTQBJkSJ9-xz3p_yJxX0dbHe108dS1P5O6A,183
-autogluon/timeseries/configs/hyperparameter_presets.py,sha256=GbI2sd3uakWtaeaMyF7B5z_lmyfb6ToK6PZEUZTyG9w,2031
-autogluon/timeseries/configs/predictor_presets.py,sha256=B5HFHIelh91hhG0YYE5SJ7_14P7sylFAABgHX8n_53M,2712
-autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=EwxKBScspwKnJTqIk2Icukk8vIrbKYObOMAkNIn4zc8,51760
-autogluon/timeseries/metrics/__init__.py,sha256=YJPXxsJ0tRDXq7p-sTZSLb0DuXMJH6sT1PgbZ3tMt30,3594
-autogluon/timeseries/metrics/abstract.py,sha256=6jbluvHXfLc_cuK1Fx0ZYle2sR4WGG6YxFQhkor46Q8,11545
-autogluon/timeseries/metrics/point.py,sha256=sS__n_Em7m4CUaBu3PNWQ_dHw1YCOHbEyC15fhytFL8,18308
-autogluon/timeseries/metrics/quantile.py,sha256=x0cq44fXRoMiuI4BVQ7mpWk1YgrK4OwLTlJAhCHQ7Xg,4634
-autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhxm1-S20s0,910
-autogluon/timeseries/models/__init__.py,sha256=9YnqkOILtVEkbICk7J3VlMkMNySs-f5ErIUKrE5-fys,1294
-autogluon/timeseries/models/registry.py,sha256=8n7W04ql0ckNQUzKcAW7bxreLI8wTAUTymACgLklH9M,2158
-autogluon/timeseries/models/abstract/__init__.py,sha256=Htfkjjc3vo92RvyM8rIlQ0PLWt3jcrCKZES07UvCMV0,146
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=97HOi7fRPxtx8Y9hq-xdJI-kLMp6Z-8LUSvcfBjXFsM,31978
-autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
-autogluon/timeseries/models/abstract/tunable.py,sha256=jA6p-FPZkMva67B-1foqvHK-1rr0IdEfp9RvGW1WS9I,7155
-autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=E5fZsdFPgVdyCVyj5bGmn_lQFlCMn2NvuRLBMcCFvhM,205
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=k3a0JqBeuLQfjCtZ8MA7UvS2eqHjwbw0-4kN_StMMUQ,37623
-autogluon/timeseries/models/autogluon_tabular/per_step.py,sha256=M5rhj_jjcQz27wPYm6NEBEE0aHgXe0Bl6HFc2NIuLdU,23159
-autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=aI1QJLJaOB5Xy2WA0jo6Jh25MRVyyZ8ONrqlV96kpw0,2735
-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=UYLI1HVwsW5KfA-jXqJdBel-7N6l6ggdBVrjLLaq9P0,32333
-autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=bkTR0LSKIxAaKFOr9A0HSkCtnRdikDPUPp810WOKgxE,247
-autogluon/timeseries/models/chronos/pipeline/base.py,sha256=Us-TUpHSN3mM3ut05IVc2a9Q6KYq1n9pTb7JZG7b6kA,5546
-autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=bgow5FkHG7y5qWBXcggqXemnistJUfrl0lWFXcGXg5g,20197
-autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=KJYgxASTW2VhS0ObkP5DUQXyfnTRTXzjRD5Gm-FQFI4,21355
-autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=WYeCKFP5dxs4u09XTncBI2486VV22O1DiM9a3ZvZ1OE,12790
-autogluon/timeseries/models/ensemble/__init__.py,sha256=x2Y6dWk15XugTEWNUKq8U5z6nIjelo3UjpI-TfS13OE,159
-autogluon/timeseries/models/ensemble/abstract.py,sha256=wvtXNZTwiYpIurPkOYSzsi3XTRRx5guJLMYLmXTdOeQ,5695
-autogluon/timeseries/models/ensemble/basic.py,sha256=aSQRYylUpFZVk_Lpv5GY8uYgmE0_ipLy_tx6ELTZyWc,3426
-autogluon/timeseries/models/ensemble/greedy.py,sha256=zXJFenn1XxNNvCp4TlmIq1Dx3pUDWjKG1K3HsejmDeY,7323
-autogluon/timeseries/models/gluonts/__init__.py,sha256=YfyNYOkhhNsloA4MAavfmqKO29_q6o4lwPoV7L4_h7M,355
-autogluon/timeseries/models/gluonts/abstract.py,sha256=fYXV5fQk79LtPtpa4uk8MzCUGZ5J6n47ClEYuYSBDLY,27770
-autogluon/timeseries/models/gluonts/dataset.py,sha256=iUVKZyec1efVW2-71AWn-m9cowXYYj5hJM1JWuioscA,5115
-autogluon/timeseries/models/gluonts/models.py,sha256=1Z3x3-jVoae5X4cSnDIgJMvTJ9_O94aDSW8HEnBaL5k,25907
-autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=A3sNYMA67UbbEKIIN30BcBdE_NpwaBtcG22O5mVWS6k,11482
-autogluon/timeseries/models/local/naive.py,sha256=xur3WWhLaS9Iix_p_yfaStbr58nL5K4rV0dReTm3BQQ,7496
-autogluon/timeseries/models/local/npts.py,sha256=VRZk5tEJOIentt0tLM6lxyoU8US736nHOvhSAgagYMc,4203
-autogluon/timeseries/models/local/statsforecast.py,sha256=sZ6aEFzAyPNZX3rMULGWFht0Toapjb3EwHe5Rb76ZxA,33318
-autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
-autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=Hn-H2jLdeuB0_TxhAdununS8ti-iO-WSl3FOoxzcEJA,12369
-autogluon/timeseries/trainer/__init__.py,sha256=_tw3iioJfvtIV7wnjtEMv0yS8oabmCFxDnGRodYE7RI,72
-autogluon/timeseries/trainer/model_set_builder.py,sha256=s6tozfND3lLfst6Vxa_oP_wgCmDapyCJYFmCjkEn-es,10788
-autogluon/timeseries/trainer/prediction_cache.py,sha256=Vi6EbMiMheq_smA93U_MoMxYUV85RdPm0dvJFdsM8K4,5551
-autogluon/timeseries/trainer/trainer.py,sha256=LF2X5UNnrU8w5h_i09SphGWvGFvZ6KvPDq89Z3GzZZQ,54959
-autogluon/timeseries/transforms/__init__.py,sha256=fKlT4pkJ_8Gl7IUTc3uSDzt2Xow5iH5w6fPB3ePNrTg,127
-autogluon/timeseries/transforms/covariate_scaler.py,sha256=9lEfDS4wnVZohQNnm9OcAXr3voUl83RCnctKR3O66iU,7030
-autogluon/timeseries/transforms/target_scaler.py,sha256=kTQrXAsDHCnYuqfpaVuvefyTgyp_ylDpUIPz7pArjeY,6043
-autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/utils/features.py,sha256=tdL7jZKeySO7dgB09FweR44wPCmfWg8-ZM5uVzeyvYQ,22593
-autogluon/timeseries/utils/forecast.py,sha256=yK1_eNtRUPYGs0R-VWMO4c81LrTGF57ih3yzsXVHyGY,2191
-autogluon/timeseries/utils/warning_filters.py,sha256=SroNhLU3kwbD8anM58vdxWq36Z8j_uiY42mEt0ya-JI,2589
-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=rjJtdBU0M41R1jwfmvCbo045s-6XBjhGVnGBQJ9-U1E,5997
-autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
-autogluon/timeseries/utils/datetime/time_features.py,sha256=kEOFls4Nzh8nO0Pcz1DwLsC_NA3hMI4JUlZI3kuvuts,2666
-autogluon.timeseries-1.4.1b20250830.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.4.1b20250830.dist-info/METADATA,sha256=eStbpOycDQRMqTzu2HyK8t-mFPsjHfjUNaE0X9L5hKo,12463
-autogluon.timeseries-1.4.1b20250830.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.4.1b20250830.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.4.1b20250830.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.4.1b20250830.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.4.1b20250830.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.4.1b20250830.dist-info/RECORD,,