diff --git a/.gitignore b/.gitignore index 60c3fb09..c89b8b78 100644 --- a/.gitignore +++ b/.gitignore @@ -237,3 +237,5 @@ dl/notebooks/**/*.ipynb !dl/notebooks/**/tree_darts.ipynb dl/notebooks/lightning_logs/* dl/notebooks/tmp/* + +dl/notebooks/data/predictive_coding/ diff --git a/dl/notebooks/configs/predictive_coding/config.binaryheartbeat.yaml b/dl/notebooks/configs/predictive_coding/config.binaryheartbeat.yaml new file mode 100644 index 00000000..a30db090 --- /dev/null +++ b/dl/notebooks/configs/predictive_coding/config.binaryheartbeat.yaml @@ -0,0 +1,42 @@ +data: + dataset_name: BinaryHeartbeat + data_dir: data/predictive_coding + +dataloader: + batch_size: 32 + drop_last: false + num_workers: 0 + val_split: 0.1 + +encoder: + hidden_size: 64 + norm_mode: layerNorm + conv_layers: + - {kernel_size: 10, stride: 5, padding: 3} + - {kernel_size: 8, stride: 4, padding: 2} + - {kernel_size: 4, stride: 2, padding: 1} + - {kernel_size: 4, stride: 2, padding: 1} + +ar: + mode: GRU + hidden_size: 200 + n_levels: 1 + reverse: true + +loss: + n_predictions: 8 + negative_sampling_ext: 128 + temperature: 0.07 + +optimizer: + learning_rate: 0.0002 + weight_decay: 0.000001 + +trainer: + epochs: 300 + output_dir: lightning_logs/binaryheartbeat_cpc + +runtime: + seed: 137 + accelerator: auto + devices: 1 diff --git a/dl/notebooks/configs/predictive_coding/config.ecg200.yaml b/dl/notebooks/configs/predictive_coding/config.ecg200.yaml new file mode 100644 index 00000000..4c74f201 --- /dev/null +++ b/dl/notebooks/configs/predictive_coding/config.ecg200.yaml @@ -0,0 +1,51 @@ +data: + dataset_name: ECG200 + data_dir: data/predictive_coding + +dataloader: + batch_size: 32 + drop_last: false + num_workers: 0 + val_split: 0.1 + +encoder: + hidden_size: 50 + norm_mode: layerNorm + conv_layers: + - {kernel_size: 10, stride: 5, padding: 3} + - {kernel_size: 8, stride: 4, padding: 2} + - {kernel_size: 3, stride: 1, padding: 1} + # - {kernel_size: 4, stride: 2, padding: 1} + +ar: + # mode: LSTM + # mode: transformer + mode: GRU + # mode: no_ar + hidden_size: 150 + n_levels: 1 + reverse: true + # transformer: + # layers: 1 + # heads: 4 + # dropout: 0.1 + # max_seq_len: 256 + # abspos: false + +loss: + n_predictions: 2 + negative_sampling_ext: 64 + temperature: 0.07 + +optimizer: + learning_rate: 0.0002 + weight_decay: 0.000001 + +trainer: + epochs: 400 + output_dir: lightning_logs/ecg200_cpc + +runtime: + seed: 137 + accelerator: auto + devices: 1 diff --git a/dl/notebooks/configs/predictive_coding/config.ecg5000.yaml b/dl/notebooks/configs/predictive_coding/config.ecg5000.yaml new file mode 100644 index 00000000..2a9c8675 --- /dev/null +++ b/dl/notebooks/configs/predictive_coding/config.ecg5000.yaml @@ -0,0 +1,41 @@ +data: + dataset_name: ECG5000 + data_dir: data/predictive_coding + +dataloader: + batch_size: 64 + drop_last: false + num_workers: 0 + val_split: 0.1 + +encoder: + hidden_size: 64 + norm_mode: layerNorm + conv_layers: + - {kernel_size: 10, stride: 5, padding: 3} + - {kernel_size: 8, stride: 4, padding: 2} + - {kernel_size: 4, stride: 1, padding: 1} + +ar: + mode: GRU + hidden_size: 200 + n_levels: 2 + reverse: true + +loss: + n_predictions: 1 + negative_sampling_ext: 128 + temperature: 0.07 + +optimizer: + learning_rate: 0.0002 + weight_decay: 0.000001 + +trainer: + epochs: 500 + output_dir: lightning_logs/ecg5000_cpc + +runtime: + seed: 137 + accelerator: auto + devices: 1 diff --git a/dl/notebooks/configs/predictive_coding/config.forda.yaml b/dl/notebooks/configs/predictive_coding/config.forda.yaml new file mode 100644 index 00000000..b1bfdd27 --- /dev/null +++ b/dl/notebooks/configs/predictive_coding/config.forda.yaml @@ -0,0 +1,40 @@ +data: + dataset_name: FordA + data_dir: data/predictive_coding + +dataloader: + batch_size: 128 + drop_last: false + num_workers: 0 + val_split: 0.1 + +encoder: + hidden_size: 128 + norm_mode: layerNorm + conv_layers: + - {kernel_size: 10, stride: 5, padding: 3} + - {kernel_size: 8, stride: 4, padding: 2} + +ar: + mode: GRU + hidden_size: 256 + n_levels: 1 + reverse: true + +loss: + n_predictions: 6 + negative_sampling_ext: 256 + temperature: 0.07 + +optimizer: + learning_rate: 0.0002 + weight_decay: 0.000001 + +trainer: + epochs: 250 + output_dir: lightning_logs/forda_cpc + +runtime: + seed: 137 + accelerator: auto + devices: 1 diff --git a/dl/notebooks/configs/predictive_coding/config.sleep.yaml b/dl/notebooks/configs/predictive_coding/config.sleep.yaml new file mode 100644 index 00000000..23c0f1dd --- /dev/null +++ b/dl/notebooks/configs/predictive_coding/config.sleep.yaml @@ -0,0 +1,41 @@ +data: + dataset_name: Sleep + data_dir: data/predictive_coding + +dataloader: + batch_size: 256 + drop_last: false + num_workers: 0 + val_split: 0.02 + +encoder: + hidden_size: 128 + norm_mode: layerNorm + conv_layers: + - {kernel_size: 10, stride: 5, padding: 3} + - {kernel_size: 8, stride: 4, padding: 2} + - {kernel_size: 3, stride: 1, padding: 1} + +ar: + mode: GRU + hidden_size: 256 + n_levels: 1 + reverse: true + +loss: + n_predictions: 4 + negative_sampling_ext: 256 + temperature: 0.07 + +optimizer: + learning_rate: 0.0002 + weight_decay: 0.000001 + +trainer: + epochs: 300 + output_dir: lightning_logs/sleep_cpc + +runtime: + seed: 137 + accelerator: auto + devices: 1 diff --git a/dl/notebooks/configs/predictive_coding/config.synth.yaml b/dl/notebooks/configs/predictive_coding/config.synth.yaml new file mode 100644 index 00000000..371d9945 --- /dev/null +++ b/dl/notebooks/configs/predictive_coding/config.synth.yaml @@ -0,0 +1,41 @@ +encoder: + hidden_size: 50 + norm_mode: layerNorm + conv_layers: + - {kernel_size: 10, stride: 5, padding: 3} + - {kernel_size: 8, stride: 4, padding: 2} + - {kernel_size: 3, stride: 1, padding: 1} + # - {kernel_size: 4, stride: 2, padding: 1} + +ar: + # mode: LSTM + # mode: transformer + mode: GRU + # mode: no_ar + hidden_size: 150 + n_levels: 1 + reverse: true + # transformer: + # layers: 1 + # heads: 4 + # dropout: 0.1 + # max_seq_len: 256 + # abspos: false + +loss: + n_predictions: 2 + negative_sampling_ext: 64 + temperature: 0.07 + +optimizer: + learning_rate: 0.0002 + weight_decay: 0.000001 + +trainer: + epochs: 250 + output_dir: lightning_logs/synth_cpc + +runtime: + seed: 137 + accelerator: auto + devices: 1 diff --git a/dl/notebooks/creating_time_series_datasets.py b/dl/notebooks/creating_time_series_datasets.py index f06b09bb..fc7ee0e8 100644 --- a/dl/notebooks/creating_time_series_datasets.py +++ b/dl/notebooks/creating_time_series_datasets.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/diffusion_model.py b/dl/notebooks/diffusion_model.py index e15cb284..3a168f48 100644 --- a/dl/notebooks/diffusion_model.py +++ b/dl/notebooks/diffusion_model.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/diffusion_model_timegrad.py b/dl/notebooks/diffusion_model_timegrad.py index 096dcb77..8acdd40d 100644 --- a/dl/notebooks/diffusion_model_timegrad.py +++ b/dl/notebooks/diffusion_model_timegrad.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/diffusion_process.py b/dl/notebooks/diffusion_process.py index 491fb529..412590fe 100644 --- a/dl/notebooks/diffusion_process.py +++ b/dl/notebooks/diffusion_process.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # --- # # Diffusion Process diff --git a/dl/notebooks/feedforward_neural_netwroks_timeseries.py b/dl/notebooks/feedforward_neural_netwroks_timeseries.py index 8aba4135..736dbfdf 100644 --- a/dl/notebooks/feedforward_neural_netwroks_timeseries.py +++ b/dl/notebooks/feedforward_neural_netwroks_timeseries.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/hierarchical_forecasting_mint.py b/dl/notebooks/hierarchical_forecasting_mint.py index ff991912..c62cbde7 100644 --- a/dl/notebooks/hierarchical_forecasting_mint.py +++ b/dl/notebooks/hierarchical_forecasting_mint.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: Python 3 # language: python diff --git a/dl/notebooks/lstm_properties.py b/dl/notebooks/lstm_properties.py index a1702ed9..06e93579 100644 --- a/dl/notebooks/lstm_properties.py +++ b/dl/notebooks/lstm_properties.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/neuralode_timeseries.py b/dl/notebooks/neuralode_timeseries.py index e64fc9c3..65caa529 100644 --- a/dl/notebooks/neuralode_timeseries.py +++ b/dl/notebooks/neuralode_timeseries.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/pendulum_dataset.py b/dl/notebooks/pendulum_dataset.py index 1d1cebc2..051d19b7 100644 --- a/dl/notebooks/pendulum_dataset.py +++ b/dl/notebooks/pendulum_dataset.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/predictive_coding.py b/dl/notebooks/predictive_coding.py new file mode 100644 index 00000000..d8b8f4f7 --- /dev/null +++ b/dl/notebooks/predictive_coding.py @@ -0,0 +1,1638 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.15.2 +# kernelspec: +# display_name: .venv +# language: python +# name: python3 +# --- + +# # CPC for Time Series Data +# +# References: +# +# - [mqwfrog/ULTS/tree/main/models/CPC](https://github.com/mqwfrog/ULTS/tree/main/models/CPC) +# - [ECG200](https://www.timeseriesclassification.com/description.php?Dataset=ECG200) +# - R. T. Olszewski, “Generalized feature extraction for structural pattern recognition in time-series data,” Carnegie Mellon University, Pittsburgh, PA, 2001. Available: https://www.cs.cmu.edu/~bobski/pubs/tr01108-twosided.pdf +# +# + +# configs + +from pathlib import Path +from typing import Literal + +import yaml +from pydantic import BaseModel, Field + +# + + + +class DataConfig(BaseModel): + """Dataset location and dataset identity settings.""" + + dataset_name: str = "ECG200" + data_dir: str = "data" + + +class DataloaderConfig(BaseModel): + """PyTorch DataLoader settings for train and validation loaders.""" + + batch_size: int = 64 + drop_last: bool = False + num_workers: int = 0 + val_split: float = 0.1 + + +class DataModuleConfig(BaseModel): + """Top-level configuration object for CPC training.""" + + data: DataConfig = Field(default_factory=DataConfig) + dataloader: DataloaderConfig = Field(default_factory=DataloaderConfig) + + +# - + +# Data + +# + +import os + +import lightning as L +import numpy as np +import torch +from torch.utils.data import DataLoader, Dataset, Subset + + +class CPCDataset(Dataset): + """Simple dataset wrapper for CPC tensors. + + Expected input object format: + - ``samples``: array/tensor with shape ``[N, T]`` or ``[N, C, T]`` or + ``[N, T, C]``. + - ``labels``: array/tensor with shape ``[N]``. + """ + + def __init__(self, dataset_obj): + """Initialize dataset tensors. + + :param dataset_obj: Dictionary containing ``samples`` and ``labels`` + arrays/tensors. Samples are converted to ``float32`` and labels + to ``int64``. + """ + super().__init__() + + samples = dataset_obj["samples"] + labels = dataset_obj["labels"] + + if isinstance(samples, np.ndarray): + samples = torch.from_numpy(samples) + if isinstance(labels, np.ndarray): + labels = torch.from_numpy(labels) + + if samples.ndim == 2: + samples = samples.unsqueeze(1) + elif samples.ndim == 3: + # Keep channels in dim=1. + if list(samples.shape).index(min(samples.shape)) != 1: + samples = samples.permute(0, 2, 1) + + self.samples = samples.float() + self.labels = labels.long() + + def __len__(self): + """Return number of samples ``N``.""" + return self.samples.shape[0] + + def __getitem__(self, index): + """Return one sample-label pair. + + :param index: Sample index. + :returns: Tuple ``(x, y)`` where ``x`` has shape ``[C, T]`` and ``y`` + is a scalar class label tensor. + """ + return self.samples[index], self.labels[index] + + +def _stratified_split( + labels: np.ndarray, val_fraction: float, random_state: int = 42 +) -> tuple[np.ndarray, np.ndarray]: + """Stratified train/val index split without sklearn.""" + rng = np.random.default_rng(random_state) + train_idx, val_idx = [], [] + for cls in np.unique(labels): + cls_indices = np.where(labels == cls)[0] + rng.shuffle(cls_indices) + n_val = max(1, round(len(cls_indices) * val_fraction)) + val_idx.extend(cls_indices[:n_val].tolist()) + train_idx.extend(cls_indices[n_val:].tolist()) + return np.array(train_idx), np.array(val_idx) + + +class CPCDataModule(L.LightningDataModule): + def __init__(self, config: DataModuleConfig): + super().__init__() + self.config = config + self.train_loader = None + self.val_loader = None + self.test_loader = None + self.input_channels = None + + def setup(self, stage=None): + if self.train_loader is not None: + return + + dataset_path = os.path.join( + self.config.data.data_dir, self.config.data.dataset_name + ) + train_obj = torch.load(os.path.join(dataset_path, "train.pt")) + test_obj = torch.load(os.path.join(dataset_path, "test.pt")) + + full_train_ds = CPCDataset(train_obj) + test_ds = CPCDataset(test_obj) + + self.input_channels = int(full_train_ds.samples.shape[1]) + + labels = full_train_ds.labels.numpy() + train_idx, val_idx = _stratified_split( + labels, + val_fraction=self.config.dataloader.val_split, + random_state=42, + ) + train_ds = Subset(full_train_ds, train_idx) + val_ds = Subset(full_train_ds, val_idx) + + dl_kwargs = dict( + batch_size=self.config.dataloader.batch_size, + num_workers=self.config.dataloader.num_workers, + ) + self.train_loader = DataLoader( + train_ds, + shuffle=True, + drop_last=self.config.dataloader.drop_last, + **dl_kwargs, + ) + self.val_loader = DataLoader( + val_ds, shuffle=False, drop_last=False, **dl_kwargs + ) + self.test_loader = DataLoader( + test_ds, shuffle=False, drop_last=False, **dl_kwargs + ) + + def train_dataloader(self): + return self.train_loader + + def val_dataloader(self): + return self.val_loader + + def test_dataloader(self): + return self.test_loader + + +# - + +# Modules + + +# + +class ConvLayerConfig(BaseModel): + """Single 1D convolution specification. + + Parameters define one convolution block as + ``Conv1d(in_channels, out_channels, kernel_size, stride, padding)``. + """ + + kernel_size: int + stride: int + padding: int + + +class EncoderConfig(BaseModel): + """Encoder architecture and normalization settings.""" + + hidden_size: int = 256 + norm_mode: Literal["batchNorm", "instanceNorm", "ID", "layerNorm"] = "layerNorm" + conv_layers: list[ConvLayerConfig] = Field( + default_factory=lambda: [ + ConvLayerConfig(kernel_size=10, stride=5, padding=3), + ConvLayerConfig(kernel_size=8, stride=4, padding=2), + ConvLayerConfig(kernel_size=4, stride=2, padding=1), + ConvLayerConfig(kernel_size=4, stride=2, padding=1), + ConvLayerConfig(kernel_size=4, stride=2, padding=1), + ] + ) + + +class ARConfig(BaseModel): + """Autoregressive model selection and parameters. + + Supports recurrent modes (GRU/LSTM/RNN), Transformer mode, and + identity mode (``no_ar``). + """ + + mode: Literal["GRU", "LSTM", "RNN", "transformer", "no_ar"] = "LSTM" + hidden_size: int = 256 + n_levels: int = 1 + reverse: bool = False + + +class LossConfig(BaseModel): + """CPC/InfoNCE objective configuration.""" + + n_predictions: int = 12 + negative_sampling_ext: int = 128 + temperature: float = 0.07 + + +import math + +# + +from functools import cached_property +from typing import Callable, Literal + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class CPCEncoder(nn.Module): + """Convolutional encoder for time-series CPC. + + Input is expected as ``[B, C_in, T]`` and output as ``[B, H, T_enc]``, + where ``H`` is ``size_hidden`` and ``T_enc`` depends on convolution specs. + """ + + def __init__( + self, + input_channels: int = 1, + size_hidden: int = 256, + conv_specs: list[tuple[int, int, int]] | None = None, + ): + """Build the encoder stack. + + :param input_channels: Number of input channels ``C_in``. + :param size_hidden: Number of output channels for each convolution + block. + :param conv_specs: List of convolution settings as + ``(kernel_size, stride, padding)``. If ``None``, a default + 5-layer downsampling stack is used. + """ + super().__init__() + + norm_factory: Callable[[int], nn.Module] + norm_factory = nn.BatchNorm1d + # norm_factory = nn.Identity + + if conv_specs is None: + conv_specs = [ + (10, 5, 3), + (8, 4, 2), + (4, 2, 1), + (4, 2, 1), + (4, 2, 1), + ] + blocks: list[nn.Module] = [] + in_channels = input_channels + for kernel_size, stride, padding in conv_specs: + blocks.extend( + [ + nn.Conv1d( + in_channels, + size_hidden, + kernel_size, + stride=stride, + padding=padding, + ), + norm_factory(size_hidden), + nn.ReLU(), + ] + ) + in_channels = size_hidden + + self.network = nn.Sequential(*blocks) + self.output_dim = size_hidden + + @cached_property + def output_dimension(self) -> int: + """Return the encoder feature dimension ``H``.""" + return self.output_dim + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Encode raw sequence features. + + :param x: Input tensor with shape ``[B, C_in, T]``. + :returns: Encoded tensor with shape ``[B, H, T_enc]``. + """ + return self.network(x) + + +class CPCAR(nn.Module): + """Recurrent autoregressive context model for CPC. + + Operates on encoded sequences in ``[B, T, C]`` format and returns + contextualized representations in ``[B, T, C_ctx]``. + """ + + def __init__( + self, + dim_encoded: int, + dim_output: int, + n_levels_gru: int = 1, + rnn_type: Literal["GRU", "LSTM", "RNN"] = "LSTM", + reverse: bool = False, + ): + """Initialize recurrent AR module. + + :param dim_encoded: Input feature size ``C`` from the encoder. + :param dim_output: Hidden/context size ``C_ctx`` of the recurrent + module. + :param n_levels_gru: Number of recurrent layers. + :param rnn_type: Recurrent cell type. + :param reverse: If ``True``, run AR in reverse time and flip output + back. + """ + super().__init__() + self.reverse = reverse + + rnn_cls = {"LSTM": nn.LSTM, "RNN": nn.RNN, "GRU": nn.GRU}[rnn_type] + self.rnn = rnn_cls( + dim_encoded, dim_output, num_layers=n_levels_gru, batch_first=True + ) + + @cached_property + def output_dimension(self) -> int: + """Return context feature dimension ``C_ctx``.""" + return self.rnn.hidden_size + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Run recurrent AR on encoded sequence. + + :param x: Encoded tensor with shape ``[B, T, C]``. + :returns: Context tensor with shape ``[B, T, C_ctx]``. + """ + if self.reverse: + x = torch.flip(x, [1]) + try: + self.rnn.flatten_parameters() + except RuntimeError: + pass + x, _ = self.rnn(x) + if self.reverse: + x = torch.flip(x, [1]) + return x + + +class CPCModel(nn.Module): + """Compose encoder and autoregressive context model.""" + + def __init__(self, encoder: nn.Module, ar: nn.Module): + """Initialize CPC model. + + :param encoder: Module mapping ``[B, C_in, T]`` to + ``[B, C_enc, T_enc]``. + :param ar: Module mapping ``[B, T_enc, C_enc]`` to context features + ``[B, T_enc, C_ctx]``. + """ + super().__init__() + self.encoder = encoder + self.ar = ar + + def forward(self, batch_data: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + """Run encoder then AR network. + + :param batch_data: Input batch with shape ``[B, C_in, T]``. + :returns: Tuple ``(context, encoded)`` where ``context`` has shape + ``[B, T_enc, C_ctx]`` and ``encoded`` has shape + ``[B, T_enc, C_enc]``. + """ + encoded = self.encoder(batch_data).permute(0, 2, 1) + context = self.ar(encoded) + return context, encoded + + +class CPCCriterion(nn.Module): + """InfoNCE loss used by Contrastive Predictive Coding. + + For each prediction horizon ``k``, the criterion predicts future encoded + vectors from context, then contrasts one positive against sampled negatives. + """ + + def __init__( + self, + dim_context: int, + dim_encoded: int, + n_predictions: int = 12, + n_negatives: int = 128, + temperature: float = 0.07, + ): + """Initialize CPC criterion. + + :param dim_context: Context feature dimension ``C_ctx``. + :param dim_encoded: Encoded target feature dimension ``C_enc``. + :param n_predictions: Number of future steps to predict. + :param n_negatives: Number of negative samples per query. + :param temperature: Logit temperature scaling factor. + """ + super().__init__() + self.n_predictions = n_predictions + self.n_negatives = n_negatives + self.temperature = temperature + self.predictors = nn.ModuleList( + [ + nn.Linear(dim_context, dim_encoded, bias=False) + for _ in range(n_predictions) + ] + ) + + def _sample_negatives( + self, encoded_pool: torch.Tensor, n_queries: int + ) -> torch.Tensor: + """Sample negative encoded vectors. + + :param encoded_pool: Flattened encoded with shape ``[B*T, C_enc]``. + :param n_queries: Number of query vectors to match. + :returns: Negative samples with shape + ``[n_queries, n_negatives, C_enc]``. + """ + idx = torch.randint( + low=0, + high=encoded_pool.size(0), + size=(n_queries, self.n_negatives), + device=encoded_pool.device, + ) + return encoded_pool[idx] + + def forward(self, context: torch.Tensor, encoded: torch.Tensor) -> torch.Tensor: + """Compute averaged InfoNCE loss across valid prediction horizons. + + :param context: Context tensor with shape ``[B, T, C_ctx]``. + :param encoded: Encoded tensor with shape ``[B, T, C_enc]``. + :returns: Scalar loss tensor. + :raises RuntimeError: If no prediction horizon is valid, usually + because ``T`` is too short relative to ``n_predictions``. + """ + _, seq_len, _ = encoded.shape + encoded_pool = F.normalize(encoded.flatten(0, 1), dim=-1) + + total_loss: torch.Tensor | None = None + used_steps = 0 + + for k in range(1, self.n_predictions + 1): + if seq_len - k <= 0: + break + + c_t = context[:, : seq_len - k, :] + z_pos = encoded[:, k:, :] + + z_hat = self.predictors[k - 1](c_t) + z_hat = F.normalize(z_hat.flatten(0, 1), dim=-1) + z_pos = F.normalize(z_pos.flatten(0, 1), dim=-1) + + n_queries = z_hat.size(0) + pos_logits = torch.sum(z_hat * z_pos, dim=-1, keepdim=True) + + z_neg = self._sample_negatives(encoded_pool, n_queries) + neg_logits = torch.einsum("nc,nkc->nk", z_hat, z_neg) + + logits = torch.cat([pos_logits, neg_logits], dim=1) / self.temperature + targets = torch.zeros(n_queries, dtype=torch.long, device=logits.device) + + step_loss = F.cross_entropy(logits, targets) + total_loss = step_loss if total_loss is None else total_loss + step_loss + used_steps += 1 + + if used_steps == 0: + raise RuntimeError( + "CPCCriterion has no valid prediction steps: encoded sequence length is too short " + f"(seq_len={seq_len}) for n_predictions={self.n_predictions}. " + "Use fewer downsampling conv layers, smaller strides, or lower n_predictions." + ) + + if total_loss is None: + raise RuntimeError( + "CPCCriterion failed to compute loss: total_loss is None after processing all prediction steps. " + ) + + return total_loss / used_steps + + +# - + +# Model + +# + + + +class OptimizerConfig(BaseModel): + """Optimizer hyperparameters.""" + + learning_rate: float = 2e-4 + weight_decay: float = 1e-6 + + +class TrainerConfig(BaseModel): + """Trainer runtime options, including epoch count and output path.""" + + epochs: int = 100 + output_dir: str = "lightning_logs/ts_cpc" + + +class RuntimeConfig(BaseModel): + """Execution environment settings such as seed and device.""" + + seed: int = 0 + accelerator: Literal["auto", "cpu", "gpu", "mps"] = "auto" + devices: int = 1 + + +class TrainConfig(BaseModel): + """Top-level configuration object for CPC training.""" + + data: DataConfig = Field(default_factory=DataConfig) + dataloader: DataloaderConfig = Field(default_factory=DataloaderConfig) + encoder: EncoderConfig = Field(default_factory=EncoderConfig) + ar: ARConfig = Field(default_factory=ARConfig) + loss: LossConfig = Field(default_factory=LossConfig) + optimizer: OptimizerConfig = Field(default_factory=OptimizerConfig) + trainer: TrainerConfig = Field(default_factory=TrainerConfig) + runtime: RuntimeConfig = Field(default_factory=RuntimeConfig) + + @classmethod + def from_yaml(cls, path: Path) -> "TrainConfig": + """Load a training configuration from YAML. + + :param path: Path to a YAML file containing any subset of + ``TrainConfig`` fields. + :returns: Parsed configuration with defaults applied to omitted + fields. + """ + with open(path) as f: + data = yaml.safe_load(f) + return cls(**(data or {})) + + +# + +import os + +import lightning as L +import torch +from lightning.pytorch.callbacks import ModelCheckpoint + + +class CPCLightningModule(L.LightningModule): + """Lightning wrapper around CPC model and criterion. + + This module handles model construction, train/validation steps, and + optimizer configuration. + """ + + def __init__(self, config: TrainConfig, input_channels: int): + """Initialize the Lightning module. + + :param config: Hierarchical training configuration. + :param input_channels: Number of input channels in each sample ``x`` + where ``x`` has shape ``[B, C_in, T]``. + """ + super().__init__() + self.config = config + self.save_hyperparameters(config.model_dump()) + + encoder = CPCEncoder( + input_channels=input_channels, + size_hidden=config.encoder.hidden_size, + # norm_mode=config.encoder.norm_mode, + conv_specs=[ + (l.kernel_size, l.stride, l.padding) for l in config.encoder.conv_layers + ], + ) + + ar = CPCAR( + dim_encoded=config.encoder.hidden_size, + dim_output=config.ar.hidden_size, + n_levels_gru=config.ar.n_levels, + rnn_type=config.ar.mode, + reverse=config.ar.reverse, + ) + + self.model = CPCModel(encoder, ar) + self.criterion = CPCCriterion( + dim_context=ar.output_dimension, + dim_encoded=encoder.output_dimension, + n_predictions=config.loss.n_predictions, + n_negatives=config.loss.negative_sampling_ext, + temperature=config.loss.temperature, + ) + + def _shared_step(self, batch, split: str): + """Run one shared forward/loss step for train or validation. + + :param batch: Tuple ``(x, y)`` where ``x`` has shape ``[B, C_in, T]`` + and ``y`` is the label tensor. + :param split: Metric prefix, typically ``"train"`` or ``"val"``. + :returns: Scalar CPC loss. + """ + batch_x, _ = batch + batch_x = batch_x.float() + context, encoded = self.model(batch_x) + loss = self.criterion(context, encoded) + self.log( + f"{split}_loss", + loss, + on_step=False, + on_epoch=True, + prog_bar=True, + batch_size=batch_x.size(0), + ) + return loss + + def training_step(self, batch, batch_idx): + """Run one training step. + + :param batch: Mini-batch tuple ``(x, y)``. + :param batch_idx: Batch index within the epoch. + :returns: Scalar training loss. + """ + return self._shared_step(batch, "train") + + def validation_step(self, batch, batch_idx): + """Run one validation step. + + :param batch: Mini-batch tuple ``(x, y)``. + :param batch_idx: Batch index within the validation epoch. + """ + self._shared_step(batch, "val") + + def predict_step( + self, data, batch_idx: int = 0 + ) -> tuple[torch.Tensor, torch.Tensor]: + """Run one prediction step. + + :param data: Mini-batch tuple ``(x, y)``. + :param batch_idx: Batch index within the prediction epoch. + :returns: Tuple of context and encoded tensors. + """ + x = data.float() + context, encoded = self.model(x) + return context, encoded + + def configure_optimizers(self): + """Create optimizer for model and criterion parameters. + + :returns: Adam optimizer configured from ``config.optimizer``. + """ + return torch.optim.Adam( + list(self.model.parameters()) + list(self.criterion.parameters()), + lr=self.config.optimizer.learning_rate, + weight_decay=self.config.optimizer.weight_decay, + ) + + +# + +# config = TrainConfig.from_yaml( +# Path("configs/predictive_coding/config.ecg200.yaml") +# ) +# config = TrainConfig.from_yaml( +# Path("configs/predictive_coding/config.ecg5000.yaml") +# ) +# config = TrainConfig.from_yaml( +# Path("configs/predictive_coding/config.forda.yaml") +# ) +# config = TrainConfig.from_yaml(Path("configs/predictive_coding/config.sleep.yaml")) + +config = TrainConfig.from_yaml( + Path("configs/predictive_coding/config.binaryheartbeat.yaml") +) +# - + +config.model_dump() + +# + + + +L.seed_everything(config.runtime.seed, workers=True) +os.makedirs(config.trainer.output_dir, exist_ok=True) + +data_module = CPCDataModule( + DataModuleConfig( + data=config.data, + dataloader=config.dataloader, + ) +) +data_module.setup(stage="fit") +lightning_module = CPCLightningModule( + config=config, input_channels=data_module.input_channels +) + +trainer = L.Trainer( + max_epochs=config.trainer.epochs, + accelerator=config.runtime.accelerator, + devices=config.runtime.devices, + default_root_dir=config.trainer.output_dir, + log_every_n_steps=5, +) +trainer.fit(lightning_module, datamodule=data_module) + +# - + + +# ## Load Artifacts and Interpret + +import numpy as np +import pandas as pd +import plotly.express as px +import torch +from sklearn.decomposition import PCA +from sklearn.manifold import TSNE +from sklearn.pipeline import make_pipeline +from sklearn.preprocessing import StandardScaler + +# ### Visualize One Batch + +for i in data_module.train_dataloader(): + pred_data, pred_label = i + break + +pred_data.shape, pred_label.shape + +# + +data_pca2 = PCA( + n_components=2, +).fit_transform(pred_data.detach().numpy()[:, 0, :]) + +df_data_pca = pd.DataFrame(data_pca2, columns=["pc_1", "pc_2"]) + +df_data_pca["label"] = pred_label.numpy().astype(str) + +df_data_pca.head() +# - + +px.scatter( + df_data_pca, + x="pc_1", + y="pc_2", + color="label", + title="PCA of CPC Input Data", + width=800, + height=600, + color_discrete_sequence=px.colors.qualitative.Set2, +) + +pred_label.numpy() + +pred_context, pred_encoded = trainer.model.predict_step(pred_data) + +pred_context.shape, pred_encoded.shape + +from sklearn.decomposition import PCA +from sklearn.linear_model import LogisticRegression +from sklearn.manifold import TSNE +from sklearn.metrics import silhouette_score +from sklearn.model_selection import StratifiedKFold, cross_val_score + +# + +context_pca2 = PCA( + n_components=2, +).fit_transform(pred_context.detach().numpy()[:, 0, :]) + +df_context = pd.DataFrame(context_pca2, columns=["pc_1", "pc_2"]) + +df_context["label"] = pred_label.numpy().astype(str) + +df_context.head() +# - + +px.scatter( + df_context, + x="pc_1", + y="pc_2", + color="label", + title="PCA of CPC Context Representations", + width=800, + height=600, + color_discrete_sequence=px.colors.qualitative.Set2, +) + +# + +context_tsne2d = TSNE( + n_components=2, + perplexity=15, + random_state=0, + # init="pca" +).fit_transform( + # PCA( + # n_components=10, + # ).fit_transform( + # pred_context.detach().numpy()[:,0,:] + # ) + pred_context.detach().numpy()[:, 0, :] +) + +df_context_tsne = pd.DataFrame(context_tsne2d, columns=["tsne_1", "tsne_2"]) + +df_context_tsne["label"] = pred_label.numpy().astype(str) + +df_context_tsne.head() +# - + +px.scatter( + df_context_tsne, + x="tsne_1", + y="tsne_2", + color="label", + title="t-SNE of CPC Context Representations", + width=800, + height=600, + color_discrete_sequence=px.colors.qualitative.Set2, +) + +# + +encoded_pca2 = PCA( + n_components=2, +).fit_transform(pred_encoded.detach().numpy()[:, 0, :]) + +df_encoded_pca = pd.DataFrame(encoded_pca2, columns=["pc_1", "pc_2"]) + +df_encoded_pca["label"] = pred_label.numpy().astype(str) + +df_encoded_pca.head() +# - + +px.scatter( + df_encoded_pca, + x="pc_1", + y="pc_2", + color="label", + title="PCA of CPC Encoded Representations", + width=800, + height=600, + color_discrete_sequence=px.colors.qualitative.Set2, +) + +# + +encoded_tsne2d = TSNE( + n_components=2, + perplexity=15, + random_state=0, + # init="pca" +).fit_transform( + # PCA( + # n_components=10, + # ).fit_transform( + # pred_encoded.detach().numpy()[:,0,:] + # ) + pred_encoded.detach().numpy()[:, 0, :] +) + +df_encoded_tsne = pd.DataFrame(encoded_tsne2d, columns=["tsne_1", "tsne_2"]) + +df_encoded_tsne["label"] = pred_label.numpy().astype(str) + +df_encoded_tsne.head() +# - + +px.scatter( + df_encoded_tsne, + x="tsne_1", + y="tsne_2", + color="label", + title="t-SNE of CPC Encoded Representations", + width=800, + height=600, + color_discrete_sequence=px.colors.qualitative.Set2, +) + +# ### Visualizez All + +import numpy as np +import pandas as pd +import plotly.express as px +import plotly.graph_objects as go +from sklearn.decomposition import PCA + +# + +# Faceted comparison: raw vs context vs encoded for the same reduction method +# Produces two figures: +# 1) PCA with facet rows (raw/context/encoded) +# 2) t-SNE with facet rows (raw/context/encoded) + + +# Rebuild tensors if they are not already in memory +if ( + "raw_all" not in globals() + or "context_all" not in globals() + or "encoded_all" not in globals() +): + module = trainer.model if hasattr(trainer, "model") else lightning_module + module.eval() + device = module.device + + all_raw, all_context, all_encoded, all_labels = [], [], [], [] + with torch.no_grad(): + for x, y_batch in data_module.train_dataloader(): + x = x.float().to(device) + context, encoded = module.model(x) + + all_raw.append(x.cpu()) + all_context.append(context.cpu()) + all_encoded.append(encoded.cpu()) + all_labels.append(y_batch.cpu()) + + raw_all = torch.cat(all_raw, dim=0) # [N, C_in, T] + context_all = torch.cat(all_context, dim=0) # [N, T_enc, C] + encoded_all = torch.cat(all_encoded, dim=0) # [N, T_enc, C] + y = torch.cat(all_labels, dim=0).numpy() + y_str = y.astype(str) + +# Choose one view per family for fair visual comparison +Z_by_family = { + "raw": raw_all.reshape(raw_all.shape[0], -1).numpy(), # flatten_all_channels + "context": context_all.reshape(context_all.shape[0], -1).numpy(), # flatten_tokens + "encoded": encoded_all.reshape(encoded_all.shape[0], -1).numpy(), # flatten_tokens + # "encoded": ( + # encoded_all[:, 0, :] + # .reshape(encoded_all.shape[0], -1) + # .numpy(), # flatten_tokens + # ) +} + +family_order = ["raw", "context", "encoded"] + + +def reduce_family(Z, method="pca", random_state=0): + if method == "pca": + return make_pipeline( + StandardScaler(), + PCA(n_components=2, random_state=random_state), + ).fit_transform(Z) + if method == "tsne": + n = Z.shape[0] + perp = max(5, min(30, (n - 1) // 3)) + return TSNE( + n_components=2, + perplexity=perp, + random_state=random_state, + init="pca", + ).fit_transform(Z) + raise ValueError(f"Unknown method: {method}") + + +def build_facet_df(method): + rows = [] + for fam in family_order: + Z2 = reduce_family(Z_by_family[fam], method=method, random_state=0) + df_f = pd.DataFrame( + { + "dim1": Z2[:, 0], + "dim2": Z2[:, 1], + "label": y_str, + "family": fam, + } + ) + rows.append(df_f) + return pd.concat(rows, ignore_index=True) + + +def plot_facet(dataframe, method, width=700, height=1100): + df_plot = dataframe.copy() + title = f"{method.upper()} comparison by family (facet rows)" + fig = px.scatter( + df_plot, + x="dim1", + y="dim2", + color="label", + facet_row="family", + category_orders={"family": family_order}, + title=title, + width=width, + height=height, + # color_discrete_sequence=px.colors.qualitative.Set2, + opacity=0.8, + ) + fig.update_traces(marker=dict(size=5)) + fig.for_each_annotation(lambda a: a.update(text=a.text.split("=")[-1])) + fig.update_layout(legend_title_text="label") + fig.update_xaxes(matches=None) + fig.update_yaxes(matches=None) + fig.show() + + +# Show both methods with the same faceting layout +df_plot_pca = build_facet_df("pca") +plot_facet(df_plot_pca, "pca") +df_plot_tsne = build_facet_df("tsne") +plot_facet(df_plot_tsne, "tsne") +# - +df_dr = pd.merge( + df_plot_pca[["dim1", "dim2"]], + df_plot_tsne, + how="left", + left_index=True, + right_index=True, + suffixes=("_pca", "_tsne"), +) +df_dr + +# + +import numpy as np +import pandas as pd + +# Expect df_dr columns from your merge: +# dim1_pca, dim2_pca, dim1_tsne, dim2_tsne, label, family + +required = {"dim1_pca", "dim2_pca", "label", "family"} +missing = required - set(df_dr.columns) +if missing: + raise ValueError(f"df_dr is missing required columns: {missing}") + +# Keep only families needed for this vector +df_tmp = df_dr[df_dr["family"].isin(["raw", "encoded"])].copy() + +# Create per-sample index inside each family block so raw and encoded can be paired +df_tmp["idx"] = df_tmp.groupby("family").cumcount() + +# Split and rename PCA columns +raw_df = ( + df_tmp[df_tmp["family"] == "raw"][["idx", "label", "dim1_pca", "dim2_pca"]] + .rename(columns={"dim1_pca": "raw_x", "dim2_pca": "raw_y"}) + .reset_index(drop=True) +) + +enc_df = ( + df_tmp[df_tmp["family"] == "encoded"][["idx", "label", "dim1_pca", "dim2_pca"]] + .rename(columns={"dim1_pca": "enc_x", "dim2_pca": "enc_y", "label": "label_enc"}) + .reset_index(drop=True) +) + +# Pair raw and encoded rows by idx (and optionally validate labels) +df_vec = raw_df.merge(enc_df, on="idx", how="inner") + +# Optional sanity check: label consistency +if not (df_vec["label"] == df_vec["label_enc"]).all(): + print("Warning: label mismatch found between raw and encoded pairing.") +df_vec = df_vec.drop(columns=["label_enc"]) + +# Vector components and norm +df_vec["vec_x"] = df_vec["enc_x"] - df_vec["raw_x"] +df_vec["vec_y"] = df_vec["enc_y"] - df_vec["raw_y"] +df_vec["vec_norm"] = np.linalg.norm(df_vec[["vec_x", "vec_y"]].to_numpy(), axis=1) + +df_vec.head() + + +# + +labels = sorted(df_vec["label"].unique()) +label_symbols = ["circle", "square", "triangle-up", "star", "hexagram"] + +raw_color = "rgba(31, 119, 180, 0.85)" # blue +enc_color = "rgba(214, 39, 40, 0.85)" # red + +line_x = np.column_stack( + [df_vec["raw_x"], df_vec["enc_x"], np.full(len(df_vec), np.nan)] +).ravel() +line_y = np.column_stack( + [df_vec["raw_y"], df_vec["enc_y"], np.full(len(df_vec), np.nan)] +).ravel() + +fig = go.Figure() + +fig.add_trace( + go.Scatter( + x=line_x, + y=line_y, + mode="lines", + line=dict(color="rgba(80,80,80,0.20)", width=1), + hoverinfo="skip", + showlegend=False, + ) +) + +for i, lbl in enumerate(labels): + sym = label_symbols[i % len(label_symbols)] + mask = df_vec["label"] == lbl + subset = df_vec[mask] + + # raw — blue, label symbol + fig.add_trace( + go.Scatter( + x=subset["raw_x"], + y=subset["raw_y"], + mode="markers", + marker=dict( + size=9, symbol=sym, color=raw_color, line=dict(width=1, color="white") + ), + name=f"raw (label={lbl})", + legendgroup=f"label_{lbl}", + text=[f"idx={r}, label={lbl}" for r in subset["idx"]], + hovertemplate="RAW
%{text}
x=%{x:.3f}, y=%{y:.3f}", + ) + ) + + # encoded — red, same label symbol + fig.add_trace( + go.Scatter( + x=subset["enc_x"], + y=subset["enc_y"], + mode="markers", + marker=dict( + size=9, symbol=sym, color=enc_color, line=dict(width=1, color="white") + ), + name=f"encoded (label={lbl})", + legendgroup=f"label_{lbl}", + text=[ + f"idx={r}, label={lbl}, norm={n:.3f}" + for r, n in zip(subset["idx"], subset["vec_norm"]) + ], + hovertemplate="ENCODED
%{text}
x=%{x:.3f}, y=%{y:.3f}", + ) + ) + +fig.update_layout( + title=f"Per-index vectors — color: raw(blue)/encoded(red), symbol: label (N={len(df_vec)})", + xaxis_title="PC1 (raw space) / PC1 (encoded space)", + yaxis_title="PC2", + width=980, + height=720, + legend=dict(groupclick="toggleitem"), +) +fig.show() + +# + +# Pick one label value to plot +target_label = 1.0 # change this to the label you want + +# For float/continuous labels, exact equality can be brittle, so use tolerance +tol = 1e-8 +subset = df_vec[ + np.isclose(df_vec["label"].astype(float), float(target_label), atol=tol) +].copy() + +if subset.empty: + raise ValueError(f"No rows found for target_label={target_label} (tol={tol})") + +raw_color = "rgba(31, 119, 180, 0.85)" # blue +enc_color = "rgba(214, 39, 40, 0.85)" # red + +# Connector lines for only the selected label +line_x = np.column_stack( + [subset["raw_x"], subset["enc_x"], np.full(len(subset), np.nan)] +).ravel() +line_y = np.column_stack( + [subset["raw_y"], subset["enc_y"], np.full(len(subset), np.nan)] +).ravel() + +fig = go.Figure() + +fig.add_trace( + go.Scatter( + x=line_x, + y=line_y, + mode="lines", + line=dict(color="rgba(80,80,80,0.20)", width=1), + hoverinfo="skip", + showlegend=False, + ) +) + +fig.add_trace( + go.Scatter( + x=subset["raw_x"], + y=subset["raw_y"], + mode="markers", + marker=dict( + size=9, symbol="circle", color=raw_color, line=dict(width=1, color="white") + ), + name=f"raw (label={target_label})", + text=[ + f"idx={r}, label={lbl}" for r, lbl in zip(subset["idx"], subset["label"]) + ], + hovertemplate="RAW
%{text}
x=%{x:.3f}, y=%{y:.3f}", + ) +) + +fig.add_trace( + go.Scatter( + x=subset["enc_x"], + y=subset["enc_y"], + mode="markers", + marker=dict( + size=9, symbol="diamond", color=enc_color, line=dict(width=1, color="white") + ), + name=f"encoded (label={target_label})", + text=[ + f"idx={r}, label={lbl}, norm={n:.3f}" + for r, lbl, n in zip(subset["idx"], subset["label"], subset["vec_norm"]) + ], + hovertemplate="ENCODED
%{text}
x=%{x:.3f}, y=%{y:.3f}", + ) +) + +fig.update_layout( + title=f"Per-index vectors for label={target_label} (N={len(subset)})", + xaxis_title="PC1 (raw space) / PC1 (encoded space)", + yaxis_title="PC2", + width=980, + height=720, +) +fig.show() + +# + + + +# Derive vec_x / vec_y from whichever df_vec is in scope +vec_x = (df_vec["enc_x"] - df_vec["raw_x"]).values +vec_y = (df_vec["enc_y"] - df_vec["raw_y"]).values +V = np.stack([vec_x, vec_y], axis=1) # [N, 2] +labels = df_vec["label"].values + +# 1) Mean displacement and residuals +v_mean = V.mean(axis=0) +residuals = V - v_mean +residual_norms = np.linalg.norm(residuals, axis=1) +vector_norms = np.linalg.norm(V, axis=1) +explained_by_mean = 1 - (residual_norms / (vector_norms + 1e-9)) + +print(f"Mean displacement vector: ({v_mean[0]:.3f}, {v_mean[1]:.3f})") +print(f"Mean |v|: {vector_norms.mean():.3f} ± {vector_norms.std():.3f}") +print(f"Mean |residual|: {residual_norms.mean():.3f} ± {residual_norms.std():.3f}") +print(f"Fraction explained by global shift: {explained_by_mean.mean():.3f}") + +# 2) Angle relative to mean direction +v_mean_unit = v_mean / (np.linalg.norm(v_mean) + 1e-9) +cos_sim = np.clip(V @ v_mean_unit / (vector_norms + 1e-9), -1, 1) +angles_deg = np.degrees(np.arccos(cos_sim)) + +# 3) PCA of displacement vectors +pca_v = PCA(n_components=2).fit(V) +print( + f"\nPCA of displacement vectors — variance explained: {pca_v.explained_variance_ratio_}" +) + +df_angle = pd.DataFrame( + { + "angle_deg": angles_deg, + "residual_norm": residual_norms, + "vec_norm": vector_norms, + "label": labels, + } +) + +fig = px.histogram( + df_angle, + x="angle_deg", + color="label", + nbins=30, + barmode="overlay", + opacity=0.7, + title="Distribution of displacement angle relative to mean vector (degrees)
" + "Near 0° = moves with the crowd; large angle = outlier movement", + labels={"angle_deg": "Angle to mean displacement (°)"}, + width=850, + height=450, +) +fig.show() + +fig2 = px.scatter( + df_angle, + x="vec_norm", + y="residual_norm", + color="label", + title="Vector norm vs residual norm after removing global shift
" + "Near x-axis = moved with global trend; high residual = distinctive movement", + labels={"vec_norm": "|v|", "residual_norm": "|v - v̄|"}, + width=800, + height=500, + opacity=0.8, +) +fig2.add_hline(y=0, line_dash="dot", line_color="gray") +fig2.show() +# - + +# ## Downstream Tasks + +import lightning as L + +# + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from lightning.pytorch.callbacks import EarlyStopping +from sklearn.metrics import accuracy_score, f1_score +from sklearn.model_selection import RepeatedStratifiedKFold +from sklearn.preprocessing import StandardScaler +from torch.utils.data import DataLoader, TensorDataset + + +class SmallMLPClassifier(L.LightningModule): + def __init__( + self, + input_dim: int, + n_classes: int, + hidden_dim: int = 128, + dropout: float = 0.2, + lr: float = 1e-3, + weight_decay: float = 1e-4, + class_weights: torch.Tensor | None = None, + ): + super().__init__() + self.save_hyperparameters(ignore=["class_weights"]) + + self.net = nn.Sequential( + nn.Linear(input_dim, hidden_dim), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, hidden_dim // 2), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim // 2, n_classes), + ) + self.loss_fn = nn.CrossEntropyLoss(weight=class_weights) + + def forward(self, x): + return self.net(x) + + def training_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + loss = self.loss_fn(logits, y) + self.log("train_loss", loss, prog_bar=False, on_epoch=True, on_step=False) + return loss + + def validation_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + loss = self.loss_fn(logits, y) + self.log("val_loss", loss, prog_bar=False, on_epoch=True, on_step=False) + return loss + + def predict_step(self, batch, batch_idx, dataloader_idx=0): + x, _ = batch + return self(x) + + def configure_optimizers(self): + return torch.optim.AdamW( + self.parameters(), + lr=self.hparams.lr, + weight_decay=self.hparams.weight_decay, + ) + + +def collect_raw_and_encoded(loader, model_module): + x_raw, x_enc, y_all = [], [], [] + + model_module.eval() + device = model_module.device + + with torch.no_grad(): + for x_batch, y_batch in loader: + x_batch = x_batch.float() + + raw_feat = x_batch.reshape(x_batch.size(0), -1).cpu().numpy() + _, encoded = model_module.model(x_batch.to(device)) + # encoded is [B, T_enc, C]; pool over time (second dimension) -> [B, C] + # enc_feat = encoded.mean(dim=1).cpu().numpy() + # flatten the encoded + enc_feat = encoded.reshape(encoded.size(0), -1).cpu().numpy() + + x_raw.append(raw_feat) + x_enc.append(enc_feat) + y_all.append(y_batch.cpu().numpy()) + + X_raw = np.concatenate(x_raw, axis=0) + X_enc = np.concatenate(x_enc, axis=0) + y = np.concatenate(y_all, axis=0) + return X_raw, X_enc, y + + +def fit_predict_mlp_on_fold( + X_train, + y_train, + X_val, + y_val, + seed: int = 0, + max_epochs: int = 80, + batch_size: int = 32, +): + # Scale inside each fold to avoid leakage + scaler = StandardScaler() + X_train_s = scaler.fit_transform(X_train).astype(np.float32) + X_val_s = scaler.transform(X_val).astype(np.float32) + + y_train_t = torch.from_numpy(y_train.astype(np.int64)) + y_val_t = torch.from_numpy(y_val.astype(np.int64)) + + train_ds = TensorDataset(torch.from_numpy(X_train_s), y_train_t) + val_ds = TensorDataset(torch.from_numpy(X_val_s), y_val_t) + + train_loader = DataLoader( + train_ds, batch_size=batch_size, shuffle=True, num_workers=0 + ) + val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=0) + + n_classes = int(np.unique(y_train).size) + counts = np.bincount(y_train, minlength=n_classes).astype(np.float32) + class_weights = counts.sum() / np.maximum(counts, 1.0) + class_weights = class_weights / class_weights.mean() + class_weights_t = torch.tensor(class_weights, dtype=torch.float32) + + L.seed_everything(seed, workers=True) + + model = SmallMLPClassifier( + input_dim=X_train_s.shape[1], + n_classes=n_classes, + hidden_dim=64, + dropout=0.2, + lr=1e-3, + weight_decay=1e-4, + class_weights=class_weights_t, + ) + + trainer = L.Trainer( + max_epochs=max_epochs, + accelerator="auto", + devices=1, + logger=False, + enable_checkpointing=False, + enable_progress_bar=False, + deterministic=True, + callbacks=[EarlyStopping(monitor="val_loss", mode="min", patience=8)], + ) + trainer.fit(model, train_dataloaders=train_loader, val_dataloaders=val_loader) + + pred_batches = trainer.predict(model, dataloaders=val_loader) + logits = torch.cat(pred_batches, dim=0) + y_pred = torch.argmax(logits, dim=1).cpu().numpy() + return y_pred + + +def evaluate_representation_cv_mlp(X, y, splits, rep_name): + rows = [] + for split_id, (idx_tr, idx_va) in enumerate(splits, start=1): + y_pred = fit_predict_mlp_on_fold( + X_train=X[idx_tr], + y_train=y[idx_tr], + X_val=X[idx_va], + y_val=y[idx_va], + seed=split_id, + max_epochs=80, + batch_size=32, + ) + + rows.append( + { + "representation": rep_name, + "split_id": split_id, + "repeat": (split_id - 1) // 5 + 1, + "fold": (split_id - 1) % 5 + 1, + "accuracy": accuracy_score(y[idx_va], y_pred), + "f1_macro": f1_score(y[idx_va], y_pred, average="macro"), + "f1_weighted": f1_score(y[idx_va], y_pred, average="weighted"), + } + ) + return pd.DataFrame(rows) + + +# Fixed CPC model +module = trainer.model if hasattr(trainer, "model") else lightning_module + +# Feature extraction once (CPC frozen) +train_loader = data_module.train_dataloader() +test_loader = data_module.val_dataloader() + +X_train_raw, X_train_enc, y_train = collect_raw_and_encoded(train_loader, module) +X_test_raw, X_test_enc, y_test = collect_raw_and_encoded(test_loader, module) + +USE_TEST_IN_CV = False +if USE_TEST_IN_CV: + X_raw = np.concatenate([X_train_raw, X_test_raw], axis=0) + X_enc = np.concatenate([X_train_enc, X_test_enc], axis=0) + y_all = np.concatenate([y_train, y_test], axis=0) +else: + X_raw = X_train_raw + X_enc = X_train_enc + y_all = y_train + +cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=5, random_state=42) +splits = list(cv.split(X_raw, y_all)) + +df_raw = evaluate_representation_cv_mlp(X_raw, y_all, splits, "raw") +df_enc = evaluate_representation_cv_mlp(X_enc, y_all, splits, "encoded") +df_cv = pd.concat([df_raw, df_enc], ignore_index=True) + +summary = ( + df_cv.groupby("representation")[["accuracy", "f1_macro", "f1_weighted"]] + .agg(["mean", "std"]) + .round(4) +) + +paired = df_raw[["split_id", "accuracy", "f1_macro", "f1_weighted"]].merge( + df_enc[["split_id", "accuracy", "f1_macro", "f1_weighted"]], + on="split_id", + suffixes=("_raw", "_enc"), +) +paired["acc_delta_enc_minus_raw"] = paired["accuracy_enc"] - paired["accuracy_raw"] +paired["f1m_delta_enc_minus_raw"] = paired["f1_macro_enc"] - paired["f1_macro_raw"] +paired["f1w_delta_enc_minus_raw"] = ( + paired["f1_weighted_enc"] - paired["f1_weighted_raw"] +) + +print("=== MLP Repeated Stratified 5x5 CV Summary (mean ± std) ===") +print(summary) + +print("\n=== Paired Delta Across Same Splits (encoded - raw) ===") +print( + paired[ + [ + "acc_delta_enc_minus_raw", + "f1m_delta_enc_minus_raw", + "f1w_delta_enc_minus_raw", + ] + ] + .agg(["mean", "std", "min", "max"]) + .round(4) +) + +print("\n=== Win Rate (encoded > raw) ===") +print( + { + "accuracy": float((paired["acc_delta_enc_minus_raw"] > 0).mean()), + "f1_macro": float((paired["f1m_delta_enc_minus_raw"] > 0).mean()), + "f1_weighted": float((paired["f1w_delta_enc_minus_raw"] > 0).mean()), + } +) + +df_cv.head() + +# + + + +from scipy.stats import binomtest, ttest_rel, wilcoxon + + +def summarize_paired(metric_name, col_raw, col_enc): + d = paired[col_enc] - paired[col_raw] + n = len(d) + + t_res = ttest_rel(paired[col_enc], paired[col_raw], alternative="two-sided") + w_res = wilcoxon(d, zero_method="wilcox", alternative="two-sided", correction=False) + + wins = int((d > 0).sum()) + losses = int((d < 0).sum()) + ties = int((d == 0).sum()) + + # Sign test ignores ties + n_sign = wins + losses + sign_p = np.nan + if n_sign > 0: + sign_p = binomtest(k=wins, n=n_sign, p=0.5, alternative="two-sided").pvalue + + mean_delta = float(d.mean()) + std_delta = float(d.std(ddof=1)) + se = std_delta / np.sqrt(n) + ci95_low = mean_delta - 1.96 * se + ci95_high = mean_delta + 1.96 * se + + return { + "metric": metric_name, + "n_splits": n, + "mean_delta_enc_minus_raw": mean_delta, + "std_delta": std_delta, + "ci95_low": ci95_low, + "ci95_high": ci95_high, + "wins": wins, + "losses": losses, + "ties": ties, + "ttest_p": float(t_res.pvalue), + "wilcoxon_p": float(w_res.pvalue), + "sign_test_p": float(sign_p) if not np.isnan(sign_p) else np.nan, + } + + +stats_rows = [ + summarize_paired("accuracy", "accuracy_raw", "accuracy_enc"), + summarize_paired("f1_macro", "f1_macro_raw", "f1_macro_enc"), + summarize_paired("f1_weighted", "f1_weighted_raw", "f1_weighted_enc"), +] + +df_stats = pd.DataFrame(stats_rows).round(6) + +print("=== Paired significance tests: encoded vs raw (same 25 splits) ===") +print(df_stats.to_string(index=False)) + +alpha = 0.05 +print("\n=== Quick significance flags at alpha=0.05 ===") +for _, r in df_stats.iterrows(): + print( + f"{r['metric']}: " + f"ttest={r['ttest_p'] < alpha}, " + f"wilcoxon={r['wilcoxon_p'] < alpha}, " + f"sign_test={r['sign_test_p'] < alpha if not np.isnan(r['sign_test_p']) else False}" + ) +# - + +# diff --git a/dl/notebooks/predictive_coding_forecasting.py b/dl/notebooks/predictive_coding_forecasting.py new file mode 100644 index 00000000..3ed6fa75 --- /dev/null +++ b/dl/notebooks/predictive_coding_forecasting.py @@ -0,0 +1,1166 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.15.2 +# kernelspec: +# display_name: .venv +# language: python +# name: python3 +# --- + +# # CPC for Time Series Data +# +# References: +# +# - [mqwfrog/ULTS/tree/main/models/CPC](https://github.com/mqwfrog/ULTS/tree/main/models/CPC) +# - [ECG200](https://www.timeseriesclassification.com/description.php?Dataset=ECG200) +# - R. T. Olszewski, “Generalized feature extraction for structural pattern recognition in time-series data,” Carnegie Mellon University, Pittsburgh, PA, 2001. Available: https://www.cs.cmu.edu/~bobski/pubs/tr01108-twosided.pdf +# +# + +# configs + +from pathlib import Path +from typing import Literal + +import numpy as np +import pandas as pd +import plotly.express as px +import yaml +from pydantic import BaseModel, Field + +df = pd.DataFrame( + {"t": np.linspace(0, 100, 501), "y": np.sin(np.linspace(0, 100, 501))} +) +df = df.astype(np.float32) + +px.line(df, x="t", y="y") + + +# Data + +from ts_bolt.datamodules.pandas import DataFrameDataModule + +# Modules + + +# + +class ConvLayerConfig(BaseModel): + """Single 1D convolution specification. + + Parameters define one convolution block as + ``Conv1d(in_channels, out_channels, kernel_size, stride, padding)``. + """ + + kernel_size: int + stride: int + padding: int + + +class EncoderConfig(BaseModel): + """Encoder architecture and normalization settings.""" + + hidden_size: int = 256 + norm_mode: Literal["batchNorm", "instanceNorm", "ID", "layerNorm"] = "layerNorm" + conv_layers: list[ConvLayerConfig] = Field( + default_factory=lambda: [ + ConvLayerConfig(kernel_size=10, stride=5, padding=3), + ConvLayerConfig(kernel_size=8, stride=4, padding=2), + ConvLayerConfig(kernel_size=4, stride=2, padding=1), + ConvLayerConfig(kernel_size=4, stride=2, padding=1), + ConvLayerConfig(kernel_size=4, stride=2, padding=1), + ] + ) + + +class ARConfig(BaseModel): + """Autoregressive model selection and parameters. + + Supports recurrent modes (GRU/LSTM/RNN), Transformer mode, and + identity mode (``no_ar``). + """ + + mode: Literal["GRU", "LSTM", "RNN", "transformer", "no_ar"] = "LSTM" + hidden_size: int = 256 + n_levels: int = 1 + reverse: bool = False + + +class LossConfig(BaseModel): + """CPC/InfoNCE objective configuration.""" + + n_predictions: int = 12 + negative_sampling_ext: int = 128 + temperature: float = 0.07 + + +import math + +# + +from functools import cached_property +from typing import Callable, Literal + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class CPCEncoder(nn.Module): + """Convolutional encoder for time-series CPC. + + Input is expected as ``[B, C_in, T]`` and output as ``[B, H, T_enc]``, + where ``H`` is ``size_hidden`` and ``T_enc`` depends on convolution specs. + """ + + def __init__( + self, + input_channels: int = 1, + size_hidden: int = 256, + conv_specs: list[tuple[int, int, int]] | None = None, + ): + """Build the encoder stack. + + :param input_channels: Number of input channels ``C_in``. + :param size_hidden: Number of output channels for each convolution + block. + :param conv_specs: List of convolution settings as + ``(kernel_size, stride, padding)``. If ``None``, a default + 5-layer downsampling stack is used. + """ + super().__init__() + + norm_factory: Callable[[int], nn.Module] + # norm_factory = nn.BatchNorm1d + norm_factory = nn.Identity + + if conv_specs is None: + conv_specs = [ + (10, 5, 3), + (8, 4, 2), + (4, 2, 1), + (4, 2, 1), + (4, 2, 1), + ] + blocks: list[nn.Module] = [] + in_channels = input_channels + for kernel_size, stride, padding in conv_specs: + blocks.extend( + [ + nn.Conv1d( + in_channels, + size_hidden, + kernel_size, + stride=stride, + padding=padding, + ), + norm_factory(size_hidden), + nn.ReLU(), + ] + ) + in_channels = size_hidden + + self.network = nn.Sequential(*blocks) + self.output_dim = size_hidden + + @cached_property + def output_dimension(self) -> int: + """Return the encoder feature dimension ``H``.""" + return self.output_dim + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Encode raw sequence features. + + :param x: Input tensor with shape ``[B, C_in, T]``. + :returns: Encoded tensor with shape ``[B, H, T_enc]``. + """ + return self.network(x) + + +class CPCAR(nn.Module): + """Recurrent autoregressive context model for CPC. + + Operates on encoded sequences in ``[B, T, C]`` format and returns + contextualized representations in ``[B, T, C_ctx]``. + """ + + def __init__( + self, + dim_encoded: int, + dim_output: int, + n_levels_gru: int = 1, + rnn_type: Literal["GRU", "LSTM", "RNN"] = "LSTM", + reverse: bool = False, + ): + """Initialize recurrent AR module. + + :param dim_encoded: Input feature size ``C`` from the encoder. + :param dim_output: Hidden/context size ``C_ctx`` of the recurrent + module. + :param n_levels_gru: Number of recurrent layers. + :param rnn_type: Recurrent cell type. + :param reverse: If ``True``, run AR in reverse time and flip output + back. + """ + super().__init__() + self.reverse = reverse + + rnn_cls = {"LSTM": nn.LSTM, "RNN": nn.RNN, "GRU": nn.GRU}[rnn_type] + self.rnn = rnn_cls( + dim_encoded, dim_output, num_layers=n_levels_gru, batch_first=True + ) + + @cached_property + def output_dimension(self) -> int: + """Return context feature dimension ``C_ctx``.""" + return self.rnn.hidden_size + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Run recurrent AR on encoded sequence. + + :param x: Encoded tensor with shape ``[B, T, C]``. + :returns: Context tensor with shape ``[B, T, C_ctx]``. + """ + if self.reverse: + x = torch.flip(x, [1]) + try: + self.rnn.flatten_parameters() + except RuntimeError: + pass + x, _ = self.rnn(x) + if self.reverse: + x = torch.flip(x, [1]) + return x + + +class CPCModel(nn.Module): + """Compose encoder and autoregressive context model.""" + + def __init__(self, encoder: nn.Module, ar: nn.Module): + """Initialize CPC model. + + :param encoder: Module mapping ``[B, C_in, T]`` to + ``[B, C_enc, T_enc]``. + :param ar: Module mapping ``[B, T_enc, C_enc]`` to context features + ``[B, T_enc, C_ctx]``. + """ + super().__init__() + self.encoder = encoder + self.ar = ar + + def forward(self, batch_data: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + """Run encoder then AR network. + + :param batch_data: Input batch with shape ``[B, C_in, T]``. + :returns: Tuple ``(context, encoded)`` where ``context`` has shape + ``[B, T_enc, C_ctx]`` and ``encoded`` has shape + ``[B, T_enc, C_enc]``. + """ + encoded = self.encoder(batch_data).permute(0, 2, 1) + context = self.ar(encoded) + return context, encoded + + +class CPCCriterion(nn.Module): + """InfoNCE loss used by Contrastive Predictive Coding. + + For each prediction horizon ``k``, the criterion predicts future encoded + vectors from context, then contrasts one positive against sampled negatives. + """ + + def __init__( + self, + dim_context: int, + dim_encoded: int, + n_predictions: int = 12, + n_negatives: int = 128, + temperature: float = 0.07, + ): + """Initialize CPC criterion. + + :param dim_context: Context feature dimension ``C_ctx``. + :param dim_encoded: Encoded target feature dimension ``C_enc``. + :param n_predictions: Number of future steps to predict. + :param n_negatives: Number of negative samples per query. + :param temperature: Logit temperature scaling factor. + """ + super().__init__() + self.n_predictions = n_predictions + self.n_negatives = n_negatives + self.temperature = temperature + self.predictors = nn.ModuleList( + [ + nn.Linear(dim_context, dim_encoded, bias=False) + for _ in range(n_predictions) + ] + ) + + def _sample_negatives( + self, encoded_pool: torch.Tensor, n_queries: int + ) -> torch.Tensor: + """Sample negative encoded vectors. + + :param encoded_pool: Flattened encoded with shape ``[B*T, C_enc]``. + :param n_queries: Number of query vectors to match. + :returns: Negative samples with shape + ``[n_queries, n_negatives, C_enc]``. + """ + idx = torch.randint( + low=0, + high=encoded_pool.size(0), + size=(n_queries, self.n_negatives), + device=encoded_pool.device, + ) + return encoded_pool[idx] + + def forward(self, context: torch.Tensor, encoded: torch.Tensor) -> torch.Tensor: + """Compute averaged InfoNCE loss across valid prediction horizons. + + :param context: Context tensor with shape ``[B, T, C_ctx]``. + :param encoded: Encoded tensor with shape ``[B, T, C_enc]``. + :returns: Scalar loss tensor. + :raises RuntimeError: If no prediction horizon is valid, usually + because ``T`` is too short relative to ``n_predictions``. + """ + _, seq_len, _ = encoded.shape + encoded_pool = F.normalize(encoded.flatten(0, 1), dim=-1) + + total_loss: torch.Tensor | None = None + used_steps = 0 + + for k in range(1, self.n_predictions + 1): + if seq_len - k <= 0: + break + + c_t = context[:, : seq_len - k, :] + z_pos = encoded[:, k:, :] + + z_hat = self.predictors[k - 1](c_t) + z_hat = F.normalize(z_hat.flatten(0, 1), dim=-1) + z_pos = F.normalize(z_pos.flatten(0, 1), dim=-1) + + n_queries = z_hat.size(0) + pos_logits = torch.sum(z_hat * z_pos, dim=-1, keepdim=True) + + z_neg = self._sample_negatives(encoded_pool, n_queries) + neg_logits = torch.einsum("nc,nkc->nk", z_hat, z_neg) + + logits = torch.cat([pos_logits, neg_logits], dim=1) / self.temperature + targets = torch.zeros(n_queries, dtype=torch.long, device=logits.device) + + step_loss = F.cross_entropy(logits, targets) + total_loss = step_loss if total_loss is None else total_loss + step_loss + used_steps += 1 + + if used_steps == 0: + raise RuntimeError( + "CPCCriterion has no valid prediction steps: encoded sequence length is too short " + f"(seq_len={seq_len}) for n_predictions={self.n_predictions}. " + "Use fewer downsampling conv layers, smaller strides, or lower n_predictions." + ) + + if total_loss is None: + raise RuntimeError( + "CPCCriterion failed to compute loss: total_loss is None after processing all prediction steps. " + ) + + return total_loss / used_steps + + +# - + +# Model + +# + + + +class OptimizerConfig(BaseModel): + """Optimizer hyperparameters.""" + + learning_rate: float = 2e-4 + weight_decay: float = 1e-6 + + +class TrainerConfig(BaseModel): + """Trainer runtime options, including epoch count and output path.""" + + epochs: int = 100 + output_dir: str = "lightning_logs/ts_cpc" + + +class RuntimeConfig(BaseModel): + """Execution environment settings such as seed and device.""" + + seed: int = 0 + accelerator: Literal["auto", "cpu", "gpu", "mps"] = "auto" + devices: int = 1 + + +class TrainConfig(BaseModel): + """Top-level configuration object for CPC training.""" + + encoder: EncoderConfig = Field(default_factory=EncoderConfig) + ar: ARConfig = Field(default_factory=ARConfig) + loss: LossConfig = Field(default_factory=LossConfig) + optimizer: OptimizerConfig = Field(default_factory=OptimizerConfig) + trainer: TrainerConfig = Field(default_factory=TrainerConfig) + runtime: RuntimeConfig = Field(default_factory=RuntimeConfig) + + @classmethod + def from_yaml(cls, path: Path) -> "TrainConfig": + """Load a training configuration from YAML. + + :param path: Path to a YAML file containing any subset of + ``TrainConfig`` fields. + :returns: Parsed configuration with defaults applied to omitted + fields. + """ + with open(path) as f: + data = yaml.safe_load(f) + return cls(**(data or {})) + + +# - + + +class CPCLightningModule(L.LightningModule): + """Lightning wrapper around CPC model and criterion. + + This module handles model construction, train/validation steps, and + optimizer configuration. + """ + + def __init__(self, config: TrainConfig, input_channels: int): + """Initialize the Lightning module. + + :param config: Hierarchical training configuration. + :param input_channels: Number of input channels in each sample ``x`` + where ``x`` has shape ``[B, C_in, T]``. + """ + super().__init__() + self.config = config + self.save_hyperparameters(config.model_dump()) + + encoder = CPCEncoder( + input_channels=input_channels, + size_hidden=config.encoder.hidden_size, + # norm_mode=config.encoder.norm_mode, + conv_specs=[ + (l.kernel_size, l.stride, l.padding) for l in config.encoder.conv_layers + ], + ) + + ar = CPCAR( + dim_encoded=config.encoder.hidden_size, + dim_output=config.ar.hidden_size, + n_levels_gru=config.ar.n_levels, + rnn_type=config.ar.mode, + reverse=config.ar.reverse, + ) + + self.model = CPCModel(encoder, ar) + self.criterion = CPCCriterion( + dim_context=ar.output_dimension, + dim_encoded=encoder.output_dimension, + n_predictions=config.loss.n_predictions, + n_negatives=config.loss.negative_sampling_ext, + temperature=config.loss.temperature, + ) + + def _shared_step(self, batch, split: str): + """Run one shared forward/loss step for train or validation. + + :param batch: Tuple ``(x, y)`` where ``x`` has shape ``[B, C_in, T]`` + and ``y`` is the label tensor. + :param split: Metric prefix, typically ``"train"`` or ``"val"``. + :returns: Scalar CPC loss. + """ + batch_x, _ = batch + batch_x = batch_x.permute(0, 2, 1).float() + context, encoded = self.model(batch_x) + loss = self.criterion(context, encoded) + self.log( + f"{split}_loss", + loss, + on_step=False, + on_epoch=True, + prog_bar=True, + batch_size=batch_x.size(0), + ) + return loss + + def training_step(self, batch, batch_idx): + """Run one training step. + + :param batch: Mini-batch tuple ``(x, y)``. + :param batch_idx: Batch index within the epoch. + :returns: Scalar training loss. + """ + return self._shared_step(batch, "train") + + def validation_step(self, batch, batch_idx): + """Run one validation step. + + :param batch: Mini-batch tuple ``(x, y)``. + :param batch_idx: Batch index within the validation epoch. + """ + self._shared_step(batch, "val") + + def predict_step( + self, data, batch_idx: int = 0 + ) -> tuple[torch.Tensor, torch.Tensor]: + """Run one prediction step. + + :param data: Mini-batch tuple ``(x, y)``. + :param batch_idx: Batch index within the prediction epoch. + :returns: Tuple of context and encoded tensors. + """ + x = data.permute(0, 2, 1).float() + context, encoded = self.model(x) + return context, encoded + + def configure_optimizers(self): + """Create optimizer for model and criterion parameters. + + :returns: Adam optimizer configured from ``config.optimizer``. + """ + return torch.optim.Adam( + list(self.model.parameters()) + list(self.criterion.parameters()), + lr=self.config.optimizer.learning_rate, + weight_decay=self.config.optimizer.weight_decay, + ) + + +# config = TrainConfig.from_yaml( +# Path("configs/predictive_coding/config.ecg200.yaml") +# ) +# config = TrainConfig.from_yaml( +# Path("configs/predictive_coding/config.ecg5000.yaml") +# ) +# config = TrainConfig.from_yaml( +# Path("configs/predictive_coding/config.forda.yaml") +# ) +config = TrainConfig.from_yaml(Path("configs/predictive_coding/config.synth.yaml")) + +config.model_dump() + +# + +history_length_1_step = 100 +horizon_1_step = 1 + +pdm_1_step = DataFrameDataModule( + history_length=history_length_1_step, + horizon=horizon_1_step, + dataframe=df[["y"]], +) +# - + +for i in pdm_1_step.train_dataloader(): + print(i[0].shape, i[1].shape) + break + +# + + + +L.seed_everything(config.runtime.seed, workers=True) +os.makedirs(config.trainer.output_dir, exist_ok=True) + +lightning_module = CPCLightningModule(config=config, input_channels=1) + +trainer = L.Trainer( + max_epochs=config.trainer.epochs, + accelerator=config.runtime.accelerator, + devices=config.runtime.devices, + default_root_dir=config.trainer.output_dir, + log_every_n_steps=5, + precision="32-true", # Enforce float32 for MPS compatibility +) +trainer.fit(lightning_module, datamodule=pdm_1_step) +# - + + +# ## Load Artifacts and Interpret + +import pandas as pd +import plotly.express as px +import torch +from sklearn.decomposition import PCA +from sklearn.manifold import TSNE +from sklearn.pipeline import make_pipeline +from sklearn.preprocessing import StandardScaler + +# ### Visualize One Batch + +for i in pdm_1_step.train_dataloader(): + pred_data, pred_label = i + break + +pred_data.shape, pred_label.shape + +# + +data_pca2 = PCA( + n_components=2, +).fit_transform(pred_data.detach().numpy()[:, :, 0]) + +df_data_pca = pd.DataFrame(data_pca2, columns=["pc_1", "pc_2"]) + +df_data_pca["label"] = pred_label[:, 0, 0].numpy() + +df_data_pca.head() +# - + +px.scatter( + df_data_pca, + x="pc_1", + y="pc_2", + color="label", + title="PCA of CPC Input Data", + width=800, + height=600, + color_continuous_scale="Viridis", +) + +pred_context, pred_encoded = trainer.model.predict_step(pred_data) + +pred_context.shape, pred_encoded.shape + +from sklearn.decomposition import PCA +from sklearn.linear_model import LogisticRegression +from sklearn.manifold import TSNE +from sklearn.metrics import silhouette_score +from sklearn.model_selection import StratifiedKFold, cross_val_score + +# + +context_pca2 = PCA( + n_components=2, +).fit_transform(pred_context.detach().numpy()[:, 0, :]) + +df_context = pd.DataFrame(context_pca2, columns=["pc_1", "pc_2"]) + +df_context["label"] = pred_label[:, 0, 0].numpy() + +df_context.head() +# - + +px.scatter( + df_context, + x="pc_1", + y="pc_2", + color="label", + title="PCA of CPC Context Representations", + width=800, + height=600, + color_continuous_scale="Viridis", +) + +# + +context_tsne2d = TSNE( + n_components=2, + perplexity=20, + random_state=0, + # init="pca" +).fit_transform( + # PCA( + # n_components=10, + # ).fit_transform( + # pred_context.detach().numpy()[:,0,:] + # ) + pred_context.detach().numpy()[:, 0, :] +) + +df_context_tsne = pd.DataFrame(context_tsne2d, columns=["tsne_1", "tsne_2"]) + +df_context_tsne["label"] = pred_label[:, 0, 0].numpy() + +df_context_tsne.head() +# - + +px.scatter( + df_context_tsne, + x="tsne_1", + y="tsne_2", + color="label", + title="t-SNE of CPC Context Representations", + width=800, + height=600, + color_continuous_scale="Viridis", +) + +# + +encoded_pca2 = PCA( + n_components=2, +).fit_transform(pred_encoded.detach().numpy()[:, 0, :]) + +df_encoded_pca = pd.DataFrame(encoded_pca2, columns=["pc_1", "pc_2"]) + +df_encoded_pca["label"] = pred_label[:, 0, 0].numpy() + +df_encoded_pca.head() +# - + +px.scatter( + df_encoded_pca, + x="pc_1", + y="pc_2", + color="label", + title="PCA of CPC Encoded Representations", + width=800, + height=600, + color_continuous_scale="Viridis", +) + +# + +encoded_tsne2d = TSNE( + n_components=2, + perplexity=20, + random_state=0, + # init="pca" +).fit_transform( + # PCA( + # n_components=10, + # ).fit_transform( + # pred_encoded.detach().numpy()[:,0,:] + # ) + pred_encoded.detach().numpy()[:, 0, :] +) + +df_encoded_tsne = pd.DataFrame(encoded_tsne2d, columns=["tsne_1", "tsne_2"]) + +df_encoded_tsne["label"] = pred_label[:, 0, 0].numpy() + +df_encoded_tsne.head() +# - + +px.scatter( + df_encoded_tsne, + x="tsne_1", + y="tsne_2", + color="label", + title="t-SNE of CPC Encoded Representations", + width=800, + height=600, + color_continuous_scale="Viridis", +) + +# ### Visualizez All + +import pandas as pd +import plotly.express as px +import plotly.graph_objects as go +from sklearn.decomposition import PCA + +# + +# Faceted comparison: raw vs context vs encoded for the same reduction method +# Produces two figures: +# 1) PCA with facet rows (raw/context/encoded) +# 2) t-SNE with facet rows (raw/context/encoded) + + +# Rebuild tensors if they are not already in memory + +module = trainer.model if hasattr(trainer, "model") else lightning_module +module.eval() +device = module.device + +all_raw, all_context, all_encoded, all_labels = [], [], [], [] +with torch.no_grad(): + for x, y_batch in pdm_1_step.train_dataloader(): + x = x.permute(0, 2, 1).float().to(device) + context, encoded = module.model(x) + + all_raw.append(x.cpu()) + all_context.append(context.cpu()) + all_encoded.append(encoded.cpu()) + all_labels.append(y_batch[:, 0, 0].cpu()) + +raw_all = torch.cat(all_raw, dim=0) # [N, C_in, T] +context_all = torch.cat(all_context, dim=0) # [N, T_enc, C] +encoded_all = torch.cat(all_encoded, dim=0) # [N, T_enc, C] +y = torch.cat(all_labels, dim=0).numpy().astype(np.float32) + +# Choose one view per family for fair visual comparison +Z_by_family = { + "raw": raw_all.reshape(raw_all.shape[0], -1).numpy(), # flatten_all_channels + "context": context_all.reshape(context_all.shape[0], -1).numpy(), # flatten_tokens + # "encoded": encoded_all.reshape(encoded_all.shape[0], -1).numpy(),# flatten_tokens + "encoded": encoded_all[:, 1, :] + .reshape(encoded_all.shape[0], -1) + .numpy(), # flatten_tokens +} + +family_order = ["raw", "context", "encoded"] + + +def reduce_family(Z, method="pca", random_state=0): + if method == "pca": + return make_pipeline( + StandardScaler(), + PCA(n_components=2, random_state=random_state), + ).fit_transform(Z) + if method == "tsne": + n = Z.shape[0] + perp = max(5, min(30, (n - 1) // 3)) + return TSNE( + n_components=2, + perplexity=perp, + random_state=random_state, + init="pca", + ).fit_transform(Z) + raise ValueError(f"Unknown method: {method}") + + +def build_facet_df(method): + rows = [] + for fam in family_order: + Z2 = reduce_family(Z_by_family[fam], method=method, random_state=0) + df_f = pd.DataFrame( + { + "dim1": Z2[:, 0], + "dim2": Z2[:, 1], + "label": y, + "family": fam, + } + ) + rows.append(df_f) + return pd.concat(rows, ignore_index=True) + + +def plot_facet(dataframe, method, width=700, height=1100): + df_plot = dataframe.copy() + title = f"{method.upper()} comparison by family (facet rows)" + fig = px.scatter( + df_plot, + x="dim1", + y="dim2", + color="label", + facet_row="family", + category_orders={"family": family_order}, + title=title, + width=width, + height=height, + color_continuous_scale="Viridis", + opacity=0.8, + ) + fig.update_traces(marker=dict(size=5)) + fig.for_each_annotation(lambda a: a.update(text=a.text.split("=")[-1])) + fig.update_layout(legend_title_text="label") + fig.update_xaxes(matches=None) + fig.update_yaxes(matches=None) + fig.show() + + +# Show both methods with the same faceting layout +df_plot_pca = build_facet_df("pca") +plot_facet(df_plot_pca, "pca") +df_plot_tsne = build_facet_df("tsne") +plot_facet(df_plot_tsne, "tsne") +# - +df_dr = pd.merge( + df_plot_pca[["dim1", "dim2"]], + df_plot_tsne, + how="left", + left_index=True, + right_index=True, + suffixes=("_pca", "_tsne"), +) +df_dr + +# + +import numpy as np +import pandas as pd + +# Expect df_dr columns from your merge: +# dim1_pca, dim2_pca, dim1_tsne, dim2_tsne, label, family + +required = {"dim1_pca", "dim2_pca", "label", "family"} +missing = required - set(df_dr.columns) +if missing: + raise ValueError(f"df_dr is missing required columns: {missing}") + +# Keep only families needed for this vector +df_tmp = df_dr[df_dr["family"].isin(["raw", "encoded"])].copy() + +# Create per-sample index inside each family block so raw and encoded can be paired +df_tmp["idx"] = df_tmp.groupby("family").cumcount() + +# Split and rename PCA columns +raw_df = ( + df_tmp[df_tmp["family"] == "raw"][["idx", "label", "dim1_pca", "dim2_pca"]] + .rename(columns={"dim1_pca": "raw_x", "dim2_pca": "raw_y"}) + .reset_index(drop=True) +) + +enc_df = ( + df_tmp[df_tmp["family"] == "encoded"][["idx", "label", "dim1_pca", "dim2_pca"]] + .rename(columns={"dim1_pca": "enc_x", "dim2_pca": "enc_y", "label": "label_enc"}) + .reset_index(drop=True) +) + +# Pair raw and encoded rows by idx (and optionally validate labels) +df_vec = raw_df.merge(enc_df, on="idx", how="inner") + +# Optional sanity check: label consistency +if not (df_vec["label"] == df_vec["label_enc"]).all(): + print("Warning: label mismatch found between raw and encoded pairing.") +df_vec = df_vec.drop(columns=["label_enc"]) + +# Vector components and norm +df_vec["vec_x"] = df_vec["enc_x"] - df_vec["raw_x"] +df_vec["vec_y"] = df_vec["enc_y"] - df_vec["raw_y"] +df_vec["vec_norm"] = np.linalg.norm(df_vec[["vec_x", "vec_y"]].to_numpy(), axis=1) + +df_vec.head() + + +# + +label_values = df_vec["label"].astype(np.float32).to_numpy() + +raw_color = "rgba(31, 119, 180, 0.2)" # blue-ish connector tint + +line_x = np.column_stack( + [df_vec["raw_x"], df_vec["enc_x"], np.full(len(df_vec), np.nan)] +).ravel() +line_y = np.column_stack( + [df_vec["raw_y"], df_vec["enc_y"], np.full(len(df_vec), np.nan)] +).ravel() + +fig = go.Figure() + +fig.add_trace( + go.Scatter( + x=line_x, + y=line_y, + mode="lines", + line=dict(color=raw_color, width=1), + hoverinfo="skip", + showlegend=False, + ) +) + +fig.add_trace( + go.Scatter( + x=df_vec["raw_x"], + y=df_vec["raw_y"], + mode="markers", + marker=dict( + size=8, + symbol="circle", + color=label_values, + coloraxis="coloraxis", + line=dict(width=1, color="white"), + ), + name="raw", + text=[ + f"idx={r}, label={lbl:.4f}" for r, lbl in zip(df_vec["idx"], label_values) + ], + hovertemplate="RAW
%{text}
x=%{x:.3f}, y=%{y:.3f}", + ) +) + +fig.add_trace( + go.Scatter( + x=df_vec["enc_x"], + y=df_vec["enc_y"], + mode="markers", + marker=dict( + size=8, + symbol="diamond", + color=label_values, + coloraxis="coloraxis", + line=dict(width=1, color="white"), + ), + name="encoded", + text=[ + f"idx={r}, label={lbl:.4f}, norm={n:.3f}" + for r, lbl, n in zip(df_vec["idx"], label_values, df_vec["vec_norm"]) + ], + hovertemplate="ENCODED
%{text}
x=%{x:.3f}, y=%{y:.3f}", + ) +) + +fig.update_layout( + title=f"Per-index vectors — marker color: continuous label, shape: raw/encoded (N={len(df_vec)})", + xaxis_title="PC1 (raw space) / PC1 (encoded space)", + yaxis_title="PC2", + width=980, + height=720, + coloraxis=dict(colorscale="Viridis", colorbar=dict(title="label")), +) +fig.show() + +# + + + +# Derive vec_x / vec_y from whichever df_vec is in scope +vec_x = (df_vec["enc_x"] - df_vec["raw_x"]).values +vec_y = (df_vec["enc_y"] - df_vec["raw_y"]).values +V = np.stack([vec_x, vec_y], axis=1) # [N, 2] +labels = df_vec["label"].values + +# 1) Mean displacement and residuals +v_mean = V.mean(axis=0) +residuals = V - v_mean +residual_norms = np.linalg.norm(residuals, axis=1) +vector_norms = np.linalg.norm(V, axis=1) +explained_by_mean = 1 - (residual_norms / (vector_norms + 1e-9)) + +print(f"Mean displacement vector: ({v_mean[0]:.3f}, {v_mean[1]:.3f})") +print(f"Mean |v|: {vector_norms.mean():.3f} ± {vector_norms.std():.3f}") +print(f"Mean |residual|: {residual_norms.mean():.3f} ± {residual_norms.std():.3f}") +print(f"Fraction explained by global shift: {explained_by_mean.mean():.3f}") + +# 2) Angle relative to mean direction +v_mean_unit = v_mean / (np.linalg.norm(v_mean) + 1e-9) +cos_sim = np.clip(V @ v_mean_unit / (vector_norms + 1e-9), -1, 1) +angles_deg = np.degrees(np.arccos(cos_sim)) + +# 3) PCA of displacement vectors +pca_v = PCA(n_components=2).fit(V) +print( + f"\nPCA of displacement vectors — variance explained: {pca_v.explained_variance_ratio_}" +) + +df_angle = pd.DataFrame( + { + "angle_deg": angles_deg, + "residual_norm": residual_norms, + "vec_norm": vector_norms, + "label": labels, + } +) + +fig = px.histogram( + df_angle, + x="angle_deg", + color="label", + nbins=30, + barmode="overlay", + opacity=0.7, + title="Distribution of displacement angle relative to mean vector (degrees)
" + "Near 0° = moves with the crowd; large angle = outlier movement", + labels={"angle_deg": "Angle to mean displacement (°)"}, + width=850, + height=450, +) +fig.show() + +fig2 = px.scatter( + df_angle, + x="vec_norm", + y="residual_norm", + color="label", + title="Vector norm vs residual norm after removing global shift
" + "Near x-axis = moved with global trend; high residual = distinctive movement", + labels={"vec_norm": "|v|", "residual_norm": "|v - v̄|"}, + width=800, + height=500, + opacity=0.8, +) +fig2.add_hline(y=0, line_dash="dot", line_color="gray") +fig2.show() +# - + +# ## Downstream Tasks + +import lightning as L + +# + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from lightning.pytorch.callbacks import EarlyStopping +from sklearn.metrics import accuracy_score, f1_score +from sklearn.model_selection import RepeatedStratifiedKFold +from sklearn.preprocessing import StandardScaler +from torch.utils.data import DataLoader, TensorDataset + + +class MLPCForecaster(L.LightningModule): + def __init__( + self, + input_dim: int, + forecast_steps: int, + hidden_dim: int = 128, + dropout: float = 0.2, + lr: float = 1e-3, + pre_trained_model: nn.Module | None = None, + ): + super().__init__() + self.save_hyperparameters(ignore=["pre_trained_model"]) + + if pre_trained_model is not None: + self.pre_net = pre_trained_model + else: + self.pre_net = nn.Identity() + + self.net = nn.Sequential( + nn.Linear(input_dim, hidden_dim), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, hidden_dim // 2), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim // 2, forecast_steps), + ) + self.loss = nn.MSELoss() + + def forward(self, x): + x = self.pre_net(x) + return self.net(x) + + def training_step(self, batch, batch_idx): + x, y = batch + forecast = self(x.permute(0, 2, 1)) + loss = self.loss(forecast, y.squeeze()) + self.log("train_loss", loss, prog_bar=False, on_epoch=True, on_step=False) + return loss + + def validation_step(self, batch, batch_idx): + x, y = batch + forecast = self(x.permute(0, 2, 1)) + loss = self.loss(forecast, y.squeeze()) + self.log("val_loss", loss, prog_bar=False, on_epoch=True, on_step=False) + return loss + + def predict_step(self, batch, batch_idx, dataloader_idx=0): + x, _ = batch + return self(x.permute(0, 2, 1)) + + def configure_optimizers(self): + return torch.optim.AdamW( + self.parameters(), + lr=self.hparams.lr, + ) + + +model = MLPCForecaster( + input_dim=history_length_1_step, + forecast_steps=horizon_1_step, + hidden_dim=64, + dropout=0.2, + lr=1e-3, +) + +forecaster_trainer_naive = L.Trainer( + max_epochs=100, + accelerator="auto", + devices=1, + logger=False, + enable_checkpointing=False, + enable_progress_bar=False, + deterministic=True, + callbacks=[EarlyStopping(monitor="val_loss", mode="min", patience=8)], +) +forecaster_trainer_naive.fit(model, datamodule=pdm_1_step) + +pred_batches = forecaster_trainer_naive.predict(model, datamodule=pdm_1_step) +y_pred = torch.cat(pred_batches, dim=0) + + +# - + +# diff --git a/dl/notebooks/rnn_phase_space.py b/dl/notebooks/rnn_phase_space.py index bc103410..fbd6273c 100644 --- a/dl/notebooks/rnn_phase_space.py +++ b/dl/notebooks/rnn_phase_space.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/rnn_timeseries.py b/dl/notebooks/rnn_timeseries.py index 14a7c91c..091d079a 100644 --- a/dl/notebooks/rnn_timeseries.py +++ b/dl/notebooks/rnn_timeseries.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/rnn_timeseries_comparison.py b/dl/notebooks/rnn_timeseries_comparison.py index 67af0376..adb22678 100644 --- a/dl/notebooks/rnn_timeseries_comparison.py +++ b/dl/notebooks/rnn_timeseries_comparison.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/tabpfn.py b/dl/notebooks/tabpfn.py index fe86f2b3..e04bb8cf 100644 --- a/dl/notebooks/tabpfn.py +++ b/dl/notebooks/tabpfn.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/time-series-data-generation.py b/dl/notebooks/time-series-data-generation.py index 962758d7..06fe9601 100644 --- a/dl/notebooks/time-series-data-generation.py +++ b/dl/notebooks/time-series-data-generation.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/time_series_data_and_embedding.py b/dl/notebooks/time_series_data_and_embedding.py index 8420372e..2c57bf4f 100644 --- a/dl/notebooks/time_series_data_and_embedding.py +++ b/dl/notebooks/time_series_data_and_embedding.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python @@ -16,13 +16,9 @@ import matplotlib.pyplot as plt import numpy as np - -# + import pandas as pd import plotly.express as px -# - - def plot_arrow_chart( dataframe: pd.DataFrame, diff --git a/dl/notebooks/time_vae.py b/dl/notebooks/time_vae.py index fbd50b57..24f8c97b 100644 --- a/dl/notebooks/time_vae.py +++ b/dl/notebooks/time_vae.py @@ -5,9 +5,9 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: -# display_name: .venv +# display_name: deep-learning-py3.10 # language: python # name: python3 # --- @@ -773,7 +773,7 @@ def configure_optimizers(self) -> dict: vae_model_reloaded.model.decoder(sampling_z).cpu().detach().numpy().squeeze() ) -generated_samples_x.size() +generated_samples_x.shape # + _, ax = plt.subplots() @@ -827,3 +827,210 @@ def configure_optimizers(self) -> dict: ax.set_title("t-SNE of original and generated samples") ax.set_xlabel("t-SNE 1") ax.set_ylabel("t-SNE 2") +# - + +# ## Investigation of Embeddings + +# + +from pathlib import Path + +import numpy as np +import pandas as pd +import plotly.express as px +from torch.utils.data import DataLoader +from torchdr import PCA, TSNE, UMAP +from ts_dl_utils.datasets.dataset import DataFrameDataset + +# - + +vae_model_reloaded + + +def embedding_extractor(forecaster: VAEModel, x: torch.Tensor) -> tuple[torch.Tensor]: + """compute the embeddings based on the input + + :param forecaster: the trained forecaster + :param x: input historical time series, + """ + forecaster.model.to(x.device) + z_mean, z_log_var, z = forecaster.model.encoder( + x.type_as(forecaster.model.encoder.z_mean_layer.weight) + ) + + return z_mean, z_log_var, z + + +# + +investigation_dl = DataLoader( + dataset=DataFrameDataset( + dataframe=df[["theta"]], history_length=window_size, horizon=1, gap=0 + ), + batch_size=400, + shuffle=False, +) + +investigation_dl +# - + +input_example = list(investigation_dl)[0][0] +input_example.shape + +z_mean_example, z_log_var_example, z_example = embedding_extractor( + vae_model_reloaded, input_example +) +z_example.shape + +(z_example.shape, z_mean_example.shape, z_log_var_example.shape) + +# + +n_components = 3 + +dr_input_result = TSNE( + # dr_input_result = PCA( + # n_neighbors=30, backend='torch', + perplexity=30, + n_components=n_components, +).fit_transform(input_example.detach().squeeze()) + +dr_input_result.shape + + +# + +dr_z_mean_result = TSNE( + # dr_z_result = PCA( + # n_neighbors=30, backend='torch', + # perplexity=30, + n_components=n_components +).fit_transform( + # z_example.detach().squeeze() + z_mean_example.detach().squeeze() +) + +dr_z_mean_result.shape +# - + +input_example.detach().shape + + +def create_embedding_dataframe( + dr_result: torch.Tensor, + n_batches: int, + input_example: torch.Tensor, + n_components: int, +) -> pd.DataFrame: + + dr_df = pd.DataFrame( + dr_result.detach().numpy(), columns=[f"DR_{i+1}" for i in range(n_components)] + ) + + dr_df["batch"] = sum( + [[i] * (len(dr_df) // n_batches) for i in range(n_batches)], [] + ) + + dr_df["sample_idx"] = list(range(len(dr_df) // n_batches)) * n_batches + + # dr_df["input"] = np.concatenate( + # input_example[:n_batches].detach().numpy().astype("float32") + # ) + + dr_df = dr_df.merge( + pd.DataFrame( + input_example[:n_batches].detach()[:, 0, 0].numpy(), + columns=["batch_first_value"], + ) + .reset_index() + .rename(columns={"index": "batch"}), + how="left", + on="batch", + ) + + return dr_df + + +dr_input_df = create_embedding_dataframe( + dr_result=dr_input_result, + n_batches=input_example.shape[0], + input_example=input_example, + n_components=n_components, +) + +px.scatter( + dr_input_df, + x="DR_1", + y="DR_2", + # z='DR_3', + # z='batch_first_value', + # color='sample_idx', + # symbol='type', + # color="batch", + # color="DR_3", + color="batch_first_value", + title="Embedding of Input Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +dr_z_df = create_embedding_dataframe( + dr_result=dr_z_mean_result, + n_batches=z_example.shape[0], + input_example=input_example, + n_components=n_components, +) + +dr_z_df + +px.scatter( + dr_z_df, + x="DR_1", + # y="batch_first_value", + y="DR_2", + # z='DR_3', + # z='batch_first_value', + # color='sample_idx', + # symbol='type', + # color="batch", + # color="DR_2", + color="batch_first_value", + title="UMAP Embedding of Encoder Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter( + dr_z_df, + x="DR_1", + y="DR_2", + # z='DR_3', + # z='batch_first_value', + # color='sample_idx', + # symbol='type', + # color="batch", + # color="DR_3", + color="batch_first_value", + title="UMAP Embedding of Encoder Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter_3d( + dr_z_df, + x="DR_1", + y="DR_2", + z="DR_3", + # z='batch_first_value', + # color='sample_idx', + # symbol='type', + # color="batch", + color="batch_first_value", + title="UMAP Embedding of Encoder Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.imshow(input_example.squeeze().T, aspect="auto") + +px.imshow(dr_input_result.T.detach().numpy(), aspect="auto") + +px.imshow(dr_z_mean_result.T.detach().numpy(), aspect="auto") + +px.imshow(dr_z_df[["DR_1", "DR_2", "DR_3"]].T, aspect="auto") diff --git a/dl/notebooks/time_vae_poison.py b/dl/notebooks/time_vae_poison.py index e8226691..9b1310d6 100644 --- a/dl/notebooks/time_vae_poison.py +++ b/dl/notebooks/time_vae_poison.py @@ -5,9 +5,9 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: -# display_name: .venv +# display_name: deep-learning-py3.10 # language: python # name: python3 # --- @@ -820,10 +820,10 @@ def configure_optimizers(self) -> dict: # ## Fitted Model -IS_RELOAD = False +IS_RELOAD = True if IS_RELOAD: - checkpoint_path = "lightning_logs/time_vae_naive/version_29/checkpoints/epoch=1999-step=354000.ckpt" + checkpoint_path = "lightning_logs/time_vae_koisk/version_8/checkpoints/epoch=1999-step=170000.ckpt" vae_model_reloaded = VAEModel.load_from_checkpoint(checkpoint_path, model=vae) else: vae_model_reloaded = vae_model @@ -853,7 +853,7 @@ def configure_optimizers(self) -> dict: vae_model_reloaded.model.decoder(sampling_z).cpu().detach().numpy().squeeze() ) -generated_samples_x.size() +generated_samples_x.size # + _, ax = plt.subplots() @@ -907,3 +907,175 @@ def configure_optimizers(self) -> dict: ax.set_title("t-SNE of original and generated samples") ax.set_xlabel("t-SNE 1") ax.set_ylabel("t-SNE 2") +# - + +# ## Embeddings + +# + +# + +from pathlib import Path + +import numpy as np +import pandas as pd +import plotly.express as px +from torch.utils.data import DataLoader +from torchdr import PCA, TSNE, UMAP +from ts_dl_utils.datasets.dataset import DataFrameDataset + +# - + +vae_model_reloaded + + +def embedding_extractor(forecaster: VAEModel, x: torch.Tensor) -> tuple[torch.Tensor]: + """compute the embeddings based on the input + + :param forecaster: the trained forecaster + :param x: input historical time series, + """ + forecaster.model.to(x.device) + z_mean, z_log_var, z = forecaster.model.encoder( + x.type_as(forecaster.model.encoder.z_mean_layer.weight) + ) + + return z_mean, z_log_var, z + + +# + +investigation_dl = DataLoader( + dataset=DataFrameDataset( + dataframe=df[["count"]], history_length=window_size, horizon=1, gap=0 + ), + batch_size=400, + shuffle=False, +) + +investigation_dl +# - + +input_example = list(investigation_dl)[0][0] +input_example.shape + +z_mean_example, z_log_var_example, z_example = embedding_extractor( + vae_model_reloaded, input_example +) +z_example.shape + +(z_example.shape, z_mean_example.shape, z_log_var_example.shape) + +# + +n_components = 3 + +# dr_z_result = TSNE( +dr_input_result = PCA( + # n_neighbors=30, backend='torch', + # perplexity=30, + n_components=n_components +).fit_transform(input_example.detach().squeeze()) + +dr_input_result.shape + +# + +dr_z_mean_result = TSNE( + # dr_z_result = PCA( + # n_neighbors=30, backend='torch', + # perplexity=30, + n_components=n_components +).fit_transform( + # z_example.detach().squeeze() + z_mean_example.detach().squeeze() +) + +dr_z_mean_result.shape + + +# - + + +def create_embedding_dataframe( + dr_result: torch.Tensor, + n_batches: int, + input_example: torch.Tensor, + n_components: int, +) -> pd.DataFrame: + + dr_df = pd.DataFrame( + dr_result.detach().numpy(), columns=[f"DR_{i+1}" for i in range(n_components)] + ) + + dr_df["batch"] = sum( + [[i] * (len(dr_df) // n_batches) for i in range(n_batches)], [] + ) + + dr_df["sample_idx"] = list(range(len(dr_df) // n_batches)) * n_batches + + # dr_df["input"] = np.concatenate( + # input_example[:n_batches].detach().numpy().astype("float32") + # ) + + dr_df = dr_df.merge( + pd.DataFrame( + input_example[:n_batches].detach()[:, 0, 0].numpy(), + columns=["batch_first_value"], + ) + .reset_index() + .rename(columns={"index": "batch"}), + how="left", + on="batch", + ) + + return dr_df + + +dr_input_df = create_embedding_dataframe( + dr_result=dr_input_result, + n_batches=input_example.shape[0], + input_example=input_example, + n_components=n_components, +) + +# px.scatter( +px.scatter_3d( + dr_input_df, + x="DR_1", + y="DR_2", + z="DR_3", + # z='batch_first_value', + # color='sample_idx', + # symbol='type', + # color="batch", + # color="DR_3", + color="batch_first_value", + title="Embedding of Input Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +dr_z_df = create_embedding_dataframe( + dr_result=dr_z_mean_result, + n_batches=z_example.shape[0], + input_example=input_example, + n_components=n_components, +) + +px.scatter( + dr_z_df, + x="DR_1", + # y="batch_first_value", + y="DR_2", + # z='DR_3', + # z='batch_first_value', + # color='sample_idx', + # symbol='type', + # color="batch", + # color="DR_2", + color="batch_first_value", + title="UMAP Embedding of Encoder Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.imshow(input_example.squeeze().T, aspect="auto") + +px.imshow(dr_input_result.T, aspect="auto") diff --git a/dl/notebooks/timeseries-comparison.py b/dl/notebooks/timeseries-comparison.py index 5eb83c50..9a99a8e9 100644 --- a/dl/notebooks/timeseries-comparison.py +++ b/dl/notebooks/timeseries-comparison.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/timeseries_data_box-cox.py b/dl/notebooks/timeseries_data_box-cox.py index 58313be2..41c8ad86 100644 --- a/dl/notebooks/timeseries_data_box-cox.py +++ b/dl/notebooks/timeseries_data_box-cox.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/timeseries_gan.py b/dl/notebooks/timeseries_gan.py index ca24687a..4b7696d1 100644 --- a/dl/notebooks/timeseries_gan.py +++ b/dl/notebooks/timeseries_gan.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer-explainer.py b/dl/notebooks/transformer-explainer.py index d65675d1..b5f970bb 100644 --- a/dl/notebooks/transformer-explainer.py +++ b/dl/notebooks/transformer-explainer.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer-ts-nixtla-testing-m5.py b/dl/notebooks/transformer-ts-nixtla-testing-m5.py index 6a0de69e..77120161 100644 --- a/dl/notebooks/transformer-ts-nixtla-testing-m5.py +++ b/dl/notebooks/transformer-ts-nixtla-testing-m5.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer-ts-nixtla-testing.py b/dl/notebooks/transformer-ts-nixtla-testing.py index 17bc656e..fe275007 100644 --- a/dl/notebooks/transformer-ts-nixtla-testing.py +++ b/dl/notebooks/transformer-ts-nixtla-testing.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer-ts-nixtla.py b/dl/notebooks/transformer-ts-nixtla.py index 61a614f9..d9af70fc 100644 --- a/dl/notebooks/transformer-ts-nixtla.py +++ b/dl/notebooks/transformer-ts-nixtla.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer-ts-nixtla_naive_data.py b/dl/notebooks/transformer-ts-nixtla_naive_data.py index 55fed854..601d92d4 100644 --- a/dl/notebooks/transformer-ts-nixtla_naive_data.py +++ b/dl/notebooks/transformer-ts-nixtla_naive_data.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer_embeddings.py b/dl/notebooks/transformer_embeddings.py new file mode 100644 index 00000000..c2d8d8c6 --- /dev/null +++ b/dl/notebooks/transformer_embeddings.py @@ -0,0 +1,9 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.19.1 +# --- diff --git a/dl/notebooks/transformer_history.py b/dl/notebooks/transformer_history.py index d8fdeba1..e5fa5df1 100644 --- a/dl/notebooks/transformer_history.py +++ b/dl/notebooks/transformer_history.py @@ -5,7 +5,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: .venv # language: python diff --git a/dl/notebooks/transformer_timeseries_univariate.py b/dl/notebooks/transformer_timeseries_univariate.py index 6ca68aa4..8ac41a62 100644 --- a/dl/notebooks/transformer_timeseries_univariate.py +++ b/dl/notebooks/transformer_timeseries_univariate.py @@ -6,9 +6,9 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: -# display_name: .venv +# display_name: deep-learning-py3.10 # language: python # name: python3 # --- @@ -219,6 +219,7 @@ class TransformerForecaster(L.LightningModule): def __init__(self, transformer: nn.Module): super().__init__() self.transformer = transformer + self.save_hyperparameters() def configure_optimizers(self) -> torch.optim.Optimizer: optimizer = torch.optim.SGD(self.parameters(), lr=1e-3) @@ -501,3 +502,437 @@ def forward(self, x: torch.Tensor) -> tuple[torch.Tensor]: evaluator_m_step.metrics(predictions_m_step, pdm_m_step.predict_dataloader()) evaluator_m_step.metrics(lobs_m_step_predictions, pdm_m_step.predict_dataloader()) + +# # Investigations +# +# We dive deeper into the intermediate results of the model. + +# + +from pathlib import Path + +import pandas as pd +import plotly.express as px +from torch.utils.data import DataLoader +from ts_dl_utils.datasets.dataset import DataFrameDataset + +# + +load_from_checkpoint = ( + Path( + # "lightning_logs/transformer_ts_1_step/version_9" + "lightning_logs/transformer_ts_1_step/version_7" + ) + / "checkpoints" +) + +# load_from_checkpoint = Path(logger_1_step.log_dir) / "checkpoints" +load_from_checkpoint, logger_1_step.log_dir +# - + +list(load_from_checkpoint.iterdir())[0] + +# + +transformer_forecaster_1_step_re = TransformerForecaster.load_from_checkpoint( + # load_from_checkpoint / "checkpoints/epoch=11-step=5495.ckpt" + list(load_from_checkpoint.iterdir())[0] +) + +transformer_forecaster_1_step_re + + +# - + +# ## Visualize Embeddings of Intermediate Layers + + +def embedding_extractor( + forecaster: TransformerForecaster, x: torch.Tensor +) -> tuple[torch.Tensor]: + """compute the embeddings based on the input + + :param forecaster: the trained forecaster + :param x: input historical time series, + """ + forecaster.transformer.to(x.device) + x_embedding = forecaster.transformer.embedding( + x.type_as(forecaster.transformer.embedding.weight) + ) + x_positional = forecaster.transformer.positional_encoding(x_embedding) + + encoder_state = forecaster.transformer.encoder(x_positional) + + reversed = forecaster.transformer.reverse_embedding(encoder_state).squeeze(-1) + + return x_embedding, x_positional, encoder_state, reversed + + +def create_embedding_dataframe( + dr_result: torch.Tensor, + n_batches: int, + input_example: torch.Tensor, + n_components: int, +) -> pd.DataFrame: + + dr_df = pd.DataFrame( + dr_result.detach().numpy(), columns=[f"DR_{i+1}" for i in range(n_components)] + ) + + dr_df["batch"] = sum( + [[i] * (len(dr_df) // n_batches) for i in range(n_batches)], [] + ) + + dr_df["sample_idx"] = list(range(len(dr_df) // n_batches)) * n_batches + + dr_df["input"] = np.concatenate( + input_example[:n_batches].detach().numpy().astype("float32") + ) + + dr_df = dr_df.merge( + pd.DataFrame( + input_example[:n_batches].detach()[:, 0, 0].numpy(), + columns=["batch_first_value"], + ) + .reset_index() + .rename(columns={"index": "batch"}), + how="left", + on="batch", + ) + + return dr_df + + +# Prepare input data for embedding visualization. + +# + +investigation_dl = DataLoader( + dataset=DataFrameDataset( + dataframe=df[["theta"]], + history_length=history_length_1_step, + horizon=horizon_1_step, + gap=gap, + ), + batch_size=400, + shuffle=False, +) + +investigation_dl +# - + +input_example = list(investigation_dl)[0][0] +input_example.shape + +(embedding_example, positional_example, encoder_example, reversed_example) = ( + embedding_extractor(transformer_forecaster_1_step, input_example) +) + +( + input_example.shape, + embedding_example.shape, + positional_example.shape, + encoder_example.shape, + reversed_example.shape, +) + +n_batches, seq_len, _ = input_example.shape +df_example = pd.DataFrame( + { + "input": input_example.squeeze(-1).detach().cpu().numpy().reshape(-1), + "reversed": reversed_example.detach().cpu().numpy().reshape(-1), + "sample": np.repeat(np.arange(n_batches), seq_len), + } +) +df_example + + +px.scatter( + df_example, x="input", y="reversed", color="sample", height=600, width=600 +).update_layout(yaxis_scaleanchor="x") + +import numpy as np +from torchdr import PCA, TSNE, UMAP + +# Latent space visualization + +# + +n_components = 2 + +dr_reversed_result = TSNE( + # dr_reversed_result = UMAP( + # dr_reversed_result = PCA( + # n_neighbors=30, + # backend='torch', + perplexity=30, + n_components=n_components, +).fit_transform( + np.concatenate( + [ + input_example.squeeze(-1).numpy().astype("float32"), + reversed_example.detach().numpy().astype("float32"), + ], + axis=0, + ) +) +# - +dr_reversed_df = pd.DataFrame( + dr_reversed_result, columns=[f"DR_{i+1}" for i in range(n_components)] +) +dr_reversed_df["type"] = ["input"] * (len(dr_reversed_df) // 2) + ["embedded"] * ( + len(dr_reversed_df) - len(dr_reversed_df) // 2 +) +dr_reversed_df["sample_idx"] = list(range(len(dr_reversed_df) // 2)) + list( + range(len(dr_reversed_df) // 2) +) + + +px.scatter( + dr_reversed_df, + x="DR_1", + y="DR_2", + # z="DR_3", + color="sample_idx", + # color="DR_4", + symbol="type", + title="Embedding of Input and Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter_3d( + dr_reversed_df, + x="DR_1", + y="DR_2", + z="DR_3", + color="sample_idx", + # color="DR_4", + symbol="type", + title="Embedding of Input and Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter_3d( + dr_reversed_df.loc[dr_reversed_df["type"] == "embedded"], + x="DR_1", + y="DR_2", + z="DR_3", + color="sample_idx", + # color="DR_4", + symbol="type", + title="Embedding of Input Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +# Embedding outout + +embedding_example.detach()[0].shape, input_example.detach()[0].shape + +# + +embedding_result = UMAP( + # embedding_result = TSNE( + n_neighbors=30, + backend="torch", + # perplexity=30, + n_components=n_components, +).fit_transform( + # np.concatenate( + # embedding_example.detach().numpy().astype("float32") + # ) + embedding_example.detach().reshape(-1, embedding_example.shape[-1]) +) + +embedding_result.shape +# - + +dr_embedding_df = create_embedding_dataframe( + dr_result=embedding_result, + n_batches=embedding_example.shape[0], + input_example=input_example, + n_components=n_components, +) + +dr_embedding_df + +px.scatter( + dr_embedding_df, + x="input", + y="DR_1", + # x='DR_1', + # y='DR_2', + # z='DR_3', + # color='sample_idx', + # symbol='type', + # color="batch_first_value", + # color="input", + title="Dimension Reduction for Embedding of Input Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter_3d( + dr_embedding_df, + x="DR_1", + y="DR_2", + # z='DR_3', + z="input", + # color='sample_idx', + # symbol='type', + # color="batch", + # color="batch_first_value", + color="input", + title="UMAP Embedding of Input Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter( + pd.DataFrame(input_example.detach()[:, 0, :].numpy()).reset_index(), + x="index", + y=0, + height=600, + width=800, +) + +# Positional encoding output + +positional_example_sample_size = 100 + +# + +# positional_result = UMAP( +positional_result = TSNE( + # n_neighbors=30, backend='torch', + perplexity=30, + n_components=n_components, +).fit_transform( + positional_example.detach()[:positional_example_sample_size].reshape( + -1, positional_example.shape[-1] + ) +) + +positional_result.shape +# - + +dr_positional_df = create_embedding_dataframe( + dr_result=positional_result, + n_batches=positional_example_sample_size, + input_example=input_example, + n_components=n_components, +) + +# + +dr_positional_df = pd.DataFrame( + positional_result.detach().numpy(), + columns=[f"DR_{i+1}" for i in range(n_components)], +) + +dr_positional_df["batch"] = sum( + [ + [i] * (len(dr_positional_df) // positional_example_sample_size) + for i in range(positional_example_sample_size) + ], + [], +) + +dr_positional_df["sample_idx"] = ( + list(range(len(dr_positional_df) // positional_example_sample_size)) + * positional_example_sample_size +) + +dr_positional_df["input"] = np.concatenate( + input_example[:positional_example_sample_size].detach().numpy().astype("float32") +) + +dr_positional_df = dr_positional_df.merge( + pd.DataFrame( + input_example[:positional_example_sample_size].detach()[:, 0, 0].numpy(), + columns=["batch_first_value"], + ) + .reset_index() + .rename(columns={"index": "batch"}), + how="left", + on="batch", +) +# - + + +dr_positional_df + +px.scatter_3d( + dr_positional_df, + x="DR_1", + y="DR_2", + z="input", + # color='sample_idx', + # symbol='type', + # color="batch", + color="batch_first_value", + title="UMAP Embedding of Positional Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter( + dr_positional_df, + x="DR_1", + y="DR_2", + # z='input', + # symbol='type', + color="batch", + # color="input", + # color="batch_first_value", + title="UMAP Embedding of Positional Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter( + dr_positional_df, + x="input", + y="DR_1", + color="batch_first_value", +) + +# Encoder output + +# + +# encoder_result = TSNE( +encoder_result = PCA( + # n_neighbors=30, backend='torch', + # perplexity=30, + n_components=n_components +).fit_transform( + encoder_example.detach()[:positional_example_sample_size].reshape( + -1, encoder_example.shape[-1] + ) +) + +encoder_result.shape +# - + +dr_encoder_df = create_embedding_dataframe( + dr_result=encoder_result, + # n_batches=encoder_example.shape[0], + n_batches=positional_example_sample_size, + input_example=input_example, + n_components=n_components, +) + +px.scatter_3d( + dr_encoder_df, + x="DR_1", + y="DR_2", + z="input", + # color='sample_idx', + # symbol='type', + # color="batch", + color="batch_first_value", + title="UMAP Embedding of Encoder Encoded Time Series", + height=600, + width=800, +).update_layout(legend=dict(itemsizing="constant", orientation="h", y=-0.2)).show() + +px.scatter( + dr_encoder_df, + x="input", + y="DR_1", + color="batch_first_value", +) diff --git a/dl/notebooks/tree_basics.py b/dl/notebooks/tree_basics.py index f12e4e4e..60630ddf 100644 --- a/dl/notebooks/tree_basics.py +++ b/dl/notebooks/tree_basics.py @@ -6,7 +6,7 @@ # extension: .py # format_name: percent # format_version: '1.3' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/tree_darts_boosted_tree.py b/dl/notebooks/tree_darts_boosted_tree.py index 824f1f92..b60d891d 100644 --- a/dl/notebooks/tree_darts_boosted_tree.py +++ b/dl/notebooks/tree_darts_boosted_tree.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/tree_darts_random_forest.py b/dl/notebooks/tree_darts_random_forest.py index 5c21b486..fc736e26 100644 --- a/dl/notebooks/tree_darts_random_forest.py +++ b/dl/notebooks/tree_darts_random_forest.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/tree_random_forest.py b/dl/notebooks/tree_random_forest.py index b4e4deff..927784ad 100644 --- a/dl/notebooks/tree_random_forest.py +++ b/dl/notebooks/tree_random_forest.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.2 +# jupytext_version: 1.19.1 # kernelspec: # display_name: deep-learning # language: python diff --git a/dl/notebooks/ts_dl_utils/embedding/__init__.py b/dl/notebooks/ts_dl_utils/embedding/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/poetry.lock b/poetry.lock index 7658484b..25c9a20e 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand. +# This file is automatically @generated by Poetry 2.1.2 and should not be changed by hand. [[package]] name = "absl-py" @@ -6,6 +6,7 @@ version = "2.0.0" description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py." optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "absl-py-2.0.0.tar.gz", hash = "sha256:d9690211c5fcfefcdd1a45470ac2b5c5acd45241c3af71eed96bc5441746c0d5"}, {file = "absl_py-2.0.0-py3-none-any.whl", hash = "sha256:9a28abb62774ae4e8edbe2dd4c49ffcd45a6a848952a5eccc6a49f3f0fc1e2f3"}, @@ -17,6 +18,7 @@ version = "0.2.4" description = "The Dag IO Framework for Fugue projects" optional = false python-versions = ">=3.6" +groups = ["darts", "nixtla"] files = [ {file = "adagio-0.2.4-py3-none-any.whl", hash = "sha256:c6c4d812f629fc3141284a0b3cfe483731b28da3a1b18f3d5498695ff87dcc12"}, {file = "adagio-0.2.4.tar.gz", hash = "sha256:e58abc4539184a65faf9956957d3787616bedeb1303ac5c9b1a201d8af6b87d7"}, @@ -31,6 +33,7 @@ version = "3.8.4" description = "Async http client/server framework (asyncio)" optional = false python-versions = ">=3.6" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "aiohttp-3.8.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5ce45967538fb747370308d3145aa68a074bdecb4f3a300869590f725ced69c1"}, {file = "aiohttp-3.8.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b744c33b6f14ca26b7544e8d8aadff6b765a80ad6164fb1a430bbadd593dfb1a"}, @@ -131,7 +134,7 @@ multidict = ">=4.5,<7.0" yarl = ">=1.0,<2.0" [package.extras] -speedups = ["Brotli", "aiodns", "cchardet"] +speedups = ["Brotli", "aiodns", "cchardet ; python_version < \"3.10\""] [[package]] name = "aiosignal" @@ -139,6 +142,7 @@ version = "1.3.1" description = "aiosignal: a list of registered asynchronous callbacks" optional = false python-versions = ">=3.7" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, @@ -153,6 +157,7 @@ version = "1.13.2" description = "A database migration tool for SQLAlchemy." optional = false python-versions = ">=3.8" +groups = ["nixtla"] files = [ {file = "alembic-1.13.2-py3-none-any.whl", hash = "sha256:6b8733129a6224a9a711e17c99b08462dbf7cc9670ba8f2e2ae9af860ceb1953"}, {file = "alembic-1.13.2.tar.gz", hash = "sha256:1ff0ae32975f4fd96028c39ed9bb3c867fe3af956bd7bb37343b54c9fe7445ef"}, @@ -164,7 +169,7 @@ SQLAlchemy = ">=1.3.0" typing-extensions = ">=4" [package.extras] -tz = ["backports.zoneinfo"] +tz = ["backports.zoneinfo ; python_version < \"3.9\""] [[package]] name = "appdirs" @@ -172,6 +177,7 @@ version = "1.4.4" description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." optional = false python-versions = "*" +groups = ["darts", "nixtla"] files = [ {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"}, {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"}, @@ -183,6 +189,8 @@ version = "0.1.3" description = "Disable App Nap on macOS >= 10.9" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] +markers = "platform_system == \"Darwin\" or sys_platform == \"darwin\"" files = [ {file = "appnope-0.1.3-py2.py3-none-any.whl", hash = "sha256:265a455292d0bd8a72453494fa24df5a11eb18373a60c7c0430889f22548605e"}, {file = "appnope-0.1.3.tar.gz", hash = "sha256:02bd91c4de869fbb1e1c50aafc4098827a7a54ab2f39d9dcba6c9547ed920e24"}, @@ -194,6 +202,7 @@ version = "2.2.1" description = "Annotate AST trees with source code positions" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "asttokens-2.2.1-py2.py3-none-any.whl", hash = "sha256:6b0ac9e93fb0335014d382b8fa9b3afa7df546984258005da0b9e7095b3deb1c"}, {file = "asttokens-2.2.1.tar.gz", hash = "sha256:4622110b2a6f30b77e1473affaa97e711bc2f07d3f10848420ff1898edbe94f3"}, @@ -211,6 +220,7 @@ version = "4.0.2" description = "Timeout context manager for asyncio programs" optional = false python-versions = ">=3.6" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "async-timeout-4.0.2.tar.gz", hash = "sha256:2163e1640ddb52b7a8c80d0a67a08587e5d245cc9c553a74a847056bc2976b15"}, {file = "async_timeout-4.0.2-py3-none-any.whl", hash = "sha256:8ca1e4fcf50d07413d66d1a5e416e42cfdf5851c981d679a09851a6853383b3c"}, @@ -222,6 +232,7 @@ version = "23.1.0" description = "Classes Without Boilerplate" optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "nixtla", "notebook", "torch"] files = [ {file = "attrs-23.1.0-py3-none-any.whl", hash = "sha256:1f28b4522cdc2fb4256ac1a020c78acf9cba2c6b461ccd2c126f3aa8e8335d04"}, {file = "attrs-23.1.0.tar.gz", hash = "sha256:6279836d581513a26f1bf235f9acd333bc9115683f14f7e8fae46c98fc50e015"}, @@ -232,7 +243,7 @@ cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] dev = ["attrs[docs,tests]", "pre-commit"] docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] tests = ["attrs[tests-no-zope]", "zope-interface"] -tests-no-zope = ["cloudpickle", "hypothesis", "mypy (>=1.1.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +tests-no-zope = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.1.1) ; platform_python_implementation == \"CPython\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version < \"3.11\"", "pytest-xdist[psutil]"] [[package]] name = "babel" @@ -240,6 +251,7 @@ version = "2.13.0" description = "Internationalization utilities" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "Babel-2.13.0-py3-none-any.whl", hash = "sha256:fbfcae1575ff78e26c7449136f1abbefc3c13ce542eeb13d43d50d8b047216ec"}, {file = "Babel-2.13.0.tar.gz", hash = "sha256:04c3e2d28d2b7681644508f836be388ae49e0cfe91465095340395b60d00f210"}, @@ -254,6 +266,7 @@ version = "0.2.0" description = "Specifications for callback functions passed in to an API" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, @@ -265,6 +278,7 @@ version = "4.12.2" description = "Screen-scraping library" optional = false python-versions = ">=3.6.0" +groups = ["main"] files = [ {file = "beautifulsoup4-4.12.2-py3-none-any.whl", hash = "sha256:bd2520ca0d9d7d12694a53d44ac482d181b4ec1888909b035a3dbf40d0f57d4a"}, {file = "beautifulsoup4-4.12.2.tar.gz", hash = "sha256:492bbc69dca35d12daac71c4db1bfff0c876c00ef4a2ffacce226d4638eb72da"}, @@ -283,6 +297,7 @@ version = "6.0.0" description = "An easy safelist-based HTML-sanitizing tool." optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "bleach-6.0.0-py3-none-any.whl", hash = "sha256:33c16e3353dbd13028ab4799a0f89a83f113405c766e9c122df8a06f5b85b3f4"}, {file = "bleach-6.0.0.tar.gz", hash = "sha256:1a1a85c1595e07d8db14c5f09f09e6433502c51c595970edc090551f0db99414"}, @@ -301,6 +316,8 @@ version = "1.0.9" description = "Python bindings for the Brotli compression library" optional = false python-versions = "*" +groups = ["main"] +markers = "platform_python_implementation == \"CPython\"" files = [ {file = "Brotli-1.0.9-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:268fe94547ba25b58ebc724680609c8ee3e5a843202e9a381f6f9c5e8bdb5c70"}, {file = "Brotli-1.0.9-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:c2415d9d082152460f2bd4e382a1e85aed233abc92db5a3880da2257dc7daf7b"}, @@ -392,6 +409,8 @@ version = "1.0.9.2" description = "Python CFFI bindings to the Brotli library" optional = false python-versions = "*" +groups = ["main"] +markers = "platform_python_implementation != \"CPython\"" files = [ {file = "brotlicffi-1.0.9.2-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:408ec4359f9763280d5c4e0ad29c51d1240b25fdd18719067e972163b4125b98"}, {file = "brotlicffi-1.0.9.2-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:2e4629f7690ded66c8818715c6d4dd6a7ff6a4f10fad6186fe99850f781ce210"}, @@ -434,6 +453,7 @@ version = "5.3.2" description = "Extensible memoizing collections and decorators" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "cachetools-5.3.2-py3-none-any.whl", hash = "sha256:861f35a13a451f94e301ce2bec7cac63e881232ccce7ed67fab9b5df4d3beaa1"}, {file = "cachetools-5.3.2.tar.gz", hash = "sha256:086ee420196f7b2ab9ca2db2520aca326318b68fe5ba8bc4d49cca91add450f2"}, @@ -445,6 +465,7 @@ version = "2023.5.7" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "certifi-2023.5.7-py3-none-any.whl", hash = "sha256:c6c2e98f5c7869efca1f8916fed228dd91539f9f1b444c314c06eef02980c716"}, {file = "certifi-2023.5.7.tar.gz", hash = "sha256:0f0d56dc5a6ad56fd4ba36484d6cc34451e1c6548c61daad8c320169f91eddc7"}, @@ -456,6 +477,7 @@ version = "1.15.1" description = "Foreign Function Interface for Python calling C code." optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "cffi-1.15.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a66d3508133af6e8548451b25058d5812812ec3798c886bf38ed24a98216fab2"}, {file = "cffi-1.15.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:470c103ae716238bbe698d67ad020e1db9d9dba34fa5a899b5e21577e6d52ed2"}, @@ -522,6 +544,7 @@ files = [ {file = "cffi-1.15.1-cp39-cp39-win_amd64.whl", hash = "sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c"}, {file = "cffi-1.15.1.tar.gz", hash = "sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9"}, ] +markers = {notebook = "implementation_name == \"pypy\"", torch = "implementation_name == \"pypy\""} [package.dependencies] pycparser = "*" @@ -532,6 +555,7 @@ version = "3.1.0" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7.0" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"}, {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"}, @@ -616,6 +640,7 @@ version = "8.1.3" description = "Composable command line interface toolkit" optional = false python-versions = ">=3.7" +groups = ["main", "data", "nixtla"] files = [ {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"}, {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"}, @@ -630,6 +655,7 @@ version = "0.16.0" description = "pathlib-style classes for cloud storage services." optional = false python-versions = ">=3.7" +groups = ["data"] files = [ {file = "cloudpathlib-0.16.0-py3-none-any.whl", hash = "sha256:f46267556bf91f03db52b5df7a152548596a15aabca1c8731ef32b0b25a1a6a3"}, {file = "cloudpathlib-0.16.0.tar.gz", hash = "sha256:cdfcd35d46d529587d744154a0bdf962aca953b725c8784cd2ec478354ea63a3"}, @@ -650,6 +676,7 @@ version = "2.2.1" description = "Extended pickling support for Python objects" optional = false python-versions = ">=3.6" +groups = ["darts", "nixtla"] files = [ {file = "cloudpickle-2.2.1-py3-none-any.whl", hash = "sha256:61f594d1f4c295fa5cd9014ceb3a1fc4a70b0de1164b94fbc2d854ccba056f9f"}, {file = "cloudpickle-2.2.1.tar.gz", hash = "sha256:d89684b8de9e34a2a43b3460fbca07d09d6e25ce858df4d5a44240403b6178f5"}, @@ -661,10 +688,12 @@ version = "0.4.6" description = "Cross-platform colored terminal text." optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +groups = ["main", "darts", "data", "huggingface", "nixtla", "notebook", "torch"] files = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +markers = {darts = "platform_system == \"Windows\"", data = "platform_system == \"Windows\" or sys_platform == \"win32\"", huggingface = "platform_system == \"Windows\"", nixtla = "platform_system == \"Windows\" or sys_platform == \"win32\"", notebook = "sys_platform == \"win32\"", torch = "sys_platform == \"win32\" or platform_system == \"Windows\""} [[package]] name = "colorlog" @@ -672,6 +701,7 @@ version = "6.8.2" description = "Add colours to the output of Python's logging module." optional = false python-versions = ">=3.6" +groups = ["nixtla"] files = [ {file = "colorlog-6.8.2-py3-none-any.whl", hash = "sha256:4dcbb62368e2800cb3c5abd348da7e53f6c362dda502ec27c560b2e58a66bd33"}, {file = "colorlog-6.8.2.tar.gz", hash = "sha256:3e3e079a41feb5a1b64f978b5ea4f46040a94f11f0e8bbb8261e3dbbeca64d44"}, @@ -689,6 +719,7 @@ version = "0.1.3" description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." optional = false python-versions = ">=3.6" +groups = ["main", "notebook", "torch"] files = [ {file = "comm-0.1.3-py3-none-any.whl", hash = "sha256:16613c6211e20223f215fc6d3b266a247b6e2641bf4e0a3ad34cb1aff2aa3f37"}, {file = "comm-0.1.3.tar.gz", hash = "sha256:a61efa9daffcfbe66fd643ba966f846a624e4e6d6767eda9cf6e993aadaab93e"}, @@ -708,6 +739,7 @@ version = "1.0.7" description = "Python library for calculating contours of 2D quadrilateral grids" optional = false python-versions = ">=3.8" +groups = ["darts", "torch", "visualization"] files = [ {file = "contourpy-1.0.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:95c3acddf921944f241b6773b767f1cbce71d03307270e2d769fd584d5d1092d"}, {file = "contourpy-1.0.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fc1464c97579da9f3ab16763c32e5c5d5bb5fa1ec7ce509a4ca6108b61b84fab"}, @@ -782,6 +814,7 @@ version = "0.0.12" description = "Fast implementations of common forecasting routines" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "coreforecast-0.0.12-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:51a13bb737e06276b79a6e70016b9361b69859cc7020ea779116ba6bcd72c2d5"}, {file = "coreforecast-0.0.12-py3-none-macosx_11_0_arm64.whl", hash = "sha256:761a73c0c15df7008852f55cae6f0001e069447ee28b7d1f1fe14825497a91d1"}, @@ -800,6 +833,7 @@ version = "0.7.0" description = "CSS selectors for Python ElementTree" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "cssselect2-0.7.0-py3-none-any.whl", hash = "sha256:fd23a65bfd444595913f02fc71f6b286c29261e354c41d722ca7a261a49b5969"}, {file = "cssselect2-0.7.0.tar.gz", hash = "sha256:1ccd984dab89fc68955043aca4e1b03e0cf29cad9880f6e28e3ba7a74b14aa5a"}, @@ -819,6 +853,7 @@ version = "0.11.0" description = "Composable style cycles" optional = false python-versions = ">=3.6" +groups = ["darts", "torch", "visualization"] files = [ {file = "cycler-0.11.0-py3-none-any.whl", hash = "sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3"}, {file = "cycler-0.11.0.tar.gz", hash = "sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f"}, @@ -830,6 +865,7 @@ version = "0.29.34" description = "The Cython compiler for writing C extensions for the Python language." optional = false python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +groups = ["darts"] files = [ {file = "Cython-0.29.34-cp27-cp27m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:742544024ddb74314e2d597accdb747ed76bd126e61fcf49940a5b5be0a8f381"}, {file = "Cython-0.29.34-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:03daae07f8cbf797506446adae512c3dd86e7f27a62a541fa1ee254baf43e32c"}, @@ -879,6 +915,7 @@ version = "0.26.0" description = "A python library for easy manipulation and forecasting of time series." optional = false python-versions = ">=3.8" +groups = ["darts"] files = [ {file = "darts-0.26.0-py3-none-any.whl", hash = "sha256:7bbf93fa4294cee0f31b27d2ba48d5e744cac4e43f499238f269adc0f84b2d76"}, {file = "darts-0.26.0.tar.gz", hash = "sha256:c18f24906d94a1751c95f4b62954833e7f403c77a93907c6fceda3b5b9061a29"}, @@ -914,6 +951,7 @@ version = "0.0.8" description = "Datasets for Time series forecasting" optional = false python-versions = ">=3.7" +groups = ["nixtla"] files = [ {file = "datasetsforecast-0.0.8-py3-none-any.whl", hash = "sha256:54bf52903227ea93867fbfe06aaea57e24d5978338718a4f6a95c3be6b0170fd"}, {file = "datasetsforecast-0.0.8.tar.gz", hash = "sha256:41b8970d1443403e68d08b58d043c1308705bd115e3799a7df085cc6c5ec2814"}, @@ -938,6 +976,7 @@ version = "1.6.7" description = "An implementation of the Debug Adapter Protocol for Python" optional = false python-versions = ">=3.7" +groups = ["main", "notebook", "torch"] files = [ {file = "debugpy-1.6.7-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:b3e7ac809b991006ad7f857f016fa92014445085711ef111fdc3f74f66144096"}, {file = "debugpy-1.6.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3876611d114a18aafef6383695dfc3f1217c98a9168c1aaf1a02b01ec7d8d1e"}, @@ -965,6 +1004,7 @@ version = "5.1.1" description = "Decorators for Humans" optional = false python-versions = ">=3.5" +groups = ["main", "notebook", "torch"] files = [ {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, @@ -976,6 +1016,7 @@ version = "0.7.1" description = "XML bomb protection for Python stdlib modules" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +groups = ["main"] files = [ {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, @@ -987,6 +1028,7 @@ version = "2.3.12" description = "Distance measures for time series (Dynamic Time Warping, fast C implementation)" optional = false python-versions = ">=3.5" +groups = ["main"] files = [ {file = "dtaidistance-2.3.12-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c11618383363d9625f2ae08a40658589023c088d558ec9d25f103d077c53f1a6"}, {file = "dtaidistance-2.3.12-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:d61cdc5656be065ddbc2bab502ac2125a8c931ec076693d4986fecb46bf720b7"}, @@ -1024,6 +1066,7 @@ version = "0.2.1" description = "Time seRies plAYground (eerily) is a playground for time series" optional = false python-versions = "*" +groups = ["data"] files = [ {file = "eerily-0.2.1.tar.gz", hash = "sha256:e10af5ea76ee1ae2c0b649dd564bfab00c3e56162345290b406cd1949b8d8913"}, ] @@ -1053,13 +1096,29 @@ version = "1.2.0" description = "Get the currently executing AST node of a frame, and other information" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "executing-1.2.0-py2.py3-none-any.whl", hash = "sha256:0314a69e37426e3608aada02473b4161d4caf5a4b244d1d0c48072b8fee7bacc"}, {file = "executing-1.2.0.tar.gz", hash = "sha256:19da64c18d2d851112f09c287f8d3dbbdf725ab0e569077efb6cdcbd3497c107"}, ] [package.extras] -tests = ["asttokens", "littleutils", "pytest", "rich"] +tests = ["asttokens", "littleutils", "pytest", "rich ; python_version >= \"3.11\""] + +[[package]] +name = "faiss-gpu" +version = "1.7.2" +description = "A library for efficient similarity search and clustering of dense vectors." +optional = false +python-versions = "*" +groups = ["main"] +files = [ + {file = "faiss_gpu-1.7.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c98abc1aac06cb4cb94de223b3186bd4a60d15fd3cae42271604168abc081ca5"}, + {file = "faiss_gpu-1.7.2-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38796433b2fe43f3a602be18668969af615a3a898e897366e6997b409b0deeab"}, + {file = "faiss_gpu-1.7.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040a413be699077931b781e470468c6b5084342c5d5773ce8d916f04b25d8c9c"}, + {file = "faiss_gpu-1.7.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e85a6bc975b2f233eb056584f33bbce8613c453c9024c099052a423eebabee23"}, + {file = "faiss_gpu-1.7.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ca9bfa2fda868f438a2f05c1d5aed53021bfaa55b25fd3ae666d2da201f3caf"}, +] [[package]] name = "fastjsonschema" @@ -1067,6 +1126,7 @@ version = "2.17.1" description = "Fastest Python implementation of JSON schema" optional = false python-versions = "*" +groups = ["main", "notebook"] files = [ {file = "fastjsonschema-2.17.1-py3-none-any.whl", hash = "sha256:4b90b252628ca695280924d863fe37234eebadc29c5360d322571233dc9746e0"}, {file = "fastjsonschema-2.17.1.tar.gz", hash = "sha256:f4eeb8a77cef54861dbf7424ac8ce71306f12cbb086c45131bcba2c6a4f726e3"}, @@ -1081,6 +1141,7 @@ version = "3.12.0" description = "A platform independent file lock." optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "filelock-3.12.0-py3-none-any.whl", hash = "sha256:ad98852315c2ab702aeb628412cbf7e95b7ce8c3bf9565670b4eaecf1db370a9"}, {file = "filelock-3.12.0.tar.gz", hash = "sha256:fc03ae43288c013d2ea83c8597001b1129db351aad9c57fe2409327916b8e718"}, @@ -1096,6 +1157,7 @@ version = "4.39.4" description = "Tools to manipulate font files" optional = false python-versions = ">=3.8" +groups = ["main", "darts", "torch", "visualization"] files = [ {file = "fonttools-4.39.4-py3-none-any.whl", hash = "sha256:106caf6167c4597556b31a8d9175a3fdc0356fdcd70ab19973c3b0d4c893c461"}, {file = "fonttools-4.39.4.zip", hash = "sha256:dba8d7cdb8e2bac1b3da28c5ed5960de09e59a2fe7e63bb73f5a59e57b0430d2"}, @@ -1107,18 +1169,18 @@ brotlicffi = {version = ">=0.8.0", optional = true, markers = "platform_python_i zopfli = {version = ">=0.1.4", optional = true, markers = "extra == \"woff\""} [package.extras] -all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0,<5)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.0.0)", "xattr", "zopfli (>=0.1.4)"] +all = ["brotli (>=1.0.1) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\"", "fs (>=2.2.0,<3)", "lxml (>=4.0,<5)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres ; platform_python_implementation == \"PyPy\"", "scipy ; platform_python_implementation != \"PyPy\"", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.0.0) ; python_version <= \"3.11\"", "xattr ; sys_platform == \"darwin\"", "zopfli (>=0.1.4)"] graphite = ["lz4 (>=1.7.4.2)"] -interpolatable = ["munkres", "scipy"] +interpolatable = ["munkres ; platform_python_implementation == \"PyPy\"", "scipy ; platform_python_implementation != \"PyPy\""] lxml = ["lxml (>=4.0,<5)"] pathops = ["skia-pathops (>=0.5.0)"] plot = ["matplotlib"] repacker = ["uharfbuzz (>=0.23.0)"] symfont = ["sympy"] -type1 = ["xattr"] +type1 = ["xattr ; sys_platform == \"darwin\""] ufo = ["fs (>=2.2.0,<3)"] -unicode = ["unicodedata2 (>=15.0.0)"] -woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] +unicode = ["unicodedata2 (>=15.0.0) ; python_version <= \"3.11\""] +woff = ["brotli (>=1.0.1) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\"", "zopfli (>=0.1.4)"] [[package]] name = "frozenlist" @@ -1126,6 +1188,7 @@ version = "1.3.3" description = "A list-like structure which implements collections.abc.MutableSequence" optional = false python-versions = ">=3.7" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "frozenlist-1.3.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff8bf625fe85e119553b5383ba0fb6aa3d0ec2ae980295aaefa552374926b3f4"}, {file = "frozenlist-1.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dfbac4c2dfcc082fcf8d942d1e49b6aa0766c19d3358bd86e2000bf0fa4a9cf0"}, @@ -1209,6 +1272,7 @@ version = "2.4.16" description = "Python's filesystem abstraction layer" optional = false python-versions = "*" +groups = ["darts", "nixtla"] files = [ {file = "fs-2.4.16-py2.py3-none-any.whl", hash = "sha256:660064febbccda264ae0b6bace80a8d1be9e089e0a5eb2427b7d517f9a91545c"}, {file = "fs-2.4.16.tar.gz", hash = "sha256:ae97c7d51213f4b70b6a958292530289090de3a7e15841e108fbe144f069d313"}, @@ -1220,7 +1284,7 @@ setuptools = "*" six = ">=1.10,<2.0" [package.extras] -scandir = ["scandir (>=1.5,<2.0)"] +scandir = ["scandir (>=1.5,<2.0) ; python_version < \"3.5\""] [[package]] name = "fsspec" @@ -1228,6 +1292,7 @@ version = "2023.5.0" description = "File-system specification" optional = false python-versions = ">=3.8" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "fsspec-2023.5.0-py3-none-any.whl", hash = "sha256:51a4ad01a5bb66fcc58036e288c0d53d3975a0df2a5dc59a93b59bade0391f2a"}, {file = "fsspec-2023.5.0.tar.gz", hash = "sha256:b3b56e00fb93ea321bc9e5d9cf6f8522a0198b20eb24e02774d329e9c6fb84ce"}, @@ -1267,6 +1332,7 @@ version = "0.9.1" description = "An abstraction layer for distributed computation" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "fugue-0.9.1-py3-none-any.whl", hash = "sha256:5b91e55e6f243af6e2b901dc37914d954d8f0231627b68007850879f8848a3a3"}, {file = "fugue-0.9.1.tar.gz", hash = "sha256:fb0f9a4780147ac8438be96efc50593e2d771d1cbf528ac56d3bcecd39915b50"}, @@ -1279,7 +1345,7 @@ triad = ">=0.9.7" [package.extras] all = ["dask-sql", "dask[dataframe,distributed] (>=2023.5.0)", "duckdb (>=0.5.0)", "fugue-sql-antlr (>=0.2.0)", "ibis-framework", "ipython (>=7.10.0)", "jinja2", "jupyterlab", "notebook", "pandas (>=2.0.2,<2.2)", "polars", "pyarrow (>=6.0.1)", "pyspark (>=3.1.1)", "qpd (>=0.4.4)", "ray[data] (>=2.5.0)", "sqlglot"] cpp-sql-parser = ["fugue-sql-antlr[cpp] (>=0.2.0)"] -dask = ["dask[dataframe,distributed] (>=2023.5.0)", "dask[dataframe,distributed] (>=2024.4.0)", "pandas (>=2.0.2)", "pyarrow (>=7.0.0)"] +dask = ["dask[dataframe,distributed] (>=2023.5.0)", "dask[dataframe,distributed] (>=2024.4.0) ; python_version >= \"3.11.9\"", "pandas (>=2.0.2)", "pyarrow (>=7.0.0)"] duckdb = ["duckdb (>=0.5.0)", "fugue-sql-antlr (>=0.2.0)", "jinja2", "numpy", "qpd (>=0.4.4)", "sqlglot"] ibis = ["fugue-sql-antlr (>=0.2.0)", "ibis-framework", "jinja2", "pandas (<2.2)", "qpd (>=0.4.4)", "sqlglot"] notebook = ["ipython (>=7.10.0)", "jupyterlab", "notebook"] @@ -1294,6 +1360,7 @@ version = "2.1.0" description = "Copy your docs directly to the gh-pages branch." optional = false python-versions = "*" +groups = ["main"] files = [ {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, @@ -1311,6 +1378,7 @@ version = "2.23.4" description = "Google Authentication Library" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "google-auth-2.23.4.tar.gz", hash = "sha256:79905d6b1652187def79d491d6e23d0cbb3a21d3c7ba0dbaa9c8a01906b13ff3"}, {file = "google_auth-2.23.4-py2.py3-none-any.whl", hash = "sha256:d4bbc92fe4b8bfd2f3e8d88e5ba7085935da208ee38a134fc280e7ce682a05f2"}, @@ -1334,6 +1402,7 @@ version = "1.1.0" description = "Google Authentication Library" optional = false python-versions = ">=3.6" +groups = ["torch"] files = [ {file = "google-auth-oauthlib-1.1.0.tar.gz", hash = "sha256:83ea8c3b0881e453790baff4448e8a6112ac8778d1de9da0b68010b843937afb"}, {file = "google_auth_oauthlib-1.1.0-py2.py3-none-any.whl", hash = "sha256:089c6e587d36f4803ac7e0720c045c6a8b1fd1790088b8424975b90d0ee61c12"}, @@ -1352,6 +1421,8 @@ version = "3.0.3" description = "Lightweight in-process concurrent programming" optional = false python-versions = ">=3.7" +groups = ["nixtla"] +markers = "platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\"" files = [ {file = "greenlet-3.0.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9da2bd29ed9e4f15955dd1595ad7bc9320308a3b766ef7f837e23ad4b4aac31a"}, {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d353cadd6083fdb056bb46ed07e4340b0869c305c8ca54ef9da3421acbdf6881"}, @@ -1423,6 +1494,7 @@ version = "1.59.3" description = "HTTP/2-based RPC framework" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "grpcio-1.59.3-cp310-cp310-linux_armv7l.whl", hash = "sha256:aca028a6c7806e5b61e5f9f4232432c52856f7fcb98e330b20b6bc95d657bdcc"}, {file = "grpcio-1.59.3-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:19ad26a7967f7999c8960d2b9fe382dae74c55b0c508c613a6c2ba21cddf2354"}, @@ -1489,6 +1561,7 @@ version = "0.25" description = "Generate and work with holidays in Python" optional = false python-versions = ">=3.7" +groups = ["darts"] files = [ {file = "holidays-0.25-py3-none-any.whl", hash = "sha256:ad9b31e5175b4c5b601e06793633c2b0fff53179cf56ad4de1aea463c3f2679c"}, {file = "holidays-0.25.tar.gz", hash = "sha256:64d85ae60dd05715cdf3483e60ece93ae254e4f4fac23f1f83c6b0f04ae35508"}, @@ -1504,6 +1577,7 @@ version = "1.1" description = "HTML parser based on the WHATWG HTML specification" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +groups = ["main"] files = [ {file = "html5lib-1.1-py2.py3-none-any.whl", hash = "sha256:0d78f8fde1c230e99fe37986a60526d7049ed4bf8a9fadbad5f00e22e58e041d"}, {file = "html5lib-1.1.tar.gz", hash = "sha256:b2e5b40261e20f354d198eae92afc10d750afb487ed5e50f9c4eaf07c184146f"}, @@ -1514,10 +1588,10 @@ six = ">=1.9" webencodings = "*" [package.extras] -all = ["chardet (>=2.2)", "genshi", "lxml"] +all = ["chardet (>=2.2)", "genshi", "lxml ; platform_python_implementation == \"CPython\""] chardet = ["chardet (>=2.2)"] genshi = ["genshi"] -lxml = ["lxml"] +lxml = ["lxml ; platform_python_implementation == \"CPython\""] [[package]] name = "huggingface-hub" @@ -1525,6 +1599,7 @@ version = "0.24.6" description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub" optional = false python-versions = ">=3.8.0" +groups = ["huggingface"] files = [ {file = "huggingface_hub-0.24.6-py3-none-any.whl", hash = "sha256:a990f3232aa985fe749bc9474060cbad75e8b2f115f6665a9fda5b9c97818970"}, {file = "huggingface_hub-0.24.6.tar.gz", hash = "sha256:cc2579e761d070713eaa9c323e3debe39d5b464ae3a7261c39a9195b27bb8000"}, @@ -1559,6 +1634,7 @@ version = "3.4" description = "Internationalized Domain Names in Applications (IDNA)" optional = false python-versions = ">=3.5" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"}, {file = "idna-3.4.tar.gz", hash = "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4"}, @@ -1570,6 +1646,7 @@ version = "6.23.1" description = "IPython Kernel for Jupyter" optional = false python-versions = ">=3.8" +groups = ["main", "notebook", "torch"] files = [ {file = "ipykernel-6.23.1-py3-none-any.whl", hash = "sha256:77aeffab056c21d16f1edccdc9e5ccbf7d96eb401bd6703610a21be8b068aadc"}, {file = "ipykernel-6.23.1.tar.gz", hash = "sha256:1aba0ae8453e15e9bc6b24e497ef6840114afcdb832ae597f32137fa19d42a6f"}, @@ -1603,6 +1680,7 @@ version = "8.13.2" description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.9" +groups = ["main", "notebook", "torch"] files = [ {file = "ipython-8.13.2-py3-none-any.whl", hash = "sha256:ffca270240fbd21b06b2974e14a86494d6d29290184e788275f55e0b55914926"}, {file = "ipython-8.13.2.tar.gz", hash = "sha256:7dff3fad32b97f6488e02f87b970f309d082f758d7b7fc252e3b19ee0e432dbb"}, @@ -1641,6 +1719,7 @@ version = "8.1.1" description = "Jupyter interactive widgets" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "ipywidgets-8.1.1-py3-none-any.whl", hash = "sha256:2b88d728656aea3bbfd05d32c747cfd0078f9d7e159cf982433b58ad717eed7f"}, {file = "ipywidgets-8.1.1.tar.gz", hash = "sha256:40211efb556adec6fa450ccc2a77d59ca44a060f4f9f136833df59c9f538e6e8"}, @@ -1662,6 +1741,7 @@ version = "0.18.2" description = "An autocompletion tool for Python that can be used for text editors." optional = false python-versions = ">=3.6" +groups = ["main", "notebook", "torch"] files = [ {file = "jedi-0.18.2-py2.py3-none-any.whl", hash = "sha256:203c1fd9d969ab8f2119ec0a3342e0b49910045abe6af0a3ae83a5764d54639e"}, {file = "jedi-0.18.2.tar.gz", hash = "sha256:bae794c30d07f6d910d32a7048af09b5a39ed740918da923c6b780790ebac612"}, @@ -1681,6 +1761,7 @@ version = "3.1.2" description = "A very fast and expressive template engine." optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "nixtla", "torch"] files = [ {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"}, {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"}, @@ -1698,6 +1779,7 @@ version = "1.2.0" description = "Lightweight pipelining with Python functions" optional = false python-versions = ">=3.7" +groups = ["main", "darts", "nixtla", "torch", "visualization"] files = [ {file = "joblib-1.2.0-py3-none-any.whl", hash = "sha256:091138ed78f800342968c523bdde947e7a305b8594b910a0fea2ab83c3c6d385"}, {file = "joblib-1.2.0.tar.gz", hash = "sha256:e1cee4a79e4af22881164f218d4311f60074197fb707e082e803b61f6d137018"}, @@ -1709,6 +1791,7 @@ version = "4.17.3" description = "An implementation of JSON Schema validation for Python" optional = false python-versions = ">=3.7" +groups = ["main", "nixtla", "notebook"] files = [ {file = "jsonschema-4.17.3-py3-none-any.whl", hash = "sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6"}, {file = "jsonschema-4.17.3.tar.gz", hash = "sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d"}, @@ -1728,6 +1811,7 @@ version = "8.2.0" description = "Jupyter protocol implementation and client libraries" optional = false python-versions = ">=3.8" +groups = ["main", "notebook", "torch"] files = [ {file = "jupyter_client-8.2.0-py3-none-any.whl", hash = "sha256:b18219aa695d39e2ad570533e0d71fb7881d35a873051054a84ee2a17c4b7389"}, {file = "jupyter_client-8.2.0.tar.gz", hash = "sha256:9fe233834edd0e6c0aa5f05ca2ab4bdea1842bfd2d8a932878212fc5301ddaf0"}, @@ -1742,7 +1826,7 @@ traitlets = ">=5.3" [package.extras] docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko ; sys_platform == \"win32\"", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] [[package]] name = "jupyter-core" @@ -1750,6 +1834,7 @@ version = "5.3.0" description = "Jupyter core package. A base package on which Jupyter projects rely." optional = false python-versions = ">=3.8" +groups = ["main", "notebook", "torch"] files = [ {file = "jupyter_core-5.3.0-py3-none-any.whl", hash = "sha256:d4201af84559bc8c70cead287e1ab94aeef3c512848dde077b7684b54d67730d"}, {file = "jupyter_core-5.3.0.tar.gz", hash = "sha256:6db75be0c83edbf1b7c9f91ec266a9a24ef945da630f3120e1a0046dc13713fc"}, @@ -1770,6 +1855,7 @@ version = "0.2.2" description = "Pygments theme using JupyterLab CSS variables" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "jupyterlab_pygments-0.2.2-py2.py3-none-any.whl", hash = "sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f"}, {file = "jupyterlab_pygments-0.2.2.tar.gz", hash = "sha256:7405d7fde60819d905a9fa8ce89e4cd830e318cdad22a0030f7a901da705585d"}, @@ -1781,6 +1867,7 @@ version = "3.0.9" description = "Jupyter interactive widgets for JupyterLab" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "jupyterlab_widgets-3.0.9-py3-none-any.whl", hash = "sha256:3cf5bdf5b897bf3bccf1c11873aa4afd776d7430200f765e0686bd352487b58d"}, {file = "jupyterlab_widgets-3.0.9.tar.gz", hash = "sha256:6005a4e974c7beee84060fdfba341a3218495046de8ae3ec64888e5fe19fdb4c"}, @@ -1792,6 +1879,7 @@ version = "1.15.2" description = "Jupyter notebooks as Markdown documents, Julia, Python or R scripts" optional = false python-versions = "~=3.6" +groups = ["main", "notebook"] files = [ {file = "jupytext-1.15.2-py3-none-any.whl", hash = "sha256:ef2a1a3eb8f63d84a3b3772014bdfbe238e4e12a30c4309b8c89e0a54adeb7d1"}, {file = "jupytext-1.15.2.tar.gz", hash = "sha256:c9976e24d834e991906c1de55af4b6d512d764f6372aabae45fc1ea72b589173"}, @@ -1814,6 +1902,7 @@ version = "1.4.4" description = "A fast implementation of the Cassowary constraint solver" optional = false python-versions = ">=3.7" +groups = ["darts", "torch", "visualization"] files = [ {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2f5e60fabb7343a836360c4f0919b8cd0d6dbf08ad2ca6b9cf90bf0c76a3c4f6"}, {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:10ee06759482c78bdb864f4109886dff7b8a56529bc1609d4f1112b93fe6423c"}, @@ -1891,6 +1980,7 @@ version = "0.3.1" description = "Korean Lunar Calendar" optional = false python-versions = "*" +groups = ["darts"] files = [ {file = "korean_lunar_calendar-0.3.1-py3-none-any.whl", hash = "sha256:392757135c492c4f42a604e6038042953c35c6f449dda5f27e3f86a7f9c943e5"}, {file = "korean_lunar_calendar-0.3.1.tar.gz", hash = "sha256:eb2c485124a061016926bdea6d89efdf9b9fdbf16db55895b6cf1e5bec17b857"}, @@ -1902,6 +1992,7 @@ version = "2.0.1" description = "A lexer and codec to work with LaTeX code in Python." optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["main"] files = [ {file = "latexcodec-2.0.1-py2.py3-none-any.whl", hash = "sha256:c277a193638dc7683c4c30f6684e3db728a06efb0dc9cf346db8bd0aa6c5d271"}, {file = "latexcodec-2.0.1.tar.gz", hash = "sha256:2aa2551c373261cefe2ad3a8953a6d6533e68238d180eb4bb91d7964adb3fe9a"}, @@ -1916,6 +2007,7 @@ version = "0.22.0" description = "Sass for Python: A straightforward binding of libsass for Python." optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "libsass-0.22.0-cp36-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:f1efc1b612299c88aec9e39d6ca0c266d360daa5b19d9430bdeaffffa86993f9"}, {file = "libsass-0.22.0-cp37-abi3-macosx_10_15_x86_64.whl", hash = "sha256:081e256ab3c5f3f09c7b8dea3bf3bf5e64a97c6995fd9eea880639b3f93a9f9a"}, @@ -1931,6 +2023,7 @@ version = "2.1.2" description = "The Deep Learning framework to train, deploy, and ship AI products Lightning fast." optional = false python-versions = ">=3.8" +groups = ["data", "torch"] files = [ {file = "lightning-2.1.2-py3-none-any.whl", hash = "sha256:f23358dedd8f5f1151475c9d95f33e4529591c992a99cb9ae89c84bca7289525"}, {file = "lightning-2.1.2.tar.gz", hash = "sha256:3b2599a8a719916cb03526e6570356809729680c6cda09391232e2aba0a4ed4b"}, @@ -1949,7 +2042,7 @@ tqdm = ">=4.57.0,<6.0" typing-extensions = ">=4.0.0,<6.0" [package.extras] -all = ["Jinja2 (<4.0)", "Pillow (>=9.5.0)", "PyYAML (<7.0)", "aiohttp (>=3.8.0,<4.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "bitsandbytes (<1.0)", "click (<9.0)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "deepspeed (>=0.8.2,<=0.9.3)", "docker (>=5.0.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "fsspec[http] (>2021.06.0,<2024.0)", "gym[classic-control] (>=0.17.0,<1.0)", "hydra-core (>=1.0.5,<2.0)", "inquirer (>=2.10.0,<4.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-api-access (>=0.0.3)", "lightning-cloud (==0.5.52)", "lightning-fabric (>=1.9.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "python-multipart (>=0.0.5,<1.0)", "pytorch-lightning (>=1.9.0)", "redis (>=4.0.1,<6.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "tensorboardX (>=2.2,<3.0)", "torch (>0.14.0,<3.0)", "torchdata (>0.5.9,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "torchvision (>=0.15.2,<1.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] +all = ["Jinja2 (<4.0)", "Pillow (>=9.5.0)", "PyYAML (<7.0)", "aiohttp (>=3.8.0,<4.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "bitsandbytes (<1.0)", "click (<9.0)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\"", "docker (>=5.0.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "fsspec[http] (>2021.06.0,<2024.0)", "gym[classic-control] (>=0.17.0,<1.0)", "hydra-core (>=1.0.5,<2.0)", "inquirer (>=2.10.0,<4.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-api-access (>=0.0.3)", "lightning-cloud (==0.5.52)", "lightning-fabric (>=1.9.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "python-multipart (>=0.0.5,<1.0)", "pytorch-lightning (>=1.9.0)", "redis (>=4.0.1,<6.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "tensorboardX (>=2.2,<3.0)", "torch (>0.14.0,<3.0)", "torchdata (>0.5.9,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "torchvision (>=0.15.2,<1.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] app = ["Jinja2 (<4.0)", "PyYAML (<7.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "click (<9.0)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "inquirer (>=2.10.0,<4.0)", "lightning-cloud (==0.5.52)", "lightning-utilities (>=0.8.0,<1.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "python-multipart (>=0.0.5,<1.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] app-all = ["Jinja2 (<4.0)", "PyYAML (<7.0)", "aiohttp (>=3.8.0,<4.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "click (<9.0)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "docker (>=5.0.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "inquirer (>=2.10.0,<4.0)", "lightning-api-access (>=0.0.3)", "lightning-cloud (==0.5.52)", "lightning-fabric (>=1.9.0)", "lightning-utilities (>=0.8.0,<1.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "python-multipart (>=0.0.5,<1.0)", "pytorch-lightning (>=1.9.0)", "redis (>=4.0.1,<6.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] app-cloud = ["docker (>=5.0.0,<7.0)", "redis (>=4.0.1,<6.0)", "s3fs (>=2022.5.0,<2024.0)"] @@ -1965,23 +2058,23 @@ data-cloud = ["fsspec[http] (>2021.06.0,<2024.0)", "s3fs (>=2022.5.0,<2024.0)"] data-dev = ["Jinja2 (<4.0)", "Pillow (>=9.5.0)", "PyYAML (<7.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "click (<9.0)", "coverage (==7.3.1)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "fsspec[http] (>2021.06.0,<2024.0)", "inquirer (>=2.10.0,<4.0)", "lightning-cloud (==0.5.52)", "lightning-utilities (>=0.8.0,<1.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "python-multipart (>=0.0.5,<1.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "torch (>0.14.0,<3.0)", "torchdata (>0.5.9,<1.0)", "torchvision (>=0.15.2,<1.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] data-examples = ["Pillow (>=9.5.0)", "torchvision (>=0.15.2,<1.0)"] data-test = ["coverage (==7.3.1)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)"] -dev = ["Jinja2 (<4.0)", "Pillow (>=9.5.0)", "PyYAML (<7.0)", "aiohttp (>=3.8.0,<4.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "bitsandbytes (<1.0)", "click (<9.0)", "click (==8.1.7)", "cloudpickle (>=1.3,<3.0)", "coverage (==7.3.1)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "deepspeed (>=0.8.2,<=0.9.3)", "docker (>=5.0.0,<7.0)", "fastapi", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "fsspec[http] (>2021.06.0,<2024.0)", "gym[classic-control] (>=0.17.0,<1.0)", "httpx (==0.25.0)", "hydra-core (>=1.0.5,<2.0)", "inquirer (>=2.10.0,<4.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-api-access (>=0.0.3)", "lightning-cloud (==0.5.52)", "lightning-fabric (>=1.9.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "onnx (>=0.14.0,<2.0)", "onnxruntime (>=0.15.0,<2.0)", "packaging", "pandas", "pandas (>1.0,<3.0)", "playwright (==1.38.0)", "psutil (<6.0)", "pydantic (>=1.7.4)", "pympler", "pytest (==7.4.0)", "pytest-asyncio (==0.21.1)", "pytest-cov (==4.1.0)", "pytest-doctestplus (==0.9.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "pytest-xdist (==3.3.1)", "python-multipart (>=0.0.5,<1.0)", "pytorch-lightning (>=1.9.0)", "redis (>=4.0.1,<6.0)", "requests (<3.0)", "requests-mock (==1.11.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "scikit-learn (>0.22.1,<2.0)", "setuptools (<69.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "tensorboard (>=2.9.1,<3.0)", "tensorboardX (>=2.2,<3.0)", "torch (>0.14.0,<3.0)", "torchdata (>0.5.9,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchmetrics (>=0.7.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "torchvision (>=0.15.2,<1.0)", "traitlets (>=5.3.0,<6.0)", "trio (<0.22.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] +dev = ["Jinja2 (<4.0)", "Pillow (>=9.5.0)", "PyYAML (<7.0)", "aiohttp (>=3.8.0,<4.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "bitsandbytes (<1.0)", "click (<9.0)", "click (==8.1.7)", "cloudpickle (>=1.3,<3.0)", "coverage (==7.3.1)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\"", "docker (>=5.0.0,<7.0)", "fastapi", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "fsspec[http] (>2021.06.0,<2024.0)", "gym[classic-control] (>=0.17.0,<1.0)", "httpx (==0.25.0)", "hydra-core (>=1.0.5,<2.0)", "inquirer (>=2.10.0,<4.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-api-access (>=0.0.3)", "lightning-cloud (==0.5.52)", "lightning-fabric (>=1.9.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "onnx (>=0.14.0,<2.0)", "onnxruntime (>=0.15.0,<2.0)", "packaging", "pandas", "pandas (>1.0,<3.0)", "playwright (==1.38.0)", "psutil (<6.0)", "pydantic (>=1.7.4)", "pympler", "pytest (==7.4.0)", "pytest-asyncio (==0.21.1)", "pytest-cov (==4.1.0)", "pytest-doctestplus (==0.9.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "pytest-xdist (==3.3.1)", "python-multipart (>=0.0.5,<1.0)", "pytorch-lightning (>=1.9.0)", "redis (>=4.0.1,<6.0)", "requests (<3.0)", "requests-mock (==1.11.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "scikit-learn (>0.22.1,<2.0)", "setuptools (<69.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "tensorboard (>=2.9.1,<3.0)", "tensorboardX (>=2.2,<3.0)", "torch (>0.14.0,<3.0)", "torchdata (>0.5.9,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchmetrics (>=0.7.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "torchvision (>=0.15.2,<1.0)", "traitlets (>=5.3.0,<6.0)", "trio (<0.22.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] examples = ["Pillow (>=9.5.0)", "gym[classic-control] (>=0.17.0,<1.0)", "ipython[all] (<9.0)", "lightning-utilities (>=0.8.0,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "torchvision (>=0.15.2,<1.0)"] extra = ["Jinja2 (<4.0)", "PyYAML (<7.0)", "aiohttp (>=3.8.0,<4.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "bitsandbytes (<1.0)", "click (<9.0)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "docker (>=5.0.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "hydra-core (>=1.0.5,<2.0)", "inquirer (>=2.10.0,<4.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-api-access (>=0.0.3)", "lightning-cloud (==0.5.52)", "lightning-fabric (>=1.9.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "python-multipart (>=0.0.5,<1.0)", "pytorch-lightning (>=1.9.0)", "redis (>=4.0.1,<6.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "s3fs (>=2022.5.0,<2024.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "tensorboardX (>=2.2,<3.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] -fabric-all = ["deepspeed (>=0.8.2,<=0.9.3)", "lightning-utilities (>=0.8.0,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] -fabric-dev = ["click (==8.1.7)", "coverage (==7.3.1)", "deepspeed (>=0.8.2,<=0.9.3)", "lightning-utilities (>=0.8.0,<1.0)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.10.0,<2.0)", "torchmetrics (>=0.7.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] +fabric-all = ["deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\"", "lightning-utilities (>=0.8.0,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] +fabric-dev = ["click (==8.1.7)", "coverage (==7.3.1)", "deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\"", "lightning-utilities (>=0.8.0,<1.0)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.10.0,<2.0)", "torchmetrics (>=0.7.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] fabric-examples = ["lightning-utilities (>=0.8.0,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] -fabric-strategies = ["deepspeed (>=0.8.2,<=0.9.3)"] +fabric-strategies = ["deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\""] fabric-test = ["click (==8.1.7)", "coverage (==7.3.1)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.7.0,<2.0)"] -pytorch-all = ["bitsandbytes (<1.0)", "deepspeed (>=0.8.2,<=0.9.3)", "gym[classic-control] (>=0.17.0,<1.0)", "hydra-core (>=1.0.5,<2.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "rich (>=12.3.0,<14.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] -pytorch-dev = ["bitsandbytes (<1.0)", "cloudpickle (>=1.3,<3.0)", "coverage (==7.3.1)", "deepspeed (>=0.8.2,<=0.9.3)", "fastapi", "gym[classic-control] (>=0.17.0,<1.0)", "hydra-core (>=1.0.5,<2.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "onnx (>=0.14.0,<2.0)", "onnxruntime (>=0.15.0,<2.0)", "pandas (>1.0,<3.0)", "psutil (<6.0)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "rich (>=12.3.0,<14.0)", "scikit-learn (>0.22.1,<2.0)", "tensorboard (>=2.9.1,<3.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "uvicorn"] +pytorch-all = ["bitsandbytes (<1.0)", "deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\"", "gym[classic-control] (>=0.17.0,<1.0)", "hydra-core (>=1.0.5,<2.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "rich (>=12.3.0,<14.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] +pytorch-dev = ["bitsandbytes (<1.0)", "cloudpickle (>=1.3,<3.0)", "coverage (==7.3.1)", "deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\"", "fastapi", "gym[classic-control] (>=0.17.0,<1.0)", "hydra-core (>=1.0.5,<2.0)", "ipython[all] (<9.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "lightning-utilities (>=0.8.0,<1.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "onnx (>=0.14.0,<2.0)", "onnxruntime (>=0.15.0,<2.0)", "pandas (>1.0,<3.0)", "psutil (<6.0)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "rich (>=12.3.0,<14.0)", "scikit-learn (>0.22.1,<2.0)", "tensorboard (>=2.9.1,<3.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)", "uvicorn"] pytorch-examples = ["gym[classic-control] (>=0.17.0,<1.0)", "ipython[all] (<9.0)", "lightning-utilities (>=0.8.0,<1.0)", "torchmetrics (>=0.10.0,<2.0)", "torchvision (>=0.13.0,<1.0)"] pytorch-extra = ["bitsandbytes (<1.0)", "hydra-core (>=1.0.5,<2.0)", "jsonargparse[signatures] (>=4.18.0,<5.0)", "matplotlib (>3.1,<4.0)", "omegaconf (>=2.0.5,<3.0)", "rich (>=12.3.0,<14.0)", "tensorboardX (>=2.2,<3.0)"] -pytorch-strategies = ["deepspeed (>=0.8.2,<=0.9.3)"] +pytorch-strategies = ["deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\""] pytorch-test = ["cloudpickle (>=1.3,<3.0)", "coverage (==7.3.1)", "fastapi", "onnx (>=0.14.0,<2.0)", "onnxruntime (>=0.15.0,<2.0)", "pandas (>1.0,<3.0)", "psutil (<6.0)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "scikit-learn (>0.22.1,<2.0)", "tensorboard (>=2.9.1,<3.0)", "uvicorn"] store = ["Jinja2 (<4.0)", "PyYAML (<7.0)", "arrow (>=1.2.0,<2.0)", "backoff (>=2.2.1,<3.0)", "beautifulsoup4 (>=4.8.0,<5.0)", "click (<9.0)", "croniter (>=1.3.0,<1.5.0)", "dateutils (<1.0)", "deepdiff (>=5.7.0,<7.0)", "fastapi (>=0.92.0,<1.0)", "fsspec (>=2022.5.0,<2024.0)", "inquirer (>=2.10.0,<4.0)", "lightning-cloud (==0.5.52)", "lightning-utilities (>=0.8.0,<1.0)", "packaging", "psutil (<6.0)", "pydantic (>=1.7.4)", "python-multipart (>=0.0.5,<1.0)", "requests (<3.0)", "rich (>=12.3.0,<14.0)", "starlette", "starsessions (>=1.2.1,<2.0)", "traitlets (>=5.3.0,<6.0)", "typing-extensions (>=4.0.0,<5.0)", "urllib3 (<3.0)", "uvicorn (<1.0)", "websocket-client (<2.0)", "websockets (<12.0)"] store-test = ["coverage (==7.3.1)", "pytest (==7.4.0)", "pytest-cov (==4.1.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)"] -strategies = ["deepspeed (>=0.8.2,<=0.9.3)"] +strategies = ["deepspeed (>=0.8.2,<=0.9.3) ; platform_system != \"Windows\""] test = ["click (==8.1.7)", "cloudpickle (>=1.3,<3.0)", "coverage (==7.3.1)", "fastapi", "httpx (==0.25.0)", "onnx (>=0.14.0,<2.0)", "onnxruntime (>=0.15.0,<2.0)", "pandas", "pandas (>1.0,<3.0)", "playwright (==1.38.0)", "psutil (<6.0)", "pympler", "pytest (==7.4.0)", "pytest-asyncio (==0.21.1)", "pytest-cov (==4.1.0)", "pytest-doctestplus (==0.9.0)", "pytest-random-order (==1.1.0)", "pytest-rerunfailures (==12.0)", "pytest-timeout (==2.1.0)", "pytest-xdist (==3.3.1)", "requests-mock (==1.11.0)", "scikit-learn (>0.22.1,<2.0)", "setuptools (<69.0)", "tensorboard (>=2.9.1,<3.0)", "tensorboardX (>=2.2,<3.0)", "torchmetrics (>=0.7.0,<2.0)", "trio (<0.22.0)", "uvicorn"] [[package]] @@ -1990,6 +2083,7 @@ version = "0.8.0" description = "PyTorch Lightning Sample project." optional = false python-versions = ">=3.7" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "lightning-utilities-0.8.0.tar.gz", hash = "sha256:8e5d95c7c57f026cdfed7c154303e88c93a7a5e868c9944cb02cf71f1db29720"}, {file = "lightning_utilities-0.8.0-py3-none-any.whl", hash = "sha256:22aa107b51c8f50ccef54d08885eb370903eb04148cddb2891b9c65c59de2a6e"}, @@ -2011,6 +2105,7 @@ version = "0.40.0" description = "lightweight wrapper around basic LLVM functionality" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "llvmlite-0.40.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90a46db1ed219d93ef05245ec17cf243074ec2b2687209cb310a803a2c2510dc"}, {file = "llvmlite-0.40.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b9d742b66023298532d0e7beddd3d9f04334c046df7a02a1ec2ba8b4046a978c"}, @@ -2044,6 +2139,7 @@ version = "0.7.2" description = "Python logging made (stupidly) simple" optional = false python-versions = ">=3.5" +groups = ["main", "data"] files = [ {file = "loguru-0.7.2-py3-none-any.whl", hash = "sha256:003d71e3d3ed35f0f8984898359d65b79e5b21943f78af86aa5491210429b8eb"}, {file = "loguru-0.7.2.tar.gz", hash = "sha256:e671a53522515f34fd406340ee968cb9ecafbc4b36c679da03c18fd8d0bd51ac"}, @@ -2054,7 +2150,7 @@ colorama = {version = ">=0.3.4", markers = "sys_platform == \"win32\""} win32-setctime = {version = ">=1.0.0", markers = "sys_platform == \"win32\""} [package.extras] -dev = ["Sphinx (==7.2.5)", "colorama (==0.4.5)", "colorama (==0.4.6)", "exceptiongroup (==1.1.3)", "freezegun (==1.1.0)", "freezegun (==1.2.2)", "mypy (==v0.910)", "mypy (==v0.971)", "mypy (==v1.4.1)", "mypy (==v1.5.1)", "pre-commit (==3.4.0)", "pytest (==6.1.2)", "pytest (==7.4.0)", "pytest-cov (==2.12.1)", "pytest-cov (==4.1.0)", "pytest-mypy-plugins (==1.9.3)", "pytest-mypy-plugins (==3.0.0)", "sphinx-autobuild (==2021.3.14)", "sphinx-rtd-theme (==1.3.0)", "tox (==3.27.1)", "tox (==4.11.0)"] +dev = ["Sphinx (==7.2.5) ; python_version >= \"3.9\"", "colorama (==0.4.5) ; python_version < \"3.8\"", "colorama (==0.4.6) ; python_version >= \"3.8\"", "exceptiongroup (==1.1.3) ; python_version >= \"3.7\" and python_version < \"3.11\"", "freezegun (==1.1.0) ; python_version < \"3.8\"", "freezegun (==1.2.2) ; python_version >= \"3.8\"", "mypy (==v0.910) ; python_version < \"3.6\"", "mypy (==v0.971) ; python_version == \"3.6\"", "mypy (==v1.4.1) ; python_version == \"3.7\"", "mypy (==v1.5.1) ; python_version >= \"3.8\"", "pre-commit (==3.4.0) ; python_version >= \"3.8\"", "pytest (==6.1.2) ; python_version < \"3.8\"", "pytest (==7.4.0) ; python_version >= \"3.8\"", "pytest-cov (==2.12.1) ; python_version < \"3.8\"", "pytest-cov (==4.1.0) ; python_version >= \"3.8\"", "pytest-mypy-plugins (==1.9.3) ; python_version >= \"3.6\" and python_version < \"3.8\"", "pytest-mypy-plugins (==3.0.0) ; python_version >= \"3.8\"", "sphinx-autobuild (==2021.3.14) ; python_version >= \"3.9\"", "sphinx-rtd-theme (==1.3.0) ; python_version >= \"3.9\"", "tox (==3.27.1) ; python_version < \"3.8\"", "tox (==4.11.0) ; python_version >= \"3.8\""] [[package]] name = "mako" @@ -2062,6 +2158,7 @@ version = "1.3.5" description = "A super-fast templating language that borrows the best ideas from the existing templating languages." optional = false python-versions = ">=3.8" +groups = ["nixtla"] files = [ {file = "Mako-1.3.5-py3-none-any.whl", hash = "sha256:260f1dbc3a519453a9c856dedfe4beb4e50bd5a26d96386cb6c80856556bb91a"}, {file = "Mako-1.3.5.tar.gz", hash = "sha256:48dbc20568c1d276a2698b36d968fa76161bf127194907ea6fc594fa81f943bc"}, @@ -2081,6 +2178,7 @@ version = "3.3.7" description = "Python implementation of Markdown." optional = false python-versions = ">=3.6" +groups = ["main", "torch"] files = [ {file = "Markdown-3.3.7-py3-none-any.whl", hash = "sha256:f5da449a6e1c989a4cea2631aa8ee67caa5a2ef855d551c88f9e309f4634c621"}, {file = "Markdown-3.3.7.tar.gz", hash = "sha256:cbb516f16218e643d8e0a95b309f77eb118cb138d39a4f27851e6a63581db874"}, @@ -2095,6 +2193,7 @@ version = "2.2.0" description = "Python port of markdown-it. Markdown parsing, done right!" optional = false python-versions = ">=3.7" +groups = ["main", "notebook"] files = [ {file = "markdown-it-py-2.2.0.tar.gz", hash = "sha256:7c9a5e412688bc771c67432cbfebcdd686c93ce6484913dccf06cb5a0bea35a1"}, {file = "markdown_it_py-2.2.0-py3-none-any.whl", hash = "sha256:5a35f8d1870171d9acc47b99612dc146129b631baf04970128b568f190d0cc30"}, @@ -2119,6 +2218,7 @@ version = "2.1.2" description = "Safely add untrusted strings to HTML/XML markup." optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "nixtla", "torch"] files = [ {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:665a36ae6f8f20a4676b53224e33d456a6f5a72657d9c83c2aa00765072f31f7"}, {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:340bea174e9761308703ae988e982005aedf427de816d1afe98147668cc03036"}, @@ -2178,6 +2278,7 @@ version = "3.7.1" description = "Python plotting package" optional = false python-versions = ">=3.8" +groups = ["darts", "torch", "visualization"] files = [ {file = "matplotlib-3.7.1-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:95cbc13c1fc6844ab8812a525bbc237fa1470863ff3dace7352e910519e194b1"}, {file = "matplotlib-3.7.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:08308bae9e91aca1ec6fd6dda66237eef9f6294ddb17f0d0b3c863169bf82353"}, @@ -2239,6 +2340,7 @@ version = "0.1.6" description = "Inline Matplotlib backend for Jupyter" optional = false python-versions = ">=3.5" +groups = ["main", "notebook", "torch"] files = [ {file = "matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304"}, {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"}, @@ -2253,6 +2355,7 @@ version = "0.3.5" description = "Collection of plugins for markdown-it-py" optional = false python-versions = ">=3.7" +groups = ["main", "notebook"] files = [ {file = "mdit-py-plugins-0.3.5.tar.gz", hash = "sha256:eee0adc7195e5827e17e02d2a258a2ba159944a0748f59c5099a4a27f78fcf6a"}, {file = "mdit_py_plugins-0.3.5-py3-none-any.whl", hash = "sha256:ca9a0714ea59a24b2b044a1831f48d817dd0c817e84339f20e7889f392d77c4e"}, @@ -2272,6 +2375,7 @@ version = "0.1.2" description = "Markdown URL utilities" optional = false python-versions = ">=3.7" +groups = ["main", "notebook"] files = [ {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, @@ -2283,6 +2387,7 @@ version = "1.3.4" description = "A deep merge function for 🐍." optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307"}, {file = "mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8"}, @@ -2294,6 +2399,7 @@ version = "2.0.5" description = "A sane Markdown parser with useful plugins and renderers" optional = false python-versions = "*" +groups = ["main"] files = [ {file = "mistune-2.0.5-py2.py3-none-any.whl", hash = "sha256:bad7f5d431886fcbaf5f758118ecff70d31f75231b34024a1341120340a65ce8"}, {file = "mistune-2.0.5.tar.gz", hash = "sha256:0246113cb2492db875c6be56974a7c893333bf26cd92891c85f63151cee09d34"}, @@ -2305,6 +2411,7 @@ version = "1.5.3" description = "Project documentation with Markdown." optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "mkdocs-1.5.3-py3-none-any.whl", hash = "sha256:3b3a78e736b31158d64dbb2f8ba29bd46a379d0c6e324c2246c3bc3d2189cfc1"}, {file = "mkdocs-1.5.3.tar.gz", hash = "sha256:eb7c99214dcb945313ba30426c2451b735992c73c2e10838f76d09e39ff4d0e2"}, @@ -2327,7 +2434,7 @@ watchdog = ">=2.0" [package.extras] i18n = ["babel (>=2.9.0)"] -min-versions = ["babel (==2.9.0)", "click (==7.0)", "colorama (==0.4)", "ghp-import (==1.0)", "importlib-metadata (==4.3)", "jinja2 (==2.11.1)", "markdown (==3.2.1)", "markupsafe (==2.0.1)", "mergedeep (==1.3.4)", "packaging (==20.5)", "pathspec (==0.11.1)", "platformdirs (==2.2.0)", "pyyaml (==5.1)", "pyyaml-env-tag (==0.1)", "typing-extensions (==3.10)", "watchdog (==2.0)"] +min-versions = ["babel (==2.9.0)", "click (==7.0)", "colorama (==0.4) ; platform_system == \"Windows\"", "ghp-import (==1.0)", "importlib-metadata (==4.3) ; python_version < \"3.10\"", "jinja2 (==2.11.1)", "markdown (==3.2.1)", "markupsafe (==2.0.1)", "mergedeep (==1.3.4)", "packaging (==20.5)", "pathspec (==0.11.1)", "platformdirs (==2.2.0)", "pyyaml (==5.1)", "pyyaml-env-tag (==0.1)", "typing-extensions (==3.10) ; python_version < \"3.8\"", "watchdog (==2.0)"] [[package]] name = "mkdocs-autorefs" @@ -2335,6 +2442,7 @@ version = "0.5.0" description = "Automatically link across pages in MkDocs." optional = false python-versions = ">=3.8" +groups = ["main"] files = [ {file = "mkdocs_autorefs-0.5.0-py3-none-any.whl", hash = "sha256:7930fcb8ac1249f10e683967aeaddc0af49d90702af111a5e390e8b20b3d97ff"}, {file = "mkdocs_autorefs-0.5.0.tar.gz", hash = "sha256:9a5054a94c08d28855cfab967ada10ed5be76e2bfad642302a610b252c3274c0"}, @@ -2350,6 +2458,7 @@ version = "2.11.0" description = "An MkDocs plugin that enables managing citations with BibTex" optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "mkdocs-bibtex-2.11.0.tar.gz", hash = "sha256:9ed78e1e7cfc8cd6f3f5ca75641dbcea8a011c36dbefcde041e36f8e6d0ed10f"}, ] @@ -2367,6 +2476,7 @@ version = "0.6.5" description = "A mkdocs plugin that lets you exclude selected files or sections from the search index." optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "mkdocs-exclude-search-0.6.5.tar.gz", hash = "sha256:6a126367653caf946c56e446ff30ffdec931438a3e2a8740feff3f8682d52a54"}, {file = "mkdocs_exclude_search-0.6.5-py3-none-any.whl", hash = "sha256:475e372dd17195700acd00213bcc804280d63f39cb7a0c76a801aceefd2807a6"}, @@ -2381,6 +2491,7 @@ version = "0.7.2" description = "Mkdocs plugin to display git authors of a page" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "mkdocs-git-authors-plugin-0.7.2.tar.gz", hash = "sha256:f541730e4cabdafa0ac758c94d28ba5e8ddca4c859e5de4c89f1226cb6ccd0ad"}, {file = "mkdocs_git_authors_plugin-0.7.2-py3-none-any.whl", hash = "sha256:c8a2784a867db79ad3b477a96ee96875d17b09192b6d3be71f08df25afff76c4"}, @@ -2395,6 +2506,7 @@ version = "0.24.2" description = "Use Jupyter in mkdocs websites" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "mkdocs_jupyter-0.24.2-py3-none-any.whl", hash = "sha256:5295a34b1d0bd0a7688a857323eaf0319d83c8a14179b2651709b8ced6eae7db"}, {file = "mkdocs_jupyter-0.24.2.tar.gz", hash = "sha256:5e0c109d535d48797230719b6941f4d08de95a7a3c95bf158662c412fc15cb2e"}, @@ -2417,6 +2529,7 @@ version = "9.4.10" description = "Documentation that simply works" optional = false python-versions = ">=3.8" +groups = ["main"] files = [ {file = "mkdocs_material-9.4.10-py3-none-any.whl", hash = "sha256:207c4ebc07faebb220437d2c626edb0c9760c82ccfc484500bd3eb30dfce988c"}, {file = "mkdocs_material-9.4.10.tar.gz", hash = "sha256:421adedaeaa461dcaf55b8d406673934ade3d4f05ed9819e4cc7b4ee1d646a62"}, @@ -2446,6 +2559,7 @@ version = "1.3" description = "Extension pack for Python Markdown and MkDocs Material." optional = false python-versions = ">=3.8" +groups = ["main"] files = [ {file = "mkdocs_material_extensions-1.3-py3-none-any.whl", hash = "sha256:0297cc48ba68a9fdd1ef3780a3b41b534b0d0df1d1181a44676fda5f464eeadc"}, {file = "mkdocs_material_extensions-1.3.tar.gz", hash = "sha256:f0446091503acb110a7cab9349cbc90eeac51b58d1caa92a704a81ca1e24ddbd"}, @@ -2457,6 +2571,7 @@ version = "2.3.6" description = "MkDocs plugin that combines all pages into one, allowing for easy export to PDF and standalone HTML." optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "mkdocs-print-site-plugin-2.3.6.tar.gz", hash = "sha256:82e5cabcfb7fe3074daecea018f28ccb4bff086f965e3103fe91019a76752f22"}, {file = "mkdocs_print_site_plugin-2.3.6-py3-none-any.whl", hash = "sha256:01ccb1ceccc87f29e1612bebb77c3bf9980809fbce750fc2113f9d6acea589d4"}, @@ -2471,6 +2586,7 @@ version = "0.9.3" description = "Generate a single PDF file from MkDocs repository" optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "mkdocs-with-pdf-0.9.3.tar.gz", hash = "sha256:bda3375d7040d1b8871da17c6d71ea736bdca6c669608f28ed62771031d2e0c6"}, {file = "mkdocs_with_pdf-0.9.3-py3-none-any.whl", hash = "sha256:002d76417b5cc584effdfdb6ec8d073266a308a85680c430562e97f00b886e49"}, @@ -2488,6 +2604,7 @@ version = "0.23.0" description = "Automatic documentation from sources, for MkDocs." optional = false python-versions = ">=3.8" +groups = ["main"] files = [ {file = "mkdocstrings-0.23.0-py3-none-any.whl", hash = "sha256:051fa4014dfcd9ed90254ae91de2dbb4f24e166347dae7be9a997fe16316c65e"}, {file = "mkdocstrings-0.23.0.tar.gz", hash = "sha256:d9c6a37ffbe7c14a7a54ef1258c70b8d394e6a33a1c80832bce40b9567138d1c"}, @@ -2512,6 +2629,7 @@ version = "0.13.4" description = "Scalable machine learning based time series forecasting" optional = false python-versions = ">=3.8" +groups = ["nixtla"] files = [ {file = "mlforecast-0.13.4-py3-none-any.whl", hash = "sha256:a33be2671e3914f2271deb1a59ab8f50a8c02c617726fdc3232c4f38fdb4e992"}, {file = "mlforecast-0.13.4.tar.gz", hash = "sha256:ca55bd7ed1a167f7c6d23554816aa539e2f678a4758d11be7fad7a288f815ee6"}, @@ -2546,6 +2664,7 @@ version = "1.3.0" description = "Python library for arbitrary-precision floating-point arithmetic" optional = false python-versions = "*" +groups = ["main", "darts", "data", "nixtla", "torch"] files = [ {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, @@ -2554,7 +2673,7 @@ files = [ [package.extras] develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"] docs = ["sphinx"] -gmpy = ["gmpy2 (>=2.1.0a4)"] +gmpy = ["gmpy2 (>=2.1.0a4) ; platform_python_implementation != \"PyPy\""] tests = ["pytest (>=4.6)"] [[package]] @@ -2563,6 +2682,7 @@ version = "1.0.8" description = "MessagePack serializer" optional = false python-versions = ">=3.8" +groups = ["nixtla"] files = [ {file = "msgpack-1.0.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:505fe3d03856ac7d215dbe005414bc28505d26f0c128906037e66d98c4e95868"}, {file = "msgpack-1.0.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b7842518a63a9f17107eb176320960ec095a8ee3b4420b5f688e24bf50c53c"}, @@ -2628,6 +2748,7 @@ version = "6.0.5" description = "multidict implementation" optional = false python-versions = ">=3.7" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9"}, {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604"}, @@ -2727,6 +2848,7 @@ version = "1.40.0" description = "Extremely lightweight compatibility layer between dataframe libraries" optional = false python-versions = ">=3.8" +groups = ["visualization"] files = [ {file = "narwhals-1.40.0-py3-none-any.whl", hash = "sha256:1e6c731811d01c61147c52433b4d4edfb6511aaf2c859aa01c2e8ca6ff4d27e5"}, {file = "narwhals-1.40.0.tar.gz", hash = "sha256:17064abffd264ea1cfe6aefc8a0080f3a4ffb3659a98bcad5456ca80b88f2a0a"}, @@ -2751,6 +2873,7 @@ version = "0.8.0" description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." optional = false python-versions = ">=3.8.0" +groups = ["main"] files = [ {file = "nbclient-0.8.0-py3-none-any.whl", hash = "sha256:25e861299e5303a0477568557c4045eccc7a34c17fc08e7959558707b9ebe548"}, {file = "nbclient-0.8.0.tar.gz", hash = "sha256:f9b179cd4b2d7bca965f900a2ebf0db4a12ebff2f36a711cb66861e4ae158e55"}, @@ -2773,6 +2896,7 @@ version = "7.4.0" description = "Converting Jupyter Notebooks" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "nbconvert-7.4.0-py3-none-any.whl", hash = "sha256:af5064a9db524f9f12f4e8be7f0799524bd5b14c1adea37e34e83c95127cc818"}, {file = "nbconvert-7.4.0.tar.gz", hash = "sha256:51b6c77b507b177b73f6729dba15676e42c4e92bcb00edc8cc982ee72e7d89d7"}, @@ -2810,6 +2934,7 @@ version = "5.8.0" description = "The Jupyter Notebook format" optional = false python-versions = ">=3.7" +groups = ["main", "notebook"] files = [ {file = "nbformat-5.8.0-py3-none-any.whl", hash = "sha256:d910082bd3e0bffcf07eabf3683ed7dda0727a326c446eeb2922abe102e65162"}, {file = "nbformat-5.8.0.tar.gz", hash = "sha256:46dac64c781f1c34dfd8acba16547024110348f9fc7eab0f31981c2a3dc48d1f"}, @@ -2831,6 +2956,7 @@ version = "1.5.6" description = "Patch asyncio to allow nested event loops" optional = false python-versions = ">=3.5" +groups = ["main", "notebook", "torch"] files = [ {file = "nest_asyncio-1.5.6-py3-none-any.whl", hash = "sha256:b9a953fb40dceaa587d109609098db21900182b16440652454a146cffb06e8b8"}, {file = "nest_asyncio-1.5.6.tar.gz", hash = "sha256:d267cc1ff794403f7df692964d1d2a3fa9418ffea2a3f6859a439ff482fef290"}, @@ -2842,6 +2968,7 @@ version = "3.1" description = "Python package for creating and manipulating graphs and networks" optional = false python-versions = ">=3.8" +groups = ["main", "darts", "data", "nixtla", "torch"] files = [ {file = "networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36"}, {file = "networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61"}, @@ -2860,6 +2987,7 @@ version = "1.7.4" description = "Time series forecasting suite using deep learning models" optional = false python-versions = ">=3.8" +groups = ["nixtla"] files = [ {file = "neuralforecast-1.7.4-py3-none-any.whl", hash = "sha256:106ad71cb00b6462e28350391d2809e2cd1089f7d8b1cfab766e8ce2551894b7"}, {file = "neuralforecast-1.7.4.tar.gz", hash = "sha256:02b6f7bfc1c472ca603deeb65ce76063bcfc4e195eb6ff8b1c6b4076d1f903e5"}, @@ -2887,6 +3015,7 @@ version = "1.0.1" description = "Implementation of N4SID, Kalman filtering and state-space models" optional = false python-versions = ">=3.7" +groups = ["darts"] files = [ {file = "nfoursid-1.0.1-py3-none-any.whl", hash = "sha256:cd780c40a30ddf81c1d67014e6abd6626360334a65646e16dccd6e6831afc795"}, {file = "nfoursid-1.0.1.tar.gz", hash = "sha256:d481e8ad58f19eba4292498ea4fd1324572a31c776fe6cf2ca774ea42448c04b"}, @@ -2903,6 +3032,7 @@ version = "0.57.0" description = "compiling Python code using LLVM" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "numba-0.57.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2e2c14c411545e80bf0f1a33232fb0bd6aa3368f86e56eeffc7f6d3ac16ea3fd"}, {file = "numba-0.57.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6b3382c56d805ffcdc7b46eb69a906be733dd35b84be14abba8e5fd27d7916b2"}, @@ -2940,6 +3070,7 @@ version = "1.24.3" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.8" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch", "visualization"] files = [ {file = "numpy-1.24.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3c1104d3c036fb81ab923f507536daedc718d0ad5a8707c6061cdfd6d184e570"}, {file = "numpy-1.24.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:202de8f38fc4a45a3eea4b63e2f376e5f2dc64ef0fa692838e31a808520efaf7"}, @@ -2977,6 +3108,8 @@ version = "12.4.5.8" description = "CUBLAS native runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0f8aa1706812e00b9f19dfe0cdb3999b092ccb8ca168c0db5b8ea712456fd9b3"}, {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl", hash = "sha256:2fc8da60df463fdefa81e323eef2e36489e1c94335b5358bcb38360adf75ac9b"}, @@ -2989,6 +3122,8 @@ version = "12.4.127" description = "CUDA profiling tools runtime libs." optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:79279b35cf6f91da114182a5ce1864997fd52294a87a16179ce275773799458a"}, {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:9dec60f5ac126f7bb551c055072b69d85392b13311fcc1bcda2202d172df30fb"}, @@ -3001,6 +3136,8 @@ version = "12.4.127" description = "NVRTC native runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0eedf14185e04b76aa05b1fea04133e59f465b6f960c0cbf4e37c3cb6b0ea198"}, {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a178759ebb095827bd30ef56598ec182b85547f1508941a3d560eb7ea1fbf338"}, @@ -3013,6 +3150,8 @@ version = "12.4.127" description = "CUDA Runtime native Libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:961fe0e2e716a2a1d967aab7caee97512f71767f852f67432d572e36cb3a11f3"}, {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:64403288fa2136ee8e467cdc9c9427e0434110899d07c779f25b5c068934faa5"}, @@ -3025,6 +3164,8 @@ version = "9.1.0.70" description = "cuDNN runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f"}, {file = "nvidia_cudnn_cu12-9.1.0.70-py3-none-win_amd64.whl", hash = "sha256:6278562929433d68365a07a4a1546c237ba2849852c0d4b2262a486e805b977a"}, @@ -3039,6 +3180,8 @@ version = "11.2.1.3" description = "CUFFT native runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5dad8008fc7f92f5ddfa2101430917ce2ffacd86824914c82e28990ad7f00399"}, {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f083fc24912aa410be21fa16d157fed2055dab1cc4b6934a0e03cba69eb242b9"}, @@ -3054,6 +3197,8 @@ version = "10.3.5.147" description = "CURAND native runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1f173f09e3e3c76ab084aba0de819c49e56614feae5c12f69883f4ae9bb5fad9"}, {file = "nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a88f583d4e0bb643c49743469964103aa59f7f708d862c3ddb0fc07f851e3b8b"}, @@ -3066,6 +3211,8 @@ version = "11.6.1.9" description = "CUDA solver native runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d338f155f174f90724bbde3758b7ac375a70ce8e706d70b018dd3375545fc84e"}, {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl", hash = "sha256:19e33fa442bcfd085b3086c4ebf7e8debc07cfe01e11513cc6d332fd918ac260"}, @@ -3083,6 +3230,8 @@ version = "12.3.1.170" description = "CUSPARSE native runtime libraries" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_aarch64.whl", hash = "sha256:9d32f62896231ebe0480efd8a7f702e143c98cfaa0e8a76df3386c1ba2b54df3"}, {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ea4f11a2904e2a8dc4b1833cc1b5181cde564edd0d5cd33e3c168eff2d1863f1"}, @@ -3098,6 +3247,8 @@ version = "2.21.5" description = "NVIDIA Collective Communication Library (NCCL) Runtime" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_nccl_cu12-2.21.5-py3-none-manylinux2014_x86_64.whl", hash = "sha256:8579076d30a8c24988834445f8d633c697d42397e92ffc3f63fa26766d25e0a0"}, ] @@ -3108,6 +3259,8 @@ version = "12.4.127" description = "Nvidia JIT LTO Library" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4abe7fef64914ccfa909bc2ba39739670ecc9e820c83ccc7a6ed414122599b83"}, {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57"}, @@ -3120,6 +3273,8 @@ version = "12.4.127" description = "NVIDIA Tools Extension" optional = false python-versions = ">=3" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7959ad635db13edf4fc65c06a6e9f9e55fc2f92596db928d169c0bb031e88ef3"}, {file = "nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a"}, @@ -3132,6 +3287,7 @@ version = "3.2.2" description = "A generic, spec-compliant, thorough implementation of the OAuth request-signing logic" optional = false python-versions = ">=3.6" +groups = ["torch"] files = [ {file = "oauthlib-3.2.2-py3-none-any.whl", hash = "sha256:8139f29aac13e25d502680e9e19963e83f16838d48a0d71c287fe40e7067fbca"}, {file = "oauthlib-3.2.2.tar.gz", hash = "sha256:9859c40929662bec5d64f34d01c99e093149682a3f38915dc0655d5a633dd918"}, @@ -3148,6 +3304,7 @@ version = "1.0.2" description = "Extensible, parallel implementations of t-SNE" optional = false python-versions = ">=3.9" +groups = ["visualization"] files = [ {file = "openTSNE-1.0.2-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:c82a2c263e570c75256d58590f7c99273c8f8152fada2e3f36a3de92d165a483"}, {file = "openTSNE-1.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a7270156cbabc249301cd30f6010387f618295ca68c50913c98b9dad8d9c682"}, @@ -3179,6 +3336,7 @@ version = "4.0.0" description = "A hyperparameter optimization framework" optional = false python-versions = ">=3.7" +groups = ["nixtla"] files = [ {file = "optuna-4.0.0-py3-none-any.whl", hash = "sha256:a825c32d13f6085bcb2229b2724a5078f2e0f61a7533e800e580ce41a8c6c10d"}, {file = "optuna-4.0.0.tar.gz", hash = "sha256:844949f09e2a7353ab414e9cfd783cf0a647a65fc32a7236212ed6a37fe08973"}, @@ -3198,7 +3356,7 @@ benchmark = ["asv (>=0.5.0)", "botorch", "cma", "virtualenv"] checking = ["black", "blackdoc", "flake8", "isort", "mypy", "mypy-boto3-s3", "types-PyYAML", "types-redis", "types-setuptools", "types-tqdm", "typing-extensions (>=3.10.0.0)"] document = ["ase", "cmaes (>=0.10.0)", "fvcore", "kaleido", "lightgbm", "matplotlib (!=3.6.0)", "pandas", "pillow", "plotly (>=4.9.0)", "scikit-learn", "sphinx", "sphinx-copybutton", "sphinx-gallery", "sphinx-rtd-theme (>=1.2.0)", "torch", "torchvision"] optional = ["boto3", "cmaes (>=0.10.0)", "google-cloud-storage", "matplotlib (!=3.6.0)", "pandas", "plotly (>=4.9.0)", "redis", "scikit-learn (>=0.24.2)", "scipy", "torch"] -test = ["coverage", "fakeredis[lua]", "kaleido", "moto", "pytest", "scipy (>=1.9.2)", "torch"] +test = ["coverage", "fakeredis[lua]", "kaleido", "moto", "pytest", "scipy (>=1.9.2) ; python_version >= \"3.8\"", "torch"] [[package]] name = "packaging" @@ -3206,6 +3364,7 @@ version = "23.1" description = "Core utilities for Python packages" optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "huggingface", "nixtla", "notebook", "torch", "visualization"] files = [ {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"}, {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"}, @@ -3217,6 +3376,7 @@ version = "0.5.6" description = "Divides large result sets into pages for easier browsing" optional = false python-versions = "*" +groups = ["main"] files = [ {file = "paginate-0.5.6.tar.gz", hash = "sha256:5e6007b6a9398177a7e1648d04fdd9f8c9766a1a945bceac82f1929e8c78af2d"}, ] @@ -3227,6 +3387,7 @@ version = "2.2.2" description = "Powerful data structures for data analysis, time series, and statistics" optional = false python-versions = ">=3.9" +groups = ["darts", "data", "nixtla", "torch", "visualization"] files = [ {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"}, {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"}, @@ -3296,6 +3457,7 @@ version = "1.5.0" description = "Utilities for writing pandoc filters in python" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["main"] files = [ {file = "pandocfilters-1.5.0-py2.py3-none-any.whl", hash = "sha256:33aae3f25fd1a026079f5d27bdd52496f0e0803b3469282162bafdcbdf6ef14f"}, {file = "pandocfilters-1.5.0.tar.gz", hash = "sha256:0b679503337d233b4339a817bfc8c50064e2eff681314376a47cb582305a7a38"}, @@ -3307,6 +3469,7 @@ version = "0.8.3" description = "A Python Parser" optional = false python-versions = ">=3.6" +groups = ["main", "notebook", "torch"] files = [ {file = "parso-0.8.3-py2.py3-none-any.whl", hash = "sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75"}, {file = "parso-0.8.3.tar.gz", hash = "sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0"}, @@ -3322,6 +3485,7 @@ version = "0.2.1" description = "Bring colors to your terminal." optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["torch"] files = [ {file = "pastel-0.2.1-py2.py3-none-any.whl", hash = "sha256:4349225fcdf6c2bb34d483e523475de5bb04a5c10ef711263452cb37d7dd4364"}, {file = "pastel-0.2.1.tar.gz", hash = "sha256:e6581ac04e973cac858828c6202c1e1e81fee1dc7de7683f3e1ffe0bfd8a573d"}, @@ -3333,6 +3497,7 @@ version = "0.11.2" description = "Utility library for gitignore style pattern matching of file paths." optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "pathspec-0.11.2-py3-none-any.whl", hash = "sha256:1d6ed233af05e679efb96b1851550ea95bbb64b7c490b0f5aa52996c11e92a20"}, {file = "pathspec-0.11.2.tar.gz", hash = "sha256:e0d8d0ac2f12da61956eb2306b69f9469b42f4deb0f3cb6ed47b9cce9996ced3"}, @@ -3344,6 +3509,7 @@ version = "0.5.3" description = "A Python package for describing statistical models and for building design matrices." optional = false python-versions = "*" +groups = ["darts", "nixtla"] files = [ {file = "patsy-0.5.3-py2.py3-none-any.whl", hash = "sha256:7eb5349754ed6aa982af81f636479b1b8db9d5b1a6e957a6016ec0534b5c86b7"}, {file = "patsy-0.5.3.tar.gz", hash = "sha256:bdc18001875e319bc91c812c1eb6a10be4bb13cb81eb763f466179dca3b67277"}, @@ -3362,6 +3528,8 @@ version = "4.8.0" description = "Pexpect allows easy control of interactive console applications." optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] +markers = "sys_platform != \"win32\"" files = [ {file = "pexpect-4.8.0-py2.py3-none-any.whl", hash = "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937"}, {file = "pexpect-4.8.0.tar.gz", hash = "sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c"}, @@ -3376,6 +3544,7 @@ version = "0.7.5" description = "Tiny 'shelve'-like database with concurrency support" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, @@ -3387,6 +3556,7 @@ version = "9.5.0" description = "Python Imaging Library (Fork)" optional = false python-versions = ">=3.7" +groups = ["main", "darts", "torch", "visualization"] files = [ {file = "Pillow-9.5.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:ace6ca218308447b9077c14ea4ef381ba0b67ee78d64046b3f19cf4e1139ad16"}, {file = "Pillow-9.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3d403753c9d5adc04d4694d35cf0391f0f3d57c8e0030aac09d7678fa8030aa"}, @@ -3466,6 +3636,7 @@ version = "3.5.1" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." optional = false python-versions = ">=3.7" +groups = ["main", "notebook", "torch"] files = [ {file = "platformdirs-3.5.1-py3-none-any.whl", hash = "sha256:e2378146f1964972c03c085bb5662ae80b2b8c06226c54b2ff4aa9483e8a13a5"}, {file = "platformdirs-3.5.1.tar.gz", hash = "sha256:412dae91f52a6f84830f39a8078cecd0e866cb72294a5c66808e74d5e88d251f"}, @@ -3481,6 +3652,7 @@ version = "6.1.1" description = "An open-source interactive data visualization library for Python" optional = false python-versions = ">=3.8" +groups = ["visualization"] files = [ {file = "plotly-6.1.1-py3-none-any.whl", hash = "sha256:9cca7167406ebf7ff541422738402159ec3621a608ff7b3e2f025573a1c76225"}, {file = "plotly-6.1.1.tar.gz", hash = "sha256:84a4f3d36655f1328fa3155377c7e8a9533196697d5b79a4bc5e905bdd09a433"}, @@ -3501,6 +3673,7 @@ version = "2.0.3" description = "Python's forecast::auto.arima equivalent" optional = false python-versions = ">=3.7" +groups = ["darts"] files = [ {file = "pmdarima-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6091a48a9e7eb3e48fdcd748bb7bdfa90635cfde110c2a5fd1ebc0c30f6c8ef5"}, {file = "pmdarima-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a9da525af80651e9d44e71c7483052e6bc68eb741768a15fb0142dbffdf50f42"}, @@ -3546,6 +3719,7 @@ version = "0.10.0" description = "A task runner that works well with poetry." optional = false python-versions = ">=3.6,<4.0" +groups = ["torch"] files = [ {file = "poethepoet-0.10.0-py3-none-any.whl", hash = "sha256:6fb3021603d4421c6fcc40072bbcf150a6c52ef70ff4d3be089b8b04e015ef5a"}, {file = "poethepoet-0.10.0.tar.gz", hash = "sha256:70b97cb194b978dc464c70793e85e6f746cddf82b84a38bfb135946ad71ae19c"}, @@ -3561,6 +3735,7 @@ version = "3.0.38" description = "Library for building powerful interactive command lines in Python" optional = false python-versions = ">=3.7.0" +groups = ["main", "notebook", "torch"] files = [ {file = "prompt_toolkit-3.0.38-py3-none-any.whl", hash = "sha256:45ea77a2f7c60418850331366c81cf6b5b9cf4c7fd34616f733c5427e6abbb1f"}, {file = "prompt_toolkit-3.0.38.tar.gz", hash = "sha256:23ac5d50538a9a38c8bde05fecb47d0b403ecd0662857a86f886f798563d5b9b"}, @@ -3575,6 +3750,7 @@ version = "3.20.3" description = "Protocol Buffers" optional = false python-versions = ">=3.7" +groups = ["darts", "nixtla", "torch"] files = [ {file = "protobuf-3.20.3-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:f4bd856d702e5b0d96a00ec6b307b0f51c1982c2bf9c0052cf9019e9a544ba99"}, {file = "protobuf-3.20.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:9aae4406ea63d825636cc11ffb34ad3379335803216ee3a856787bcf5ccc751e"}, @@ -3606,6 +3782,7 @@ version = "5.9.5" description = "Cross-platform lib for process and system monitoring in Python." optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["main", "notebook", "torch"] files = [ {file = "psutil-5.9.5-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:be8929ce4313f9f8146caad4272f6abb8bf99fc6cf59344a3167ecd74f4f203f"}, {file = "psutil-5.9.5-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:ab8ed1a1d77c95453db1ae00a3f9c50227ebd955437bcf2a574ba8adbf6a74d5"}, @@ -3624,7 +3801,7 @@ files = [ ] [package.extras] -test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] +test = ["enum34 ; python_version <= \"3.4\"", "ipaddress ; python_version < \"3.0\"", "mock ; python_version < \"3.0\"", "pywin32 ; sys_platform == \"win32\"", "wmi ; sys_platform == \"win32\""] [[package]] name = "ptyprocess" @@ -3632,6 +3809,8 @@ version = "0.7.0" description = "Run a subprocess in a pseudo terminal" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] +markers = "sys_platform != \"win32\"" files = [ {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, @@ -3643,6 +3822,7 @@ version = "0.2.2" description = "Safely evaluate AST nodes without side effects" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, @@ -3657,6 +3837,7 @@ version = "12.0.0" description = "Python library for Apache Arrow" optional = false python-versions = ">=3.7" +groups = ["darts", "nixtla"] files = [ {file = "pyarrow-12.0.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:3b97649c8a9a09e1d8dc76513054f1331bd9ece78ee39365e6bf6bc7503c1e94"}, {file = "pyarrow-12.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bc4ea634dacb03936f50fcf59574a8e727f90c17c24527e488d8ceb52ae284de"}, @@ -3694,6 +3875,7 @@ version = "0.5.0" description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs (X.208)" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +groups = ["torch"] files = [ {file = "pyasn1-0.5.0-py2.py3-none-any.whl", hash = "sha256:87a2121042a1ac9358cabcaf1d07680ff97ee6404333bacca15f76aa8ad01a57"}, {file = "pyasn1-0.5.0.tar.gz", hash = "sha256:97b7290ca68e62a832558ec3976f15cbf911bf5d7c7039d8b861c2a0ece69fde"}, @@ -3705,6 +3887,7 @@ version = "0.3.0" description = "A collection of ASN.1-based protocols modules" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +groups = ["torch"] files = [ {file = "pyasn1_modules-0.3.0-py2.py3-none-any.whl", hash = "sha256:d3ccd6ed470d9ffbc716be08bd90efbd44d0734bc9303818f7336070984a162d"}, {file = "pyasn1_modules-0.3.0.tar.gz", hash = "sha256:5bd01446b736eb9d31512a30d46c1ac3395d676c6f3cafa4c03eb54b9925631c"}, @@ -3719,6 +3902,7 @@ version = "0.24.0" description = "A BibTeX-compatible bibliography processor in Python" optional = false python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*" +groups = ["main"] files = [ {file = "pybtex-0.24.0-py2.py3-none-any.whl", hash = "sha256:e1e0c8c69998452fea90e9179aa2a98ab103f3eed894405b7264e517cc2fcc0f"}, {file = "pybtex-0.24.0.tar.gz", hash = "sha256:818eae35b61733e5c007c3fcd2cfb75ed1bc8b4173c1f70b56cc4c0802d34755"}, @@ -3738,10 +3922,12 @@ version = "2.21" description = "C parser in Python" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["main", "notebook", "torch"] files = [ {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, ] +markers = {notebook = "implementation_name == \"pypy\"", torch = "implementation_name == \"pypy\""} [[package]] name = "pydantic" @@ -3749,6 +3935,7 @@ version = "1.10.17" description = "Data validation and settings management using python type hints" optional = false python-versions = ">=3.7" +groups = ["data"] files = [ {file = "pydantic-1.10.17-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0fa51175313cc30097660b10eec8ca55ed08bfa07acbfe02f7a42f6c242e9a4b"}, {file = "pydantic-1.10.17-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7e8988bb16988890c985bd2093df9dd731bfb9d5e0860db054c23034fab8f7a"}, @@ -3808,6 +3995,7 @@ version = "0.6.0" description = "A low-level PDF generator." optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "pydyf-0.6.0-py3-none-any.whl", hash = "sha256:291802bfb7f784134de27404eb592414b3c56a1290231fe6fb548a2559bc936a"}, {file = "pydyf-0.6.0.tar.gz", hash = "sha256:b44a38855d7e47b740b3cd31ab63a2f5b9b2793931d50b0ccaed3bb7b86912fc"}, @@ -3823,13 +4011,14 @@ version = "2.16.1" description = "Pygments is a syntax highlighting package written in Python." optional = false python-versions = ">=3.7" +groups = ["main", "notebook", "torch"] files = [ {file = "Pygments-2.16.1-py3-none-any.whl", hash = "sha256:13fc09fa63bc8d8671a6d247e1eb303c4b343eaee81d861f3404db2935653692"}, {file = "Pygments-2.16.1.tar.gz", hash = "sha256:1daff0494820c69bc8941e407aa20f577374ee88364ee10a98fdbe0aece96e29"}, ] [package.extras] -plugins = ["importlib-metadata"] +plugins = ["importlib-metadata ; python_version < \"3.8\""] [[package]] name = "pymdown-extensions" @@ -3837,6 +4026,7 @@ version = "10.3.1" description = "Extension pack for Python Markdown." optional = false python-versions = ">=3.8" +groups = ["main"] files = [ {file = "pymdown_extensions-10.3.1-py3-none-any.whl", hash = "sha256:8cba67beb2a1318cdaf742d09dff7c0fc4cafcc290147ade0f8fb7b71522711a"}, {file = "pymdown_extensions-10.3.1.tar.gz", hash = "sha256:f6c79941498a458852853872e379e7bab63888361ba20992fc8b4f8a9b61735e"}, @@ -3855,6 +4045,7 @@ version = "1.0.9" description = "A Comprehensive and Scalable Python Library for Outlier Detection (Anomaly Detection)" optional = false python-versions = "*" +groups = ["darts"] files = [ {file = "pyod-1.0.9.tar.gz", hash = "sha256:1d213b98a8d56bef483eac46e2a53171ffa2f90e4ea489ecd6771bfa022ba447"}, ] @@ -3874,6 +4065,7 @@ version = "1.11" description = "Thin wrapper for pandoc." optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "pypandoc-1.11-py3-none-any.whl", hash = "sha256:b260596934e9cfc6513056110a7c8600171d414f90558bf4407e68b209be8007"}, {file = "pypandoc-1.11.tar.gz", hash = "sha256:7f6d68db0e57e0f6961bec2190897118c4d305fc2d31c22cd16037f22ee084a5"}, @@ -3885,6 +4077,7 @@ version = "3.0.9" description = "pyparsing module - Classes and methods to define and execute parsing grammars" optional = false python-versions = ">=3.6.8" +groups = ["darts", "torch", "visualization"] files = [ {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"}, {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"}, @@ -3899,6 +4092,7 @@ version = "0.14.0" description = "Pure Python module to hyphenate text" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "pyphen-0.14.0-py3-none-any.whl", hash = "sha256:414c9355958ca3c6a3ff233f65678c245b8ecb56418fb291e2b93499d61cd510"}, {file = "pyphen-0.14.0.tar.gz", hash = "sha256:596c8b3be1c1a70411ba5f6517d9ccfe3083c758ae2b94a45f2707346d8e66fa"}, @@ -3914,6 +4108,7 @@ version = "0.19.3" description = "Persistent/Functional/Immutable data structures" optional = false python-versions = ">=3.7" +groups = ["main", "nixtla", "notebook"] files = [ {file = "pyrsistent-0.19.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:20460ac0ea439a3e79caa1dbd560344b64ed75e85d8703943e0b66c2a6150e4a"}, {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c18264cb84b5e68e7085a43723f9e4c1fd1d935ab240ce02c0324a8e01ccb64"}, @@ -3950,6 +4145,7 @@ version = "2.8.2" description = "Extensions to the standard Python datetime module" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +groups = ["main", "darts", "data", "nixtla", "notebook", "torch", "visualization"] files = [ {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, @@ -3964,6 +4160,7 @@ version = "2.0.2" description = "PyTorch Lightning is the lightweight PyTorch wrapper for ML researchers. Scale your models. Write less boilerplate." optional = false python-versions = ">=3.8" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "pytorch-lightning-2.0.2.tar.gz", hash = "sha256:b37a3677a65cda920260de3899ea9dfdd221b0a2d838a0439e31bd927efa61f4"}, {file = "pytorch_lightning-2.0.2-py3-none-any.whl", hash = "sha256:e65a99f0ae53d70c35ec821225241387ec8bb01920003ab8f2d49e753d8a84d0"}, @@ -3995,6 +4192,7 @@ version = "2023.3" description = "World timezone definitions, modern and historical" optional = false python-versions = "*" +groups = ["darts", "data", "nixtla", "torch", "visualization"] files = [ {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, @@ -4006,6 +4204,8 @@ version = "306" description = "Python for Window Extensions" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] +markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\"" files = [ {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, @@ -4029,6 +4229,7 @@ version = "6.0" description = "YAML parser and emitter for Python" optional = false python-versions = ">=3.6" +groups = ["main", "darts", "data", "huggingface", "nixtla", "notebook", "torch"] files = [ {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"}, {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"}, @@ -4078,6 +4279,7 @@ version = "0.1" description = "A custom YAML tag for referencing environment variables in YAML files. " optional = false python-versions = ">=3.6" +groups = ["main"] files = [ {file = "pyyaml_env_tag-0.1-py3-none-any.whl", hash = "sha256:af31106dec8a4d68c60207c1886031cbf839b68aa7abccdb19868200532c2069"}, {file = "pyyaml_env_tag-0.1.tar.gz", hash = "sha256:70092675bda14fdec33b31ba77e7543de9ddc88f2e5b99160396572d11525bdb"}, @@ -4092,6 +4294,7 @@ version = "25.0.2" description = "Python bindings for 0MQ" optional = false python-versions = ">=3.6" +groups = ["main", "notebook", "torch"] files = [ {file = "pyzmq-25.0.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:ac178e666c097c8d3deb5097b58cd1316092fc43e8ef5b5fdb259b51da7e7315"}, {file = "pyzmq-25.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:659e62e1cbb063151c52f5b01a38e1df6b54feccfa3e2509d44c35ca6d7962ee"}, @@ -4181,6 +4384,7 @@ version = "2.35.0" description = "Ray provides a simple, universal API for building distributed applications." optional = false python-versions = ">=3.8" +groups = ["nixtla"] files = [ {file = "ray-2.35.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:1e7e2d2e987be728a81821b6fd2bccb23e4d8a6cca8417db08b24f06a08d8476"}, {file = "ray-2.35.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8bd48be4c362004d31e5df072fd58b929efc67adfefc0adece41483b15f84539"}, @@ -4221,18 +4425,18 @@ requests = "*" tensorboardX = {version = ">=1.9", optional = true, markers = "extra == \"tune\""} [package.extras] -adag = ["cupy-cuda12x"] -air = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "fastapi", "fsspec", "grpcio (>=1.32.0)", "grpcio (>=1.42.0)", "memray", "numpy (>=1.20)", "opencensus", "pandas", "pandas (>=1.3)", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pyarrow (>=6.0.1)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "starlette", "tensorboardX (>=1.9)", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] -all = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "cupy-cuda12x", "dm-tree", "fastapi", "fsspec", "grpcio (!=1.56.0)", "grpcio (>=1.32.0)", "grpcio (>=1.42.0)", "gymnasium (==0.28.1)", "lz4", "memray", "numpy (>=1.20)", "opencensus", "opentelemetry-api", "opentelemetry-exporter-otlp", "opentelemetry-sdk", "pandas", "pandas (>=1.3)", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pyarrow (>=6.0.1)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "pyyaml", "requests", "rich", "scikit-image", "scipy", "smart-open", "starlette", "tensorboardX (>=1.9)", "typer", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] -all-cpp = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "cupy-cuda12x", "dm-tree", "fastapi", "fsspec", "grpcio (!=1.56.0)", "grpcio (>=1.32.0)", "grpcio (>=1.42.0)", "gymnasium (==0.28.1)", "lz4", "memray", "numpy (>=1.20)", "opencensus", "opentelemetry-api", "opentelemetry-exporter-otlp", "opentelemetry-sdk", "pandas", "pandas (>=1.3)", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pyarrow (>=6.0.1)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "pyyaml", "ray-cpp (==2.35.0)", "requests", "rich", "scikit-image", "scipy", "smart-open", "starlette", "tensorboardX (>=1.9)", "typer", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] +adag = ["cupy-cuda12x ; sys_platform != \"darwin\""] +air = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "fastapi", "fsspec", "grpcio (>=1.32.0) ; python_version < \"3.10\"", "grpcio (>=1.42.0) ; python_version >= \"3.10\"", "memray ; sys_platform != \"win32\"", "numpy (>=1.20)", "opencensus", "pandas", "pandas (>=1.3)", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pyarrow (>=6.0.1)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "starlette", "tensorboardX (>=1.9)", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] +all = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "cupy-cuda12x ; sys_platform != \"darwin\"", "dm-tree", "fastapi", "fsspec", "grpcio (!=1.56.0)", "grpcio (>=1.32.0) ; python_version < \"3.10\"", "grpcio (>=1.42.0) ; python_version >= \"3.10\"", "gymnasium (==0.28.1)", "lz4", "memray ; sys_platform != \"win32\"", "numpy (>=1.20)", "opencensus", "opentelemetry-api", "opentelemetry-exporter-otlp", "opentelemetry-sdk", "pandas", "pandas (>=1.3)", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pyarrow (>=6.0.1)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "pyyaml", "requests", "rich", "scikit-image", "scipy", "smart-open", "starlette", "tensorboardX (>=1.9)", "typer", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] +all-cpp = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "cupy-cuda12x ; sys_platform != \"darwin\"", "dm-tree", "fastapi", "fsspec", "grpcio (!=1.56.0)", "grpcio (>=1.32.0) ; python_version < \"3.10\"", "grpcio (>=1.42.0) ; python_version >= \"3.10\"", "gymnasium (==0.28.1)", "lz4", "memray ; sys_platform != \"win32\"", "numpy (>=1.20)", "opencensus", "opentelemetry-api", "opentelemetry-exporter-otlp", "opentelemetry-sdk", "pandas", "pandas (>=1.3)", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pyarrow (>=6.0.1)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "pyyaml", "ray-cpp (==2.35.0)", "requests", "rich", "scikit-image", "scipy", "smart-open", "starlette", "tensorboardX (>=1.9)", "typer", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] client = ["grpcio (!=1.56.0)"] cpp = ["ray-cpp (==2.35.0)"] data = ["fsspec", "numpy (>=1.20)", "pandas (>=1.3)", "pyarrow (>=6.0.1)"] -default = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "grpcio (>=1.32.0)", "grpcio (>=1.42.0)", "memray", "opencensus", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "virtualenv (>=20.0.24,!=20.21.1)"] +default = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "grpcio (>=1.32.0) ; python_version < \"3.10\"", "grpcio (>=1.42.0) ; python_version >= \"3.10\"", "memray ; sys_platform != \"win32\"", "opencensus", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "virtualenv (>=20.0.24,!=20.21.1)"] observability = ["opentelemetry-api", "opentelemetry-exporter-otlp", "opentelemetry-sdk"] rllib = ["dm-tree", "fsspec", "gymnasium (==0.28.1)", "lz4", "pandas", "pyarrow (>=6.0.1)", "pyyaml", "requests", "rich", "scikit-image", "scipy", "tensorboardX (>=1.9)", "typer"] -serve = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "fastapi", "grpcio (>=1.32.0)", "grpcio (>=1.42.0)", "memray", "opencensus", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "starlette", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] -serve-grpc = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "fastapi", "grpcio (>=1.32.0)", "grpcio (>=1.42.0)", "memray", "opencensus", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "starlette", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] +serve = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "fastapi", "grpcio (>=1.32.0) ; python_version < \"3.10\"", "grpcio (>=1.42.0) ; python_version >= \"3.10\"", "memray ; sys_platform != \"win32\"", "opencensus", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "starlette", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] +serve-grpc = ["aiohttp (>=3.7)", "aiohttp-cors", "colorful", "fastapi", "grpcio (>=1.32.0) ; python_version < \"3.10\"", "grpcio (>=1.42.0) ; python_version >= \"3.10\"", "memray ; sys_platform != \"win32\"", "opencensus", "prometheus-client (>=0.7.1)", "py-spy (>=0.2.0)", "pydantic (<2.0.dev0 || >=2.5.dev0,<3)", "requests", "smart-open", "starlette", "uvicorn[standard]", "virtualenv (>=20.0.24,!=20.21.1)", "watchfiles"] train = ["fsspec", "pandas", "pyarrow (>=6.0.1)", "requests", "tensorboardX (>=1.9)"] tune = ["fsspec", "pandas", "pyarrow (>=6.0.1)", "requests", "tensorboardX (>=1.9)"] @@ -4242,6 +4446,7 @@ version = "2023.5.5" description = "Alternative regular expression module, to replace re." optional = false python-versions = ">=3.6" +groups = ["main", "huggingface"] files = [ {file = "regex-2023.5.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:48c9ec56579d4ba1c88f42302194b8ae2350265cb60c64b7b9a88dcb7fbde309"}, {file = "regex-2023.5.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02f4541550459c08fdd6f97aa4e24c6f1932eec780d58a2faa2068253df7d6ff"}, @@ -4339,6 +4544,7 @@ version = "2.31.0" description = "Python HTTP for Humans." optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, @@ -4360,6 +4566,7 @@ version = "1.3.1" description = "OAuthlib authentication support for Requests." optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["torch"] files = [ {file = "requests-oauthlib-1.3.1.tar.gz", hash = "sha256:75beac4a47881eeb94d5ea5d6ad31ef88856affe2332b9aafb52c6452ccf0d7a"}, {file = "requests_oauthlib-1.3.1-py2.py3-none-any.whl", hash = "sha256:2577c501a2fb8d05a304c09d090d6e47c306fef15809d102b327cf8364bddab5"}, @@ -4378,6 +4585,7 @@ version = "4.9" description = "Pure-Python RSA implementation" optional = false python-versions = ">=3.6,<4" +groups = ["torch"] files = [ {file = "rsa-4.9-py3-none-any.whl", hash = "sha256:90260d9058e514786967344d0ef75fa8727eed8a7d2e43ce9f4bcf1b536174f7"}, {file = "rsa-4.9.tar.gz", hash = "sha256:e38464a49c6c85d7f1351b0126661487a7e0a14a50f1675ec50eb34d4f20ef21"}, @@ -4392,6 +4600,7 @@ version = "0.4.5" description = "" optional = false python-versions = ">=3.7" +groups = ["huggingface"] files = [ {file = "safetensors-0.4.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a63eaccd22243c67e4f2b1c3e258b257effc4acd78f3b9d397edc8cf8f1298a7"}, {file = "safetensors-0.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:23fc9b4ec7b602915cbb4ec1a7c1ad96d2743c322f20ab709e2c35d1b66dad27"}, @@ -4520,45 +4729,59 @@ torch = ["safetensors[numpy]", "torch (>=1.10)"] [[package]] name = "scikit-learn" -version = "1.2.2" +version = "1.7.2" description = "A set of python modules for machine learning and data mining" optional = false -python-versions = ">=3.8" -files = [ - {file = "scikit-learn-1.2.2.tar.gz", hash = "sha256:8429aea30ec24e7a8c7ed8a3fa6213adf3814a6efbea09e16e0a0c71e1a1a3d7"}, - {file = "scikit_learn-1.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:99cc01184e347de485bf253d19fcb3b1a3fb0ee4cea5ee3c43ec0cc429b6d29f"}, - {file = "scikit_learn-1.2.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:e6e574db9914afcb4e11ade84fab084536a895ca60aadea3041e85b8ac963edb"}, - {file = "scikit_learn-1.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fe83b676f407f00afa388dd1fdd49e5c6612e551ed84f3b1b182858f09e987d"}, - {file = "scikit_learn-1.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e2642baa0ad1e8f8188917423dd73994bf25429f8893ddbe115be3ca3183584"}, - {file = "scikit_learn-1.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ad66c3848c0a1ec13464b2a95d0a484fd5b02ce74268eaa7e0c697b904f31d6c"}, - {file = "scikit_learn-1.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:dfeaf8be72117eb61a164ea6fc8afb6dfe08c6f90365bde2dc16456e4bc8e45f"}, - {file = "scikit_learn-1.2.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:fe0aa1a7029ed3e1dcbf4a5bc675aa3b1bc468d9012ecf6c6f081251ca47f590"}, - {file = "scikit_learn-1.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:065e9673e24e0dc5113e2dd2b4ca30c9d8aa2fa90f4c0597241c93b63130d233"}, - {file = "scikit_learn-1.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf036ea7ef66115e0d49655f16febfa547886deba20149555a41d28f56fd6d3c"}, - {file = "scikit_learn-1.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:8b0670d4224a3c2d596fd572fb4fa673b2a0ccfb07152688ebd2ea0b8c61025c"}, - {file = "scikit_learn-1.2.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9c710ff9f9936ba8a3b74a455ccf0dcf59b230caa1e9ba0223773c490cab1e51"}, - {file = "scikit_learn-1.2.2-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:2dd3ffd3950e3d6c0c0ef9033a9b9b32d910c61bd06cb8206303fb4514b88a49"}, - {file = "scikit_learn-1.2.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44b47a305190c28dd8dd73fc9445f802b6ea716669cfc22ab1eb97b335d238b1"}, - {file = "scikit_learn-1.2.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:953236889928d104c2ef14027539f5f2609a47ebf716b8cbe4437e85dce42744"}, - {file = "scikit_learn-1.2.2-cp38-cp38-win_amd64.whl", hash = "sha256:7f69313884e8eb311460cc2f28676d5e400bd929841a2c8eb8742ae78ebf7c20"}, - {file = "scikit_learn-1.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8156db41e1c39c69aa2d8599ab7577af53e9e5e7a57b0504e116cc73c39138dd"}, - {file = "scikit_learn-1.2.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:fe175ee1dab589d2e1033657c5b6bec92a8a3b69103e3dd361b58014729975c3"}, - {file = "scikit_learn-1.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7d5312d9674bed14f73773d2acf15a3272639b981e60b72c9b190a0cffed5bad"}, - {file = "scikit_learn-1.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea061bf0283bf9a9f36ea3c5d3231ba2176221bbd430abd2603b1c3b2ed85c89"}, - {file = "scikit_learn-1.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:6477eed40dbce190f9f9e9d0d37e020815825b300121307942ec2110302b66a3"}, -] - -[package.dependencies] -joblib = ">=1.1.1" -numpy = ">=1.17.3" -scipy = ">=1.3.2" -threadpoolctl = ">=2.0.0" +python-versions = ">=3.10" +groups = ["main", "darts", "nixtla", "torch", "visualization"] +files = [ + {file = "scikit_learn-1.7.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b33579c10a3081d076ab403df4a4190da4f4432d443521674637677dc91e61f"}, + {file = "scikit_learn-1.7.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:36749fb62b3d961b1ce4fedf08fa57a1986cd409eff2d783bca5d4b9b5fce51c"}, + {file = "scikit_learn-1.7.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7a58814265dfc52b3295b1900cfb5701589d30a8bb026c7540f1e9d3499d5ec8"}, + {file = "scikit_learn-1.7.2-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a847fea807e278f821a0406ca01e387f97653e284ecbd9750e3ee7c90347f18"}, + {file = "scikit_learn-1.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:ca250e6836d10e6f402436d6463d6c0e4d8e0234cfb6a9a47835bd392b852ce5"}, + {file = "scikit_learn-1.7.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e"}, + {file = "scikit_learn-1.7.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1"}, + {file = "scikit_learn-1.7.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d"}, + {file = "scikit_learn-1.7.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1"}, + {file = "scikit_learn-1.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1"}, + {file = "scikit_learn-1.7.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8d91a97fa2b706943822398ab943cde71858a50245e31bc71dba62aab1d60a96"}, + {file = "scikit_learn-1.7.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:acbc0f5fd2edd3432a22c69bed78e837c70cf896cd7993d71d51ba6708507476"}, + {file = "scikit_learn-1.7.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e5bf3d930aee75a65478df91ac1225ff89cd28e9ac7bd1196853a9229b6adb0b"}, + {file = "scikit_learn-1.7.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d6e9deed1a47aca9fe2f267ab8e8fe82ee20b4526b2c0cd9e135cea10feb44"}, + {file = "scikit_learn-1.7.2-cp312-cp312-win_amd64.whl", hash = "sha256:6088aa475f0785e01bcf8529f55280a3d7d298679f50c0bb70a2364a82d0b290"}, + {file = "scikit_learn-1.7.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0b7dacaa05e5d76759fb071558a8b5130f4845166d88654a0f9bdf3eb57851b7"}, + {file = "scikit_learn-1.7.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:abebbd61ad9e1deed54cca45caea8ad5f79e1b93173dece40bb8e0c658dbe6fe"}, + {file = "scikit_learn-1.7.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:502c18e39849c0ea1a5d681af1dbcf15f6cce601aebb657aabbfe84133c1907f"}, + {file = "scikit_learn-1.7.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a4c328a71785382fe3fe676a9ecf2c86189249beff90bf85e22bdb7efaf9ae0"}, + {file = "scikit_learn-1.7.2-cp313-cp313-win_amd64.whl", hash = "sha256:63a9afd6f7b229aad94618c01c252ce9e6fa97918c5ca19c9a17a087d819440c"}, + {file = "scikit_learn-1.7.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9acb6c5e867447b4e1390930e3944a005e2cb115922e693c08a323421a6966e8"}, + {file = "scikit_learn-1.7.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:2a41e2a0ef45063e654152ec9d8bcfc39f7afce35b08902bfe290c2498a67a6a"}, + {file = "scikit_learn-1.7.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98335fb98509b73385b3ab2bd0639b1f610541d3988ee675c670371d6a87aa7c"}, + {file = "scikit_learn-1.7.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191e5550980d45449126e23ed1d5e9e24b2c68329ee1f691a3987476e115e09c"}, + {file = "scikit_learn-1.7.2-cp313-cp313t-win_amd64.whl", hash = "sha256:57dc4deb1d3762c75d685507fbd0bc17160144b2f2ba4ccea5dc285ab0d0e973"}, + {file = "scikit_learn-1.7.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fa8f63940e29c82d1e67a45d5297bdebbcb585f5a5a50c4914cc2e852ab77f33"}, + {file = "scikit_learn-1.7.2-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f95dc55b7902b91331fa4e5845dd5bde0580c9cd9612b1b2791b7e80c3d32615"}, + {file = "scikit_learn-1.7.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9656e4a53e54578ad10a434dc1f993330568cfee176dff07112b8785fb413106"}, + {file = "scikit_learn-1.7.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96dc05a854add0e50d3f47a1ef21a10a595016da5b007c7d9cd9d0bffd1fcc61"}, + {file = "scikit_learn-1.7.2-cp314-cp314-win_amd64.whl", hash = "sha256:bb24510ed3f9f61476181e4db51ce801e2ba37541def12dc9333b946fc7a9cf8"}, + {file = "scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda"}, +] + +[package.dependencies] +joblib = ">=1.2.0" +numpy = ">=1.22.0" +scipy = ">=1.8.0" +threadpoolctl = ">=3.1.0" [package.extras] -benchmark = ["matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "pandas (>=1.0.5)"] -docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "plotly (>=5.10.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)", "sphinx (>=4.0.1)", "sphinx-gallery (>=0.7.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] -examples = ["matplotlib (>=3.1.3)", "pandas (>=1.0.5)", "plotly (>=5.10.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)"] -tests = ["black (>=22.3.0)", "flake8 (>=3.8.2)", "matplotlib (>=3.1.3)", "mypy (>=0.961)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pytest (>=5.3.1)", "pytest-cov (>=2.9.0)", "scikit-image (>=0.16.2)"] +benchmark = ["matplotlib (>=3.5.0)", "memory_profiler (>=0.57.0)", "pandas (>=1.4.0)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.17.1)", "numpy (>=1.22.0)", "scipy (>=1.8.0)"] +docs = ["Pillow (>=8.4.0)", "matplotlib (>=3.5.0)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.4.0)", "plotly (>=5.14.0)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pydata-sphinx-theme (>=0.15.3)", "scikit-image (>=0.19.0)", "seaborn (>=0.9.0)", "sphinx (>=7.3.7)", "sphinx-copybutton (>=0.5.2)", "sphinx-design (>=0.5.0)", "sphinx-design (>=0.6.0)", "sphinx-gallery (>=0.17.1)", "sphinx-prompt (>=1.4.0)", "sphinx-remove-toctrees (>=1.0.0.post1)", "sphinxcontrib-sass (>=0.3.4)", "sphinxext-opengraph (>=0.9.1)", "towncrier (>=24.8.0)"] +examples = ["matplotlib (>=3.5.0)", "pandas (>=1.4.0)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.19.0)", "seaborn (>=0.9.0)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.22.0)", "scipy (>=1.8.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==3.0.1)"] +tests = ["matplotlib (>=3.5.0)", "mypy (>=1.15)", "numpydoc (>=1.2.0)", "pandas (>=1.4.0)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pyamg (>=4.2.1)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.11.7)", "scikit-image (>=0.19.0)"] [[package]] name = "scipy" @@ -4566,6 +4789,7 @@ version = "1.14.0" description = "Fundamental algorithms for scientific computing in Python" optional = false python-versions = ">=3.10" +groups = ["main", "darts", "data", "nixtla", "torch", "visualization"] files = [ {file = "scipy-1.14.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7e911933d54ead4d557c02402710c2396529540b81dd554fc1ba270eb7308484"}, {file = "scipy-1.14.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:687af0a35462402dd851726295c1a5ae5f987bd6e9026f52e9505994e2f84ef6"}, @@ -4600,7 +4824,7 @@ numpy = ">=1.23.5,<2.3" [package.extras] dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"] doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.13.1)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] -test = ["Cython", "array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] +test = ["Cython", "array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja ; sys_platform != \"emscripten\"", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] [[package]] name = "seaborn" @@ -4608,6 +4832,7 @@ version = "0.13.2" description = "Statistical data visualization" optional = false python-versions = ">=3.8" +groups = ["visualization"] files = [ {file = "seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987"}, {file = "seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7"}, @@ -4629,6 +4854,7 @@ version = "67.8.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = false python-versions = ">=3.7" +groups = ["darts", "nixtla", "torch"] files = [ {file = "setuptools-67.8.0-py3-none-any.whl", hash = "sha256:5df61bf30bb10c6f756eb19e7c9f3b473051f48db77fddbe06ff2ca307df9a6f"}, {file = "setuptools-67.8.0.tar.gz", hash = "sha256:62642358adc77ffa87233bc4d2354c4b2682d214048f500964dbe760ccedf102"}, @@ -4636,7 +4862,7 @@ files = [ [package.extras] docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-hoverxref (<2)", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (==0.8.3)", "sphinx-reredirects", "sphinxcontrib-towncrier"] -testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pip-run (>=8.8)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pip-run (>=8.8)", "pytest (>=6)", "pytest-black (>=0.3.7) ; platform_python_implementation != \"PyPy\"", "pytest-checkdocs (>=2.4)", "pytest-cov ; platform_python_implementation != \"PyPy\"", "pytest-enabler (>=1.3)", "pytest-mypy (>=0.9.1) ; platform_python_implementation != \"PyPy\"", "pytest-perf", "pytest-ruff ; sys_platform != \"cygwin\"", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] testing-integration = ["build[virtualenv]", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] [[package]] @@ -4645,6 +4871,7 @@ version = "0.41.0" description = "A unified approach to explain the output of any machine learning model." optional = false python-versions = "*" +groups = ["darts"] files = [ {file = "shap-0.41.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9e867dd8be6c0644c8d954dcc9efc51c0f0eec432de2d4cb253a7878489bb9f1"}, {file = "shap-0.41.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:48d52fe9d2ebb7bd829484e55c3b8a2edd8f3e50c4ad9ab905d5b6b72741b018"}, @@ -4698,6 +4925,7 @@ version = "1.16.0" description = "Python 2 and 3 compatibility utilities" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +groups = ["main", "darts", "data", "nixtla", "notebook", "torch", "visualization"] files = [ {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, @@ -4709,6 +4937,7 @@ version = "0.0.7" description = "A small package for big slicing." optional = false python-versions = ">=3.6" +groups = ["darts"] files = [ {file = "slicer-0.0.7-py3-none-any.whl", hash = "sha256:0b94faa5251c0f23782c03f7b7eedda91d80144059645f452c4bc80fab875976"}, {file = "slicer-0.0.7.tar.gz", hash = "sha256:f5d5f7b45f98d155b9c0ba6554fa9770c6b26d5793a3e77a1030fb56910ebeec"}, @@ -4720,6 +4949,7 @@ version = "2.4.1" description = "A modern CSS selector implementation for Beautiful Soup." optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "soupsieve-2.4.1-py3-none-any.whl", hash = "sha256:1c1bfee6819544a3447586c889157365a27e10d88cde3ad3da0cf0ddf646feb8"}, {file = "soupsieve-2.4.1.tar.gz", hash = "sha256:89d12b2d5dfcd2c9e8c22326da9d9aa9cb3dfab0a83a024f05704076ee8d35ea"}, @@ -4731,6 +4961,7 @@ version = "2.0.34" description = "Database Abstraction Library" optional = false python-versions = ">=3.7" +groups = ["nixtla"] files = [ {file = "SQLAlchemy-2.0.34-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:95d0b2cf8791ab5fb9e3aa3d9a79a0d5d51f55b6357eecf532a120ba3b5524db"}, {file = "SQLAlchemy-2.0.34-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:243f92596f4fd4c8bd30ab8e8dd5965afe226363d75cab2468f2c707f64cd83b"}, @@ -4818,6 +5049,7 @@ version = "0.6.2" description = "Extract data from python stack frames and tracebacks for informative displays" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "stack_data-0.6.2-py3-none-any.whl", hash = "sha256:cbb2a53eb64e5785878201a97ed7c7b94883f48b87bfb0bbe8b623c74679e4a8"}, {file = "stack_data-0.6.2.tar.gz", hash = "sha256:32d2dd0376772d01b6cb9fc996f3c8b57a357089dec328ed4b6553d037eaf815"}, @@ -4837,6 +5069,7 @@ version = "1.7.6" description = "Time series forecasting suite using statistical models" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "statsforecast-1.7.6-py3-none-any.whl", hash = "sha256:a9d39ef0303788063562737912db79c84047177c9b2ac68a9c95c36d7b499028"}, {file = "statsforecast-1.7.6.tar.gz", hash = "sha256:fd956802e72039d9ac8833cfe693dbeef90c939132bf56984d312a2866fbd8ce"}, @@ -4870,6 +5103,7 @@ version = "0.14.0" description = "Statistical computations and models for Python" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "statsmodels-0.14.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:16bfe0c96a53b20fa19067e3b6bd2f1d39e30d4891ea0d7bc20734a0ae95942d"}, {file = "statsmodels-0.14.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5a6a0a1a06ff79be8aa89c8494b33903442859add133f0dda1daf37c3c71682e"}, @@ -4914,7 +5148,7 @@ scipy = ">=1.4,<1.9.2 || >1.9.2" [package.extras] build = ["cython (>=0.29.26)"] -develop = ["colorama", "cython (>=0.29.26)", "cython (>=0.29.28,<3.0.0)", "flake8", "isort", "joblib", "matplotlib (>=3)", "oldest-supported-numpy (>=2022.4.18)", "pytest (>=7.0.1,<7.1.0)", "pytest-randomly", "pytest-xdist", "pywinpty", "setuptools-scm[toml] (>=7.0.0,<7.1.0)"] +develop = ["colorama", "cython (>=0.29.26)", "cython (>=0.29.28,<3.0.0)", "flake8", "isort", "joblib", "matplotlib (>=3)", "oldest-supported-numpy (>=2022.4.18)", "pytest (>=7.0.1,<7.1.0)", "pytest-randomly", "pytest-xdist", "pywinpty ; os_name == \"nt\"", "setuptools-scm[toml] (>=7.0.0,<7.1.0)"] docs = ["ipykernel", "jupyter-client", "matplotlib", "nbconvert", "nbformat", "numpydoc", "pandas-datareader", "sphinx"] [[package]] @@ -4923,6 +5157,7 @@ version = "0.4.15" description = "An Enum that inherits from str." optional = false python-versions = "*" +groups = ["data"] files = [ {file = "StrEnum-0.4.15-py3-none-any.whl", hash = "sha256:a30cda4af7cc6b5bf52c8055bc4bf4b2b6b14a93b574626da33df53cf7740659"}, {file = "StrEnum-0.4.15.tar.gz", hash = "sha256:878fb5ab705442070e4dd1929bb5e2249511c0bcf2b0eeacf3bcd80875c82eff"}, @@ -4939,6 +5174,7 @@ version = "1.13.1" description = "Computer algebra system (CAS) in Python" optional = false python-versions = ">=3.8" +groups = ["main", "darts", "data", "nixtla", "torch"] files = [ {file = "sympy-1.13.1-py3-none-any.whl", hash = "sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8"}, {file = "sympy-1.13.1.tar.gz", hash = "sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f"}, @@ -4956,6 +5192,7 @@ version = "0.9.0" description = "Pretty-print tabular data" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"}, {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"}, @@ -4970,6 +5207,7 @@ version = "1.1.3" description = "BATS and TBATS for time series forecasting" optional = false python-versions = "*" +groups = ["darts"] files = [ {file = "tbats-1.1.3-py3-none-any.whl", hash = "sha256:aff37f39115583028dacbd87227bc2ac65e696ea25543ddcd78e334e1fbe8e3a"}, {file = "tbats-1.1.3.tar.gz", hash = "sha256:dccd0d4cd9e2fde30bf19a944ee957d2f865975846284f48ce673992c4f5d89e"}, @@ -4990,6 +5228,7 @@ version = "2.15.1" description = "TensorBoard lets you watch Tensors Flow" optional = false python-versions = ">=3.9" +groups = ["torch"] files = [ {file = "tensorboard-2.15.1-py3-none-any.whl", hash = "sha256:c46c1d1cf13a458c429868a78b2531d8ff5f682058d69ec0840b0bc7a38f1c0f"}, ] @@ -5014,6 +5253,7 @@ version = "0.7.2" description = "Fast data loading for TensorBoard" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "tensorboard_data_server-0.7.2-py3-none-any.whl", hash = "sha256:7e0610d205889588983836ec05dc098e80f97b7e7bbff7e994ebb78f578d0ddb"}, {file = "tensorboard_data_server-0.7.2-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:9fe5d24221b29625dbc7328b0436ca7fc1c23de4acf4d272f1180856e32f9f60"}, @@ -5026,6 +5266,7 @@ version = "2.6" description = "TensorBoardX lets you watch Tensors Flow without Tensorflow" optional = false python-versions = "*" +groups = ["darts", "nixtla"] files = [ {file = "tensorboardX-2.6-py2.py3-none-any.whl", hash = "sha256:24a7cd076488de1e9d15ef25371b8ebf90c4f8f622af2477c611198f03f4a606"}, {file = "tensorboardX-2.6.tar.gz", hash = "sha256:d4c036964dd2deb075a1909832b276daa383eab3f9db519ad90b99f5aea06b0c"}, @@ -5042,6 +5283,7 @@ version = "3.1.0" description = "threadpoolctl" optional = false python-versions = ">=3.6" +groups = ["main", "darts", "nixtla", "torch", "visualization"] files = [ {file = "threadpoolctl-3.1.0-py3-none-any.whl", hash = "sha256:8b99adda265feb6773280df41eece7b2e6561b772d21ffd52e372f999024907b"}, {file = "threadpoolctl-3.1.0.tar.gz", hash = "sha256:a335baacfaa4400ae1f0d8e3a58d6674d2f8828e3716bb2802c44955ad391380"}, @@ -5053,6 +5295,7 @@ version = "1.2.1" description = "A tiny CSS parser" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, @@ -5071,6 +5314,7 @@ version = "0.19.1" description = "" optional = false python-versions = ">=3.7" +groups = ["huggingface"] files = [ {file = "tokenizers-0.19.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:952078130b3d101e05ecfc7fc3640282d74ed26bcf691400f872563fca15ac97"}, {file = "tokenizers-0.19.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:82c8b8063de6c0468f08e82c4e198763e7b97aabfe573fd4cf7b33930ca4df77"}, @@ -5188,6 +5432,7 @@ version = "0.10.2" description = "Python Library for Tom's Obvious, Minimal Language" optional = false python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +groups = ["main", "notebook"] files = [ {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, @@ -5199,6 +5444,7 @@ version = "0.12.3" description = "Style preserving TOML library" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "tomlkit-0.12.3-py3-none-any.whl", hash = "sha256:b0a645a9156dc7cb5d3a1f0d4bab66db287fcb8e0430bdd4664a095ea16414ba"}, {file = "tomlkit-0.12.3.tar.gz", hash = "sha256:75baf5012d06501f07bee5bf8e801b9f343e7aac5a92581f20f80ce632e6b5a4"}, @@ -5210,6 +5456,7 @@ version = "2.5.1" description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" optional = false python-versions = ">=3.8.0" +groups = ["main", "darts", "data", "nixtla", "torch"] files = [ {file = "torch-2.5.1-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:71328e1bbe39d213b8721678f9dcac30dfc452a46d586f1d514a6aa0a99d4744"}, {file = "torch-2.5.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:34bfa1a852e5714cbfa17f27c49d8ce35e1b7af5608c4bc6e81392c352dbc601"}, @@ -5261,6 +5508,7 @@ version = "0.4.3" description = "PyTorch Profiler TensorBoard Plugin" optional = false python-versions = ">=3.6.2" +groups = ["torch"] files = [ {file = "torch_tb_profiler-0.4.3-py3-none-any.whl", hash = "sha256:207a49b05572dd983e4ab29eb5e0fcadd60374a8f93c78ec638217e8d18788dc"}, {file = "torch_tb_profiler-0.4.3.tar.gz", hash = "sha256:8b8d29b2de960b3c4423087b23cec29beaf9ac3a8c7b046c18fd25b218f726b1"}, @@ -5282,6 +5530,7 @@ version = "0.2.5" description = "Differentiable controlled differential equation solvers for PyTorch with GPU support and memory-efficient adjoint backpropagation." optional = false python-versions = "~=3.6" +groups = ["torch"] files = [ {file = "torchcde-0.2.5-py3-none-any.whl", hash = "sha256:90ad5943d74d601400476a3cdaf6ea7aabd3967033ba6d513bc8f6a93f982ffd"}, {file = "torchcde-0.2.5.tar.gz", hash = "sha256:6e6081192e00476314eb0d97ce54e6c6a67134d868b97b06db7b8017e60f0de6"}, @@ -5298,6 +5547,7 @@ version = "0.2.3" description = "ODE solvers and adjoint sensitivity analysis in PyTorch." optional = false python-versions = "~=3.6" +groups = ["torch"] files = [ {file = "torchdiffeq-0.2.3-py3-none-any.whl", hash = "sha256:b5b01ec1294a2d8d5f77e567bf17c5de1237c0573cb94deefa88326f0e18c338"}, {file = "torchdiffeq-0.2.3.tar.gz", hash = "sha256:fe75f434b9090ac0c27702e02bed21472b0f87035be6581f51edc5d4013ea31a"}, @@ -5307,12 +5557,39 @@ files = [ scipy = ">=1.4.0" torch = ">=1.3.0" +[[package]] +name = "torchdr" +version = "0.3" +description = "Torch Dimensionality Reduction Library" +optional = false +python-versions = ">=3.7" +groups = ["main"] +files = [ + {file = "torchdr-0.3-py3-none-any.whl", hash = "sha256:b0bedb5a79788971a1f9d12919922ffd660664757dd44606915feb521f659cc7"}, + {file = "torchdr-0.3.tar.gz", hash = "sha256:eb6df12cad9b7fb56bf01a737a670c4a4e67d320f6563059e2f8eccba3904d7d"}, +] + +[package.dependencies] +numpy = "*" +scikit-learn = "*" +torch = "*" + +[package.extras] +all = ["torchdr[benchmarks,dev,doc,examples,keops,test]"] +benchmarks = ["psutil", "requests", "umap-learn"] +dev = ["codecov", "coverage", "numpydoc", "pre-commit", "pykeops", "pytest", "pytest-cov"] +doc = ["matplotlib", "memory_profiler", "myst-parser", "numpydoc", "pandas", "pydata_sphinx_theme", "sphinx", "sphinx_gallery", "sphinxcontrib-bibtex"] +examples = ["datamapplot", "datasets", "matplotlib", "pandas", "seaborn", "transformers"] +keops = ["pykeops"] +test = ["codecov", "coverage", "flake8", "matplotlib", "numpydoc", "pytest", "pytest-cov"] + [[package]] name = "torchdyn" version = "1.0.6" description = "A PyTorch library entirely dedicated to neural differential equations, implicit models and related numerical methods." optional = false python-versions = ">=3.8,<4.0" +groups = ["torch"] files = [ {file = "torchdyn-1.0.6-py3-none-any.whl", hash = "sha256:1699db47296b14756172cd26b814bd49ce702420f8c4b049c8ae60b4ae6ac88d"}, {file = "torchdyn-1.0.6.tar.gz", hash = "sha256:3b74d785e3d9c8a42a65dc061af11d39fb2036500ca73d32f077c9314148cdbf"}, @@ -5337,6 +5614,7 @@ version = "1.2.0" description = "PyTorch native Metrics" optional = false python-versions = ">=3.8" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "torchmetrics-1.2.0-py3-none-any.whl", hash = "sha256:da2cb18822b285786d082c40efb9e1d861aac425f58230234fe6ce233cf002f8"}, {file = "torchmetrics-1.2.0.tar.gz", hash = "sha256:7eb28340bde45e13187a9ad54a4a7010a50417815d8181a5df6131f116ffe1b7"}, @@ -5365,6 +5643,7 @@ version = "0.2.6" description = "SDE solvers and stochastic adjoint sensitivity analysis in PyTorch." optional = false python-versions = ">=3.8" +groups = ["torch"] files = [ {file = "torchsde-0.2.6-py3-none-any.whl", hash = "sha256:19bf7ff02eec7e8e46ba1cdb4aa0f9db1c51d492524a16975234b467f7fc463b"}, {file = "torchsde-0.2.6.tar.gz", hash = "sha256:81d074d3504f9d190f1694fb526395afbe4608ee43a88adb1262a639e5b4778b"}, @@ -5382,6 +5661,7 @@ version = "0.20.1" description = "image and video datasets and models for torch deep learning" optional = false python-versions = ">=3.8" +groups = ["torch"] files = [ {file = "torchvision-0.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4878fefb96ef293d06c27210918adc83c399d9faaf34cda5a63e129f772328f1"}, {file = "torchvision-0.20.1-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:8ffbdf8bf5b30eade22d459f5a313329eeadb20dc75efa142987b53c007098c3"}, @@ -5416,6 +5696,7 @@ version = "6.3.2" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." optional = false python-versions = ">= 3.8" +groups = ["main", "notebook", "torch"] files = [ {file = "tornado-6.3.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:c367ab6c0393d71171123ca5515c61ff62fe09024fa6bf299cd1339dc9456829"}, {file = "tornado-6.3.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b46a6ab20f5c7c1cb949c72c1994a4585d2eaa0be4853f50a03b5031e964fc7c"}, @@ -5436,6 +5717,7 @@ version = "4.65.0" description = "Fast, Extensible Progress Meter" optional = false python-versions = ">=3.7" +groups = ["darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "tqdm-4.65.0-py3-none-any.whl", hash = "sha256:c4f53a17fe37e132815abceec022631be8ffe1b9381c2e6e30aa70edc99e9671"}, {file = "tqdm-4.65.0.tar.gz", hash = "sha256:1871fb68a86b8fb3b59ca4cdd3dcccbc7e6d613eeed31f4c332531977b89beb5"}, @@ -5456,6 +5738,7 @@ version = "5.9.0" description = "Traitlets Python configuration system" optional = false python-versions = ">=3.7" +groups = ["main", "notebook", "torch"] files = [ {file = "traitlets-5.9.0-py3-none-any.whl", hash = "sha256:9e6ec080259b9a5940c797d58b613b5e31441c2257b87c2e795c5228ae80d2d8"}, {file = "traitlets-5.9.0.tar.gz", hash = "sha256:f6cde21a9c68cf756af02035f72d5a723bf607e862e7be33ece505abf4a3bad9"}, @@ -5471,6 +5754,7 @@ version = "0.1.2" description = "Simple and tiny yield-based trampoline implementation." optional = false python-versions = "*" +groups = ["torch"] files = [ {file = "trampoline-0.1.2-py3-none-any.whl", hash = "sha256:36cc9a4ff9811843d177fc0e0740efbd7da39eadfe6e50c9e2937cbc06d899d9"}, ] @@ -5481,6 +5765,7 @@ version = "4.44.2" description = "State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow" optional = false python-versions = ">=3.8.0" +groups = ["huggingface"] files = [ {file = "transformers-4.44.2-py3-none-any.whl", hash = "sha256:1c02c65e7bfa5e52a634aff3da52138b583fc6f263c1f28d547dc144ba3d412d"}, {file = "transformers-4.44.2.tar.gz", hash = "sha256:36aa17cc92ee154058e426d951684a2dab48751b35b49437896f898931270826"}, @@ -5549,6 +5834,7 @@ version = "0.9.8" description = "A collection of python utils for Fugue projects" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "triad-0.9.8-py3-none-any.whl", hash = "sha256:2c0ba7d83977c6d4e7b59e3cc70727f858014ef7676c62d184aa8e63f7bef5de"}, {file = "triad-0.9.8.tar.gz", hash = "sha256:5b67673124891981daf8afbab44b2e6358932ca35ef3ff38a25bc3e0f6f03f17"}, @@ -5571,6 +5857,8 @@ version = "3.1.0" description = "A language and compiler for custom Deep Learning operations" optional = false python-versions = "*" +groups = ["main", "darts", "data", "nixtla", "torch"] +markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\"" files = [ {file = "triton-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b0dd10a925263abbe9fa37dcde67a5e9b2383fc269fdf59f5657cac38c5d1d8"}, {file = "triton-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f34f6e7885d1bf0eaaf7ba875a5f0ce6f3c13ba98f9503651c1e6dc6757ed5c"}, @@ -5589,13 +5877,14 @@ tutorials = ["matplotlib", "pandas", "tabulate"] [[package]] name = "ts-bolt" -version = "0.0.6" +version = "0.0.7" description = "The Lightning Bolt for Time Series Data and Models" optional = false python-versions = "<3.13,>=3.10" +groups = ["data"] files = [ - {file = "ts_bolt-0.0.6-py3-none-any.whl", hash = "sha256:c60c186d8abcf98cb4a8d0f490973431565cebcb344605acdd984c6b3010ec77"}, - {file = "ts_bolt-0.0.6.tar.gz", hash = "sha256:18b3e4ededf58ceafa2c6c1ae91abb1034925f39b9679b75633ac013e6bf20ff"}, + {file = "ts_bolt-0.0.7-py3-none-any.whl", hash = "sha256:77f728dd435fea6cdf8c602af75b3c8fd98d83f5b74618fc45b48b33ad2590cf"}, + {file = "ts_bolt-0.0.7.tar.gz", hash = "sha256:94cc2d4bc5739e4da112a30ad390e0abdc2697ef35fd83a8a6567815a7dd012d"}, ] [package.dependencies] @@ -5617,6 +5906,7 @@ version = "4.12.2" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, @@ -5628,6 +5918,7 @@ version = "2024.1" description = "Provider of IANA time zone data" optional = false python-versions = ">=2" +groups = ["darts", "data", "nixtla", "torch", "visualization"] files = [ {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, @@ -5639,13 +5930,14 @@ version = "2.0.2" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.7" +groups = ["main", "darts", "data", "huggingface", "nixtla", "torch"] files = [ {file = "urllib3-2.0.2-py3-none-any.whl", hash = "sha256:d055c2f9d38dc53c808f6fdc8eab7360b6fdbbde02340ed25cfbcd817c62469e"}, {file = "urllib3-2.0.2.tar.gz", hash = "sha256:61717a1095d7e155cdb737ac7bb2f4324a858a1e2e6466f6d03ff630ca68d3cc"}, ] [package.extras] -brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""] secure = ["certifi", "cryptography (>=1.9)", "idna (>=2.0.0)", "pyopenssl (>=17.1.0)", "urllib3-secure-extra"] socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] zstd = ["zstandard (>=0.18.0)"] @@ -5656,6 +5948,7 @@ version = "0.2.4" description = "Forecasting utilities" optional = false python-versions = ">=3.8" +groups = ["darts", "nixtla"] files = [ {file = "utilsforecast-0.2.4-py3-none-any.whl", hash = "sha256:f4357aaec9757e79ffbadad5318e0aa067c57ea51a4802b71d630761adf73f0b"}, {file = "utilsforecast-0.2.4.tar.gz", hash = "sha256:72f07adb99c6cd638322832bc0229d6d0e3acd97ac4c94cd832bc012ac4ef0cf"}, @@ -5677,6 +5970,7 @@ version = "0.20.0" description = "Python Data Validation for Humans™." optional = false python-versions = ">=3.4" +groups = ["main"] files = [ {file = "validators-0.20.0.tar.gz", hash = "sha256:24148ce4e64100a2d5e267233e23e7afeb55316b47d30faae7eb6e7292bc226a"}, ] @@ -5693,6 +5987,7 @@ version = "3.0.0" description = "Filesystem events monitoring" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "watchdog-3.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:336adfc6f5cc4e037d52db31194f7581ff744b67382eb6021c868322e32eef41"}, {file = "watchdog-3.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a70a8dcde91be523c35b2bf96196edc5730edb347e374c7de7cd20c43ed95397"}, @@ -5732,6 +6027,7 @@ version = "0.2.6" description = "Measures the displayed width of unicode strings in a terminal" optional = false python-versions = "*" +groups = ["main", "notebook", "torch"] files = [ {file = "wcwidth-0.2.6-py2.py3-none-any.whl", hash = "sha256:795b138f6875577cd91bba52baf9e445cd5118fd32723b460e30a0af30ea230e"}, {file = "wcwidth-0.2.6.tar.gz", hash = "sha256:a5220780a404dbe3353789870978e472cfe477761f06ee55077256e509b156d0"}, @@ -5743,6 +6039,7 @@ version = "59.0" description = "The Awesome Document Factory" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "weasyprint-59.0-py3-none-any.whl", hash = "sha256:a308d67c5e99f536b15527baaad4e91be0cf307317e0f66e8d934a0bc99bfb38"}, {file = "weasyprint-59.0.tar.gz", hash = "sha256:223a76636b3744eaa4ab8a2885f50cf46cf8ebb1acb99b5276d02feccf507492"}, @@ -5768,6 +6065,7 @@ version = "0.5.1" description = "Character encoding aliases for legacy web content" optional = false python-versions = "*" +groups = ["main"] files = [ {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, @@ -5779,6 +6077,7 @@ version = "2.3.4" description = "The comprehensive WSGI web application library." optional = false python-versions = ">=3.8" +groups = ["torch"] files = [ {file = "Werkzeug-2.3.4-py3-none-any.whl", hash = "sha256:48e5e61472fee0ddee27ebad085614ebedb7af41e88f687aaf881afb723a162f"}, {file = "Werkzeug-2.3.4.tar.gz", hash = "sha256:1d5a58e0377d1fe39d061a5de4469e414e78ccb1e1e59c0f5ad6fa1c36c52b76"}, @@ -5796,6 +6095,7 @@ version = "4.0.9" description = "Jupyter interactive widgets for Jupyter Notebook" optional = false python-versions = ">=3.7" +groups = ["torch"] files = [ {file = "widgetsnbextension-4.0.9-py3-none-any.whl", hash = "sha256:91452ca8445beb805792f206e560c1769284267a30ceb1cec9f5bcc887d15175"}, {file = "widgetsnbextension-4.0.9.tar.gz", hash = "sha256:3c1f5e46dc1166dfd40a42d685e6a51396fd34ff878742a3e47c6f0cc4a2a385"}, @@ -5807,13 +6107,15 @@ version = "1.1.0" description = "A small Python utility to set file creation time on Windows" optional = false python-versions = ">=3.5" +groups = ["main", "data"] +markers = "sys_platform == \"win32\"" files = [ {file = "win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"}, {file = "win32_setctime-1.1.0.tar.gz", hash = "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2"}, ] [package.extras] -dev = ["black (>=19.3b0)", "pytest (>=4.6.2)"] +dev = ["black (>=19.3b0) ; python_version >= \"3.6\"", "pytest (>=4.6.2)"] [[package]] name = "window-ops" @@ -5821,6 +6123,7 @@ version = "0.0.15" description = "Implementations of window operations such as rolling and expanding." optional = false python-versions = ">=3.6" +groups = ["nixtla"] files = [ {file = "window_ops-0.0.15-py3-none-any.whl", hash = "sha256:7dbd18b467939ac5db3f6834c07e7ffb723691f5d86c22a39e707713d8ac86e3"}, {file = "window_ops-0.0.15.tar.gz", hash = "sha256:3c762d35a38d562f34cda33a272ced2c8d5dd88bd050c13bc82a592cf668a535"}, @@ -5839,6 +6142,7 @@ version = "2023.5.0" description = "N-D labeled arrays and datasets in Python" optional = false python-versions = ">=3.9" +groups = ["darts"] files = [ {file = "xarray-2023.5.0-py3-none-any.whl", hash = "sha256:b62f19bb04e68f684a92a8a458c63c91cf76e6fabe54cf4438f7e2ca56348854"}, {file = "xarray-2023.5.0.tar.gz", hash = "sha256:318a651f4182b9cecb7d1c57ad0ed9bdaed5f49c43dbb638c0a845b8faf405e8"}, @@ -5851,9 +6155,9 @@ pandas = ">=1.4" [package.extras] accel = ["bottleneck", "flox", "numbagg", "scipy"] -complete = ["bottleneck", "cftime", "dask[complete]", "flox", "fsspec", "h5netcdf", "matplotlib", "nc-time-axis", "netCDF4", "numbagg", "pooch", "pydap", "scipy", "seaborn", "zarr"] -docs = ["bottleneck", "cftime", "dask[complete]", "flox", "fsspec", "h5netcdf", "ipykernel", "ipython", "jupyter-client", "matplotlib", "nbsphinx", "nc-time-axis", "netCDF4", "numbagg", "pooch", "pydap", "scanpydoc", "scipy", "seaborn", "sphinx-autosummary-accessors", "sphinx-rtd-theme", "zarr"] -io = ["cftime", "fsspec", "h5netcdf", "netCDF4", "pooch", "pydap", "scipy", "zarr"] +complete = ["bottleneck", "cftime", "dask[complete]", "flox", "fsspec", "h5netcdf", "matplotlib", "nc-time-axis", "netCDF4", "numbagg", "pooch", "pydap ; python_version < \"3.10\"", "scipy", "seaborn", "zarr"] +docs = ["bottleneck", "cftime", "dask[complete]", "flox", "fsspec", "h5netcdf", "ipykernel", "ipython", "jupyter-client", "matplotlib", "nbsphinx", "nc-time-axis", "netCDF4", "numbagg", "pooch", "pydap ; python_version < \"3.10\"", "scanpydoc", "scipy", "seaborn", "sphinx-autosummary-accessors", "sphinx-rtd-theme", "zarr"] +io = ["cftime", "fsspec", "h5netcdf", "netCDF4", "pooch", "pydap ; python_version < \"3.10\"", "scipy", "zarr"] parallel = ["dask[complete]"] viz = ["matplotlib", "nc-time-axis", "seaborn"] @@ -5863,6 +6167,7 @@ version = "1.7.5" description = "XGBoost Python Package" optional = false python-versions = ">=3.8" +groups = ["darts"] files = [ {file = "xgboost-1.7.5-py3-none-macosx_10_15_x86_64.macosx_11_0_x86_64.macosx_12_0_x86_64.whl", hash = "sha256:ca9e8455343cc3f1fddc825209ad00623bc82de0364097b31d649bca6a5f8fb4"}, {file = "xgboost-1.7.5-py3-none-macosx_12_0_arm64.whl", hash = "sha256:9eed5629c9008c36d65db6869defac31de635f766f215fc4b09b6a389c637f27"}, @@ -5890,6 +6195,7 @@ version = "2.0.1" description = "Library for developers to extract data from Microsoft Excel (tm) .xls spreadsheet files" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +groups = ["nixtla"] files = [ {file = "xlrd-2.0.1-py2.py3-none-any.whl", hash = "sha256:6a33ee89877bd9abc1158129f6e94be74e2679636b8a205b43b85206c3f0bbdd"}, {file = "xlrd-2.0.1.tar.gz", hash = "sha256:f72f148f54442c6b056bf931dbc34f986fd0c3b0b6b5a58d013c9aef274d0c88"}, @@ -5906,6 +6212,7 @@ version = "1.9.2" description = "Yet another URL library" optional = false python-versions = ">=3.7" +groups = ["darts", "data", "nixtla", "torch"] files = [ {file = "yarl-1.9.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8c2ad583743d16ddbdf6bb14b5cd76bf43b0d0006e918809d5d4ddf7bde8dd82"}, {file = "yarl-1.9.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:82aa6264b36c50acfb2424ad5ca537a2060ab6de158a5bd2a72a032cc75b9eb8"}, @@ -5993,6 +6300,7 @@ version = "0.2.2" description = "Zopfli module for python" optional = false python-versions = ">=3.7" +groups = ["main"] files = [ {file = "zopfli-0.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e340851bbdea91408e6713748b4082c2e464a80eef9f9a69ff5a20e5e008cace"}, {file = "zopfli-0.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:093a58fdf1e592f01233fc16900ceb69f27f19b347deb49544df96d912664f6d"}, @@ -6062,6 +6370,6 @@ files = [ test = ["pytest"] [metadata] -lock-version = "2.0" +lock-version = "2.1" python-versions = "3.10.14" -content-hash = "0aa12366838d486e92f0db596d2345b19b0fffb646d82694381814c3f2bc65f8" +content-hash = "7cebdf700e292f00cfa14accb4afb50ded4c86099106fc2cf61a174b04ed0aac" diff --git a/pyproject.toml b/pyproject.toml index 0ffd1d6f..449a2f97 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,6 +20,8 @@ mkdocs-print-site-plugin = "^2.3.6" loguru = "^0.7.2" tabulate = "^0.9.0" dtaidistance = "^2.3.12" +torchdr = "^0.3" +faiss-gpu = "^1.7.2" [tool.poetry.group.darts.dependencies] @@ -38,7 +40,7 @@ plotly = "^6.1.1" [tool.poetry.group.data.dependencies] eerily = "^0.2.1" -ts-bolt = "0.0.6" +ts-bolt = "0.0.7" [tool.poetry.group.torch.dependencies] diff --git a/requirements.txt b/requirements.txt index 7106e41f..6d80f330 100644 --- a/requirements.txt +++ b/requirements.txt @@ -337,12 +337,24 @@ dtaidistance==2.3.12 ; python_full_version == "3.10.14" \ executing==1.2.0 ; python_full_version == "3.10.14" \ --hash=sha256:0314a69e37426e3608aada02473b4161d4caf5a4b244d1d0c48072b8fee7bacc \ --hash=sha256:19da64c18d2d851112f09c287f8d3dbbdf725ab0e569077efb6cdcbd3497c107 +faiss-gpu==1.7.2 ; python_full_version == "3.10.14" \ + --hash=sha256:040a413be699077931b781e470468c6b5084342c5d5773ce8d916f04b25d8c9c \ + --hash=sha256:38796433b2fe43f3a602be18668969af615a3a898e897366e6997b409b0deeab \ + --hash=sha256:3ca9bfa2fda868f438a2f05c1d5aed53021bfaa55b25fd3ae666d2da201f3caf \ + --hash=sha256:c98abc1aac06cb4cb94de223b3186bd4a60d15fd3cae42271604168abc081ca5 \ + --hash=sha256:e85a6bc975b2f233eb056584f33bbce8613c453c9024c099052a423eebabee23 fastjsonschema==2.17.1 ; python_full_version == "3.10.14" \ --hash=sha256:4b90b252628ca695280924d863fe37234eebadc29c5360d322571233dc9746e0 \ --hash=sha256:f4eeb8a77cef54861dbf7424ac8ce71306f12cbb086c45131bcba2c6a4f726e3 +filelock==3.12.0 ; python_full_version == "3.10.14" \ + --hash=sha256:ad98852315c2ab702aeb628412cbf7e95b7ce8c3bf9565670b4eaecf1db370a9 \ + --hash=sha256:fc03ae43288c013d2ea83c8597001b1129db351aad9c57fe2409327916b8e718 fonttools[woff]==4.39.4 ; python_full_version == "3.10.14" \ --hash=sha256:106caf6167c4597556b31a8d9175a3fdc0356fdcd70ab19973c3b0d4c893c461 \ --hash=sha256:dba8d7cdb8e2bac1b3da28c5ed5960de09e59a2fe7e63bb73f5a59e57b0430d2 +fsspec==2023.5.0 ; python_full_version == "3.10.14" \ + --hash=sha256:51a4ad01a5bb66fcc58036e288c0d53d3975a0df2a5dc59a93b59bade0391f2a \ + --hash=sha256:b3b56e00fb93ea321bc9e5d9cf6f8522a0198b20eb24e02774d329e9c6fb84ce ghp-import==2.1.0 ; python_full_version == "3.10.14" \ --hash=sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619 \ --hash=sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343 @@ -364,6 +376,9 @@ jedi==0.18.2 ; python_full_version == "3.10.14" \ jinja2==3.1.2 ; python_full_version == "3.10.14" \ --hash=sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852 \ --hash=sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61 +joblib==1.2.0 ; python_full_version == "3.10.14" \ + --hash=sha256:091138ed78f800342968c523bdde947e7a305b8594b910a0fea2ab83c3c6d385 \ + --hash=sha256:e1cee4a79e4af22881164f218d4311f60074197fb707e082e803b61f6d137018 jsonschema==4.17.3 ; python_full_version == "3.10.14" \ --hash=sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d \ --hash=sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6 @@ -496,6 +511,9 @@ mkdocs==1.5.3 ; python_full_version == "3.10.14" \ mkdocstrings==0.23.0 ; python_full_version == "3.10.14" \ --hash=sha256:051fa4014dfcd9ed90254ae91de2dbb4f24e166347dae7be9a997fe16316c65e \ --hash=sha256:d9c6a37ffbe7c14a7a54ef1258c70b8d394e6a33a1c80832bce40b9567138d1c +mpmath==1.3.0 ; python_full_version == "3.10.14" \ + --hash=sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f \ + --hash=sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c nbclient==0.8.0 ; python_full_version == "3.10.14" \ --hash=sha256:25e861299e5303a0477568557c4045eccc7a34c17fc08e7959558707b9ebe548 \ --hash=sha256:f9b179cd4b2d7bca965f900a2ebf0db4a12ebff2f36a711cb66861e4ae158e55 @@ -508,6 +526,9 @@ nbformat==5.8.0 ; python_full_version == "3.10.14" \ nest-asyncio==1.5.6 ; python_full_version == "3.10.14" \ --hash=sha256:b9a953fb40dceaa587d109609098db21900182b16440652454a146cffb06e8b8 \ --hash=sha256:d267cc1ff794403f7df692964d1d2a3fa9418ffea2a3f6859a439ff482fef290 +networkx==3.1 ; python_full_version == "3.10.14" \ + --hash=sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36 \ + --hash=sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61 numpy==1.24.3 ; python_full_version == "3.10.14" \ --hash=sha256:0ec87a7084caa559c36e0a2309e4ecb1baa03b687201d0a847c8b0ed476a7187 \ --hash=sha256:1a7d6acc2e7524c9955e5c903160aa4ea083736fde7e91276b0e5d98e6332812 \ @@ -537,6 +558,51 @@ numpy==1.24.3 ; python_full_version == "3.10.14" \ --hash=sha256:ea8282b9bcfe2b5e7d491d0bf7f3e2da29700cec05b49e64d6246923329f2b02 \ --hash=sha256:ecde0f8adef7dfdec993fd54b0f78183051b6580f606111a6d789cd14c61ea0c \ --hash=sha256:f21c442fdd2805e91799fbe044a7b999b8571bb0ab0f7850d0cb9641a687092b +nvidia-cublas-cu12==12.4.5.8 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:0f8aa1706812e00b9f19dfe0cdb3999b092ccb8ca168c0db5b8ea712456fd9b3 \ + --hash=sha256:2fc8da60df463fdefa81e323eef2e36489e1c94335b5358bcb38360adf75ac9b \ + --hash=sha256:5a796786da89203a0657eda402bcdcec6180254a8ac22d72213abc42069522dc +nvidia-cuda-cupti-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:5688d203301ab051449a2b1cb6690fbe90d2b372f411521c86018b950f3d7922 \ + --hash=sha256:79279b35cf6f91da114182a5ce1864997fd52294a87a16179ce275773799458a \ + --hash=sha256:9dec60f5ac126f7bb551c055072b69d85392b13311fcc1bcda2202d172df30fb +nvidia-cuda-nvrtc-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:0eedf14185e04b76aa05b1fea04133e59f465b6f960c0cbf4e37c3cb6b0ea198 \ + --hash=sha256:a178759ebb095827bd30ef56598ec182b85547f1508941a3d560eb7ea1fbf338 \ + --hash=sha256:a961b2f1d5f17b14867c619ceb99ef6fcec12e46612711bcec78eb05068a60ec +nvidia-cuda-runtime-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:09c2e35f48359752dfa822c09918211844a3d93c100a715d79b59591130c5e1e \ + --hash=sha256:64403288fa2136ee8e467cdc9c9427e0434110899d07c779f25b5c068934faa5 \ + --hash=sha256:961fe0e2e716a2a1d967aab7caee97512f71767f852f67432d572e36cb3a11f3 +nvidia-cudnn-cu12==9.1.0.70 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f \ + --hash=sha256:6278562929433d68365a07a4a1546c237ba2849852c0d4b2262a486e805b977a +nvidia-cufft-cu12==11.2.1.3 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:5dad8008fc7f92f5ddfa2101430917ce2ffacd86824914c82e28990ad7f00399 \ + --hash=sha256:d802f4954291101186078ccbe22fc285a902136f974d369540fd4a5333d1440b \ + --hash=sha256:f083fc24912aa410be21fa16d157fed2055dab1cc4b6934a0e03cba69eb242b9 +nvidia-curand-cu12==10.3.5.147 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:1f173f09e3e3c76ab084aba0de819c49e56614feae5c12f69883f4ae9bb5fad9 \ + --hash=sha256:a88f583d4e0bb643c49743469964103aa59f7f708d862c3ddb0fc07f851e3b8b \ + --hash=sha256:f307cc191f96efe9e8f05a87096abc20d08845a841889ef78cb06924437f6771 +nvidia-cusolver-cu12==11.6.1.9 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:19e33fa442bcfd085b3086c4ebf7e8debc07cfe01e11513cc6d332fd918ac260 \ + --hash=sha256:d338f155f174f90724bbde3758b7ac375a70ce8e706d70b018dd3375545fc84e \ + --hash=sha256:e77314c9d7b694fcebc84f58989f3aa4fb4cb442f12ca1a9bde50f5e8f6d1b9c +nvidia-cusparse-cu12==12.3.1.170 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:9bc90fb087bc7b4c15641521f31c0371e9a612fc2ba12c338d3ae032e6b6797f \ + --hash=sha256:9d32f62896231ebe0480efd8a7f702e143c98cfaa0e8a76df3386c1ba2b54df3 \ + --hash=sha256:ea4f11a2904e2a8dc4b1833cc1b5181cde564edd0d5cd33e3c168eff2d1863f1 +nvidia-nccl-cu12==2.21.5 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:8579076d30a8c24988834445f8d633c697d42397e92ffc3f63fa26766d25e0a0 +nvidia-nvjitlink-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57 \ + --hash=sha256:4abe7fef64914ccfa909bc2ba39739670ecc9e820c83ccc7a6ed414122599b83 \ + --hash=sha256:fd9020c501d27d135f983c6d3e244b197a7ccad769e34df53a42e276b0e25fa1 +nvidia-nvtx-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:641dccaaa1139f3ffb0d3164b4b84f9d253397e38246a4f2f36728b48566d485 \ + --hash=sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a \ + --hash=sha256:7959ad635db13edf4fc65c06a6e9f9e55fc2f92596db928d169c0bb031e88ef3 packaging==23.1 ; python_full_version == "3.10.14" \ --hash=sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61 \ --hash=sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f @@ -932,6 +998,64 @@ regex==2023.5.5 ; python_full_version == "3.10.14" \ requests==2.31.0 ; python_full_version == "3.10.14" \ --hash=sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f \ --hash=sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1 +scikit-learn==1.7.2 ; python_full_version == "3.10.14" \ + --hash=sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1 \ + --hash=sha256:0b7dacaa05e5d76759fb071558a8b5130f4845166d88654a0f9bdf3eb57851b7 \ + --hash=sha256:191e5550980d45449126e23ed1d5e9e24b2c68329ee1f691a3987476e115e09c \ + --hash=sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda \ + --hash=sha256:2a41e2a0ef45063e654152ec9d8bcfc39f7afce35b08902bfe290c2498a67a6a \ + --hash=sha256:36749fb62b3d961b1ce4fedf08fa57a1986cd409eff2d783bca5d4b9b5fce51c \ + --hash=sha256:4a847fea807e278f821a0406ca01e387f97653e284ecbd9750e3ee7c90347f18 \ + --hash=sha256:502c18e39849c0ea1a5d681af1dbcf15f6cce601aebb657aabbfe84133c1907f \ + --hash=sha256:57dc4deb1d3762c75d685507fbd0bc17160144b2f2ba4ccea5dc285ab0d0e973 \ + --hash=sha256:6088aa475f0785e01bcf8529f55280a3d7d298679f50c0bb70a2364a82d0b290 \ + --hash=sha256:63a9afd6f7b229aad94618c01c252ce9e6fa97918c5ca19c9a17a087d819440c \ + --hash=sha256:6b33579c10a3081d076ab403df4a4190da4f4432d443521674637677dc91e61f \ + --hash=sha256:7a4c328a71785382fe3fe676a9ecf2c86189249beff90bf85e22bdb7efaf9ae0 \ + --hash=sha256:7a58814265dfc52b3295b1900cfb5701589d30a8bb026c7540f1e9d3499d5ec8 \ + --hash=sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d \ + --hash=sha256:8d91a97fa2b706943822398ab943cde71858a50245e31bc71dba62aab1d60a96 \ + --hash=sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1 \ + --hash=sha256:9656e4a53e54578ad10a434dc1f993330568cfee176dff07112b8785fb413106 \ + --hash=sha256:96dc05a854add0e50d3f47a1ef21a10a595016da5b007c7d9cd9d0bffd1fcc61 \ + --hash=sha256:98335fb98509b73385b3ab2bd0639b1f610541d3988ee675c670371d6a87aa7c \ + --hash=sha256:9acb6c5e867447b4e1390930e3944a005e2cb115922e693c08a323421a6966e8 \ + --hash=sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1 \ + --hash=sha256:abebbd61ad9e1deed54cca45caea8ad5f79e1b93173dece40bb8e0c658dbe6fe \ + --hash=sha256:acbc0f5fd2edd3432a22c69bed78e837c70cf896cd7993d71d51ba6708507476 \ + --hash=sha256:b4d6e9deed1a47aca9fe2f267ab8e8fe82ee20b4526b2c0cd9e135cea10feb44 \ + --hash=sha256:bb24510ed3f9f61476181e4db51ce801e2ba37541def12dc9333b946fc7a9cf8 \ + --hash=sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e \ + --hash=sha256:ca250e6836d10e6f402436d6463d6c0e4d8e0234cfb6a9a47835bd392b852ce5 \ + --hash=sha256:e5bf3d930aee75a65478df91ac1225ff89cd28e9ac7bd1196853a9229b6adb0b \ + --hash=sha256:f95dc55b7902b91331fa4e5845dd5bde0580c9cd9612b1b2791b7e80c3d32615 \ + --hash=sha256:fa8f63940e29c82d1e67a45d5297bdebbcb585f5a5a50c4914cc2e852ab77f33 +scipy==1.14.0 ; python_full_version == "3.10.14" \ + --hash=sha256:076c27284c768b84a45dcf2e914d4000aac537da74236a0d45d82c6fa4b7b3c0 \ + --hash=sha256:07e179dc0205a50721022344fb85074f772eadbda1e1b3eecdc483f8033709b7 \ + --hash=sha256:176c6f0d0470a32f1b2efaf40c3d37a24876cebf447498a4cefb947a79c21e9d \ + --hash=sha256:42470ea0195336df319741e230626b6225a740fd9dce9642ca13e98f667047c0 \ + --hash=sha256:4c4161597c75043f7154238ef419c29a64ac4a7c889d588ea77690ac4d0d9b20 \ + --hash=sha256:5b083c8940028bb7e0b4172acafda6df762da1927b9091f9611b0bcd8676f2bc \ + --hash=sha256:64b2ff514a98cf2bb734a9f90d32dc89dc6ad4a4a36a312cd0d6327170339eb0 \ + --hash=sha256:65df4da3c12a2bb9ad52b86b4dcf46813e869afb006e58be0f516bc370165159 \ + --hash=sha256:687af0a35462402dd851726295c1a5ae5f987bd6e9026f52e9505994e2f84ef6 \ + --hash=sha256:6a9c9a9b226d9a21e0a208bdb024c3982932e43811b62d202aaf1bb59af264b1 \ + --hash=sha256:6d056a8709ccda6cf36cdd2eac597d13bc03dba38360f418560a93050c76a16e \ + --hash=sha256:7d3da42fbbbb860211a811782504f38ae7aaec9de8764a9bef6b262de7a2b50f \ + --hash=sha256:7e911933d54ead4d557c02402710c2396529540b81dd554fc1ba270eb7308484 \ + --hash=sha256:94c164a9e2498e68308e6e148646e486d979f7fcdb8b4cf34b5441894bdb9caf \ + --hash=sha256:9e3154691b9f7ed73778d746da2df67a19d046a6c8087c8b385bc4cdb2cfca74 \ + --hash=sha256:9eee2989868e274aae26125345584254d97c56194c072ed96cb433f32f692ed8 \ + --hash=sha256:a01cc03bcdc777c9da3cfdcc74b5a75caffb48a6c39c8450a9a05f82c4250a14 \ + --hash=sha256:a7d46c3e0aea5c064e734c3eac5cf9eb1f8c4ceee756262f2c7327c4c2691c86 \ + --hash=sha256:ad36af9626d27a4326c8e884917b7ec321d8a1841cd6dacc67d2a9e90c2f0359 \ + --hash=sha256:b5923f48cb840380f9854339176ef21763118a7300a88203ccd0bdd26e58527b \ + --hash=sha256:bbc0471b5f22c11c389075d091d3885693fd3f5e9a54ce051b46308bc787e5d4 \ + --hash=sha256:bff2438ea1330e06e53c424893ec0072640dac00f29c6a43a575cbae4c99b2b9 \ + --hash=sha256:c40003d880f39c11c1edbae8144e3813904b10514cd3d3d00c277ae996488cdb \ + --hash=sha256:d91db2c41dd6c20646af280355d41dfa1ec7eead235642178bd57635a3f82209 \ + --hash=sha256:f0a50da861a7ec4573b7c716b2ebdcdf142b66b756a0d392c236ae568b3a93fb six==1.16.0 ; python_full_version == "3.10.14" \ --hash=sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926 \ --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254 @@ -941,15 +1065,42 @@ soupsieve==2.4.1 ; python_full_version == "3.10.14" \ stack-data==0.6.2 ; python_full_version == "3.10.14" \ --hash=sha256:32d2dd0376772d01b6cb9fc996f3c8b57a357089dec328ed4b6553d037eaf815 \ --hash=sha256:cbb2a53eb64e5785878201a97ed7c7b94883f48b87bfb0bbe8b623c74679e4a8 +sympy==1.13.1 ; python_full_version == "3.10.14" \ + --hash=sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f \ + --hash=sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8 tabulate==0.9.0 ; python_full_version == "3.10.14" \ --hash=sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c \ --hash=sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f +threadpoolctl==3.1.0 ; python_full_version == "3.10.14" \ + --hash=sha256:8b99adda265feb6773280df41eece7b2e6561b772d21ffd52e372f999024907b \ + --hash=sha256:a335baacfaa4400ae1f0d8e3a58d6674d2f8828e3716bb2802c44955ad391380 tinycss2==1.2.1 ; python_full_version == "3.10.14" \ --hash=sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847 \ --hash=sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627 toml==0.10.2 ; python_full_version == "3.10.14" \ --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \ --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f +torch==2.5.1 ; python_full_version == "3.10.14" \ + --hash=sha256:1f3b7fb3cf7ab97fae52161423f81be8c6b8afac8d9760823fd623994581e1a3 \ + --hash=sha256:23d062bf70776a3d04dbe74db950db2a5245e1ba4f27208a87f0d743b0d06e86 \ + --hash=sha256:31f8c39660962f9ae4eeec995e3049b5492eb7360dd4f07377658ef4d728fa4c \ + --hash=sha256:32a037bd98a241df6c93e4c789b683335da76a2ac142c0973675b715102dc5fa \ + --hash=sha256:340ce0432cad0d37f5a31be666896e16788f1adf8ad7be481196b503dad675b9 \ + --hash=sha256:34bfa1a852e5714cbfa17f27c49d8ce35e1b7af5608c4bc6e81392c352dbc601 \ + --hash=sha256:3f4b7f10a247e0dcd7ea97dc2d3bfbfc90302ed36d7f3952b0008d0df264e697 \ + --hash=sha256:46c817d3ea33696ad3b9df5e774dba2257e9a4cd3c4a3afbf92f6bb13ac5ce2d \ + --hash=sha256:603c52d2fe06433c18b747d25f5c333f9c1d58615620578c326d66f258686f9a \ + --hash=sha256:71328e1bbe39d213b8721678f9dcac30dfc452a46d586f1d514a6aa0a99d4744 \ + --hash=sha256:73e58e78f7d220917c5dbfad1a40e09df9929d3b95d25e57d9f8558f84c9a11c \ + --hash=sha256:7974e3dce28b5a21fb554b73e1bc9072c25dde873fa00d54280861e7a009d7dc \ + --hash=sha256:8046768b7f6d35b85d101b4b38cba8aa2f3cd51952bc4c06a49580f2ce682291 \ + --hash=sha256:8c712df61101964eb11910a846514011f0b6f5920c55dbf567bff8a34163d5b1 \ + --hash=sha256:9b61edf3b4f6e3b0e0adda8b3960266b9009d02b37555971f4d1c8f7a05afed7 \ + --hash=sha256:de5b7d6740c4b636ef4db92be922f0edc425b65ed78c5076c43c42d362a45457 \ + --hash=sha256:ed231a4b3a5952177fafb661213d690a72caaad97d5824dd4fc17ab9e15cec03 +torchdr==0.3 ; python_full_version == "3.10.14" \ + --hash=sha256:b0bedb5a79788971a1f9d12919922ffd660664757dd44606915feb521f659cc7 \ + --hash=sha256:eb6df12cad9b7fb56bf01a737a670c4a4e67d320f6563059e2f8eccba3904d7d tornado==6.3.2 ; python_full_version == "3.10.14" \ --hash=sha256:05615096845cf50a895026f749195bf0b10b8909f9be672f50b0fe69cba368e4 \ --hash=sha256:0c325e66c8123c606eea33084976c832aa4e766b7dff8aedd7587ea44a604cdf \ @@ -965,6 +1116,15 @@ tornado==6.3.2 ; python_full_version == "3.10.14" \ traitlets==5.9.0 ; python_full_version == "3.10.14" \ --hash=sha256:9e6ec080259b9a5940c797d58b613b5e31441c2257b87c2e795c5228ae80d2d8 \ --hash=sha256:f6cde21a9c68cf756af02035f72d5a723bf607e862e7be33ece505abf4a3bad9 +triton==3.1.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_full_version == "3.10.14" \ + --hash=sha256:0f34f6e7885d1bf0eaaf7ba875a5f0ce6f3c13ba98f9503651c1e6dc6757ed5c \ + --hash=sha256:6b0dd10a925263abbe9fa37dcde67a5e9b2383fc269fdf59f5657cac38c5d1d8 \ + --hash=sha256:6dadaca7fc24de34e180271b5cf864c16755702e9f63a16f62df714a8099126a \ + --hash=sha256:aafa9a20cd0d9fee523cd4504aa7131807a864cd77dcf6efe7e981f18b8c6c11 \ + --hash=sha256:c8182f42fd8080a7d39d666814fa36c5e30cc00ea7eeeb1a2983dbb4c99a0fdc +typing-extensions==4.12.2 ; python_full_version == "3.10.14" \ + --hash=sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d \ + --hash=sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8 urllib3==2.0.2 ; python_full_version == "3.10.14" \ --hash=sha256:61717a1095d7e155cdb737ac7bb2f4324a858a1e2e6466f6d03ff630ca68d3cc \ --hash=sha256:d055c2f9d38dc53c808f6fdc8eab7360b6fdbbde02340ed25cfbcd817c62469e