From a7786f4830a93696afbba5b5b9a971c944137ea7 Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Tue, 15 Nov 2022 11:45:35 +0100 Subject: [PATCH] initial std scaler --- ns-transformer/__init__.py | 9 + ns-transformer/estimator.py | 309 +++++++ ns-transformer/lightning_module.py | 79 ++ ns-transformer/module.py | 675 ++++++++++++++ .../ns-transformer-electricity.ipynb | 858 ++++++++++++++++++ 5 files changed, 1930 insertions(+) create mode 100644 ns-transformer/__init__.py create mode 100644 ns-transformer/estimator.py create mode 100644 ns-transformer/lightning_module.py create mode 100644 ns-transformer/module.py create mode 100644 ns-transformer/ns-transformer-electricity.ipynb diff --git a/ns-transformer/__init__.py b/ns-transformer/__init__.py new file mode 100644 index 0000000..0f8224e --- /dev/null +++ b/ns-transformer/__init__.py @@ -0,0 +1,9 @@ +from .estimator import TransformerEstimator +from .lightning_module import TransformerLightningModule +from .module import TransformerModel + +__all__ = [ + "TransformerModel", + "TransformerLightningModule", + "TransformerEstimator", +] diff --git a/ns-transformer/estimator.py b/ns-transformer/estimator.py new file mode 100644 index 0000000..176eaeb --- /dev/null +++ b/ns-transformer/estimator.py @@ -0,0 +1,309 @@ +from typing import Any, Dict, Iterable, List, Optional + +# + +import torch +from torch.utils.data import DataLoader + +from gluonts.core.component import validated +from gluonts.dataset.common import Dataset +from gluonts.dataset.field_names import FieldName +from gluonts.itertools import Cyclic, IterableSlice, PseudoShuffled +from gluonts.time_feature import TimeFeature, time_features_from_frequency_str +from gluonts.torch.model.estimator import PyTorchLightningEstimator +from gluonts.torch.model.predictor import PyTorchPredictor +from gluonts.torch.distributions import DistributionOutput, StudentTOutput +from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood +from gluonts.torch.util import IterableDataset +from gluonts.transform import ( + AddAgeFeature, + AddObservedValuesIndicator, + AddTimeFeatures, + AsNumpyArray, + Chain, + ExpectedNumInstanceSampler, + InstanceSplitter, + RemoveFields, + SelectFields, + SetField, + TestSplitSampler, + Transformation, + ValidationSplitSampler, + VstackFeatures, +) +from gluonts.transform.sampler import InstanceSampler + +from lightning_module import NSTransformerLightningModule +from module import NSTransformerModel +# - + +PREDICTION_INPUT_NAMES = [ + "feat_static_cat", + "feat_static_real", + "past_time_feat", + "past_target", + "past_observed_values", + "future_time_feat", +] + +TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [ + "future_target", + "future_observed_values", +] + + +class NSTransformerEstimator(PyTorchLightningEstimator): + @validated() + def __init__( + self, + prediction_length: int, + # Transformer arguments + nhead: int, + num_encoder_layers: int, + num_decoder_layers: int, + dim_feedforward: int, + freq: Optional[str] = None, + input_size: int = 1, + activation: str = "gelu", + dropout: float = 0.1, + context_length: Optional[int] = None, + num_feat_dynamic_real: int = 0, + num_feat_static_cat: int = 0, + num_feat_static_real: int = 0, + cardinality: Optional[List[int]] = None, + embedding_dimension: Optional[List[int]] = None, + distr_output: DistributionOutput = StudentTOutput(), + loss: DistributionLoss = NegativeLogLikelihood(), + lags_seq: Optional[List[int]] = None, + time_features: Optional[List[TimeFeature]] = None, + num_parallel_samples: int = 100, + batch_size: int = 32, + num_batches_per_epoch: int = 50, + trainer_kwargs: Optional[Dict[str, Any]] = dict(), + train_sampler: Optional[InstanceSampler] = None, + validation_sampler: Optional[InstanceSampler] = None, + ) -> None: + trainer_kwargs = { + "max_epochs": 100, + **trainer_kwargs, + } + super().__init__(trainer_kwargs=trainer_kwargs) + + self.freq = freq + self.context_length = ( + context_length if context_length is not None else prediction_length + ) + self.prediction_length = prediction_length + self.distr_output = distr_output + self.loss = loss + + self.input_size = input_size + self.nhead = nhead + self.num_encoder_layers = num_encoder_layers + self.num_decoder_layers = num_decoder_layers + self.activation = activation + self.dim_feedforward = dim_feedforward + self.dropout = dropout + + self.num_feat_dynamic_real = num_feat_dynamic_real + self.num_feat_static_cat = num_feat_static_cat + self.num_feat_static_real = num_feat_static_real + self.cardinality = ( + cardinality if cardinality and num_feat_static_cat > 0 else [1] + ) + self.embedding_dimension = embedding_dimension + self.lags_seq = lags_seq + self.time_features = ( + time_features + if time_features is not None + else time_features_from_frequency_str(self.freq) + ) + + self.num_parallel_samples = num_parallel_samples + self.batch_size = batch_size + self.num_batches_per_epoch = num_batches_per_epoch + + self.train_sampler = train_sampler or ExpectedNumInstanceSampler( + num_instances=1.0, min_future=prediction_length + ) + self.validation_sampler = validation_sampler or ValidationSplitSampler( + min_future=prediction_length + ) + + def create_transformation(self) -> Transformation: + remove_field_names = [] + if self.num_feat_static_real == 0: + remove_field_names.append(FieldName.FEAT_STATIC_REAL) + if self.num_feat_dynamic_real == 0: + remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL) + + return Chain( + [RemoveFields(field_names=remove_field_names)] + + ( + [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])] + if not self.num_feat_static_cat > 0 + else [] + ) + + ( + [SetField(output_field=FieldName.FEAT_STATIC_REAL, value=[0.0])] + if not self.num_feat_static_real > 0 + else [] + ) + + [ + AsNumpyArray( + field=FieldName.FEAT_STATIC_CAT, + expected_ndim=1, + dtype=int, + ), + AsNumpyArray( + field=FieldName.FEAT_STATIC_REAL, + expected_ndim=1, + ), + AsNumpyArray( + field=FieldName.TARGET, + # in the following line, we add 1 for the time dimension + expected_ndim=1 + len(self.distr_output.event_shape), + ), + AddObservedValuesIndicator( + target_field=FieldName.TARGET, + output_field=FieldName.OBSERVED_VALUES, + ), + AddTimeFeatures( + start_field=FieldName.START, + target_field=FieldName.TARGET, + output_field=FieldName.FEAT_TIME, + time_features=self.time_features, + pred_length=self.prediction_length, + ), + AddAgeFeature( + target_field=FieldName.TARGET, + output_field=FieldName.FEAT_AGE, + pred_length=self.prediction_length, + log_scale=True, + ), + VstackFeatures( + output_field=FieldName.FEAT_TIME, + input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE] + + ( + [FieldName.FEAT_DYNAMIC_REAL] + if self.num_feat_dynamic_real > 0 + else [] + ), + ), + ] + ) + + def _create_instance_splitter(self, module: NSTransformerLightningModule, mode: str): + assert mode in ["training", "validation", "test"] + + instance_sampler = { + "training": self.train_sampler, + "validation": self.validation_sampler, + "test": TestSplitSampler(), + }[mode] + + return InstanceSplitter( + target_field=FieldName.TARGET, + is_pad_field=FieldName.IS_PAD, + start_field=FieldName.START, + forecast_start_field=FieldName.FORECAST_START, + instance_sampler=instance_sampler, + past_length=module.model._past_length, + future_length=self.prediction_length, + time_series_fields=[ + FieldName.FEAT_TIME, + FieldName.OBSERVED_VALUES, + ], + dummy_value=self.distr_output.value_in_support, + ) + + def create_training_data_loader( + self, + data: Dataset, + module: NSTransformerLightningModule, + shuffle_buffer_length: Optional[int] = None, + **kwargs, + ) -> Iterable: + transformation = self._create_instance_splitter( + module, "training" + ) + SelectFields(TRAINING_INPUT_NAMES) + + training_instances = transformation.apply( + Cyclic(data) + if shuffle_buffer_length is None + else PseudoShuffled( + Cyclic(data), shuffle_buffer_length=shuffle_buffer_length + ) + ) + + return IterableSlice( + iter( + DataLoader( + IterableDataset(training_instances), + batch_size=self.batch_size, + **kwargs, + ) + ), + self.num_batches_per_epoch, + ) + + def create_validation_data_loader( + self, + data: Dataset, + module: NSTransformerLightningModule, + **kwargs, + ) -> Iterable: + transformation = self._create_instance_splitter( + module, "validation" + ) + SelectFields(TRAINING_INPUT_NAMES) + + validation_instances = transformation.apply(data) + + return DataLoader( + IterableDataset(validation_instances), + batch_size=self.batch_size, + **kwargs, + ) + + def create_predictor( + self, + transformation: Transformation, + module: NSTransformerLightningModule, + ) -> PyTorchPredictor: + prediction_splitter = self._create_instance_splitter(module, "test") + + return PyTorchPredictor( + input_transform=transformation + prediction_splitter, + input_names=PREDICTION_INPUT_NAMES, + prediction_net=module.model, + batch_size=self.batch_size, + prediction_length=self.prediction_length, + device=torch.device("cuda" if torch.cuda.is_available() else "cpu"), + ) + + def create_lightning_module(self) -> NSTransformerLightningModule: + model = NSTransformerModel( + freq=self.freq, + context_length=self.context_length, + prediction_length=self.prediction_length, + num_feat_dynamic_real=1 + + self.num_feat_dynamic_real + + len(self.time_features), + num_feat_static_real=max(1, self.num_feat_static_real), + num_feat_static_cat=max(1, self.num_feat_static_cat), + cardinality=self.cardinality, + embedding_dimension=self.embedding_dimension, + # transformer arguments + nhead=self.nhead, + num_encoder_layers=self.num_encoder_layers, + num_decoder_layers=self.num_decoder_layers, + activation=self.activation, + dropout=self.dropout, + dim_feedforward=self.dim_feedforward, + # univariate input + input_size=self.input_size, + distr_output=self.distr_output, + lags_seq=self.lags_seq, + num_parallel_samples=self.num_parallel_samples, + ) + + return NSTransformerLightningModule(model=model, loss=self.loss) diff --git a/ns-transformer/lightning_module.py b/ns-transformer/lightning_module.py new file mode 100644 index 0000000..29cb8db --- /dev/null +++ b/ns-transformer/lightning_module.py @@ -0,0 +1,79 @@ +import pytorch_lightning as pl +import torch +from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood +from gluonts.torch.util import weighted_average +from module import NSTransformerModel + + +class NSTransformerLightningModule(pl.LightningModule): + def __init__( + self, + model: NSTransformerModel, + loss: DistributionLoss = NegativeLogLikelihood(), + lr: float = 1e-3, + weight_decay: float = 1e-8, + ) -> None: + super().__init__() + self.save_hyperparameters() + self.model = model + self.loss = loss + self.lr = lr + self.weight_decay = weight_decay + + def training_step(self, batch, batch_idx: int): + """Execute training step""" + train_loss = self(batch) + self.log( + "train_loss", + train_loss, + on_epoch=True, + on_step=False, + prog_bar=True, + ) + return train_loss + + def validation_step(self, batch, batch_idx: int): + """Execute validation step""" + with torch.inference_mode(): + val_loss = self(batch) + self.log("val_loss", val_loss, on_epoch=True, on_step=False, prog_bar=True) + return val_loss + + def configure_optimizers(self): + """Returns the optimizer to use""" + return torch.optim.Adam( + self.model.parameters(), + lr=self.lr, + weight_decay=self.weight_decay, + ) + + def forward(self, batch): + feat_static_cat = batch["feat_static_cat"] + feat_static_real = batch["feat_static_real"] + past_time_feat = batch["past_time_feat"] + past_target = batch["past_target"] + future_time_feat = batch["future_time_feat"] + future_target = batch["future_target"] + past_observed_values = batch["past_observed_values"] + future_observed_values = batch["future_observed_values"] + + transformer_inputs, loc, scale, _, _, _ = self.model.create_network_inputs( + feat_static_cat, + feat_static_real, + past_time_feat, + past_target, + past_observed_values, + future_time_feat, + future_target, + ) + params = self.model.output_params(transformer_inputs) + distr = self.model.output_distribution(params, loc=loc, scale=scale) + + loss_values = self.loss(distr, future_target) + + if len(self.model.target_shape) == 0: + loss_weights = future_observed_values + else: + loss_weights, _ = future_observed_values.min(dim=-1, keepdim=False) + + return weighted_average(loss_values, weights=loss_weights) diff --git a/ns-transformer/module.py b/ns-transformer/module.py new file mode 100644 index 0000000..60d8915 --- /dev/null +++ b/ns-transformer/module.py @@ -0,0 +1,675 @@ +from typing import List, Optional, Tuple + +import torch +import torch.nn as nn +from gluonts.core.component import validated +from gluonts.time_feature import get_lags_for_frequency +from gluonts.torch.distributions import DistributionOutput, StudentTOutput +from gluonts.torch.modules.feature import FeatureEmbedder + + +class StdScaler(nn.Module): + """ + Computes a std scaling value along + dimension ``dim``, and scales the data accordingly. + + Parameters + ---------- + dim + dimension along which to compute the scale + keepdim + controls whether to retain dimension ``dim`` (of length 1) in the + scale tensor, or suppress it. + minimum_scale + default scale that is used for elements that are constantly zero + along dimension ``dim``. + """ + + @validated() + def __init__( + self, dim: int, keepdim: bool = False, minimum_scale: float = 1e-10 + ): + super().__init__() + assert dim > 0, ( + "Cannot compute scale along dim = 0 (batch dimension), please" + " provide dim > 0" + ) + self.dim = dim + self.keepdim = keepdim + self.register_buffer("minimum_scale", torch.tensor(minimum_scale)) + + def forward( + self, data: torch.Tensor, weights: torch.Tensor + ) -> Tuple[torch.Tensor, torch.Tensor]: + + mean_data = data.mean(self.dim, keepdim=self.keepdim).detach() + + std_data = torch.sqrt(torch.var(data - mean_data, dim=self.dim, keepdim=self.keepdim, unbiased=False) + self.minimum_scale).detach() + + return (data - mean_data) / std_data, mean_data if self.keepdim else mean_data.squeeze(dim=self.dim), std_data if self.keepdim else scale.squeeze( + dim=self.dim + ) + + +class Projector(nn.Module): + ''' + MLP to learn the De-stationary factors + ''' + def __init__(self, enc_in, seq_len, hidden_dims, hidden_layers, output_dim, kernel_size=3): + super(Projector, self).__init__() + + self.series_conv = nn.Conv1d(in_channels=seq_len, out_channels=1, kernel_size=kernel_size, + padding=1, padding_mode='circular', bias=False) + + layers = [nn.Linear(2 * enc_in, hidden_dims[0]), nn.ReLU()] + for i in range(hidden_layers-1): + layers += [nn.Linear(hidden_dims[i], hidden_dims[i+1]), nn.ReLU()] + + layers += [nn.Linear(hidden_dims[-1], output_dim, bias=False)] + self.backbone = nn.Sequential(*layers) + + def forward(self, x, stats): + # x: B x S x E + # stats: B x 1 x E + # y: B x O + batch_size = x.shape[0] + + x = self.series_conv(x) # B x 1 x E + x = torch.cat([x, stats], dim=1) # B x 2 x E + x = x.view(batch_size, -1) # B x 2E + y = self.backbone(x) # B x O + + return y + + +class NSMultiheadAttention(nn.MultiheadAttention): + def forward(self, + query: Tensor, + key: Tensor, + value: Tensor, + tau=None, delta=None, + key_padding_mask: Optional[Tensor] = None, + need_weights: bool = True, + attn_mask: Optional[Tensor] = None, + average_attn_weights: bool = True) -> Tuple[Tensor, Optional[Tensor]]: + r""" + Note:: + Please, refer to :func:`~torch.nn.MultiheadAttention.forward` for more + information + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. When given a binary mask and a value is True, + the corresponding value on the attention layer will be ignored. When given + a byte mask and a value is non-zero, the corresponding value on the attention + layer will be ignored + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + Shape: + - Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. :math:`(N, L, E)` if ``batch_first`` is ``True``. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. :math:`(N, S, E)` if ``batch_first`` is ``True``. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. :math:`(N, S, E)` if ``batch_first`` is ``True``. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the position + with the zero positions will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensure that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + is not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + - average_attn_weights: If true, indicates that the returned ``attn_weights`` should be averaged across + heads. Otherwise, ``attn_weights`` are provided separately per head. Note that this flag only has an + effect when ``need_weights=True.``. Default: True (i.e. average weights across heads) + - Outputs: + - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, + E is the embedding dimension. :math:`(N, L, E)` if ``batch_first`` is ``True``. + - attn_output_weights: If ``average_attn_weights=True``, returns attention weights averaged + across heads of shape :math:`(N, L, S)`, where N is the batch size, L is the target sequence length, + S is the source sequence length. If ``average_attn_weights=False``, returns attention weights per + head of shape :math:`(N, num_heads, L, S)`. + """ + return self._forward_impl(query, key, value, key_padding_mask=key_padding_mask, + need_weights=need_weights, attn_mask=attn_mask, + average_attn_weights=average_attn_weights, tau=tau, delta=delta) + + def _forward_impl(self, + query: Tensor, + key: Tensor, + value: Tensor, + tau=None, delta=None, + key_padding_mask: Optional[Tensor] = None, + need_weights: bool = True, + attn_mask: Optional[Tensor] = None, + average_attn_weights: bool = True) -> Tuple[Tensor, Optional[Tensor]]: + # This version will not deal with the static key/value pairs. + # Keeping it here for future changes. + # + # TODO: This method has some duplicate lines with the + # `torch.nn.functional.multi_head_attention`. Will need to refactor. + static_k = None + static_v = None + + if self.batch_first: + query, key, value = [x.transpose(0, 1) for x in (query, key, value)] + + tgt_len, bsz, embed_dim_to_check = query.size() + assert self.embed_dim == embed_dim_to_check + # allow MHA to have different sizes for the feature dimension + assert key.size(0) == value.size(0) and key.size(1) == value.size(1) + + head_dim = self.embed_dim // self.num_heads + assert head_dim * self.num_heads == self.embed_dim, "embed_dim must be divisible by num_heads" + scaling = float(head_dim) ** -0.5 + + q = self.linear_Q(query) + k = self.linear_K(key) + v = self.linear_V(value) + + q = self.q_scaling_product.mul_scalar(q, scaling) + + if attn_mask is not None: + assert attn_mask.dtype == torch.float32 or attn_mask.dtype == torch.float64 or \ + attn_mask.dtype == torch.float16 or attn_mask.dtype == torch.uint8 or attn_mask.dtype == torch.bool, \ + 'Only float, byte, and bool types are supported for attn_mask, not {}'.format(attn_mask.dtype) + if attn_mask.dtype == torch.uint8: + warnings.warn("Byte tensor for attn_mask in nn.MultiheadAttention is deprecated. Use bool tensor instead.") + attn_mask = attn_mask.to(torch.bool) + + if attn_mask.dim() == 2: + attn_mask = attn_mask.unsqueeze(0) + if list(attn_mask.size()) != [1, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 2D attn_mask is not correct.') + elif attn_mask.dim() == 3: + if list(attn_mask.size()) != [bsz * self.num_heads, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 3D attn_mask is not correct.') + else: + raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim())) + # attn_mask's dim is 3 now. + + # convert ByteTensor key_padding_mask to bool + if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8: + warnings.warn("Byte tensor for key_padding_mask in nn.MultiheadAttention is deprecated. Use bool tensor instead.") + key_padding_mask = key_padding_mask.to(torch.bool) + if self.bias_k is not None and self.bias_v is not None: + if static_k is None and static_v is None: + + # Explicitly assert that bias_k and bias_v are not None + # in a way that TorchScript can understand. + bias_k = self.bias_k + assert bias_k is not None + bias_v = self.bias_v + assert bias_v is not None + + k = torch.cat([k, bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = nnF.pad(attn_mask, (0, 1)) + if key_padding_mask is not None: + key_padding_mask = nnF.pad(key_padding_mask, (0, 1)) + else: + assert static_k is None, "bias cannot be added to static key." + assert static_v is None, "bias cannot be added to static value." + else: + assert self.bias_k is None + assert self.bias_v is None + + q = q.contiguous().view(tgt_len, bsz * self.num_heads, head_dim).transpose(0, 1) + if k is not None: + k = k.contiguous().view(-1, bsz * self.num_heads, head_dim).transpose(0, 1) + if v is not None: + v = v.contiguous().view(-1, bsz * self.num_heads, head_dim).transpose(0, 1) + + if static_k is not None: + assert static_k.size(0) == bsz * self.num_heads + assert static_k.size(2) == head_dim + k = static_k + + if static_v is not None: + assert static_v.size(0) == bsz * self.num_heads + assert static_v.size(2) == head_dim + v = static_v + + src_len = k.size(1) + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if self.add_zero_attn: + src_len += 1 + k_zeros = torch.zeros((k.size(0), 1) + k.size()[2:]) + if k.is_quantized: + k_zeros = torch.quantize_per_tensor(k_zeros, k.q_scale(), k.q_zero_point(), k.dtype) + k = torch.cat([k, k_zeros], dim=1) + v_zeros = torch.zeros((v.size(0), 1) + k.size()[2:]) + if v.is_quantized: + v_zeros = torch.quantize_per_tensor(v_zeros, v.q_scale(), v.q_zero_point(), v.dtype) + v = torch.cat([v, v_zeros], dim=1) + + if attn_mask is not None: + attn_mask = nnF.pad(attn_mask, (0, 1)) + if key_padding_mask is not None: + key_padding_mask = nnF.pad(key_padding_mask, (0, 1)) + + # Leaving the quantized zone here + q = self.dequant_q(q) + k = self.dequant_k(k) + v = self.dequant_v(v) + attn_output_weights = torch.bmm(q, k.transpose(1, 2)) + assert list(attn_output_weights.size()) == [bsz * self.num_heads, tgt_len, src_len] + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + attn_output_weights.masked_fill_(attn_mask, float('-inf')) + else: + attn_output_weights += attn_mask + + if key_padding_mask is not None: + attn_output_weights = attn_output_weights.view(bsz, self.num_heads, tgt_len, src_len) + attn_output_weights = attn_output_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), + float('-inf'), + ) + attn_output_weights = attn_output_weights.view(bsz * self.num_heads, tgt_len, src_len) + + attn_output_weights = nnF.softmax( + attn_output_weights, dim=-1) + attn_output_weights = nnF.dropout(attn_output_weights, p=self.dropout, training=self.training) + + + + tau = 1.0 if tau is None else tau.unsqueeze(1).unsqueeze(1) # B x 1 x 1 x 1 + delta = 0.0 if delta is None else delta.unsqueeze(1).unsqueeze(1) # B x 1 x 1 x S + + attn_output = torch.bmm(attn_output_weights, v)* tau + delta + + + assert list(attn_output.size()) == [bsz * self.num_heads, tgt_len, head_dim] + if self.batch_first: + attn_output = attn_output.view(bsz, tgt_len, self.embed_dim) + else: + attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, self.embed_dim) + + # Reentering the quantized zone + attn_output = self.quant_attn_output(attn_output) + # for the type: ignore[has-type], see https://github.com/pytorch/pytorch/issues/58969 + attn_output = self.out_proj(attn_output) # type: ignore[has-type] + attn_output_weights = self.quant_attn_output_weights(attn_output_weights) + + if need_weights: + # average attention weights over heads + attn_output_weights = attn_output_weights.view(bsz, self.num_heads, tgt_len, src_len) + if average_attn_weights: + attn_output_weights = attn_output_weights.mean(dim=1) + return attn_output, attn_output_weights + else: + return attn_output, None + + + +class NSTransformerModel(nn.Module): + @validated() + def __init__( + self, + context_length: int, + prediction_length: int, + num_feat_dynamic_real: int, + num_feat_static_real: int, + num_feat_static_cat: int, + cardinality: List[int], + # transformer arguments + nhead: int, + num_encoder_layers: int, + num_decoder_layers: int, + dim_feedforward: int, + activation: str = "gelu", + dropout: float = 0.1, + # univariate input + input_size: int = 1, + embedding_dimension: Optional[List[int]] = None, + distr_output: DistributionOutput = StudentTOutput(), + lags_seq: Optional[List[int]] = None, + freq: Optional[str] = None, + num_parallel_samples: int = 100, + ) -> None: + super().__init__() + + self.input_size = input_size + + self.target_shape = distr_output.event_shape + self.num_feat_dynamic_real = num_feat_dynamic_real + self.num_feat_static_cat = num_feat_static_cat + self.num_feat_static_real = num_feat_static_real + self.embedding_dimension = ( + embedding_dimension + if embedding_dimension is not None or cardinality is None + else [min(50, (cat + 1) // 2) for cat in cardinality] + ) + self.lags_seq = lags_seq or get_lags_for_frequency(freq_str=freq) + self.num_parallel_samples = num_parallel_samples + self.history_length = context_length + max(self.lags_seq) + self.embedder = FeatureEmbedder( + cardinalities=cardinality, + embedding_dims=self.embedding_dimension, + ) + + self.scaler = StdScaler(dim=1, keepdim=True) + + + # total feature size + d_model = self.input_size * len(self.lags_seq) + self._number_of_features + + + self.tau_learner = Projector( + enc_in=input_size, + seq_len=context_length, + hidden_dims=[64, 64], + hidden_layers=2, + output_dim=1, + ) + self.delta_learner = Projector( + enc_in=input_size, + seq_len=context_length, + hidden_dims=[64, 64], + hidden_layers=2, + output_dim=context_length, + ) + + self.context_length = context_length + self.prediction_length = prediction_length + self.distr_output = distr_output + self.param_proj = distr_output.get_args_proj(d_model) + + # transformer enc-decoder and mask initializer + self.transformer = nn.Transformer( + d_model=d_model, + nhead=nhead, + num_encoder_layers=num_encoder_layers, + num_decoder_layers=num_decoder_layers, + dim_feedforward=dim_feedforward, + dropout=dropout, + activation=activation, + batch_first=True, + norm_first=True, + ) + + # causal decoder tgt mask + self.register_buffer( + "tgt_mask", + self.transformer.generate_square_subsequent_mask(prediction_length), + ) + + @property + def _number_of_features(self) -> int: + return ( + sum(self.embedding_dimension) + + self.num_feat_dynamic_real + + self.num_feat_static_real + + self.input_size * 2 # the log(scale) and log(loc) + ) + + @property + def _past_length(self) -> int: + return self.context_length + max(self.lags_seq) + + def get_lagged_subsequences( + self, sequence: torch.Tensor, subsequences_length: int, shift: int = 0 + ) -> torch.Tensor: + """ + Returns lagged subsequences of a given sequence. + Parameters + ---------- + sequence : Tensor + the sequence from which lagged subsequences should be extracted. + Shape: (N, T, C). + subsequences_length : int + length of the subsequences to be extracted. + shift: int + shift the lags by this amount back. + Returns + -------- + lagged : Tensor + a tensor of shape (N, S, C, I), where S = subsequences_length and + I = len(indices), containing lagged subsequences. Specifically, + lagged[i, j, :, k] = sequence[i, -indices[k]-S+j, :]. + """ + sequence_length = sequence.shape[1] + indices = [lag - shift for lag in self.lags_seq] + + assert max(indices) + subsequences_length <= sequence_length, ( + f"lags cannot go further than history length, found lag {max(indices)} " + f"while history length is only {sequence_length}" + ) + + lagged_values = [] + for lag_index in indices: + begin_index = -lag_index - subsequences_length + end_index = -lag_index if lag_index > 0 else None + lagged_values.append(sequence[:, begin_index:end_index, ...]) + return torch.stack(lagged_values, dim=-1) + + def _check_shapes( + self, + prior_input: torch.Tensor, + inputs: torch.Tensor, + features: Optional[torch.Tensor], + ) -> None: + assert len(prior_input.shape) == len(inputs.shape) + assert ( + len(prior_input.shape) == 2 and self.input_size == 1 + ) or prior_input.shape[2] == self.input_size + assert (len(inputs.shape) == 2 and self.input_size == 1) or inputs.shape[ + -1 + ] == self.input_size + assert ( + features is None or features.shape[2] == self._number_of_features + ), f"{features.shape[2]}, expected {self._number_of_features}" + + def create_network_inputs( + self, + feat_static_cat: torch.Tensor, + feat_static_real: torch.Tensor, + past_time_feat: torch.Tensor, + past_target: torch.Tensor, + past_observed_values: torch.Tensor, + future_time_feat: Optional[torch.Tensor] = None, + future_target: Optional[torch.Tensor] = None, + ): + # time feature + time_feat = ( + torch.cat( + ( + past_time_feat[:, self._past_length - self.context_length :, ...], + future_time_feat, + ), + dim=1, + ) + if future_target is not None + else past_time_feat[:, self._past_length - self.context_length :, ...] + ) + + # target + context = past_target[:, -self.context_length :] + observed_context = past_observed_values[:, -self.context_length :] + _, loc, scale = self.scaler(context, observed_context) + + + # B x S x E, B x 1 x E -> B x 1, positive scalar + tau = self.tau_learner( + context.unsqueeze(-1) if self.input_size == 1 else context, + scale.unsqueeze(1) if self.input_size == 1 else scale + ).exp() + + # B x S x E, B x 1 x E -> B x S + delta = self.delta_learner( + context.unsqueeze(-1) if self.input_size == 1 else context, + loc.unsqueeze(1) if self.input_size == 1 else loc + ) + + inputs = ( + (torch.cat((past_target, future_target), dim=1) - loc )/ scale + if future_target is not None + else (past_target - loc) / scale + ) + + inputs_length = ( + self._past_length + self.prediction_length + if future_target is not None + else self._past_length + ) + assert inputs.shape[1] == inputs_length + + subsequences_length = ( + self.context_length + self.prediction_length + if future_target is not None + else self.context_length + ) + + # embeddings + embedded_cat = self.embedder(feat_static_cat) + log_scale = scale.log1p() if self.input_size == 1 else scale.squeeze(1).log1p() + log_loc = loc.log1p() if self.input_size == 1 else loc.scale.squeeze(1).log1p() + + static_feat = torch.cat( + (embedded_cat, feat_static_real, log_scale, log_loc), + dim=1, + ) + expanded_static_feat = static_feat.unsqueeze(1).expand( + -1, time_feat.shape[1], -1 + ) + + features = torch.cat((expanded_static_feat, time_feat), dim=-1) + + # self._check_shapes(prior_input, inputs, features) + + # sequence = torch.cat((prior_input, inputs), dim=1) + lagged_sequence = self.get_lagged_subsequences( + sequence=inputs, + subsequences_length=subsequences_length, + ) + + lags_shape = lagged_sequence.shape + reshaped_lagged_sequence = lagged_sequence.reshape( + lags_shape[0], lags_shape[1], -1 + ) + + transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1) + + return transformer_inputs, loc, scale, static_feat, tau, delta + + def output_params(self, transformer_inputs): + enc_input = transformer_inputs[:, : self.context_length, ...] + dec_input = transformer_inputs[:, self.context_length :, ...] + + enc_out = self.transformer.encoder(enc_input) + dec_output = self.transformer.decoder( + dec_input, enc_out, tgt_mask=self.tgt_mask + ) + + return self.param_proj(dec_output) + + @torch.jit.ignore + def output_distribution( + self, params, loc=None, scale=None, trailing_n=None + ) -> torch.distributions.Distribution: + sliced_params = params + if trailing_n is not None: + sliced_params = [p[:, -trailing_n:] for p in params] + return self.distr_output.distribution(sliced_params, loc=loc, scale=scale) + + # for prediction + def forward( + self, + feat_static_cat: torch.Tensor, + feat_static_real: torch.Tensor, + past_time_feat: torch.Tensor, + past_target: torch.Tensor, + past_observed_values: torch.Tensor, + future_time_feat: torch.Tensor, + num_parallel_samples: Optional[int] = None, + ) -> torch.Tensor: + + if num_parallel_samples is None: + num_parallel_samples = self.num_parallel_samples + + encoder_inputs, loc, scale, static_feat, tau, delta = self.create_network_inputs( + feat_static_cat, + feat_static_real, + past_time_feat, + past_target, + past_observed_values, + ) + + enc_out = self.transformer.encoder(encoder_inputs) + + repeated_loc = loc.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + repeated_scale = scale.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + repeated_past_target = ( + (past_target.repeat_interleave(repeats=self.num_parallel_samples, dim=0) -repeated_loc) + / repeated_scale + ) + + expanded_static_feat = static_feat.unsqueeze(1).expand( + -1, future_time_feat.shape[1], -1 + ) + features = torch.cat((expanded_static_feat, future_time_feat), dim=-1) + repeated_features = features.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + repeated_enc_out = enc_out.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + future_samples = [] + + # greedy decoding + for k in range(self.prediction_length): + # self._check_shapes(repeated_past_target, next_sample, next_features) + # sequence = torch.cat((repeated_past_target, next_sample), dim=1) + + lagged_sequence = self.get_lagged_subsequences( + sequence=repeated_past_target, + subsequences_length=1 + k, + shift=1, + ) + + lags_shape = lagged_sequence.shape + reshaped_lagged_sequence = lagged_sequence.reshape( + lags_shape[0], lags_shape[1], -1 + ) + + decoder_input = torch.cat( + (reshaped_lagged_sequence, repeated_features[:, : k + 1]), dim=-1 + ) + + output = self.transformer.decoder(decoder_input, repeated_enc_out) + + params = self.param_proj(output[:, -1:]) + distr = self.output_distribution(params, loc=repeated_loc, scale=repeated_scale) + next_sample = distr.sample() + + repeated_past_target = torch.cat( + (repeated_past_target, (next_sample - repeated_loc) / repeated_scale), dim=1 + ) + future_samples.append(next_sample) + + concat_future_samples = torch.cat(future_samples, dim=1) + return concat_future_samples.reshape( + (-1, self.num_parallel_samples, self.prediction_length) + self.target_shape, + ) diff --git a/ns-transformer/ns-transformer-electricity.ipynb b/ns-transformer/ns-transformer-electricity.ipynb new file mode 100644 index 0000000..cb0f13f --- /dev/null +++ b/ns-transformer/ns-transformer-electricity.ipynb @@ -0,0 +1,858 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7c64affd", + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import islice" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8aa55868", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "import pandas as pd\n", + "from sklearn.manifold import TSNE" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6a730716", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-11-14 22:26:47.623986: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: SSE3 SSE4.1 SSE4.2 AVX AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "from gluonts.dataset.repository.datasets import get_dataset\n", + "from gluonts.dataset.common import ListDataset\n", + "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", + "from gluonts.torch.distributions import NormalOutput\n", + "\n", + "from pytorch_lightning.loggers import CSVLogger\n", + "from datasets import load_dataset\n", + "\n", + "from estimator import NSTransformerEstimator" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fc889c9f", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = get_dataset(\"electricity\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1717d0d2", + "metadata": {}, + "outputs": [], + "source": [ + "estimator = NSTransformerEstimator(\n", + " freq=dataset.metadata.freq,\n", + " prediction_length=dataset.metadata.prediction_length,\n", + " context_length=dataset.metadata.prediction_length*6,\n", + " \n", + " num_feat_static_cat=len(dataset.metadata.feat_static_cat),\n", + " cardinality=[int(cat_feat_info.cardinality) for cat_feat_info in dataset.metadata.feat_static_cat],\n", + " embedding_dimension=[4],\n", + " \n", + " nhead=2,\n", + " num_encoder_layers=4,\n", + " num_decoder_layers=2,\n", + " dim_feedforward=16,\n", + " activation=\"gelu\",\n", + "# distr_output=NormalOutput(),\n", + " \n", + " batch_size=256,\n", + " num_batches_per_epoch=100,\n", + " trainer_kwargs=dict(gpus=\"1\", max_epochs=50, logger=CSVLogger(\".\", \"lightning_logs/\")),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c77b420c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/utilities/parsing.py:262: UserWarning: Attribute 'model' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['model'])`.\n", + " rank_zero_warn(\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/accelerator_connector.py:446: LightningDeprecationWarning: Setting `Trainer(gpus='1')` is deprecated in v1.7 and will be removed in v2.0. Please use `Trainer(accelerator='gpu', devices='1')` instead.\n", + " rank_zero_deprecation(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/configuration_validator.py:108: PossibleUserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------\n", + "0 | model | NSTransformerModel | 120 K \n", + "---------------------------------------------\n", + "120 K Trainable params\n", + "0 Non-trainable params\n", + "120 K Total params\n", + "0.482 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d8479f5987db4a1da3e106c16dd3adb2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/call.py:48: UserWarning: Detected KeyboardInterrupt, attempting graceful shutdown...\n", + " rank_zero_warn(\"Detected KeyboardInterrupt, attempting graceful shutdown...\")\n" + ] + }, + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ /tmp/ipykernel_34976/464979933.py:1 in <module>                                                  │\n",
+       "│                                                                                                  │\n",
+       "│ [Errno 2] No such file or directory: '/tmp/ipykernel_34976/464979933.py'                         │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/gluonts/torch/model/estimator.py:243 in   │\n",
+       "│ train                                                                                            │\n",
+       "│                                                                                                  │\n",
+       "│   240 │   │   ckpt_path: Optional[str] = None,                                                   │\n",
+       "│   241 │   │   **kwargs,                                                                          │\n",
+       "│   242 │   ) -> PyTorchPredictor:                                                                 │\n",
+       "│ ❱ 243 │   │   return self.train_model(                                                           │\n",
+       "│   244 │   │   │   training_data,                                                                 │\n",
+       "│   245 │   │   │   validation_data,                                                               │\n",
+       "│   246 │   │   │   num_workers=num_workers,                                                       │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/gluonts/torch/model/estimator.py:218 in   │\n",
+       "│ train_model                                                                                      │\n",
+       "│                                                                                                  │\n",
+       "│   215 │   │   )                                                                                  │\n",
+       "│   216 │   │                                                                                      │\n",
+       "│   217 │   │   logger.info(f\"Loading best model from {checkpoint.best_model_path}\")               │\n",
+       "│ ❱ 218 │   │   best_model = training_network.load_from_checkpoint(                                │\n",
+       "│   219 │   │   │   checkpoint.best_model_path                                                     │\n",
+       "│   220 │   │   )                                                                                  │\n",
+       "│   221                                                                                            │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/core/saving.py:137 in   │\n",
+       "│ load_from_checkpoint                                                                             │\n",
+       "│                                                                                                  │\n",
+       "│   134 │   │   │   pretrained_model.freeze()                                                      │\n",
+       "│   135 │   │   │   y_hat = pretrained_model(x)                                                    │\n",
+       "│   136 │   │   \"\"\"                                                                                │\n",
+       "│ ❱ 137 │   │   return _load_from_checkpoint(                                                      │\n",
+       "│   138 │   │   │   cls,                                                                           │\n",
+       "│   139 │   │   │   checkpoint_path,                                                               │\n",
+       "│   140 │   │   │   map_location,                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/core/saving.py:158 in   │\n",
+       "│ _load_from_checkpoint                                                                            │\n",
+       "│                                                                                                  │\n",
+       "│   155 │   if map_location is None:                                                               │\n",
+       "│   156 │   │   map_location = cast(_MAP_LOCATION_TYPE, lambda storage, loc: storage)              │\n",
+       "│   157 │   with pl_legacy_patch():                                                                │\n",
+       "│ ❱ 158 │   │   checkpoint = pl_load(checkpoint_path, map_location=map_location)                   │\n",
+       "│   159 │                                                                                          │\n",
+       "│   160 │   if hparams_file is not None:                                                           │\n",
+       "│   161 │   │   extension = str(hparams_file).split(\".\")[-1]                                       │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/lightning_lite/utilities/cloud_io.py:47   │\n",
+       "│ in _load                                                                                         │\n",
+       "│                                                                                                  │\n",
+       "│   44 │   │   │   map_location=map_location,  # type: ignore[arg-type] # upstream annotation i    │\n",
+       "│   45 │   │   )                                                                                   │\n",
+       "│   46 │   fs = get_filesystem(path_or_url)                                                        │\n",
+       "│ ❱ 47 │   with fs.open(path_or_url, \"rb\") as f:                                                   │\n",
+       "│   48 │   │   return torch.load(f, map_location=map_location)                                     │\n",
+       "│   49                                                                                             │\n",
+       "│   50                                                                                             │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/spec.py:1034 in open               │\n",
+       "│                                                                                                  │\n",
+       "│   1031 │   │   │   )                                                                             │\n",
+       "│   1032 │   │   else:                                                                             │\n",
+       "│   1033 │   │   │   ac = kwargs.pop(\"autocommit\", not self._intrans)                              │\n",
+       "│ ❱ 1034 │   │   │   f = self._open(                                                               │\n",
+       "│   1035 │   │   │   │   path,                                                                     │\n",
+       "│   1036 │   │   │   │   mode=mode,                                                                │\n",
+       "│   1037 │   │   │   │   block_size=block_size,                                                    │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/implementations/local.py:162 in    │\n",
+       "│ _open                                                                                            │\n",
+       "│                                                                                                  │\n",
+       "│   159 │   │   path = self._strip_protocol(path)                                                  │\n",
+       "│   160 │   │   if self.auto_mkdir and \"w\" in mode:                                                │\n",
+       "│   161 │   │   │   self.makedirs(self._parent(path), exist_ok=True)                               │\n",
+       "│ ❱ 162 │   │   return LocalFileOpener(path, mode, fs=self, **kwargs)                              │\n",
+       "│   163 │                                                                                          │\n",
+       "│   164 │   def touch(self, path, truncate=True, **kwargs):                                        │\n",
+       "│   165 │   │   path = self._strip_protocol(path)                                                  │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/implementations/local.py:260 in    │\n",
+       "│ __init__                                                                                         │\n",
+       "│                                                                                                  │\n",
+       "│   257 │   │   self.autocommit = autocommit                                                       │\n",
+       "│   258 │   │   self.compression = get_compression(path, compression)                              │\n",
+       "│   259 │   │   self.blocksize = io.DEFAULT_BUFFER_SIZE                                            │\n",
+       "│ ❱ 260 │   │   self._open()                                                                       │\n",
+       "│   261 │                                                                                          │\n",
+       "│   262 │   def _open(self):                                                                       │\n",
+       "│   263 │   │   if self.f is None or self.f.closed:                                                │\n",
+       "│                                                                                                  │\n",
+       "│ /home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/implementations/local.py:265 in    │\n",
+       "│ _open                                                                                            │\n",
+       "│                                                                                                  │\n",
+       "│   262 │   def _open(self):                                                                       │\n",
+       "│   263 │   │   if self.f is None or self.f.closed:                                                │\n",
+       "│   264 │   │   │   if self.autocommit or \"w\" not in self.mode:                                    │\n",
+       "│ ❱ 265 │   │   │   │   self.f = open(self.path, mode=self.mode)                                   │\n",
+       "│   266 │   │   │   │   if self.compression:                                                       │\n",
+       "│   267 │   │   │   │   │   compress = compr[self.compression]                                     │\n",
+       "│   268 │   │   │   │   │   self.f = compress(self.f, mode=self.mode)                              │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "IsADirectoryError: [Errno 21] Is a directory: '/mnt/scratch/kashif/pytorch-transformer-ts/ns-transformer'\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/tmp/ipykernel_34976/\u001b[0m\u001b[1;33m464979933.py\u001b[0m:\u001b[94m1\u001b[0m in \u001b[92m\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[3;31m[Errno 2] No such file or directory: '/tmp/ipykernel_34976/464979933.py'\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/gluonts/torch/model/\u001b[0m\u001b[1;33mestimator.py\u001b[0m:\u001b[94m243\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92mtrain\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m240 \u001b[0m\u001b[2m│ │ \u001b[0mckpt_path: Optional[\u001b[96mstr\u001b[0m] = \u001b[94mNone\u001b[0m, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m241 \u001b[0m\u001b[2m│ │ \u001b[0m**kwargs, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m242 \u001b[0m\u001b[2m│ \u001b[0m) -> PyTorchPredictor: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m243 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m \u001b[96mself\u001b[0m.train_model( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m244 \u001b[0m\u001b[2m│ │ │ \u001b[0mtraining_data, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m245 \u001b[0m\u001b[2m│ │ │ \u001b[0mvalidation_data, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m246 \u001b[0m\u001b[2m│ │ │ \u001b[0mnum_workers=num_workers, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/gluonts/torch/model/\u001b[0m\u001b[1;33mestimator.py\u001b[0m:\u001b[94m218\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92mtrain_model\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m215 \u001b[0m\u001b[2m│ │ \u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m216 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m217 \u001b[0m\u001b[2m│ │ \u001b[0mlogger.info(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mLoading best model from \u001b[0m\u001b[33m{\u001b[0mcheckpoint.best_model_path\u001b[33m}\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m218 \u001b[2m│ │ \u001b[0mbest_model = training_network.load_from_checkpoint( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m219 \u001b[0m\u001b[2m│ │ │ \u001b[0mcheckpoint.best_model_path \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m220 \u001b[0m\u001b[2m│ │ \u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m221 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/core/\u001b[0m\u001b[1;33msaving.py\u001b[0m:\u001b[94m137\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92mload_from_checkpoint\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m134 \u001b[0m\u001b[2;33m│ │ │ \u001b[0m\u001b[33mpretrained_model.freeze()\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m135 \u001b[0m\u001b[2;33m│ │ │ \u001b[0m\u001b[33my_hat = pretrained_model(x)\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m136 \u001b[0m\u001b[2;33m│ │ \u001b[0m\u001b[33m\"\"\"\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m137 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m _load_from_checkpoint( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m138 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mcls\u001b[0m, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m139 \u001b[0m\u001b[2m│ │ │ \u001b[0mcheckpoint_path, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m140 \u001b[0m\u001b[2m│ │ │ \u001b[0mmap_location, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/core/\u001b[0m\u001b[1;33msaving.py\u001b[0m:\u001b[94m158\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92m_load_from_checkpoint\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m155 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m map_location \u001b[95mis\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m156 \u001b[0m\u001b[2m│ │ \u001b[0mmap_location = cast(_MAP_LOCATION_TYPE, \u001b[94mlambda\u001b[0m storage, loc: storage) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m157 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mwith\u001b[0m pl_legacy_patch(): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m158 \u001b[2m│ │ \u001b[0mcheckpoint = pl_load(checkpoint_path, map_location=map_location) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m159 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m160 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m hparams_file \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m161 \u001b[0m\u001b[2m│ │ \u001b[0mextension = \u001b[96mstr\u001b[0m(hparams_file).split(\u001b[33m\"\u001b[0m\u001b[33m.\u001b[0m\u001b[33m\"\u001b[0m)[-\u001b[94m1\u001b[0m] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/lightning_lite/utilities/\u001b[0m\u001b[1;33mcloud_io.py\u001b[0m:\u001b[94m47\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m_load\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m44 \u001b[0m\u001b[2m│ │ │ \u001b[0mmap_location=map_location, \u001b[2m# type: ignore[arg-type] # upstream annotation i\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m45 \u001b[0m\u001b[2m│ │ \u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m46 \u001b[0m\u001b[2m│ \u001b[0mfs = get_filesystem(path_or_url) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m47 \u001b[2m│ \u001b[0m\u001b[94mwith\u001b[0m fs.open(path_or_url, \u001b[33m\"\u001b[0m\u001b[33mrb\u001b[0m\u001b[33m\"\u001b[0m) \u001b[94mas\u001b[0m f: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m48 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m torch.load(f, map_location=map_location) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m49 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m50 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/\u001b[0m\u001b[1;33mspec.py\u001b[0m:\u001b[94m1034\u001b[0m in \u001b[92mopen\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1031 \u001b[0m\u001b[2m│ │ │ \u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1032 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1033 \u001b[0m\u001b[2m│ │ │ \u001b[0mac = kwargs.pop(\u001b[33m\"\u001b[0m\u001b[33mautocommit\u001b[0m\u001b[33m\"\u001b[0m, \u001b[95mnot\u001b[0m \u001b[96mself\u001b[0m._intrans) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1034 \u001b[2m│ │ │ \u001b[0mf = \u001b[96mself\u001b[0m._open( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1035 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mpath, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1036 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mmode=mode, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1037 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mblock_size=block_size, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/implementations/\u001b[0m\u001b[1;33mlocal.py\u001b[0m:\u001b[94m162\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92m_open\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m159 \u001b[0m\u001b[2m│ │ \u001b[0mpath = \u001b[96mself\u001b[0m._strip_protocol(path) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m160 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.auto_mkdir \u001b[95mand\u001b[0m \u001b[33m\"\u001b[0m\u001b[33mw\u001b[0m\u001b[33m\"\u001b[0m \u001b[95min\u001b[0m mode: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m161 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m.makedirs(\u001b[96mself\u001b[0m._parent(path), exist_ok=\u001b[94mTrue\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m162 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m LocalFileOpener(path, mode, fs=\u001b[96mself\u001b[0m, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m163 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m164 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mtouch\u001b[0m(\u001b[96mself\u001b[0m, path, truncate=\u001b[94mTrue\u001b[0m, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m165 \u001b[0m\u001b[2m│ │ \u001b[0mpath = \u001b[96mself\u001b[0m._strip_protocol(path) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/implementations/\u001b[0m\u001b[1;33mlocal.py\u001b[0m:\u001b[94m260\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92m__init__\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m257 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.autocommit = autocommit \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m258 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.compression = get_compression(path, compression) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m259 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.blocksize = io.DEFAULT_BUFFER_SIZE \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m260 \u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._open() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m261 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m262 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_open\u001b[0m(\u001b[96mself\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m263 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.f \u001b[95mis\u001b[0m \u001b[94mNone\u001b[0m \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m.f.closed: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/kashif/.env/pytorch/lib/python3.10/site-packages/fsspec/implementations/\u001b[0m\u001b[1;33mlocal.py\u001b[0m:\u001b[94m265\u001b[0m in \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[92m_open\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m262 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_open\u001b[0m(\u001b[96mself\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m263 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.f \u001b[95mis\u001b[0m \u001b[94mNone\u001b[0m \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m.f.closed: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m264 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.autocommit \u001b[95mor\u001b[0m \u001b[33m\"\u001b[0m\u001b[33mw\u001b[0m\u001b[33m\"\u001b[0m \u001b[95mnot\u001b[0m \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.mode: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m265 \u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m.f = \u001b[96mopen\u001b[0m(\u001b[96mself\u001b[0m.path, mode=\u001b[96mself\u001b[0m.mode) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m266 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.compression: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m267 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mcompress = compr[\u001b[96mself\u001b[0m.compression] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m268 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0m\u001b[96mself\u001b[0m.f = compress(\u001b[96mself\u001b[0m.f, mode=\u001b[96mself\u001b[0m.mode) \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mIsADirectoryError: \u001b[0m\u001b[1m[\u001b[0mErrno \u001b[1;36m21\u001b[0m\u001b[1m]\u001b[0m Is a directory: \u001b[32m'/mnt/scratch/kashif/pytorch-transformer-ts/ns-transformer'\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictor = estimator.train(\n", + " training_data=dataset.train,\n", + " shuffle_buffer_length=1024,\n", + " num_workers=0,\n", + " cache_data=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f8a362b6", + "metadata": {}, + "outputs": [], + "source": [ + "forecast_it, ts_it = make_evaluation_predictions(\n", + " dataset=dataset.test,\n", + " predictor=predictor,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5fdc12da", + "metadata": {}, + "outputs": [], + "source": [ + "forecasts = list(forecast_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4b7d3409", + "metadata": {}, + "outputs": [], + "source": [ + "tss = list(ts_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9b154bde", + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = Evaluator()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0fdec8a7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running evaluation: 2247it [00:00, 5457.58it/s]\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pandas/core/dtypes/astype.py:170: UserWarning: Warning: converting a masked element to nan.\n", + " return arr.astype(dtype, copy=True)\n" + ] + } + ], + "source": [ + "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7f28f4d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 2236509.168963794,\n", + " 'abs_error': 8324822.379784622,\n", + " 'abs_target_sum': 128632956.0,\n", + " 'abs_target_mean': 2385.272140631954,\n", + " 'seasonal_error': 189.49338196116761,\n", + " 'MASE': 0.6698150047439067,\n", + " 'MAPE': 0.08691797733896235,\n", + " 'sMAPE': 0.09759165937855493,\n", + " 'MSIS': 5.569897501694887,\n", + " 'QuantileLoss[0.1]': 3546676.8417349765,\n", + " 'Coverage[0.1]': 0.07493324432576769,\n", + " 'QuantileLoss[0.2]': 5565987.262607762,\n", + " 'Coverage[0.2]': 0.16596202343865896,\n", + " 'QuantileLoss[0.3]': 6942721.682276855,\n", + " 'Coverage[0.3]': 0.2651869158878505,\n", + " 'QuantileLoss[0.4]': 7852264.925932953,\n", + " 'Coverage[0.4]': 0.3690847055333037,\n", + " 'QuantileLoss[0.5]': 8324822.418652334,\n", + " 'Coverage[0.5]': 0.47411363299213766,\n", + " 'QuantileLoss[0.6]': 8340378.741592136,\n", + " 'Coverage[0.6]': 0.5701305444296099,\n", + " 'QuantileLoss[0.7]': 7810405.163447293,\n", + " 'Coverage[0.7]': 0.6769210799584632,\n", + " 'QuantileLoss[0.8]': 6711281.096624529,\n", + " 'Coverage[0.8]': 0.7819685506601394,\n", + " 'QuantileLoss[0.9]': 4796936.551227636,\n", + " 'Coverage[0.9]': 0.883900756564308,\n", + " 'RMSE': 1495.4962952022963,\n", + " 'NRMSE': 0.6269709312104235,\n", + " 'ND': 0.06471764809466574,\n", + " 'wQuantileLoss[0.1]': 0.027572069802508283,\n", + " 'wQuantileLoss[0.2]': 0.04327030518219423,\n", + " 'wQuantileLoss[0.3]': 0.053973117762114206,\n", + " 'wQuantileLoss[0.4]': 0.061043959262919785,\n", + " 'wQuantileLoss[0.5]': 0.06471764839682558,\n", + " 'wQuantileLoss[0.6]': 0.06483858414629091,\n", + " 'wQuantileLoss[0.7]': 0.06071853906122855,\n", + " 'wQuantileLoss[0.8]': 0.052173885334832304,\n", + " 'wQuantileLoss[0.9]': 0.03729166070962123,\n", + " 'mean_absolute_QuantileLoss': 6654608.298232942,\n", + " 'mean_wQuantileLoss': 0.05173330773983723,\n", + " 'MAE_Coverage': 0.02642206068997346,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cc3f804d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 15))\n", + "date_formater = mdates.DateFormatter('%b, %d')\n", + "plt.rcParams.update({'font.size': 15})\n", + "\n", + "for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 9):\n", + " ax = plt.subplot(3, 3, idx+1)\n", + "\n", + " plt.plot(ts[-4 * dataset.metadata.prediction_length:].to_timestamp(), label=\"target\", )\n", + " forecast.plot( color='g')\n", + " plt.xticks(rotation=60)\n", + " ax.xaxis.set_major_formatter(date_formater)\n", + " ax.set_title(forecast.item_id)\n", + "\n", + "plt.gcf().tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6f03bfd2", + "metadata": {}, + "outputs": [], + "source": [ + "metrics = pd.read_csv(\"lightning_logs/version_86/metrics.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "8e76b769", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
train_perplexityepochstepval_losstrain_loss
02.042362049NaNNaN
12.050069099NaNNaN
22.7432270149NaNNaN
32.4409840199NaNNaN
4NaN01994.355846NaN
..................
29580.659866499899NaNNaN
29682.568138499949NaNNaN
29781.211136499999NaNNaN
298NaN4999991.084462NaN
299NaN499999NaN1.707654
\n", + "

300 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " train_perplexity epoch step val_loss train_loss\n", + "0 2.042362 0 49 NaN NaN\n", + "1 2.050069 0 99 NaN NaN\n", + "2 2.743227 0 149 NaN NaN\n", + "3 2.440984 0 199 NaN NaN\n", + "4 NaN 0 199 4.355846 NaN\n", + ".. ... ... ... ... ...\n", + "295 80.659866 49 9899 NaN NaN\n", + "296 82.568138 49 9949 NaN NaN\n", + "297 81.211136 49 9999 NaN NaN\n", + "298 NaN 49 9999 1.084462 NaN\n", + "299 NaN 49 9999 NaN 1.707654\n", + "\n", + "[300 rows x 5 columns]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ad490889", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'perplexity')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = metrics.train_perplexity.dropna().plot(kind=\"line\")\n", + "ax.set_xlabel(\"training steps\")\n", + "ax.set_ylabel(\"perplexity\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "f1185a0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'val neg. log likelihood')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = metrics.val_loss.dropna().plot()\n", + "ax.set_xlabel(\"training steps\")\n", + "ax.set_ylabel(\"val neg. log likelihood\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d887cb3b", + "metadata": {}, + "outputs": [], + "source": [ + "X = predictor.prediction_net.vq_vae.embed.cpu()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ae16d4bd", + "metadata": {}, + "outputs": [], + "source": [ + "X_embedded = TSNE(n_components=2, learning_rate='auto', init='random').fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8feaef88", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X_embedded[:,0], X_embedded[:,1], alpha=1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50a0e3d3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}