From 40981abdb4f83eafc4ba64bd6c836d23044cfca7 Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 10:35:36 +0200 Subject: [PATCH 1/8] initial switch transformer --- switch/.typesafe | 0 switch/__init__.py | 9 + switch/estimator.py | 311 +++ switch/lightning_module.py | 79 + switch/module.py | 561 +++++ switch/switch.ipynb | 4600 ++++++++++++++++++++++++++++++++++++ 6 files changed, 5560 insertions(+) create mode 100644 switch/.typesafe create mode 100644 switch/__init__.py create mode 100644 switch/estimator.py create mode 100644 switch/lightning_module.py create mode 100644 switch/module.py create mode 100644 switch/switch.ipynb diff --git a/switch/.typesafe b/switch/.typesafe new file mode 100644 index 0000000..e69de29 diff --git a/switch/__init__.py b/switch/__init__.py new file mode 100644 index 0000000..25d95ea --- /dev/null +++ b/switch/__init__.py @@ -0,0 +1,9 @@ +from .estimator import SwitchTransformerEstimator +from .lightning_module import SwitchTransformerLightningModule +from .module import SwitchTransformerModel + +__all__ = [ + "SwitchTransformerModel", + "SwitchTransformerLightningModule", + "SwitchTransformerEstimator", +] diff --git a/switch/estimator.py b/switch/estimator.py new file mode 100644 index 0000000..bd08c16 --- /dev/null +++ b/switch/estimator.py @@ -0,0 +1,311 @@ +from typing import Any, Dict, Iterable, List, Optional + +import torch +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.modules.distribution_output 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 SwitchTransformerLightningModule +from module import SwitchTransformerModel +from torch.utils.data import DataLoader + +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 SwitchTransformerEstimator(PyTorchLightningEstimator): + @validated() + def __init__( + self, + freq: str, + prediction_length: int, + # Transformer arguments + nhead: int, + num_encoder_layers: int, + num_decoder_layers: int, + dim_feedforward: int, + 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(), + scaling: bool = True, + 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.scaling = scaling + 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: SwitchTransformerLightningModule, 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: SwitchTransformerLightningModule, + 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: SwitchTransformerLightningModule, + **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: SwitchTransformerLightningModule, + ) -> 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, + freq=self.freq, + prediction_length=self.prediction_length, + device=torch.device("cuda" if torch.cuda.is_available() else "cpu"), + ) + + def create_lightning_module(self) -> SwitchTransformerLightningModule: + model = SwitchTransformerModel( + 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, + scaling=self.scaling, + num_parallel_samples=self.num_parallel_samples, + ) + + return TransformerLightningModule(model=model, loss=self.loss) diff --git a/switch/lightning_module.py b/switch/lightning_module.py new file mode 100644 index 0000000..211db08 --- /dev/null +++ b/switch/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 SwitchTransformerModel + + +class SwitchTransformerLightningModule(pl.LightningModule): + def __init__( + self, + model: SwitchTransformerModel, + 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, 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, 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/switch/module.py b/switch/module.py new file mode 100644 index 0000000..8fb828e --- /dev/null +++ b/switch/module.py @@ -0,0 +1,561 @@ +from typing import List, Optional, Union, Callable + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.nn.modules.transformer import _get_activation_fn, _get_clones +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 +from gluonts.torch.modules.scaler import MeanScaler, NOPScaler + + +class SwitchFeedForward(nn.Module): + """ + ## Routing among multiple FFNs + """ + + def __init__( + self, + *, + capacity_factor: float, + drop_tokens: bool, + is_scale_prob: bool, + n_experts: int, + expert: nn.Module, + d_model: int, + dim_feedforward: int, + ): + """ + * `capacity_factor` is the capacity of each expert as a factor relative to ideally balanced load + * `drop_tokens` specifies whether to drop tokens if more tokens are routed to an expert than the capacity + * `is_scale_prob` specifies whether to multiply the input to the FFN by the routing probability + * `n_experts` is the number of experts + * `expert` is the expert layer, a [FFN module](../feed_forward.html) + * `d_model` is the number of features in a token embedding + """ + super().__init__() + + self.capacity_factor = capacity_factor + self.is_scale_prob = is_scale_prob + self.n_experts = n_experts + self.drop_tokens = drop_tokens + self.dim_feedforward = dim_feedforward + + # make copies of the FFNs + self.experts = _get_clones(expert, n_experts) + # Routing layer and softmax + self.switch = nn.Linear(d_model, n_experts) + self.softmax = nn.Softmax(dim=-1) + + def forward(self, x: torch.Tensor): + """ + * `x` is the input to the switching module with shape `[batch_size, seq_len, d_model]` + """ + + # Capture the shape to change shapes later + batch_size, seq_len, d_model = x.shape + # Flatten the sequence and batch dimensions + x = x.view(-1, d_model) + + # Get routing probabilities for each of the tokens. + # $$p_i(x) = \frac{e^{h(x)_i}}{\sum^N_j e^{h(x)_j}}$$ + # where $N$ is the number of experts `n_experts` and + # $h(\cdot)$ is the linear transformation of token embeddings. + route_prob = self.softmax(self.switch(x)) + + # Get the maximum routing probabilities and the routes. + # We route to the expert with highest probability + route_prob_max, routes = torch.max(route_prob, dim=-1) + + # Get indexes of tokens going to each expert + indexes_list = [ + torch.eq(routes, i).nonzero(as_tuple=True)[0] for i in range(self.n_experts) + ] + + # Initialize an empty tensor to store outputs + final_output = x.new_zeros((batch_size, seq_len, self.dim_feedforward)) + + # Capacity of each expert. + # $$\mathrm{expert\;capacity} = + # \frac{\mathrm{tokens\;per\;batch}}{\mathrm{number\;of\;experts}} + # \times \mathrm{capacity\;factor}$$ + capacity = int(self.capacity_factor * len(x) / self.n_experts) + # Number of tokens routed to each expert. + counts = x.new_tensor([len(indexes_list[i]) for i in range(self.n_experts)]) + + # Initialize an empty list of dropped tokens + dropped = [] + # Only drop tokens if `drop_tokens` is `True`. + if self.drop_tokens: + # Drop tokens in each of the experts + for i in range(self.n_experts): + # Ignore if the expert is not over capacity + if len(indexes_list[i]) <= capacity: + continue + # Shuffle indexes before dropping + indexes_list[i] = indexes_list[i][torch.randperm(len(indexes_list[i]))] + # Collect the tokens over capacity as dropped tokens + dropped.append(indexes_list[i][capacity:]) + # Keep only the tokens upto the capacity of the expert + indexes_list[i] = indexes_list[i][:capacity] + + # Get outputs of the expert FFNs + expert_output = [ + self.experts[i](x[indexes_list[i], :]) for i in range(self.n_experts) + ] + + # Assign to final output + for i in range(self.n_experts): + final_output[indexes_list[i], :] = expert_output[i] + + # Pass through the dropped tokens + if dropped: + dropped = torch.cat(dropped) + final_output[dropped, :] = x[dropped, :] + + if self.is_scale_prob: + # Multiply by the expert outputs by the probabilities $y = p_i(x) E_i(x)$ + final_output = final_output * route_prob_max.view(-1, 1) + else: + # Don't scale the values but multiply by $\frac{p}{\hat{p}} = 1$ so that the gradients flow + # (this is something we experimented with). + final_output = final_output * ( + route_prob_max / route_prob_max.detach() + ).view(-1, 1) + + # Change the shape of the final output back to `[batch_size, seq_len, d_ff]` + final_output = final_output.view(batch_size, seq_len, -1) + + # Return + # + # * the final output + # * number of tokens routed to each expert + # * sum of probabilities for each expert + # * number of tokens dropped. + # * routing probabilities of the selected experts + # + # These are used for the load balancing loss and logging + return final_output, counts, route_prob.sum(0), len(dropped), route_prob_max + + +class TransformerEncoderLayer(nn.Module): + + __constants__ = ["batch_first", "norm_first"] + + def __init__( + self, + d_model: int, + nhead: int, + capacity_factor: int, + drop_tokens: bool, + is_scale_prob: bool, + n_experts: int = 1, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: Union[str, Callable[[torch.Tensor], torch.Tensor]] = F.relu, + layer_norm_eps: float = 1e-5, + batch_first: bool = True, + norm_first: bool = False, + device=None, + dtype=None, + ) -> None: + factory_kwargs = {"device": device, "dtype": dtype} + super(TransformerEncoderLayer, self).__init__() + self.self_attn = nn.MultiheadAttention( + d_model, nhead, dropout=dropout, batch_first=batch_first, **factory_kwargs + ) + # Implementation of Feedforward model + linear = nn.Linear(d_model, dim_feedforward, **factory_kwargs) + self.linear1 = SwitchFeedForward( + capacity_factor, + drop_tokens, + is_scale_prob, + n_experts, + expert=linear, + d_model=d_model, + dim_feedforward=dim_feedforward, + ) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model, **factory_kwargs) + + self.norm_first = norm_first + self.norm1 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs) + self.norm2 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + + # Legacy string support for activation function. + if isinstance(activation, str): + self.activation = _get_activation_fn(activation) + else: + self.activation = activation + + def __setstate__(self, state): + if "activation" not in state: + state["activation"] = F.relu + super(TransformerEncoderLayer, self).__setstate__(state) + + def forward( + self, + src: torch.Tensor, + src_mask: Optional[torch.Tensor] = None, + src_key_padding_mask: Optional[torch.Tensor] = None, + ) -> torch.Tensor: + + x = src + if self.norm_first: + x = x + self._sa_block(self.norm1(x), src_mask, src_key_padding_mask) + x = x + self._ff_block(self.norm2(x)) + else: + x = self.norm1(x + self._sa_block(x, src_mask, src_key_padding_mask)) + x = self.norm2(x + self._ff_block(x)) + + return x + + # self-attention block + def _sa_block( + self, + x: torch.Tensor, + attn_mask: Optional[torch.Tensor], + key_padding_mask: Optional[torch.Tensor], + ) -> torch.Tensor: + x = self.self_attn( + x, + x, + x, + attn_mask=attn_mask, + key_padding_mask=key_padding_mask, + need_weights=False, + )[0] + return self.dropout1(x) + + # feed forward block + def _ff_block(self, x: torch.Tensor) -> torch.Tensor: + x = self.linear2(self.dropout(self.activation(self.linear1(x)))) + return self.dropout2(x) + + +class SwitchTransformerModel(nn.Module): + @validated() + def __init__( + self, + freq: str, + context_length: int, + prediction_length: int, + num_feat_dynamic_real: int, + num_feat_static_real: int, + num_feat_static_cat: int, + cardinality: List[int], + # switch 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, + scaling: bool = True, + 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, + ) + if scaling: + self.scaler = MeanScaler(dim=1, keepdim=True) + else: + self.scaler = NOPScaler(dim=1, keepdim=True) + + # total feature size + d_model = self.input_size * len(self.lags_seq) + self._number_of_features + + 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, + ) + + # 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 + + 1 # the log(scale) + ) + + @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 :] + _, scale = self.scaler(context, observed_context) + + inputs = ( + torch.cat((past_target, future_target), dim=1) / scale + if future_target is not None + else past_target / 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) + static_feat = torch.cat( + (embedded_cat, feat_static_real, scale.log()), + 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, scale, static_feat + + 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, 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, 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, scale, static_feat = 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_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_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, scale=repeated_scale) + next_sample = distr.sample() + + repeated_past_target = torch.cat( + (repeated_past_target, next_sample / 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/switch/switch.ipynb b/switch/switch.ipynb new file mode 100644 index 0000000..63a06e4 --- /dev/null +++ b/switch/switch.ipynb @@ -0,0 +1,4600 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b19f0e22", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bc1a0f32", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/xgboost/compat.py:36: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", + " from pandas import MultiIndex, Int64Index\n" + ] + } + ], + "source": [ + "from typing import List, Optional, Iterable, Dict, Any\n", + "from itertools import islice\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "import tqdm.auto as tqdm\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import DataLoader\n", + "\n", + "import pytorch_lightning as pl\n", + "from pytorch_lightning.loggers import CSVLogger\n", + "\n", + "from gluonts.core.component import validated\n", + "from gluonts.dataset.common import Dataset\n", + "from gluonts.dataset.field_names import FieldName\n", + "from gluonts.itertools import Cyclic, PseudoShuffled, IterableSlice\n", + "from gluonts.time_feature import (\n", + " TimeFeature,\n", + " time_features_from_frequency_str,\n", + ")\n", + "from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood\n", + "from gluonts.transform import (\n", + " Transformation,\n", + " Chain,\n", + " RemoveFields,\n", + " SetField,\n", + " AsNumpyArray,\n", + " AddObservedValuesIndicator,\n", + " AddTimeFeatures,\n", + " AddAgeFeature,\n", + " VstackFeatures,\n", + " InstanceSplitter,\n", + " ValidationSplitSampler,\n", + " TestSplitSampler,\n", + " ExpectedNumInstanceSampler,\n", + " SelectFields,\n", + " InstanceSampler,\n", + ")\n", + "from gluonts.torch.util import (\n", + " IterableDataset,\n", + ")\n", + "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", + "from gluonts.torch.model.estimator import PyTorchLightningEstimator\n", + "from gluonts.torch.model.predictor import PyTorchPredictor\n", + "from gluonts.torch.modules.distribution_output import (\n", + " DistributionOutput,\n", + " StudentTOutput,\n", + ")\n", + "from gluonts.torch.util import weighted_average\n", + "from gluonts.torch.modules.scaler import MeanScaler, NOPScaler\n", + "from gluonts.torch.modules.feature import FeatureEmbedder\n", + "from gluonts.time_feature import get_lags_for_frequency\n", + "from gluonts.dataset.repository.datasets import get_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ac78c47a", + "metadata": {}, + "outputs": [], + "source": [ + "class TransformerModel(nn.Module):\n", + " @validated()\n", + " def __init__(\n", + " self,\n", + " freq: str,\n", + " context_length: int,\n", + " prediction_length: int,\n", + " num_feat_dynamic_real: int,\n", + " num_feat_static_real: int,\n", + " num_feat_static_cat: int,\n", + " cardinality: List[int],\n", + " \n", + " # transformer arguments\n", + " nhead: int,\n", + " num_encoder_layers: int,\n", + " num_decoder_layers: int,\n", + " dim_feedforward: int,\n", + " activation: str = \"gelu\",\n", + " dropout: float = 0.1,\n", + "\n", + " # univariate input\n", + " input_size: int = 1,\n", + " embedding_dimension: Optional[List[int]] = None,\n", + " distr_output: DistributionOutput = StudentTOutput(),\n", + " lags_seq: Optional[List[int]] = None,\n", + " scaling: bool = True,\n", + " num_parallel_samples: int = 100,\n", + " ) -> None:\n", + " super().__init__()\n", + " \n", + " self.input_size = input_size\n", + " \n", + " self.target_shape = distr_output.event_shape\n", + " self.num_feat_dynamic_real = num_feat_dynamic_real\n", + " self.num_feat_static_cat = num_feat_static_cat\n", + " self.num_feat_static_real = num_feat_static_real\n", + " self.embedding_dimension = (\n", + " embedding_dimension\n", + " if embedding_dimension is not None or cardinality is None\n", + " else [min(50, (cat + 1) // 2) for cat in cardinality]\n", + " )\n", + " self.lags_seq = lags_seq or get_lags_for_frequency(freq_str=freq)\n", + " self.num_parallel_samples = num_parallel_samples\n", + " self.history_length = context_length + max(self.lags_seq)\n", + " self.embedder = FeatureEmbedder(\n", + " cardinalities=cardinality,\n", + " embedding_dims=self.embedding_dimension,\n", + " )\n", + " if scaling:\n", + " self.scaler = MeanScaler(dim=1, keepdim=True)\n", + " else:\n", + " self.scaler = NOPScaler(dim=1, keepdim=True)\n", + " \n", + " # total feature size\n", + " d_model = self.input_size * len(self.lags_seq) + self._number_of_features\n", + " \n", + " self.context_length = context_length\n", + " self.prediction_length = prediction_length\n", + " self.distr_output = distr_output\n", + " self.param_proj = distr_output.get_args_proj(d_model)\n", + " \n", + " # transformer enc-decoder and mask initializer\n", + " self.transformer = nn.Transformer(\n", + " d_model=d_model,\n", + " nhead=nhead,\n", + " num_encoder_layers=num_encoder_layers,\n", + " num_decoder_layers=num_decoder_layers,\n", + " dim_feedforward=dim_feedforward,\n", + " dropout=dropout,\n", + " activation=activation,\n", + " batch_first=True,\n", + " )\n", + " \n", + " # causal decoder tgt mask\n", + " self.register_buffer(\n", + " \"tgt_mask\",\n", + " self.transformer.generate_square_subsequent_mask(prediction_length),\n", + " )\n", + " \n", + " @property\n", + " def _number_of_features(self) -> int:\n", + " return (\n", + " sum(self.embedding_dimension)\n", + " + self.num_feat_dynamic_real\n", + " + self.num_feat_static_real\n", + " + 1 # the log(scale)\n", + " )\n", + "\n", + " @property\n", + " def _past_length(self) -> int:\n", + " return self.context_length + max(self.lags_seq)\n", + " \n", + " def get_lagged_subsequences(\n", + " self,\n", + " sequence: torch.Tensor,\n", + " subsequences_length: int,\n", + " shift: int = 0\n", + " ) -> torch.Tensor:\n", + " \"\"\"\n", + " Returns lagged subsequences of a given sequence.\n", + " Parameters\n", + " ----------\n", + " sequence : Tensor\n", + " the sequence from which lagged subsequences should be extracted.\n", + " Shape: (N, T, C).\n", + " subsequences_length : int\n", + " length of the subsequences to be extracted.\n", + " shift: int\n", + " shift the lags by this amount back.\n", + " Returns\n", + " --------\n", + " lagged : Tensor\n", + " a tensor of shape (N, S, C, I), where S = subsequences_length and\n", + " I = len(indices), containing lagged subsequences. Specifically,\n", + " lagged[i, j, :, k] = sequence[i, -indices[k]-S+j, :].\n", + " \"\"\"\n", + " sequence_length = sequence.shape[1]\n", + " indices = [l - shift for l in self.lags_seq]\n", + "\n", + " assert max(indices) + subsequences_length <= sequence_length, (\n", + " f\"lags cannot go further than history length, found lag {max(indices)} \"\n", + " f\"while history length is only {sequence_length}\"\n", + " )\n", + "\n", + " lagged_values = []\n", + " for lag_index in indices:\n", + " begin_index = -lag_index - subsequences_length\n", + " end_index = -lag_index if lag_index > 0 else None\n", + " lagged_values.append(sequence[:, begin_index:end_index, ...])\n", + " return torch.stack(lagged_values, dim=-1)\n", + "\n", + " def _check_shapes(\n", + " self,\n", + " prior_input: torch.Tensor,\n", + " inputs: torch.Tensor,\n", + " features: Optional[torch.Tensor],\n", + " ) -> None:\n", + " assert len(prior_input.shape) == len(inputs.shape)\n", + " assert (\n", + " len(prior_input.shape) == 2 and self.input_size == 1\n", + " ) or prior_input.shape[2] == self.input_size\n", + " assert (len(inputs.shape) == 2 and self.input_size == 1) or inputs.shape[\n", + " -1\n", + " ] == self.input_size\n", + " assert (\n", + " features is None or features.shape[2] == self._number_of_features\n", + " ), f\"{features.shape[2]}, expected {self._number_of_features}\"\n", + " \n", + " \n", + " def create_network_inputs(\n", + " self, \n", + " feat_static_cat: torch.Tensor, \n", + " feat_static_real: torch.Tensor,\n", + " past_time_feat: torch.Tensor,\n", + " past_target: torch.Tensor,\n", + " past_observed_values: torch.Tensor,\n", + " future_time_feat: Optional[torch.Tensor] = None,\n", + " future_target: Optional[torch.Tensor] = None,\n", + " ): \n", + " # time feature\n", + " time_feat = (\n", + " torch.cat(\n", + " (\n", + " past_time_feat[:, self._past_length - self.context_length :, ...],\n", + " future_time_feat,\n", + " ),\n", + " dim=1,\n", + " )\n", + " if future_target is not None\n", + " else past_time_feat[:, self._past_length - self.context_length :, ...]\n", + " )\n", + "\n", + " # target\n", + " context = past_target[:, -self.context_length :]\n", + " observed_context = past_observed_values[:, -self.context_length :]\n", + " _, scale = self.scaler(context, observed_context)\n", + "\n", + " inputs = (\n", + " torch.cat((past_target, future_target), dim=1) / scale\n", + " if future_target is not None\n", + " else past_target / scale\n", + " )\n", + "\n", + " inputs_length = (\n", + " self._past_length + self.prediction_length\n", + " if future_target is not None\n", + " else self._past_length\n", + " )\n", + " assert inputs.shape[1] == inputs_length\n", + " \n", + " subsequences_length = (\n", + " self.context_length + self.prediction_length\n", + " if future_target is not None\n", + " else self.context_length\n", + " )\n", + " \n", + " # embeddings\n", + " embedded_cat = self.embedder(feat_static_cat)\n", + " static_feat = torch.cat(\n", + " (embedded_cat, feat_static_real, scale.log()),\n", + " dim=1,\n", + " )\n", + " expanded_static_feat = static_feat.unsqueeze(1).expand(\n", + " -1, time_feat.shape[1], -1\n", + " )\n", + " \n", + " \n", + " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", + " \n", + " \n", + " #self._check_shapes(prior_input, inputs, features)\n", + "\n", + " #sequence = torch.cat((prior_input, inputs), dim=1)\n", + " lagged_sequence = self.get_lagged_subsequences(\n", + " sequence=inputs,\n", + " subsequences_length=subsequences_length,\n", + " )\n", + "\n", + " lags_shape = lagged_sequence.shape\n", + " reshaped_lagged_sequence = lagged_sequence.reshape(\n", + " lags_shape[0], lags_shape[1], -1\n", + " )\n", + "\n", + "\n", + " transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", + " \n", + " return transformer_inputs, scale, static_feat\n", + " \n", + " def output_params(self, transformer_inputs):\n", + " enc_input = transformer_inputs[:, :self.context_length, ...]\n", + " dec_input = transformer_inputs[:, self.context_length:, ...]\n", + " \n", + " enc_out = self.transformer.encoder(\n", + " enc_input\n", + " )\n", + " dec_output = self.transformer.decoder(\n", + " dec_input,\n", + " enc_out,\n", + " tgt_mask=self.tgt_mask\n", + " )\n", + " \n", + " return self.param_proj(dec_output)\n", + "\n", + " @torch.jit.ignore\n", + " def output_distribution(\n", + " self, params, scale=None, trailing_n=None\n", + " ) -> torch.distributions.Distribution:\n", + " sliced_params = params\n", + " if trailing_n is not None:\n", + " sliced_params = [p[:, -trailing_n:] for p in params]\n", + " return self.distr_output.distribution(sliced_params, scale=scale)\n", + " \n", + " # for prediction\n", + " def forward(\n", + " self,\n", + " feat_static_cat: torch.Tensor,\n", + " feat_static_real: torch.Tensor,\n", + " past_time_feat: torch.Tensor,\n", + " past_target: torch.Tensor,\n", + " past_observed_values: torch.Tensor,\n", + " future_time_feat: torch.Tensor,\n", + " num_parallel_samples: Optional[int] = None,\n", + " ) -> torch.Tensor:\n", + " \n", + " \n", + " if num_parallel_samples is None:\n", + " num_parallel_samples = self.num_parallel_samples\n", + " \n", + " encoder_inputs, scale, static_feat = self.create_network_inputs(\n", + " feat_static_cat,\n", + " feat_static_real,\n", + " past_time_feat,\n", + " past_target,\n", + " past_observed_values,\n", + " )\n", + " \n", + " enc_out = self.transformer.encoder(encoder_inputs)\n", + " \n", + " repeated_scale = scale.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + "\n", + " repeated_past_target = (\n", + " past_target.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + " / repeated_scale\n", + " )\n", + " \n", + " expanded_static_feat = static_feat.unsqueeze(1).expand(\n", + " -1, future_time_feat.shape[1], -1\n", + " )\n", + " features = torch.cat((expanded_static_feat, future_time_feat), dim=-1)\n", + " repeated_features = features.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + " \n", + " repeated_enc_out = enc_out.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + "\n", + " future_samples = []\n", + " \n", + " # greedy decoding\n", + " for k in range(self.prediction_length): \n", + " #self._check_shapes(repeated_past_target, next_sample, next_features)\n", + " #sequence = torch.cat((repeated_past_target, next_sample), dim=1)\n", + " \n", + " lagged_sequence = self.get_lagged_subsequences(\n", + " sequence=repeated_past_target,\n", + " subsequences_length=1+k,\n", + " shift=1, \n", + " )\n", + "\n", + " lags_shape = lagged_sequence.shape\n", + " reshaped_lagged_sequence = lagged_sequence.reshape(\n", + " lags_shape[0], lags_shape[1], -1\n", + " )\n", + " \n", + " decoder_input = torch.cat((reshaped_lagged_sequence, repeated_features[:, : k+1]), dim=-1)\n", + "\n", + " output = self.transformer.decoder(decoder_input, repeated_enc_out)\n", + " \n", + " params = self.param_proj(output[:,-1:])\n", + " distr = self.output_distribution(params, scale=repeated_scale)\n", + " next_sample = distr.sample()\n", + " \n", + " repeated_past_target = torch.cat(\n", + " (repeated_past_target, next_sample / repeated_scale), dim=1\n", + " )\n", + " future_samples.append(next_sample)\n", + "\n", + " concat_future_samples = torch.cat(future_samples, dim=1)\n", + " return concat_future_samples.reshape(\n", + " (-1, self.num_parallel_samples, self.prediction_length)\n", + " + self.target_shape,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a8873ae3", + "metadata": {}, + "outputs": [], + "source": [ + "class TransformerLightningModule(pl.LightningModule):\n", + " def __init__(\n", + " self,\n", + " model: TransformerModel,\n", + " loss: DistributionLoss = NegativeLogLikelihood(),\n", + " lr: float = 1e-3,\n", + " weight_decay: float = 1e-8,\n", + " ) -> None:\n", + " super().__init__()\n", + " self.save_hyperparameters()\n", + " self.model = model\n", + " self.loss = loss\n", + " self.lr = lr\n", + " self.weight_decay = weight_decay\n", + " \n", + " def training_step(self, batch, batch_idx: int):\n", + " \"\"\"Execute training step\"\"\"\n", + " train_loss = self(batch)\n", + " self.log(\n", + " \"train_loss\",\n", + " train_loss,\n", + " on_epoch=True,\n", + " on_step=False,\n", + " prog_bar=True,\n", + " )\n", + " return train_loss\n", + "\n", + " def validation_step(self, batch, batch_idx: int):\n", + " \"\"\"Execute validation step\"\"\"\n", + " with torch.inference_mode():\n", + " val_loss = self(batch)\n", + " self.log(\n", + " \"val_loss\", val_loss, on_epoch=True, on_step=False, prog_bar=True\n", + " )\n", + " return val_loss\n", + "\n", + " def configure_optimizers(self):\n", + " \"\"\"Returns the optimizer to use\"\"\"\n", + " return torch.optim.Adam(\n", + " self.model.parameters(),\n", + " lr=self.lr,\n", + " weight_decay=self.weight_decay,\n", + " )\n", + "\n", + " def forward(self, batch):\n", + " feat_static_cat = batch[\"feat_static_cat\"]\n", + " feat_static_real = batch[\"feat_static_real\"]\n", + " past_time_feat = batch[\"past_time_feat\"]\n", + " past_target = batch[\"past_target\"]\n", + " future_time_feat = batch[\"future_time_feat\"]\n", + " future_target = batch[\"future_target\"]\n", + " past_observed_values = batch[\"past_observed_values\"]\n", + " future_observed_values = batch[\"future_observed_values\"]\n", + " \n", + " transformer_inputs, scale, _ = self.model.create_network_inputs(\n", + " feat_static_cat,\n", + " feat_static_real,\n", + " past_time_feat,\n", + " past_target,\n", + " past_observed_values,\n", + " future_time_feat,\n", + " future_target,\n", + " )\n", + " params = self.model.output_params(transformer_inputs)\n", + " distr = self.model.output_distribution(params, scale)\n", + "\n", + " loss_values = self.loss(distr, future_target)\n", + " \n", + " if len(self.model.target_shape) == 0:\n", + " loss_weights = future_observed_values\n", + " else:\n", + " loss_weights = future_observed_values.min(dim=-1, keepdim=False)\n", + "\n", + " return weighted_average(loss_values, weights=loss_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "99d97334", + "metadata": {}, + "outputs": [], + "source": [ + "PREDICTION_INPUT_NAMES = [\n", + " \"feat_static_cat\",\n", + " \"feat_static_real\",\n", + " \"past_time_feat\",\n", + " \"past_target\",\n", + " \"past_observed_values\",\n", + " \"future_time_feat\",\n", + "]\n", + "\n", + "TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [\n", + " \"future_target\",\n", + " \"future_observed_values\",\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bc39c0e9", + "metadata": {}, + "outputs": [], + "source": [ + "class TransformerEstimator(PyTorchLightningEstimator):\n", + " @validated()\n", + " def __init__(\n", + " self,\n", + " freq: str,\n", + " prediction_length: int,\n", + " \n", + " # Transformer arguments\n", + " nhead: int,\n", + " num_encoder_layers: int,\n", + " num_decoder_layers: int,\n", + " dim_feedforward: int,\n", + " input_size: int = 1,\n", + " activation: str = \"gelu\",\n", + " dropout: float = 0.1,\n", + "\n", + " context_length: Optional[int] = None,\n", + "\n", + " num_feat_dynamic_real: int = 0,\n", + " num_feat_static_cat: int = 0,\n", + " num_feat_static_real: int = 0,\n", + " cardinality: Optional[List[int]] = None,\n", + " embedding_dimension: Optional[List[int]] = None,\n", + " distr_output: DistributionOutput = StudentTOutput(),\n", + " loss: DistributionLoss = NegativeLogLikelihood(),\n", + " scaling: bool = True,\n", + " lags_seq: Optional[List[int]] = None,\n", + " time_features: Optional[List[TimeFeature]] = None,\n", + " num_parallel_samples: int = 100,\n", + " batch_size: int = 32,\n", + " num_batches_per_epoch: int = 50,\n", + " trainer_kwargs: Optional[Dict[str, Any]] = dict(),\n", + " train_sampler: Optional[InstanceSampler] = None,\n", + " validation_sampler: Optional[InstanceSampler] = None,\n", + " ) -> None:\n", + " trainer_kwargs = {\n", + " \"max_epochs\": 100,\n", + " **trainer_kwargs,\n", + " }\n", + " super().__init__(trainer_kwargs=trainer_kwargs)\n", + " \n", + " self.freq = freq\n", + " self.context_length = (\n", + " context_length if context_length is not None else prediction_length\n", + " )\n", + " self.prediction_length = prediction_length\n", + " self.distr_output = distr_output\n", + " self.loss = loss\n", + " \n", + " self.input_size = input_size\n", + " self.nhead = nhead\n", + " self.num_encoder_layers = num_encoder_layers\n", + " self.num_decoder_layers = num_decoder_layers\n", + " self.activation = activation\n", + " self.dim_feedforward = dim_feedforward\n", + " self.dropout = dropout\n", + " \n", + " self.num_feat_dynamic_real = num_feat_dynamic_real\n", + " self.num_feat_static_cat = num_feat_static_cat\n", + " self.num_feat_static_real = num_feat_static_real\n", + " self.cardinality = (\n", + " cardinality if cardinality and num_feat_static_cat > 0 else [1]\n", + " )\n", + " self.embedding_dimension = embedding_dimension\n", + " self.scaling = scaling\n", + " self.lags_seq = lags_seq\n", + " self.time_features = (\n", + " time_features\n", + " if time_features is not None\n", + " else time_features_from_frequency_str(self.freq)\n", + " )\n", + "\n", + " self.num_parallel_samples = num_parallel_samples\n", + " self.batch_size = batch_size\n", + " self.num_batches_per_epoch = num_batches_per_epoch\n", + "\n", + " self.train_sampler = train_sampler or ExpectedNumInstanceSampler(\n", + " num_instances=1.0, min_future=prediction_length\n", + " )\n", + " self.validation_sampler = validation_sampler or ValidationSplitSampler(\n", + " min_future=prediction_length\n", + " )\n", + " \n", + " def create_transformation(self) -> Transformation:\n", + " remove_field_names = []\n", + " if self.num_feat_static_real == 0:\n", + " remove_field_names.append(FieldName.FEAT_STATIC_REAL)\n", + " if self.num_feat_dynamic_real == 0:\n", + " remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)\n", + "\n", + " return Chain(\n", + " [RemoveFields(field_names=remove_field_names)]\n", + " + (\n", + " [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])]\n", + " if not self.num_feat_static_cat > 0\n", + " else []\n", + " )\n", + " + (\n", + " [\n", + " SetField(\n", + " output_field=FieldName.FEAT_STATIC_REAL, value=[0.0]\n", + " )\n", + " ]\n", + " if not self.num_feat_static_real > 0\n", + " else []\n", + " )\n", + " + [\n", + " AsNumpyArray(\n", + " field=FieldName.FEAT_STATIC_CAT,\n", + " expected_ndim=1,\n", + " dtype=int,\n", + " ),\n", + " AsNumpyArray(\n", + " field=FieldName.FEAT_STATIC_REAL,\n", + " expected_ndim=1,\n", + " ),\n", + " AsNumpyArray(\n", + " field=FieldName.TARGET,\n", + " # in the following line, we add 1 for the time dimension\n", + " expected_ndim=1 + len(self.distr_output.event_shape),\n", + " ),\n", + " AddObservedValuesIndicator(\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.OBSERVED_VALUES,\n", + " ),\n", + " AddTimeFeatures(\n", + " start_field=FieldName.START,\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.FEAT_TIME,\n", + " time_features=self.time_features,\n", + " pred_length=self.prediction_length,\n", + " ),\n", + " AddAgeFeature(\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.FEAT_AGE,\n", + " pred_length=self.prediction_length,\n", + " log_scale=True,\n", + " ),\n", + " VstackFeatures(\n", + " output_field=FieldName.FEAT_TIME,\n", + " input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE]\n", + " + (\n", + " [FieldName.FEAT_DYNAMIC_REAL]\n", + " if self.num_feat_dynamic_real > 0\n", + " else []\n", + " ),\n", + " ),\n", + " ]\n", + " )\n", + "\n", + " def _create_instance_splitter(\n", + " self, module: TransformerLightningModule, mode: str\n", + " ):\n", + " assert mode in [\"training\", \"validation\", \"test\"]\n", + "\n", + " instance_sampler = {\n", + " \"training\": self.train_sampler,\n", + " \"validation\": self.validation_sampler,\n", + " \"test\": TestSplitSampler(),\n", + " }[mode]\n", + "\n", + " return InstanceSplitter(\n", + " target_field=FieldName.TARGET,\n", + " is_pad_field=FieldName.IS_PAD,\n", + " start_field=FieldName.START,\n", + " forecast_start_field=FieldName.FORECAST_START,\n", + " instance_sampler=instance_sampler,\n", + " past_length=module.model._past_length,\n", + " future_length=self.prediction_length,\n", + " time_series_fields=[\n", + " FieldName.FEAT_TIME,\n", + " FieldName.OBSERVED_VALUES,\n", + " ],\n", + " dummy_value=self.distr_output.value_in_support,\n", + " )\n", + "\n", + " def create_training_data_loader(\n", + " self,\n", + " data: Dataset,\n", + " module: TransformerLightningModule,\n", + " shuffle_buffer_length: Optional[int] = None,\n", + " **kwargs,\n", + " ) -> Iterable:\n", + " transformation = self._create_instance_splitter(\n", + " module, \"training\"\n", + " ) + SelectFields(TRAINING_INPUT_NAMES)\n", + "\n", + " training_instances = transformation.apply(\n", + " Cyclic(data)\n", + " if shuffle_buffer_length is None\n", + " else PseudoShuffled(\n", + " Cyclic(data), shuffle_buffer_length=shuffle_buffer_length\n", + " )\n", + " )\n", + "\n", + " return IterableSlice(\n", + " iter(\n", + " DataLoader(\n", + " IterableDataset(training_instances),\n", + " batch_size=self.batch_size,\n", + " **kwargs,\n", + " )\n", + " ),\n", + " self.num_batches_per_epoch,\n", + " )\n", + "\n", + " def create_validation_data_loader(\n", + " self,\n", + " data: Dataset,\n", + " module: TransformerLightningModule,\n", + " **kwargs,\n", + " ) -> Iterable:\n", + " transformation = self._create_instance_splitter(\n", + " module, \"validation\"\n", + " ) + SelectFields(TRAINING_INPUT_NAMES)\n", + "\n", + " validation_instances = transformation.apply(data)\n", + "\n", + " return DataLoader(\n", + " IterableDataset(validation_instances),\n", + " batch_size=self.batch_size,\n", + " **kwargs,\n", + " )\n", + " \n", + " def create_predictor(\n", + " self,\n", + " transformation: Transformation,\n", + " module: TransformerLightningModule,\n", + " ) -> PyTorchPredictor:\n", + " prediction_splitter = self._create_instance_splitter(module, \"test\")\n", + "\n", + " return PyTorchPredictor(\n", + " input_transform=transformation + prediction_splitter,\n", + " input_names=PREDICTION_INPUT_NAMES,\n", + " prediction_net=module.model,\n", + " batch_size=self.batch_size,\n", + " freq=self.freq,\n", + " prediction_length=self.prediction_length,\n", + " device=torch.device('cuda' if torch.cuda.is_available() else 'cpu'),\n", + " )\n", + "\n", + " def create_lightning_module(self) -> TransformerLightningModule:\n", + " model = TransformerModel(\n", + " freq=self.freq,\n", + " context_length=self.context_length,\n", + " prediction_length=self.prediction_length,\n", + " num_feat_dynamic_real=1 + self.num_feat_dynamic_real + len(self.time_features),\n", + " num_feat_static_real=max(1, self.num_feat_static_real),\n", + " num_feat_static_cat=max(1, self.num_feat_static_cat),\n", + " cardinality=self.cardinality,\n", + " embedding_dimension=self.embedding_dimension,\n", + "\n", + " # transformer arguments\n", + " nhead=self.nhead,\n", + " num_encoder_layers=self.num_encoder_layers,\n", + " num_decoder_layers=self.num_decoder_layers,\n", + " activation=self.activation,\n", + " dropout=self.dropout,\n", + " dim_feedforward=self.dim_feedforward,\n", + "\n", + " # univariate input\n", + " input_size=self.input_size,\n", + " distr_output=self.distr_output,\n", + " lags_seq=self.lags_seq,\n", + " scaling=self.scaling,\n", + " num_parallel_samples=self.num_parallel_samples,\n", + " )\n", + " \n", + " return TransformerLightningModule(model=model, loss=self.loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f1c38a2a", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = get_dataset(\"electricity\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dc5f66a9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "TrainDatasets(metadata=MetaData(freq='1H', target=None, feat_static_cat=[CategoricalFeatureInfo(name='feat_static_cat', cardinality='321')], feat_static_real=[], feat_dynamic_real=[], feat_dynamic_cat=[], prediction_length=24), train=, test=)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "6e17f04e", + "metadata": {}, + "outputs": [], + "source": [ + "estimator = TransformerEstimator(\n", + " freq=dataset.metadata.freq,\n", + " prediction_length=dataset.metadata.prediction_length,\n", + "\n", + " nhead=2,\n", + " num_encoder_layers=2,\n", + " num_decoder_layers=2,\n", + " dim_feedforward=32,\n", + " activation=\"gelu\",\n", + " \n", + " num_feat_static_cat=1,\n", + " cardinality=[321],\n", + " embedding_dimension=[5],\n", + " \n", + " batch_size=128,\n", + " num_batches_per_epoch=100,\n", + " trainer_kwargs=dict(max_epochs=20, accelerator='auto', gpus=1),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ed0d8504", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | model | TransformerModel | 82.8 K\n", + "1 | loss | NegativeLogLikelihood | 0 \n", + "------------------------------------------------\n", + "82.8 K Trainable params\n", + "0 Non-trainable params\n", + "82.8 K Total params\n", + "0.331 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6c85fc01474d4be7af31b881893ef179", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 0, global step 99: val_loss reached 5.88591 (best 5.88591), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=0-step=99.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 1, global step 199: val_loss reached 5.62166 (best 5.62166), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=1-step=199.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 2, global step 299: val_loss reached 5.46650 (best 5.46650), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=2-step=299.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 3, global step 399: val_loss reached 5.35825 (best 5.35825), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=3-step=399.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 4, global step 499: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 5, global step 599: val_loss reached 5.28393 (best 5.28393), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=5-step=599.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 6, global step 699: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 7, global step 799: val_loss reached 5.28351 (best 5.28351), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=7-step=799.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 8, global step 899: val_loss reached 5.26218 (best 5.26218), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=8-step=899.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 9, global step 999: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 10, global step 1099: val_loss reached 5.14227 (best 5.14227), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=10-step=1099.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 11, global step 1199: val_loss reached 5.11745 (best 5.11745), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=11-step=1199.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 12, global step 1299: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 13, global step 1399: val_loss reached 5.11113 (best 5.11113), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=13-step=1399.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 14, global step 1499: val_loss reached 5.09926 (best 5.09926), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=14-step=1499.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 15, global step 1599: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 16, global step 1699: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 17, global step 1799: val_loss was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 18, global step 1899: val_loss reached 5.05392 (best 5.05392), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=18-step=1899.ckpt\" as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 19, global step 1999: val_loss reached 5.05254 (best 5.05254), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=19-step=1999.ckpt\" as top 1\n" + ] + } + ], + "source": [ + "predictor = estimator.train(\n", + " training_data=dataset.train,\n", + " validation_data=dataset.test,\n", + " num_workers=16,\n", + " shuffle_buffer_length=1024\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "4f319643", + "metadata": {}, + "outputs": [], + "source": [ + "forecast_it, ts_it = make_evaluation_predictions(\n", + " dataset=dataset.test, \n", + " predictor=predictor\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "c4d84519", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + } + ], + "source": [ + "forecasts = list(forecast_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fcfa0dc3", + "metadata": {}, + "outputs": [], + "source": [ + "tss = list(ts_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "4239bdbb", + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = Evaluator()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "bf9638c4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running evaluation: 2247it [00:00, 3817.35it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pandas/core/construction.py:781: UserWarning: Warning: converting a masked element to nan.\n", + " subarr = np.array(arr, dtype=dtype, copy=copy)\n" + ] + } + ], + "source": [ + "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "58151870", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 2290308.638491056,\n", + " 'abs_error': 8935766.12021637,\n", + " 'abs_target_sum': 128632956.0,\n", + " 'abs_target_mean': 2385.272140631954,\n", + " 'seasonal_error': 189.49338196116761,\n", + " 'MASE': 0.7702394584937287,\n", + " 'MAPE': 0.09905294725225479,\n", + " 'sMAPE': 0.11066244638590851,\n", + " 'MSIS': 6.179870294636366,\n", + " 'QuantileLoss[0.1]': 4123019.1300659077,\n", + " 'Coverage[0.1]': 0.10990580032636107,\n", + " 'QuantileLoss[0.2]': 6267998.181722605,\n", + " 'Coverage[0.2]': 0.21773475745438362,\n", + " 'QuantileLoss[0.3]': 7668596.503774263,\n", + " 'Coverage[0.3]': 0.3327028630766949,\n", + " 'QuantileLoss[0.4]': 8546316.953158284,\n", + " 'Coverage[0.4]': 0.44765242545616374,\n", + " 'QuantileLoss[0.5]': 8935766.081627503,\n", + " 'Coverage[0.5]': 0.5612297878653019,\n", + " 'QuantileLoss[0.6]': 8830596.935430296,\n", + " 'Coverage[0.6]': 0.6539460020768433,\n", + " 'QuantileLoss[0.7]': 8159344.228591463,\n", + " 'Coverage[0.7]': 0.75072318647085,\n", + " 'QuantileLoss[0.8]': 6832265.371796237,\n", + " 'Coverage[0.8]': 0.8361704494882065,\n", + " 'QuantileLoss[0.9]': 4622603.4241216,\n", + " 'Coverage[0.9]': 0.9121977451416704,\n", + " 'RMSE': 1513.3765686342101,\n", + " 'NRMSE': 0.6344670458580278,\n", + " 'ND': 0.06946715987943533,\n", + " 'wQuantileLoss[0.1]': 0.03205258790807783,\n", + " 'wQuantileLoss[0.2]': 0.04872777845300084,\n", + " 'wQuantileLoss[0.3]': 0.05961611038289646,\n", + " 'wQuantileLoss[0.4]': 0.06643955965031452,\n", + " 'wQuantileLoss[0.5]': 0.06946715957944326,\n", + " 'wQuantileLoss[0.6]': 0.06864956858668704,\n", + " 'wQuantileLoss[0.7]': 0.06343121142758675,\n", + " 'wQuantileLoss[0.8]': 0.05311442405005633,\n", + " 'wQuantileLoss[0.9]': 0.035936384950382386,\n", + " 'mean_absolute_QuantileLoss': 7109611.867809796,\n", + " 'mean_wQuantileLoss': 0.055270531665382816,\n", + " 'MAE_Coverage': 0.035807001928497256,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "d61f32ab", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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:], label=\"target\", )\n", + " forecast.plot( color='g')\n", + " plt.xticks(rotation=60)\n", + " ax.xaxis.set_major_formatter(date_formater)\n", + "\n", + "plt.gcf().tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "d494463f", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_prob_forecasts(ts_entry, forecast_entry):\n", + " plot_length = 70\n", + " prediction_intervals = (50.0, 90.0)\n", + " legend = [\"observations\", \"median prediction\"] + [f\"{k}% prediction interval\" for k in prediction_intervals][::-1]\n", + "\n", + " fig, ax = plt.subplots(1, 1, figsize=(10, 7))\n", + " ts_entry[-plot_length:].plot(ax=ax) # plot the time series\n", + " forecast_entry.plot(prediction_intervals=prediction_intervals, color='g')\n", + " plt.grid(which=\"both\")\n", + " plt.legend(legend, loc=\"best\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "5256fde1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index = 123\n", + "plot_prob_forecasts(tss[index], forecasts[index])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66a41556", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a429cef13ddd880234ca46bf0bebdfaaf7065ffd Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 11:04:43 +0200 Subject: [PATCH 2/8] added switch encoder layer --- switch/module.py | 43 ++++++++++++++++++++++++++++++++++--------- 1 file changed, 34 insertions(+), 9 deletions(-) diff --git a/switch/module.py b/switch/module.py index 8fb828e..036d66a 100644 --- a/switch/module.py +++ b/switch/module.py @@ -131,7 +131,7 @@ class SwitchFeedForward(nn.Module): # Return # # * the final output - # * number of tokens routed to each expert + # * counts: number of tokens routed to each expert # * sum of probabilities for each expert # * number of tokens dropped. # * routing probabilities of the selected experts @@ -140,7 +140,7 @@ class SwitchFeedForward(nn.Module): return final_output, counts, route_prob.sum(0), len(dropped), route_prob_max -class TransformerEncoderLayer(nn.Module): +class SwitchTransformerEncoderLayer(nn.Module): __constants__ = ["batch_first", "norm_first"] @@ -148,7 +148,7 @@ class TransformerEncoderLayer(nn.Module): self, d_model: int, nhead: int, - capacity_factor: int, + capacity_factor: float, drop_tokens: bool, is_scale_prob: bool, n_experts: int = 1, @@ -162,12 +162,13 @@ class TransformerEncoderLayer(nn.Module): dtype=None, ) -> None: factory_kwargs = {"device": device, "dtype": dtype} - super(TransformerEncoderLayer, self).__init__() + super(SwitchTransformerEncoderLayer, self).__init__() self.self_attn = nn.MultiheadAttention( d_model, nhead, dropout=dropout, batch_first=batch_first, **factory_kwargs ) # Implementation of Feedforward model linear = nn.Linear(d_model, dim_feedforward, **factory_kwargs) + self.linear1 = SwitchFeedForward( capacity_factor, drop_tokens, @@ -195,7 +196,7 @@ class TransformerEncoderLayer(nn.Module): def __setstate__(self, state): if "activation" not in state: state["activation"] = F.relu - super(TransformerEncoderLayer, self).__setstate__(state) + super(SwitchTransformerEncoderLayer, self).__setstate__(state) def forward( self, @@ -233,7 +234,8 @@ class TransformerEncoderLayer(nn.Module): # feed forward block def _ff_block(self, x: torch.Tensor) -> torch.Tensor: - x = self.linear2(self.dropout(self.activation(self.linear1(x)))) + x, _, _, _, _ = self.linear1(x) + x = self.linear2(self.dropout(self.activation(x))) return self.dropout2(x) @@ -253,8 +255,13 @@ class SwitchTransformerModel(nn.Module): num_encoder_layers: int, num_decoder_layers: int, dim_feedforward: int, + capacity_factor: float, activation: str = "gelu", dropout: float = 0.1, + layer_norm_eps: float = 1e-5, + drop_tokens: bool = False, + is_scale_prob: bool = True, + n_experts: int = 1, # univariate input input_size: int = 1, embedding_dimension: Optional[List[int]] = None, @@ -296,11 +303,29 @@ class SwitchTransformerModel(nn.Module): self.distr_output = distr_output self.param_proj = distr_output.get_args_proj(d_model) - # transformer enc-decoder and mask initializer + # switch-transformer enc + switch_encoder_layer = SwitchTransformerEncoderLayer( + d_model=d_model, + nhead=nhead, + capacity_factor=capacity_factor, + drop_tokens=drop_tokens, + is_scale_prob=is_scale_prob, + n_experts=n_experts, + dim_feedforward=dim_feedforward, + dropout=dropout, + activation=activation, + layer_norm_eps=layer_norm_eps, + ) + switch_encoder_norm = nn.LayerNorm(d_model, eps=layer_norm_eps) + switch_encoder = nn.TransformerEncoder( + switch_encoder_layer, num_encoder_layers, switch_encoder_norm + ) + + # vanilla decoder and mask initializer self.transformer = nn.Transformer( d_model=d_model, nhead=nhead, - num_encoder_layers=num_encoder_layers, + custom_encoder=switch_encoder, num_decoder_layers=num_decoder_layers, dim_feedforward=dim_feedforward, dropout=dropout, @@ -311,7 +336,7 @@ class SwitchTransformerModel(nn.Module): # causal decoder tgt mask self.register_buffer( "tgt_mask", - self.transformer.generate_square_subsequent_mask(prediction_length), + nn.Transformer.generate_square_subsequent_mask(prediction_length), ) @property From 3eeabcd1d88425d26f38d94475e1583710cb0ef0 Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 11:34:14 +0200 Subject: [PATCH 3/8] import --- switch/estimator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/switch/estimator.py b/switch/estimator.py index bd08c16..bfe9dd5 100644 --- a/switch/estimator.py +++ b/switch/estimator.py @@ -8,7 +8,7 @@ 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.modules.distribution_output import DistributionOutput, StudentTOutput +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 ( From 159254348b9fab34429139eb275c5ec3ce2f36ec Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 11:42:52 +0200 Subject: [PATCH 4/8] fix notebook --- switch/estimator.py | 17 +- switch/switch.ipynb | 4459 +------------------------------------------ 2 files changed, 121 insertions(+), 4355 deletions(-) diff --git a/switch/estimator.py b/switch/estimator.py index bfe9dd5..cab46f6 100644 --- a/switch/estimator.py +++ b/switch/estimator.py @@ -58,6 +58,10 @@ class SwitchTransformerEstimator(PyTorchLightningEstimator): num_encoder_layers: int, num_decoder_layers: int, dim_feedforward: int, + capacity_factor: float, + n_experts: int, + is_scale_prob: bool = True, + drop_tokens: bool = False, input_size: int = 1, activation: str = "gelu", dropout: float = 0.1, @@ -100,7 +104,12 @@ class SwitchTransformerEstimator(PyTorchLightningEstimator): self.activation = activation self.dim_feedforward = dim_feedforward self.dropout = dropout - + self.n_experts = n_experts + self.capacity_factor = capacity_factor + self.is_scale_prob = is_scale_prob + self.drop_tokens = drop_tokens + + 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 @@ -293,13 +302,17 @@ class SwitchTransformerEstimator(PyTorchLightningEstimator): num_feat_static_cat=max(1, self.num_feat_static_cat), cardinality=self.cardinality, embedding_dimension=self.embedding_dimension, - # transformer arguments + # switch 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, + capacity_factor=self.capacity_factor, + drop_tokens=self.drop_tokens, + is_scale_prob=self.is_scale_prob, + n_experts=self.n_experts, # univariate input input_size=self.input_size, distr_output=self.distr_output, diff --git a/switch/switch.ipynb b/switch/switch.ipynb index 63a06e4..1e61d85 100644 --- a/switch/switch.ipynb +++ b/switch/switch.ipynb @@ -3,820 +3,46 @@ { "cell_type": "code", "execution_count": 1, - "id": "b19f0e22", + "id": "420561b7", "metadata": {}, "outputs": [], "source": [ - "%matplotlib inline" + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "from itertools import islice" ] }, { "cell_type": "code", "execution_count": 2, - "id": "bc1a0f32", + "id": "b10c3dd3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/kashif/.env/pytorch/lib/python3.8/site-packages/xgboost/compat.py:36: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", - " from pandas import MultiIndex, Int64Index\n" + "WARNING:root:Pytorch pre-release version 1.13.0a0+git9e80661 - assuming intent to test it\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/horovod/common/util.py:258: UserWarning: Framework pytorch installed with version 1.12.0a0+git689df63 but found version 1.13.0a0+git9e80661.\n", + " This can result in unexpected behavior including runtime errors.\n", + " Reinstall Horovod using `pip install --no-cache-dir` to build with the new version.\n", + " warnings.warn(get_version_mismatch_message(name, version, installed_version))\n" ] } ], "source": [ - "from typing import List, Optional, Iterable, Dict, Any\n", - "from itertools import islice\n", - "\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "import matplotlib.dates as mdates\n", - "import tqdm.auto as tqdm\n", - "\n", - "import torch\n", - "import torch.nn as nn\n", - "from torch.utils.data import DataLoader\n", - "\n", - "import pytorch_lightning as pl\n", - "from pytorch_lightning.loggers import CSVLogger\n", - "\n", - "from gluonts.core.component import validated\n", - "from gluonts.dataset.common import Dataset\n", - "from gluonts.dataset.field_names import FieldName\n", - "from gluonts.itertools import Cyclic, PseudoShuffled, IterableSlice\n", - "from gluonts.time_feature import (\n", - " TimeFeature,\n", - " time_features_from_frequency_str,\n", - ")\n", - "from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood\n", - "from gluonts.transform import (\n", - " Transformation,\n", - " Chain,\n", - " RemoveFields,\n", - " SetField,\n", - " AsNumpyArray,\n", - " AddObservedValuesIndicator,\n", - " AddTimeFeatures,\n", - " AddAgeFeature,\n", - " VstackFeatures,\n", - " InstanceSplitter,\n", - " ValidationSplitSampler,\n", - " TestSplitSampler,\n", - " ExpectedNumInstanceSampler,\n", - " SelectFields,\n", - " InstanceSampler,\n", - ")\n", - "from gluonts.torch.util import (\n", - " IterableDataset,\n", - ")\n", "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", - "from gluonts.torch.model.estimator import PyTorchLightningEstimator\n", - "from gluonts.torch.model.predictor import PyTorchPredictor\n", - "from gluonts.torch.modules.distribution_output import (\n", - " DistributionOutput,\n", - " StudentTOutput,\n", - ")\n", - "from gluonts.torch.util import weighted_average\n", - "from gluonts.torch.modules.scaler import MeanScaler, NOPScaler\n", - "from gluonts.torch.modules.feature import FeatureEmbedder\n", - "from gluonts.time_feature import get_lags_for_frequency\n", - "from gluonts.dataset.repository.datasets import get_dataset" + "from gluonts.dataset.repository.datasets import get_dataset\n", + "\n", + "from estimator import SwitchTransformerEstimator" ] }, { "cell_type": "code", "execution_count": 3, - "id": "ac78c47a", - "metadata": {}, - "outputs": [], - "source": [ - "class TransformerModel(nn.Module):\n", - " @validated()\n", - " def __init__(\n", - " self,\n", - " freq: str,\n", - " context_length: int,\n", - " prediction_length: int,\n", - " num_feat_dynamic_real: int,\n", - " num_feat_static_real: int,\n", - " num_feat_static_cat: int,\n", - " cardinality: List[int],\n", - " \n", - " # transformer arguments\n", - " nhead: int,\n", - " num_encoder_layers: int,\n", - " num_decoder_layers: int,\n", - " dim_feedforward: int,\n", - " activation: str = \"gelu\",\n", - " dropout: float = 0.1,\n", - "\n", - " # univariate input\n", - " input_size: int = 1,\n", - " embedding_dimension: Optional[List[int]] = None,\n", - " distr_output: DistributionOutput = StudentTOutput(),\n", - " lags_seq: Optional[List[int]] = None,\n", - " scaling: bool = True,\n", - " num_parallel_samples: int = 100,\n", - " ) -> None:\n", - " super().__init__()\n", - " \n", - " self.input_size = input_size\n", - " \n", - " self.target_shape = distr_output.event_shape\n", - " self.num_feat_dynamic_real = num_feat_dynamic_real\n", - " self.num_feat_static_cat = num_feat_static_cat\n", - " self.num_feat_static_real = num_feat_static_real\n", - " self.embedding_dimension = (\n", - " embedding_dimension\n", - " if embedding_dimension is not None or cardinality is None\n", - " else [min(50, (cat + 1) // 2) for cat in cardinality]\n", - " )\n", - " self.lags_seq = lags_seq or get_lags_for_frequency(freq_str=freq)\n", - " self.num_parallel_samples = num_parallel_samples\n", - " self.history_length = context_length + max(self.lags_seq)\n", - " self.embedder = FeatureEmbedder(\n", - " cardinalities=cardinality,\n", - " embedding_dims=self.embedding_dimension,\n", - " )\n", - " if scaling:\n", - " self.scaler = MeanScaler(dim=1, keepdim=True)\n", - " else:\n", - " self.scaler = NOPScaler(dim=1, keepdim=True)\n", - " \n", - " # total feature size\n", - " d_model = self.input_size * len(self.lags_seq) + self._number_of_features\n", - " \n", - " self.context_length = context_length\n", - " self.prediction_length = prediction_length\n", - " self.distr_output = distr_output\n", - " self.param_proj = distr_output.get_args_proj(d_model)\n", - " \n", - " # transformer enc-decoder and mask initializer\n", - " self.transformer = nn.Transformer(\n", - " d_model=d_model,\n", - " nhead=nhead,\n", - " num_encoder_layers=num_encoder_layers,\n", - " num_decoder_layers=num_decoder_layers,\n", - " dim_feedforward=dim_feedforward,\n", - " dropout=dropout,\n", - " activation=activation,\n", - " batch_first=True,\n", - " )\n", - " \n", - " # causal decoder tgt mask\n", - " self.register_buffer(\n", - " \"tgt_mask\",\n", - " self.transformer.generate_square_subsequent_mask(prediction_length),\n", - " )\n", - " \n", - " @property\n", - " def _number_of_features(self) -> int:\n", - " return (\n", - " sum(self.embedding_dimension)\n", - " + self.num_feat_dynamic_real\n", - " + self.num_feat_static_real\n", - " + 1 # the log(scale)\n", - " )\n", - "\n", - " @property\n", - " def _past_length(self) -> int:\n", - " return self.context_length + max(self.lags_seq)\n", - " \n", - " def get_lagged_subsequences(\n", - " self,\n", - " sequence: torch.Tensor,\n", - " subsequences_length: int,\n", - " shift: int = 0\n", - " ) -> torch.Tensor:\n", - " \"\"\"\n", - " Returns lagged subsequences of a given sequence.\n", - " Parameters\n", - " ----------\n", - " sequence : Tensor\n", - " the sequence from which lagged subsequences should be extracted.\n", - " Shape: (N, T, C).\n", - " subsequences_length : int\n", - " length of the subsequences to be extracted.\n", - " shift: int\n", - " shift the lags by this amount back.\n", - " Returns\n", - " --------\n", - " lagged : Tensor\n", - " a tensor of shape (N, S, C, I), where S = subsequences_length and\n", - " I = len(indices), containing lagged subsequences. Specifically,\n", - " lagged[i, j, :, k] = sequence[i, -indices[k]-S+j, :].\n", - " \"\"\"\n", - " sequence_length = sequence.shape[1]\n", - " indices = [l - shift for l in self.lags_seq]\n", - "\n", - " assert max(indices) + subsequences_length <= sequence_length, (\n", - " f\"lags cannot go further than history length, found lag {max(indices)} \"\n", - " f\"while history length is only {sequence_length}\"\n", - " )\n", - "\n", - " lagged_values = []\n", - " for lag_index in indices:\n", - " begin_index = -lag_index - subsequences_length\n", - " end_index = -lag_index if lag_index > 0 else None\n", - " lagged_values.append(sequence[:, begin_index:end_index, ...])\n", - " return torch.stack(lagged_values, dim=-1)\n", - "\n", - " def _check_shapes(\n", - " self,\n", - " prior_input: torch.Tensor,\n", - " inputs: torch.Tensor,\n", - " features: Optional[torch.Tensor],\n", - " ) -> None:\n", - " assert len(prior_input.shape) == len(inputs.shape)\n", - " assert (\n", - " len(prior_input.shape) == 2 and self.input_size == 1\n", - " ) or prior_input.shape[2] == self.input_size\n", - " assert (len(inputs.shape) == 2 and self.input_size == 1) or inputs.shape[\n", - " -1\n", - " ] == self.input_size\n", - " assert (\n", - " features is None or features.shape[2] == self._number_of_features\n", - " ), f\"{features.shape[2]}, expected {self._number_of_features}\"\n", - " \n", - " \n", - " def create_network_inputs(\n", - " self, \n", - " feat_static_cat: torch.Tensor, \n", - " feat_static_real: torch.Tensor,\n", - " past_time_feat: torch.Tensor,\n", - " past_target: torch.Tensor,\n", - " past_observed_values: torch.Tensor,\n", - " future_time_feat: Optional[torch.Tensor] = None,\n", - " future_target: Optional[torch.Tensor] = None,\n", - " ): \n", - " # time feature\n", - " time_feat = (\n", - " torch.cat(\n", - " (\n", - " past_time_feat[:, self._past_length - self.context_length :, ...],\n", - " future_time_feat,\n", - " ),\n", - " dim=1,\n", - " )\n", - " if future_target is not None\n", - " else past_time_feat[:, self._past_length - self.context_length :, ...]\n", - " )\n", - "\n", - " # target\n", - " context = past_target[:, -self.context_length :]\n", - " observed_context = past_observed_values[:, -self.context_length :]\n", - " _, scale = self.scaler(context, observed_context)\n", - "\n", - " inputs = (\n", - " torch.cat((past_target, future_target), dim=1) / scale\n", - " if future_target is not None\n", - " else past_target / scale\n", - " )\n", - "\n", - " inputs_length = (\n", - " self._past_length + self.prediction_length\n", - " if future_target is not None\n", - " else self._past_length\n", - " )\n", - " assert inputs.shape[1] == inputs_length\n", - " \n", - " subsequences_length = (\n", - " self.context_length + self.prediction_length\n", - " if future_target is not None\n", - " else self.context_length\n", - " )\n", - " \n", - " # embeddings\n", - " embedded_cat = self.embedder(feat_static_cat)\n", - " static_feat = torch.cat(\n", - " (embedded_cat, feat_static_real, scale.log()),\n", - " dim=1,\n", - " )\n", - " expanded_static_feat = static_feat.unsqueeze(1).expand(\n", - " -1, time_feat.shape[1], -1\n", - " )\n", - " \n", - " \n", - " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", - " \n", - " \n", - " #self._check_shapes(prior_input, inputs, features)\n", - "\n", - " #sequence = torch.cat((prior_input, inputs), dim=1)\n", - " lagged_sequence = self.get_lagged_subsequences(\n", - " sequence=inputs,\n", - " subsequences_length=subsequences_length,\n", - " )\n", - "\n", - " lags_shape = lagged_sequence.shape\n", - " reshaped_lagged_sequence = lagged_sequence.reshape(\n", - " lags_shape[0], lags_shape[1], -1\n", - " )\n", - "\n", - "\n", - " transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", - " \n", - " return transformer_inputs, scale, static_feat\n", - " \n", - " def output_params(self, transformer_inputs):\n", - " enc_input = transformer_inputs[:, :self.context_length, ...]\n", - " dec_input = transformer_inputs[:, self.context_length:, ...]\n", - " \n", - " enc_out = self.transformer.encoder(\n", - " enc_input\n", - " )\n", - " dec_output = self.transformer.decoder(\n", - " dec_input,\n", - " enc_out,\n", - " tgt_mask=self.tgt_mask\n", - " )\n", - " \n", - " return self.param_proj(dec_output)\n", - "\n", - " @torch.jit.ignore\n", - " def output_distribution(\n", - " self, params, scale=None, trailing_n=None\n", - " ) -> torch.distributions.Distribution:\n", - " sliced_params = params\n", - " if trailing_n is not None:\n", - " sliced_params = [p[:, -trailing_n:] for p in params]\n", - " return self.distr_output.distribution(sliced_params, scale=scale)\n", - " \n", - " # for prediction\n", - " def forward(\n", - " self,\n", - " feat_static_cat: torch.Tensor,\n", - " feat_static_real: torch.Tensor,\n", - " past_time_feat: torch.Tensor,\n", - " past_target: torch.Tensor,\n", - " past_observed_values: torch.Tensor,\n", - " future_time_feat: torch.Tensor,\n", - " num_parallel_samples: Optional[int] = None,\n", - " ) -> torch.Tensor:\n", - " \n", - " \n", - " if num_parallel_samples is None:\n", - " num_parallel_samples = self.num_parallel_samples\n", - " \n", - " encoder_inputs, scale, static_feat = self.create_network_inputs(\n", - " feat_static_cat,\n", - " feat_static_real,\n", - " past_time_feat,\n", - " past_target,\n", - " past_observed_values,\n", - " )\n", - " \n", - " enc_out = self.transformer.encoder(encoder_inputs)\n", - " \n", - " repeated_scale = scale.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - "\n", - " repeated_past_target = (\n", - " past_target.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - " / repeated_scale\n", - " )\n", - " \n", - " expanded_static_feat = static_feat.unsqueeze(1).expand(\n", - " -1, future_time_feat.shape[1], -1\n", - " )\n", - " features = torch.cat((expanded_static_feat, future_time_feat), dim=-1)\n", - " repeated_features = features.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - " \n", - " repeated_enc_out = enc_out.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - "\n", - " future_samples = []\n", - " \n", - " # greedy decoding\n", - " for k in range(self.prediction_length): \n", - " #self._check_shapes(repeated_past_target, next_sample, next_features)\n", - " #sequence = torch.cat((repeated_past_target, next_sample), dim=1)\n", - " \n", - " lagged_sequence = self.get_lagged_subsequences(\n", - " sequence=repeated_past_target,\n", - " subsequences_length=1+k,\n", - " shift=1, \n", - " )\n", - "\n", - " lags_shape = lagged_sequence.shape\n", - " reshaped_lagged_sequence = lagged_sequence.reshape(\n", - " lags_shape[0], lags_shape[1], -1\n", - " )\n", - " \n", - " decoder_input = torch.cat((reshaped_lagged_sequence, repeated_features[:, : k+1]), dim=-1)\n", - "\n", - " output = self.transformer.decoder(decoder_input, repeated_enc_out)\n", - " \n", - " params = self.param_proj(output[:,-1:])\n", - " distr = self.output_distribution(params, scale=repeated_scale)\n", - " next_sample = distr.sample()\n", - " \n", - " repeated_past_target = torch.cat(\n", - " (repeated_past_target, next_sample / repeated_scale), dim=1\n", - " )\n", - " future_samples.append(next_sample)\n", - "\n", - " concat_future_samples = torch.cat(future_samples, dim=1)\n", - " return concat_future_samples.reshape(\n", - " (-1, self.num_parallel_samples, self.prediction_length)\n", - " + self.target_shape,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "a8873ae3", - "metadata": {}, - "outputs": [], - "source": [ - "class TransformerLightningModule(pl.LightningModule):\n", - " def __init__(\n", - " self,\n", - " model: TransformerModel,\n", - " loss: DistributionLoss = NegativeLogLikelihood(),\n", - " lr: float = 1e-3,\n", - " weight_decay: float = 1e-8,\n", - " ) -> None:\n", - " super().__init__()\n", - " self.save_hyperparameters()\n", - " self.model = model\n", - " self.loss = loss\n", - " self.lr = lr\n", - " self.weight_decay = weight_decay\n", - " \n", - " def training_step(self, batch, batch_idx: int):\n", - " \"\"\"Execute training step\"\"\"\n", - " train_loss = self(batch)\n", - " self.log(\n", - " \"train_loss\",\n", - " train_loss,\n", - " on_epoch=True,\n", - " on_step=False,\n", - " prog_bar=True,\n", - " )\n", - " return train_loss\n", - "\n", - " def validation_step(self, batch, batch_idx: int):\n", - " \"\"\"Execute validation step\"\"\"\n", - " with torch.inference_mode():\n", - " val_loss = self(batch)\n", - " self.log(\n", - " \"val_loss\", val_loss, on_epoch=True, on_step=False, prog_bar=True\n", - " )\n", - " return val_loss\n", - "\n", - " def configure_optimizers(self):\n", - " \"\"\"Returns the optimizer to use\"\"\"\n", - " return torch.optim.Adam(\n", - " self.model.parameters(),\n", - " lr=self.lr,\n", - " weight_decay=self.weight_decay,\n", - " )\n", - "\n", - " def forward(self, batch):\n", - " feat_static_cat = batch[\"feat_static_cat\"]\n", - " feat_static_real = batch[\"feat_static_real\"]\n", - " past_time_feat = batch[\"past_time_feat\"]\n", - " past_target = batch[\"past_target\"]\n", - " future_time_feat = batch[\"future_time_feat\"]\n", - " future_target = batch[\"future_target\"]\n", - " past_observed_values = batch[\"past_observed_values\"]\n", - " future_observed_values = batch[\"future_observed_values\"]\n", - " \n", - " transformer_inputs, scale, _ = self.model.create_network_inputs(\n", - " feat_static_cat,\n", - " feat_static_real,\n", - " past_time_feat,\n", - " past_target,\n", - " past_observed_values,\n", - " future_time_feat,\n", - " future_target,\n", - " )\n", - " params = self.model.output_params(transformer_inputs)\n", - " distr = self.model.output_distribution(params, scale)\n", - "\n", - " loss_values = self.loss(distr, future_target)\n", - " \n", - " if len(self.model.target_shape) == 0:\n", - " loss_weights = future_observed_values\n", - " else:\n", - " loss_weights = future_observed_values.min(dim=-1, keepdim=False)\n", - "\n", - " return weighted_average(loss_values, weights=loss_weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "99d97334", - "metadata": {}, - "outputs": [], - "source": [ - "PREDICTION_INPUT_NAMES = [\n", - " \"feat_static_cat\",\n", - " \"feat_static_real\",\n", - " \"past_time_feat\",\n", - " \"past_target\",\n", - " \"past_observed_values\",\n", - " \"future_time_feat\",\n", - "]\n", - "\n", - "TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [\n", - " \"future_target\",\n", - " \"future_observed_values\",\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bc39c0e9", - "metadata": {}, - "outputs": [], - "source": [ - "class TransformerEstimator(PyTorchLightningEstimator):\n", - " @validated()\n", - " def __init__(\n", - " self,\n", - " freq: str,\n", - " prediction_length: int,\n", - " \n", - " # Transformer arguments\n", - " nhead: int,\n", - " num_encoder_layers: int,\n", - " num_decoder_layers: int,\n", - " dim_feedforward: int,\n", - " input_size: int = 1,\n", - " activation: str = \"gelu\",\n", - " dropout: float = 0.1,\n", - "\n", - " context_length: Optional[int] = None,\n", - "\n", - " num_feat_dynamic_real: int = 0,\n", - " num_feat_static_cat: int = 0,\n", - " num_feat_static_real: int = 0,\n", - " cardinality: Optional[List[int]] = None,\n", - " embedding_dimension: Optional[List[int]] = None,\n", - " distr_output: DistributionOutput = StudentTOutput(),\n", - " loss: DistributionLoss = NegativeLogLikelihood(),\n", - " scaling: bool = True,\n", - " lags_seq: Optional[List[int]] = None,\n", - " time_features: Optional[List[TimeFeature]] = None,\n", - " num_parallel_samples: int = 100,\n", - " batch_size: int = 32,\n", - " num_batches_per_epoch: int = 50,\n", - " trainer_kwargs: Optional[Dict[str, Any]] = dict(),\n", - " train_sampler: Optional[InstanceSampler] = None,\n", - " validation_sampler: Optional[InstanceSampler] = None,\n", - " ) -> None:\n", - " trainer_kwargs = {\n", - " \"max_epochs\": 100,\n", - " **trainer_kwargs,\n", - " }\n", - " super().__init__(trainer_kwargs=trainer_kwargs)\n", - " \n", - " self.freq = freq\n", - " self.context_length = (\n", - " context_length if context_length is not None else prediction_length\n", - " )\n", - " self.prediction_length = prediction_length\n", - " self.distr_output = distr_output\n", - " self.loss = loss\n", - " \n", - " self.input_size = input_size\n", - " self.nhead = nhead\n", - " self.num_encoder_layers = num_encoder_layers\n", - " self.num_decoder_layers = num_decoder_layers\n", - " self.activation = activation\n", - " self.dim_feedforward = dim_feedforward\n", - " self.dropout = dropout\n", - " \n", - " self.num_feat_dynamic_real = num_feat_dynamic_real\n", - " self.num_feat_static_cat = num_feat_static_cat\n", - " self.num_feat_static_real = num_feat_static_real\n", - " self.cardinality = (\n", - " cardinality if cardinality and num_feat_static_cat > 0 else [1]\n", - " )\n", - " self.embedding_dimension = embedding_dimension\n", - " self.scaling = scaling\n", - " self.lags_seq = lags_seq\n", - " self.time_features = (\n", - " time_features\n", - " if time_features is not None\n", - " else time_features_from_frequency_str(self.freq)\n", - " )\n", - "\n", - " self.num_parallel_samples = num_parallel_samples\n", - " self.batch_size = batch_size\n", - " self.num_batches_per_epoch = num_batches_per_epoch\n", - "\n", - " self.train_sampler = train_sampler or ExpectedNumInstanceSampler(\n", - " num_instances=1.0, min_future=prediction_length\n", - " )\n", - " self.validation_sampler = validation_sampler or ValidationSplitSampler(\n", - " min_future=prediction_length\n", - " )\n", - " \n", - " def create_transformation(self) -> Transformation:\n", - " remove_field_names = []\n", - " if self.num_feat_static_real == 0:\n", - " remove_field_names.append(FieldName.FEAT_STATIC_REAL)\n", - " if self.num_feat_dynamic_real == 0:\n", - " remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)\n", - "\n", - " return Chain(\n", - " [RemoveFields(field_names=remove_field_names)]\n", - " + (\n", - " [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])]\n", - " if not self.num_feat_static_cat > 0\n", - " else []\n", - " )\n", - " + (\n", - " [\n", - " SetField(\n", - " output_field=FieldName.FEAT_STATIC_REAL, value=[0.0]\n", - " )\n", - " ]\n", - " if not self.num_feat_static_real > 0\n", - " else []\n", - " )\n", - " + [\n", - " AsNumpyArray(\n", - " field=FieldName.FEAT_STATIC_CAT,\n", - " expected_ndim=1,\n", - " dtype=int,\n", - " ),\n", - " AsNumpyArray(\n", - " field=FieldName.FEAT_STATIC_REAL,\n", - " expected_ndim=1,\n", - " ),\n", - " AsNumpyArray(\n", - " field=FieldName.TARGET,\n", - " # in the following line, we add 1 for the time dimension\n", - " expected_ndim=1 + len(self.distr_output.event_shape),\n", - " ),\n", - " AddObservedValuesIndicator(\n", - " target_field=FieldName.TARGET,\n", - " output_field=FieldName.OBSERVED_VALUES,\n", - " ),\n", - " AddTimeFeatures(\n", - " start_field=FieldName.START,\n", - " target_field=FieldName.TARGET,\n", - " output_field=FieldName.FEAT_TIME,\n", - " time_features=self.time_features,\n", - " pred_length=self.prediction_length,\n", - " ),\n", - " AddAgeFeature(\n", - " target_field=FieldName.TARGET,\n", - " output_field=FieldName.FEAT_AGE,\n", - " pred_length=self.prediction_length,\n", - " log_scale=True,\n", - " ),\n", - " VstackFeatures(\n", - " output_field=FieldName.FEAT_TIME,\n", - " input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE]\n", - " + (\n", - " [FieldName.FEAT_DYNAMIC_REAL]\n", - " if self.num_feat_dynamic_real > 0\n", - " else []\n", - " ),\n", - " ),\n", - " ]\n", - " )\n", - "\n", - " def _create_instance_splitter(\n", - " self, module: TransformerLightningModule, mode: str\n", - " ):\n", - " assert mode in [\"training\", \"validation\", \"test\"]\n", - "\n", - " instance_sampler = {\n", - " \"training\": self.train_sampler,\n", - " \"validation\": self.validation_sampler,\n", - " \"test\": TestSplitSampler(),\n", - " }[mode]\n", - "\n", - " return InstanceSplitter(\n", - " target_field=FieldName.TARGET,\n", - " is_pad_field=FieldName.IS_PAD,\n", - " start_field=FieldName.START,\n", - " forecast_start_field=FieldName.FORECAST_START,\n", - " instance_sampler=instance_sampler,\n", - " past_length=module.model._past_length,\n", - " future_length=self.prediction_length,\n", - " time_series_fields=[\n", - " FieldName.FEAT_TIME,\n", - " FieldName.OBSERVED_VALUES,\n", - " ],\n", - " dummy_value=self.distr_output.value_in_support,\n", - " )\n", - "\n", - " def create_training_data_loader(\n", - " self,\n", - " data: Dataset,\n", - " module: TransformerLightningModule,\n", - " shuffle_buffer_length: Optional[int] = None,\n", - " **kwargs,\n", - " ) -> Iterable:\n", - " transformation = self._create_instance_splitter(\n", - " module, \"training\"\n", - " ) + SelectFields(TRAINING_INPUT_NAMES)\n", - "\n", - " training_instances = transformation.apply(\n", - " Cyclic(data)\n", - " if shuffle_buffer_length is None\n", - " else PseudoShuffled(\n", - " Cyclic(data), shuffle_buffer_length=shuffle_buffer_length\n", - " )\n", - " )\n", - "\n", - " return IterableSlice(\n", - " iter(\n", - " DataLoader(\n", - " IterableDataset(training_instances),\n", - " batch_size=self.batch_size,\n", - " **kwargs,\n", - " )\n", - " ),\n", - " self.num_batches_per_epoch,\n", - " )\n", - "\n", - " def create_validation_data_loader(\n", - " self,\n", - " data: Dataset,\n", - " module: TransformerLightningModule,\n", - " **kwargs,\n", - " ) -> Iterable:\n", - " transformation = self._create_instance_splitter(\n", - " module, \"validation\"\n", - " ) + SelectFields(TRAINING_INPUT_NAMES)\n", - "\n", - " validation_instances = transformation.apply(data)\n", - "\n", - " return DataLoader(\n", - " IterableDataset(validation_instances),\n", - " batch_size=self.batch_size,\n", - " **kwargs,\n", - " )\n", - " \n", - " def create_predictor(\n", - " self,\n", - " transformation: Transformation,\n", - " module: TransformerLightningModule,\n", - " ) -> PyTorchPredictor:\n", - " prediction_splitter = self._create_instance_splitter(module, \"test\")\n", - "\n", - " return PyTorchPredictor(\n", - " input_transform=transformation + prediction_splitter,\n", - " input_names=PREDICTION_INPUT_NAMES,\n", - " prediction_net=module.model,\n", - " batch_size=self.batch_size,\n", - " freq=self.freq,\n", - " prediction_length=self.prediction_length,\n", - " device=torch.device('cuda' if torch.cuda.is_available() else 'cpu'),\n", - " )\n", - "\n", - " def create_lightning_module(self) -> TransformerLightningModule:\n", - " model = TransformerModel(\n", - " freq=self.freq,\n", - " context_length=self.context_length,\n", - " prediction_length=self.prediction_length,\n", - " num_feat_dynamic_real=1 + self.num_feat_dynamic_real + len(self.time_features),\n", - " num_feat_static_real=max(1, self.num_feat_static_real),\n", - " num_feat_static_cat=max(1, self.num_feat_static_cat),\n", - " cardinality=self.cardinality,\n", - " embedding_dimension=self.embedding_dimension,\n", - "\n", - " # transformer arguments\n", - " nhead=self.nhead,\n", - " num_encoder_layers=self.num_encoder_layers,\n", - " num_decoder_layers=self.num_decoder_layers,\n", - " activation=self.activation,\n", - " dropout=self.dropout,\n", - " dim_feedforward=self.dim_feedforward,\n", - "\n", - " # univariate input\n", - " input_size=self.input_size,\n", - " distr_output=self.distr_output,\n", - " lags_seq=self.lags_seq,\n", - " scaling=self.scaling,\n", - " num_parallel_samples=self.num_parallel_samples,\n", - " )\n", - " \n", - " return TransformerLightningModule(model=model, loss=self.loss)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "f1c38a2a", + "id": "d018b7fb", "metadata": {}, "outputs": [], "source": [ @@ -825,3496 +51,68 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "dc5f66a9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "TrainDatasets(metadata=MetaData(freq='1H', target=None, feat_static_cat=[CategoricalFeatureInfo(name='feat_static_cat', cardinality='321')], feat_static_real=[], feat_dynamic_real=[], feat_dynamic_cat=[], prediction_length=24), train=, test=)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "6e17f04e", + "execution_count": 5, + "id": "e772234f", "metadata": {}, "outputs": [], "source": [ - "estimator = TransformerEstimator(\n", + "estimator = SwitchTransformerEstimator(\n", " freq=dataset.metadata.freq,\n", " prediction_length=dataset.metadata.prediction_length,\n", - "\n", - " nhead=2,\n", - " num_encoder_layers=2,\n", - " num_decoder_layers=2,\n", - " dim_feedforward=32,\n", - " activation=\"gelu\",\n", - " \n", " num_feat_static_cat=1,\n", " cardinality=[321],\n", - " embedding_dimension=[5],\n", + " embedding_dimension=[3],\n", " \n", + " dim_feedforward=16,\n", + " num_encoder_layers=2,\n", + " num_decoder_layers=2,\n", + " nhead=2,\n", + " n_experts = 4,\n", + " capacity_factor = 0.2,\n", + " \n", + " activation=\"relu\",\n", + "\n", " batch_size=128,\n", " num_batches_per_epoch=100,\n", - " trainer_kwargs=dict(max_epochs=20, accelerator='auto', gpus=1),\n", + " trainer_kwargs=dict(max_epochs=50, accelerator='gpu', gpus=1),\n", ")" ] }, { "cell_type": "code", - "execution_count": 22, - "id": "ed0d8504", - "metadata": { - "scrolled": true - }, + "execution_count": 6, + "id": "22d804e4", + "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | model | TransformerModel | 82.8 K\n", - "1 | loss | NegativeLogLikelihood | 0 \n", - "------------------------------------------------\n", - "82.8 K Trainable params\n", - "0 Non-trainable params\n", - "82.8 K Total params\n", - "0.331 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6c85fc01474d4be7af31b881893ef179", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 0, global step 99: val_loss reached 5.88591 (best 5.88591), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=0-step=99.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 1, global step 199: val_loss reached 5.62166 (best 5.62166), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=1-step=199.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 2, global step 299: val_loss reached 5.46650 (best 5.46650), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=2-step=299.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 3, global step 399: val_loss reached 5.35825 (best 5.35825), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=3-step=399.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 4, global step 499: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 5, global step 599: val_loss reached 5.28393 (best 5.28393), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=5-step=599.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 6, global step 699: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 7, global step 799: val_loss reached 5.28351 (best 5.28351), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=7-step=799.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 8, global step 899: val_loss reached 5.26218 (best 5.26218), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=8-step=899.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 9, global step 999: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 10, global step 1099: val_loss reached 5.14227 (best 5.14227), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=10-step=1099.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 11, global step 1199: val_loss reached 5.11745 (best 5.11745), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=11-step=1199.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 12, global step 1299: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 13, global step 1399: val_loss reached 5.11113 (best 5.11113), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=13-step=1399.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 14, global step 1499: val_loss reached 5.09926 (best 5.09926), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=14-step=1499.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 15, global step 1599: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 16, global step 1699: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 17, global step 1799: val_loss was not in top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 18, global step 1899: val_loss reached 5.05392 (best 5.05392), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=18-step=1899.ckpt\" as top 1\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "Epoch 19, global step 1999: val_loss reached 5.05254 (best 5.05254), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_15/checkpoints/epoch=19-step=1999.ckpt\" as top 1\n" + "ename": "ValidationError", + "evalue": "1 validation error for SwitchTransformerModelModel\ncapacity_factor\n field required (type=value_error.missing)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValidationError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [6]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m predictor \u001b[38;5;241m=\u001b[39m estimator\u001b[38;5;241m.\u001b[39mtrain(\n\u001b[1;32m 2\u001b[0m training_data\u001b[38;5;241m=\u001b[39mdataset\u001b[38;5;241m.\u001b[39mtrain,\n\u001b[1;32m 3\u001b[0m num_workers\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m8\u001b[39m,\n\u001b[1;32m 4\u001b[0m shuffle_buffer_length\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1024\u001b[39m\n\u001b[1;32m 5\u001b[0m )\n", + "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/model/estimator.py:230\u001b[0m, in \u001b[0;36mPyTorchLightningEstimator.train\u001b[0;34m(self, training_data, validation_data, num_workers, shuffle_buffer_length, cache_data, ckpt_path, **kwargs)\u001b[0m\n\u001b[1;32m 220\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtrain\u001b[39m(\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 222\u001b[0m training_data: Dataset,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 228\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 229\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m PyTorchPredictor:\n\u001b[0;32m--> 230\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[43m \u001b[49m\u001b[43mtraining_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 232\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 233\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_workers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_workers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 234\u001b[0m \u001b[43m \u001b[49m\u001b[43mshuffle_buffer_length\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshuffle_buffer_length\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 235\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 236\u001b[0m \u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mckpt_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 237\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 238\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mpredictor\n", + "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/model/estimator.py:161\u001b[0m, in \u001b[0;36mPyTorchLightningEstimator.train_model\u001b[0;34m(self, training_data, validation_data, num_workers, shuffle_buffer_length, cache_data, ckpt_path, **kwargs)\u001b[0m\n\u001b[1;32m 155\u001b[0m transformation \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_transformation()\n\u001b[1;32m 157\u001b[0m transformed_training_data \u001b[38;5;241m=\u001b[39m transformation\u001b[38;5;241m.\u001b[39mapply(\n\u001b[1;32m 158\u001b[0m training_data, is_train\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 159\u001b[0m )\n\u001b[0;32m--> 161\u001b[0m training_network \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_lightning_module\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 163\u001b[0m training_data_loader \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_training_data_loader(\n\u001b[1;32m 164\u001b[0m transformed_training_data\n\u001b[1;32m 165\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m cache_data\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 169\u001b[0m shuffle_buffer_length\u001b[38;5;241m=\u001b[39mshuffle_buffer_length,\n\u001b[1;32m 170\u001b[0m )\n\u001b[1;32m 172\u001b[0m validation_data_loader \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m/mnt/scratch/kashif/pytorch-transformer-ts/switch/estimator.py:285\u001b[0m, in \u001b[0;36mSwitchTransformerEstimator.create_lightning_module\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 284\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_lightning_module\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m SwitchTransformerLightningModule:\n\u001b[0;32m--> 285\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mSwitchTransformerModel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 286\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontext_length\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcontext_length\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 288\u001b[0m \u001b[43m \u001b[49m\u001b[43mprediction_length\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprediction_length\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 289\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_feat_dynamic_real\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\n\u001b[1;32m 290\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_feat_dynamic_real\u001b[49m\n\u001b[1;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_features\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 292\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_feat_static_real\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_feat_static_real\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_feat_static_cat\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_feat_static_cat\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[43m \u001b[49m\u001b[43mcardinality\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcardinality\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[43membedding_dimension\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43membedding_dimension\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# transformer arguments\u001b[39;49;00m\n\u001b[1;32m 297\u001b[0m \u001b[43m \u001b[49m\u001b[43mnhead\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnhead\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_encoder_layers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_encoder_layers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_decoder_layers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_decoder_layers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[43mactivation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mactivation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[43mdropout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[43mdim_feedforward\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdim_feedforward\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# univariate input\u001b[39;49;00m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[43minput_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minput_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43mdistr_output\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistr_output\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 306\u001b[0m \u001b[43m \u001b[49m\u001b[43mlags_seq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlags_seq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[43m \u001b[49m\u001b[43mscaling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 308\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_parallel_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_parallel_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 309\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TransformerLightningModule(model\u001b[38;5;241m=\u001b[39mmodel, loss\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss)\n", + "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/core/component.py:326\u001b[0m, in \u001b[0;36mvalidated..validator..init_wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs \u001b[38;5;241m=\u001b[39m args\n\u001b[1;32m 319\u001b[0m nmargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 320\u001b[0m name: arg\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (name, param), arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 324\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 325\u001b[0m }\n\u001b[0;32m--> 326\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mPydanticModel\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mnmargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 328\u001b[0m \u001b[38;5;66;03m# merge nmargs, kwargs, and the model fields into a single dict\u001b[39;00m\n\u001b[1;32m 329\u001b[0m all_args \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mnmargs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m}\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pydantic/main.py:341\u001b[0m, in \u001b[0;36mpydantic.main.BaseModel.__init__\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mValidationError\u001b[0m: 1 validation error for SwitchTransformerModelModel\ncapacity_factor\n field required (type=value_error.missing)" ] } ], "source": [ "predictor = estimator.train(\n", " training_data=dataset.train,\n", - " validation_data=dataset.test,\n", - " num_workers=16,\n", + " num_workers=8,\n", " shuffle_buffer_length=1024\n", ")" ] }, { "cell_type": "code", - "execution_count": 23, - "id": "4f319643", + "execution_count": 15, + "id": "11a47d5a", "metadata": {}, "outputs": [], "source": [ @@ -4326,11 +124,9 @@ }, { "cell_type": "code", - "execution_count": 24, - "id": "c4d84519", - "metadata": { - "scrolled": true - }, + "execution_count": 16, + "id": "1492f7fb", + "metadata": {}, "outputs": [ { "name": "stderr", @@ -4353,8 +149,8 @@ }, { "cell_type": "code", - "execution_count": 25, - "id": "fcfa0dc3", + "execution_count": 17, + "id": "d406a112", "metadata": {}, "outputs": [], "source": [ @@ -4363,8 +159,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "4239bdbb", + "execution_count": 18, + "id": "e00601c4", "metadata": {}, "outputs": [], "source": [ @@ -4373,15 +169,15 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "bf9638c4", + "execution_count": 19, + "id": "9ed4c523", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Running evaluation: 2247it [00:00, 3817.35it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + "Running evaluation: 2247it [00:00, 4312.72it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", @@ -4425,59 +221,59 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "58151870", + "execution_count": 20, + "id": "91dc33b6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'MSE': 2290308.638491056,\n", - " 'abs_error': 8935766.12021637,\n", + "{'MSE': 1912270.1601813699,\n", + " 'abs_error': 9499909.78665924,\n", " 'abs_target_sum': 128632956.0,\n", " 'abs_target_mean': 2385.272140631954,\n", " 'seasonal_error': 189.49338196116761,\n", - " 'MASE': 0.7702394584937287,\n", - " 'MAPE': 0.09905294725225479,\n", - " 'sMAPE': 0.11066244638590851,\n", - " 'MSIS': 6.179870294636366,\n", - " 'QuantileLoss[0.1]': 4123019.1300659077,\n", - " 'Coverage[0.1]': 0.10990580032636107,\n", - " 'QuantileLoss[0.2]': 6267998.181722605,\n", - " 'Coverage[0.2]': 0.21773475745438362,\n", - " 'QuantileLoss[0.3]': 7668596.503774263,\n", - " 'Coverage[0.3]': 0.3327028630766949,\n", - " 'QuantileLoss[0.4]': 8546316.953158284,\n", - " 'Coverage[0.4]': 0.44765242545616374,\n", - " 'QuantileLoss[0.5]': 8935766.081627503,\n", - " 'Coverage[0.5]': 0.5612297878653019,\n", - " 'QuantileLoss[0.6]': 8830596.935430296,\n", - " 'Coverage[0.6]': 0.6539460020768433,\n", - " 'QuantileLoss[0.7]': 8159344.228591463,\n", - " 'Coverage[0.7]': 0.75072318647085,\n", - " 'QuantileLoss[0.8]': 6832265.371796237,\n", - " 'Coverage[0.8]': 0.8361704494882065,\n", - " 'QuantileLoss[0.9]': 4622603.4241216,\n", - " 'Coverage[0.9]': 0.9121977451416704,\n", - " 'RMSE': 1513.3765686342101,\n", - " 'NRMSE': 0.6344670458580278,\n", - " 'ND': 0.06946715987943533,\n", - " 'wQuantileLoss[0.1]': 0.03205258790807783,\n", - " 'wQuantileLoss[0.2]': 0.04872777845300084,\n", - " 'wQuantileLoss[0.3]': 0.05961611038289646,\n", - " 'wQuantileLoss[0.4]': 0.06643955965031452,\n", - " 'wQuantileLoss[0.5]': 0.06946715957944326,\n", - " 'wQuantileLoss[0.6]': 0.06864956858668704,\n", - " 'wQuantileLoss[0.7]': 0.06343121142758675,\n", - " 'wQuantileLoss[0.8]': 0.05311442405005633,\n", - " 'wQuantileLoss[0.9]': 0.035936384950382386,\n", - " 'mean_absolute_QuantileLoss': 7109611.867809796,\n", - " 'mean_wQuantileLoss': 0.055270531665382816,\n", - " 'MAE_Coverage': 0.035807001928497256,\n", + " 'MASE': 0.9230363743475488,\n", + " 'MAPE': 0.13762913075625383,\n", + " 'sMAPE': 0.1225657482189261,\n", + " 'MSIS': 6.837486088818375,\n", + " 'QuantileLoss[0.1]': 4183971.882330881,\n", + " 'Coverage[0.1]': 0.13139741878059635,\n", + " 'QuantileLoss[0.2]': 6507467.195659928,\n", + " 'Coverage[0.2]': 0.24473371903278449,\n", + " 'QuantileLoss[0.3]': 8081948.245087599,\n", + " 'Coverage[0.3]': 0.34848316273549923,\n", + " 'QuantileLoss[0.4]': 9055948.958718367,\n", + " 'Coverage[0.4]': 0.4462987687286753,\n", + " 'QuantileLoss[0.5]': 9499909.849783681,\n", + " 'Coverage[0.5]': 0.5364560154279779,\n", + " 'QuantileLoss[0.6]': 9417650.74509728,\n", + " 'Coverage[0.6]': 0.6173972704346535,\n", + " 'QuantileLoss[0.7]': 8747053.378532637,\n", + " 'Coverage[0.7]': 0.7036418928942294,\n", + " 'QuantileLoss[0.8]': 7436005.54045527,\n", + " 'Coverage[0.8]': 0.7901090342679128,\n", + " 'QuantileLoss[0.9]': 5067467.9464677805,\n", + " 'Coverage[0.9]': 0.8804146269099541,\n", + " 'RMSE': 1382.8485673353282,\n", + " 'NRMSE': 0.5797445682524747,\n", + " 'ND': 0.07385284519667915,\n", + " 'wQuantileLoss[0.1]': 0.03252643811070377,\n", + " 'wQuantileLoss[0.2]': 0.05058942434363343,\n", + " 'wQuantileLoss[0.3]': 0.06282953059935589,\n", + " 'wQuantileLoss[0.4]': 0.0704014681798836,\n", + " 'wQuantileLoss[0.5]': 0.07385284568741218,\n", + " 'wQuantileLoss[0.6]': 0.0732133586753404,\n", + " 'wQuantileLoss[0.7]': 0.06800009616923237,\n", + " 'wQuantileLoss[0.8]': 0.057807934853454424,\n", + " 'wQuantileLoss[0.9]': 0.03939478733947294,\n", + " 'mean_absolute_QuantileLoss': 7555269.304681491,\n", + " 'mean_wQuantileLoss': 0.05873509821760989,\n", + " 'MAE_Coverage': 0.028653842984061054,\n", " 'OWA': nan}" ] }, - "execution_count": 28, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -4488,13 +284,13 @@ }, { "cell_type": "code", - "execution_count": 29, - "id": "d61f32ab", + "execution_count": 21, + "id": "3ce4e69d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4516,6 +312,7 @@ " plt.plot(ts[-4 * dataset.metadata.prediction_length:], label=\"target\", )\n", " forecast.plot( color='g')\n", " plt.xticks(rotation=60)\n", + " plt.title(forecast.item_id)\n", " ax.xaxis.set_major_formatter(date_formater)\n", "\n", "plt.gcf().tight_layout()\n", @@ -4523,54 +320,10 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 30, - "id": "d494463f", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_prob_forecasts(ts_entry, forecast_entry):\n", - " plot_length = 70\n", - " prediction_intervals = (50.0, 90.0)\n", - " legend = [\"observations\", \"median prediction\"] + [f\"{k}% prediction interval\" for k in prediction_intervals][::-1]\n", - "\n", - " fig, ax = plt.subplots(1, 1, figsize=(10, 7))\n", - " ts_entry[-plot_length:].plot(ax=ax) # plot the time series\n", - " forecast_entry.plot(prediction_intervals=prediction_intervals, color='g')\n", - " plt.grid(which=\"both\")\n", - " plt.legend(legend, loc=\"best\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "5256fde1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "index = 123\n", - "plot_prob_forecasts(tss[index], forecasts[index])" - ] - }, { "cell_type": "code", "execution_count": null, - "id": "66a41556", + "id": "9594a519", "metadata": {}, "outputs": [], "source": [] From c99572a6d94a56a9f0dd2073ae405de23be28f7d Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 11:44:19 +0200 Subject: [PATCH 5/8] fix args --- switch/module.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/switch/module.py b/switch/module.py index 036d66a..ec42d30 100644 --- a/switch/module.py +++ b/switch/module.py @@ -170,10 +170,10 @@ class SwitchTransformerEncoderLayer(nn.Module): linear = nn.Linear(d_model, dim_feedforward, **factory_kwargs) self.linear1 = SwitchFeedForward( - capacity_factor, - drop_tokens, - is_scale_prob, - n_experts, + capacity_factor=capacity_factor, + drop_tokens=drop_tokens, + is_scale_prob=is_scale_prob, + n_experts=n_experts, expert=linear, d_model=d_model, dim_feedforward=dim_feedforward, From 0b0ecc94f9bf3cd8c582ac06c6b3f145f130a0e4 Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 11:45:31 +0200 Subject: [PATCH 6/8] fix typo --- switch/estimator.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/switch/estimator.py b/switch/estimator.py index cab46f6..0954c92 100644 --- a/switch/estimator.py +++ b/switch/estimator.py @@ -108,8 +108,7 @@ class SwitchTransformerEstimator(PyTorchLightningEstimator): self.capacity_factor = capacity_factor self.is_scale_prob = is_scale_prob self.drop_tokens = drop_tokens - - + 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 @@ -321,4 +320,4 @@ class SwitchTransformerEstimator(PyTorchLightningEstimator): num_parallel_samples=self.num_parallel_samples, ) - return TransformerLightningModule(model=model, loss=self.loss) + return SwitchTransformerLightningModule(model=model, loss=self.loss) From d11578a2350f510d6fcba28d0ff81d1d446a221e Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 14:11:51 +0200 Subject: [PATCH 7/8] fix final_output tensor shape --- switch/module.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/switch/module.py b/switch/module.py index ec42d30..fc58dde 100644 --- a/switch/module.py +++ b/switch/module.py @@ -75,7 +75,7 @@ class SwitchFeedForward(nn.Module): ] # Initialize an empty tensor to store outputs - final_output = x.new_zeros((batch_size, seq_len, self.dim_feedforward)) + final_output = x.new_zeros((batch_size * seq_len, self.dim_feedforward)) # Capacity of each expert. # $$\mathrm{expert\;capacity} = From 6cbce657e1fbecb8bd967b178026b7b50e37afdf Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 6 Jun 2022 14:36:10 +0200 Subject: [PATCH 8/8] notebook --- switch/switch.ipynb | 272 +++++++++++++++++++++++++------------------- 1 file changed, 158 insertions(+), 114 deletions(-) diff --git a/switch/switch.ipynb b/switch/switch.ipynb index 1e61d85..2a512a2 100644 --- a/switch/switch.ipynb +++ b/switch/switch.ipynb @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "e772234f", "metadata": {}, "outputs": [], @@ -80,24 +80,115 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "22d804e4", "metadata": {}, "outputs": [ { - "ename": "ValidationError", - "evalue": "1 validation error for SwitchTransformerModelModel\ncapacity_factor\n field required (type=value_error.missing)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValidationError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [6]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m predictor \u001b[38;5;241m=\u001b[39m estimator\u001b[38;5;241m.\u001b[39mtrain(\n\u001b[1;32m 2\u001b[0m training_data\u001b[38;5;241m=\u001b[39mdataset\u001b[38;5;241m.\u001b[39mtrain,\n\u001b[1;32m 3\u001b[0m num_workers\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m8\u001b[39m,\n\u001b[1;32m 4\u001b[0m shuffle_buffer_length\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1024\u001b[39m\n\u001b[1;32m 5\u001b[0m )\n", - "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/model/estimator.py:230\u001b[0m, in \u001b[0;36mPyTorchLightningEstimator.train\u001b[0;34m(self, training_data, validation_data, num_workers, shuffle_buffer_length, cache_data, ckpt_path, **kwargs)\u001b[0m\n\u001b[1;32m 220\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtrain\u001b[39m(\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 222\u001b[0m training_data: Dataset,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 228\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 229\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m PyTorchPredictor:\n\u001b[0;32m--> 230\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[43m \u001b[49m\u001b[43mtraining_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 232\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 233\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_workers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_workers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 234\u001b[0m \u001b[43m \u001b[49m\u001b[43mshuffle_buffer_length\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshuffle_buffer_length\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 235\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 236\u001b[0m \u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mckpt_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 237\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 238\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mpredictor\n", - "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/model/estimator.py:161\u001b[0m, in \u001b[0;36mPyTorchLightningEstimator.train_model\u001b[0;34m(self, training_data, validation_data, num_workers, shuffle_buffer_length, cache_data, ckpt_path, **kwargs)\u001b[0m\n\u001b[1;32m 155\u001b[0m transformation \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_transformation()\n\u001b[1;32m 157\u001b[0m transformed_training_data \u001b[38;5;241m=\u001b[39m transformation\u001b[38;5;241m.\u001b[39mapply(\n\u001b[1;32m 158\u001b[0m training_data, is_train\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 159\u001b[0m )\n\u001b[0;32m--> 161\u001b[0m training_network \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_lightning_module\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 163\u001b[0m training_data_loader \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_training_data_loader(\n\u001b[1;32m 164\u001b[0m transformed_training_data\n\u001b[1;32m 165\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m cache_data\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 169\u001b[0m shuffle_buffer_length\u001b[38;5;241m=\u001b[39mshuffle_buffer_length,\n\u001b[1;32m 170\u001b[0m )\n\u001b[1;32m 172\u001b[0m validation_data_loader \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m/mnt/scratch/kashif/pytorch-transformer-ts/switch/estimator.py:285\u001b[0m, in \u001b[0;36mSwitchTransformerEstimator.create_lightning_module\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 284\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_lightning_module\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m SwitchTransformerLightningModule:\n\u001b[0;32m--> 285\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mSwitchTransformerModel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 286\u001b[0m \u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontext_length\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcontext_length\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 288\u001b[0m \u001b[43m \u001b[49m\u001b[43mprediction_length\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprediction_length\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 289\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_feat_dynamic_real\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\n\u001b[1;32m 290\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_feat_dynamic_real\u001b[49m\n\u001b[1;32m 291\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_features\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 292\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_feat_static_real\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_feat_static_real\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_feat_static_cat\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_feat_static_cat\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[43m \u001b[49m\u001b[43mcardinality\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcardinality\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[43membedding_dimension\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43membedding_dimension\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# transformer arguments\u001b[39;49;00m\n\u001b[1;32m 297\u001b[0m \u001b[43m \u001b[49m\u001b[43mnhead\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnhead\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_encoder_layers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_encoder_layers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_decoder_layers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_decoder_layers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[43mactivation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mactivation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[43mdropout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[43mdim_feedforward\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdim_feedforward\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# univariate input\u001b[39;49;00m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[43minput_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minput_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43mdistr_output\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistr_output\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 306\u001b[0m \u001b[43m \u001b[49m\u001b[43mlags_seq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlags_seq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[43m \u001b[49m\u001b[43mscaling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 308\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_parallel_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_parallel_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 309\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m TransformerLightningModule(model\u001b[38;5;241m=\u001b[39mmodel, loss\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss)\n", - "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/core/component.py:326\u001b[0m, in \u001b[0;36mvalidated..validator..init_wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs \u001b[38;5;241m=\u001b[39m args\n\u001b[1;32m 319\u001b[0m nmargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 320\u001b[0m name: arg\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (name, param), arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 324\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 325\u001b[0m }\n\u001b[0;32m--> 326\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mPydanticModel\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mnmargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 328\u001b[0m \u001b[38;5;66;03m# merge nmargs, kwargs, and the model fields into a single dict\u001b[39;00m\n\u001b[1;32m 329\u001b[0m all_args \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mnmargs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m}\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pydantic/main.py:341\u001b[0m, in \u001b[0;36mpydantic.main.BaseModel.__init__\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mValidationError\u001b[0m: 1 validation error for SwitchTransformerModelModel\ncapacity_factor\n field required (type=value_error.missing)" + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/utilities/parsing.py:261: 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.8/site-packages/pytorch_lightning/utilities/parsing.py:261: UserWarning: Attribute 'loss' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['loss'])`.\n", + " rank_zero_warn(\n", + "GPU available: True, 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.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:133: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------------\n", + "0 | model | SwitchTransformerModel | 75.5 K\n", + "1 | loss | NegativeLogLikelihood | 0 \n", + "-------------------------------------------------\n", + "75.5 K Trainable params\n", + "0 Non-trainable params\n", + "75.5 K Total params\n", + "0.302 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "78ce8638ba8b45e59858e078aa08b6ba", + "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.8/site-packages/torchmetrics/utilities/prints.py:36: UserWarning: Torchmetrics v0.9 introduced a new argument class property called `full_state_update` that has\n", + " not been set for this class (_ResultMetric). The property determines if `update` by\n", + " default needs access to the full metric state. If this is not the case, significant speedups can be\n", + " achieved and we recommend setting this to `False`.\n", + " We provide an checking function\n", + " `from torchmetrics.utilities import check_forward_no_full_state`\n", + " that can be used to check if the `full_state_update=True` (old and potential slower behaviour,\n", + " default for now) or if `full_state_update=False` can be used safely.\n", + " \n", + " warnings.warn(*args, **kwargs)\n", + "Epoch 0, global step 100: 'train_loss' reached 6.53932 (best 6.53932), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=0-step=100.ckpt' as top 1\n", + "Epoch 1, global step 200: 'train_loss' reached 6.06170 (best 6.06170), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=1-step=200.ckpt' as top 1\n", + "Epoch 2, global step 300: 'train_loss' reached 5.85441 (best 5.85441), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=2-step=300.ckpt' as top 1\n", + "Epoch 3, global step 400: 'train_loss' reached 5.71498 (best 5.71498), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=3-step=400.ckpt' as top 1\n", + "Epoch 4, global step 500: 'train_loss' reached 5.63095 (best 5.63095), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=4-step=500.ckpt' as top 1\n", + "Epoch 5, global step 600: 'train_loss' reached 5.59845 (best 5.59845), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=5-step=600.ckpt' as top 1\n", + "Epoch 6, global step 700: 'train_loss' reached 5.50794 (best 5.50794), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=6-step=700.ckpt' as top 1\n", + "Epoch 7, global step 800: 'train_loss' reached 5.50530 (best 5.50530), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=7-step=800.ckpt' as top 1\n", + "Epoch 8, global step 900: 'train_loss' reached 5.46209 (best 5.46209), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=8-step=900.ckpt' as top 1\n", + "Epoch 9, global step 1000: 'train_loss' reached 5.44430 (best 5.44430), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=9-step=1000.ckpt' as top 1\n", + "Epoch 10, global step 1100: 'train_loss' reached 5.44166 (best 5.44166), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=10-step=1100.ckpt' as top 1\n", + "Epoch 11, global step 1200: 'train_loss' reached 5.36817 (best 5.36817), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=11-step=1200.ckpt' as top 1\n", + "Epoch 12, global step 1300: 'train_loss' was not in top 1\n", + "Epoch 13, global step 1400: 'train_loss' was not in top 1\n", + "Epoch 14, global step 1500: 'train_loss' reached 5.32576 (best 5.32576), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=14-step=1500.ckpt' as top 1\n", + "Epoch 15, global step 1600: 'train_loss' reached 5.29555 (best 5.29555), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=15-step=1600.ckpt' as top 1\n", + "Epoch 16, global step 1700: 'train_loss' was not in top 1\n", + "Epoch 17, global step 1800: 'train_loss' reached 5.29322 (best 5.29322), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=17-step=1800.ckpt' as top 1\n", + "Epoch 18, global step 1900: 'train_loss' was not in top 1\n", + "Epoch 19, global step 2000: 'train_loss' reached 5.26062 (best 5.26062), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=19-step=2000.ckpt' as top 1\n", + "Epoch 20, global step 2100: 'train_loss' was not in top 1\n", + "Epoch 21, global step 2200: 'train_loss' reached 5.25029 (best 5.25029), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=21-step=2200.ckpt' as top 1\n", + "Epoch 22, global step 2300: 'train_loss' reached 5.23372 (best 5.23372), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=22-step=2300.ckpt' as top 1\n", + "Epoch 23, global step 2400: 'train_loss' was not in top 1\n", + "Epoch 24, global step 2500: 'train_loss' reached 5.21814 (best 5.21814), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=24-step=2500.ckpt' as top 1\n", + "Epoch 25, global step 2600: 'train_loss' was not in top 1\n", + "Epoch 26, global step 2700: 'train_loss' reached 5.21784 (best 5.21784), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=26-step=2700.ckpt' as top 1\n", + "Epoch 27, global step 2800: 'train_loss' reached 5.18084 (best 5.18084), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=27-step=2800.ckpt' as top 1\n", + "Epoch 28, global step 2900: 'train_loss' was not in top 1\n", + "Epoch 29, global step 3000: 'train_loss' was not in top 1\n", + "Epoch 30, global step 3100: 'train_loss' was not in top 1\n", + "Epoch 31, global step 3200: 'train_loss' was not in top 1\n", + "Epoch 32, global step 3300: 'train_loss' reached 5.16294 (best 5.16294), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=32-step=3300.ckpt' as top 1\n", + "Epoch 33, global step 3400: 'train_loss' was not in top 1\n", + "Epoch 34, global step 3500: 'train_loss' was not in top 1\n", + "Epoch 35, global step 3600: 'train_loss' was not in top 1\n", + "Epoch 36, global step 3700: 'train_loss' was not in top 1\n", + "Epoch 37, global step 3800: 'train_loss' was not in top 1\n", + "Epoch 38, global step 3900: 'train_loss' reached 5.16191 (best 5.16191), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=38-step=3900.ckpt' as top 1\n", + "Epoch 39, global step 4000: 'train_loss' was not in top 1\n", + "Epoch 40, global step 4100: 'train_loss' was not in top 1\n", + "Epoch 41, global step 4200: 'train_loss' reached 5.12905 (best 5.12905), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=41-step=4200.ckpt' as top 1\n", + "Epoch 42, global step 4300: 'train_loss' was not in top 1\n", + "Epoch 43, global step 4400: 'train_loss' reached 5.11128 (best 5.11128), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_1/checkpoints/epoch=43-step=4400.ckpt' as top 1\n", + "Epoch 44, global step 4500: 'train_loss' was not in top 1\n", + "Epoch 45, global step 4600: 'train_loss' was not in top 1\n", + "Epoch 46, global step 4700: 'train_loss' was not in top 1\n", + "Epoch 47, global step 4800: 'train_loss' was not in top 1\n", + "Epoch 48, global step 4900: 'train_loss' was not in top 1\n", + "Epoch 49, global step 5000: 'train_loss' was not in top 1\n" ] } ], @@ -111,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "id": "11a47d5a", "metadata": {}, "outputs": [], @@ -124,32 +215,17 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "id": "1492f7fb", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n" - ] - } - ], + "outputs": [], "source": [ "forecasts = list(forecast_it)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "id": "d406a112", "metadata": {}, "outputs": [], @@ -159,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "id": "e00601c4", "metadata": {}, "outputs": [], @@ -169,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "id": "9ed4c523", "metadata": {}, "outputs": [ @@ -177,39 +253,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Running evaluation: 2247it [00:00, 4312.72it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "Running evaluation: 2247it [00:00, 5481.81it/s]\n", "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pandas/core/construction.py:781: UserWarning: Warning: converting a masked element to nan.\n", " subarr = np.array(arr, dtype=dtype, copy=copy)\n" ] @@ -221,59 +265,59 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "91dc33b6", + "execution_count": 11, + "id": "2cb4abe2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'MSE': 1912270.1601813699,\n", - " 'abs_error': 9499909.78665924,\n", + "{'MSE': 2308789.695387119,\n", + " 'abs_error': 9913947.80090332,\n", " 'abs_target_sum': 128632956.0,\n", " 'abs_target_mean': 2385.272140631954,\n", " 'seasonal_error': 189.49338196116761,\n", - " 'MASE': 0.9230363743475488,\n", - " 'MAPE': 0.13762913075625383,\n", - " 'sMAPE': 0.1225657482189261,\n", - " 'MSIS': 6.837486088818375,\n", - " 'QuantileLoss[0.1]': 4183971.882330881,\n", - " 'Coverage[0.1]': 0.13139741878059635,\n", - " 'QuantileLoss[0.2]': 6507467.195659928,\n", - " 'Coverage[0.2]': 0.24473371903278449,\n", - " 'QuantileLoss[0.3]': 8081948.245087599,\n", - " 'Coverage[0.3]': 0.34848316273549923,\n", - " 'QuantileLoss[0.4]': 9055948.958718367,\n", - " 'Coverage[0.4]': 0.4462987687286753,\n", - " 'QuantileLoss[0.5]': 9499909.849783681,\n", - " 'Coverage[0.5]': 0.5364560154279779,\n", - " 'QuantileLoss[0.6]': 9417650.74509728,\n", - " 'Coverage[0.6]': 0.6173972704346535,\n", - " 'QuantileLoss[0.7]': 8747053.378532637,\n", - " 'Coverage[0.7]': 0.7036418928942294,\n", - " 'QuantileLoss[0.8]': 7436005.54045527,\n", - " 'Coverage[0.8]': 0.7901090342679128,\n", - " 'QuantileLoss[0.9]': 5067467.9464677805,\n", - " 'Coverage[0.9]': 0.8804146269099541,\n", - " 'RMSE': 1382.8485673353282,\n", - " 'NRMSE': 0.5797445682524747,\n", - " 'ND': 0.07385284519667915,\n", - " 'wQuantileLoss[0.1]': 0.03252643811070377,\n", - " 'wQuantileLoss[0.2]': 0.05058942434363343,\n", - " 'wQuantileLoss[0.3]': 0.06282953059935589,\n", - " 'wQuantileLoss[0.4]': 0.0704014681798836,\n", - " 'wQuantileLoss[0.5]': 0.07385284568741218,\n", - " 'wQuantileLoss[0.6]': 0.0732133586753404,\n", - " 'wQuantileLoss[0.7]': 0.06800009616923237,\n", - " 'wQuantileLoss[0.8]': 0.057807934853454424,\n", - " 'wQuantileLoss[0.9]': 0.03939478733947294,\n", - " 'mean_absolute_QuantileLoss': 7555269.304681491,\n", - " 'mean_wQuantileLoss': 0.05873509821760989,\n", - " 'MAE_Coverage': 0.028653842984061054,\n", + " 'MASE': 0.782350009562839,\n", + " 'MAPE': 0.10093158438717875,\n", + " 'sMAPE': 0.11210628837831137,\n", + " 'MSIS': 6.093644166414652,\n", + " 'QuantileLoss[0.1]': 4243983.490897928,\n", + " 'Coverage[0.1]': 0.12959872422489244,\n", + " 'QuantileLoss[0.2]': 6717838.2415222265,\n", + " 'Coverage[0.2]': 0.24310191366266132,\n", + " 'QuantileLoss[0.3]': 8384472.076653192,\n", + " 'Coverage[0.3]': 0.3441625871532414,\n", + " 'QuantileLoss[0.4]': 9423126.726327974,\n", + " 'Coverage[0.4]': 0.4417742174751521,\n", + " 'QuantileLoss[0.5]': 9913947.8229811,\n", + " 'Coverage[0.5]': 0.5353619641002819,\n", + " 'QuantileLoss[0.6]': 9806506.761595396,\n", + " 'Coverage[0.6]': 0.6134661029520843,\n", + " 'QuantileLoss[0.7]': 9047604.118984528,\n", + " 'Coverage[0.7]': 0.6995067497403945,\n", + " 'QuantileLoss[0.8]': 7602965.167928445,\n", + " 'Coverage[0.8]': 0.7845460614152203,\n", + " 'QuantileLoss[0.9]': 5178201.723310344,\n", + " 'Coverage[0.9]': 0.8760384215991693,\n", + " 'RMSE': 1519.4702022044128,\n", + " 'NRMSE': 0.637021736983791,\n", + " 'ND': 0.07707160053838241,\n", + " 'wQuantileLoss[0.1]': 0.03299297180807948,\n", + " 'wQuantileLoss[0.2]': 0.05222486095648946,\n", + " 'wQuantileLoss[0.3]': 0.06518136826967727,\n", + " 'wQuantileLoss[0.4]': 0.07325592926845259,\n", + " 'wQuantileLoss[0.5]': 0.07707160071001634,\n", + " 'wQuantileLoss[0.6]': 0.07623634771788496,\n", + " 'wQuantileLoss[0.7]': 0.07033659491572694,\n", + " 'wQuantileLoss[0.8]': 0.05910588860236132,\n", + " 'wQuantileLoss[0.9]': 0.0402556380909908,\n", + " 'mean_absolute_QuantileLoss': 7813182.903355681,\n", + " 'mean_wQuantileLoss': 0.06074013337107546,\n", + " 'MAE_Coverage': 0.02748603075705881,\n", " 'OWA': nan}" ] }, - "execution_count": 20, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -284,13 +328,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "id": "3ce4e69d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -309,7 +353,7 @@ "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:], label=\"target\", )\n", + " ts[-4 * dataset.metadata.prediction_length:].plot(ax=ax, label=\"target\",)\n", " forecast.plot( color='g')\n", " plt.xticks(rotation=60)\n", " plt.title(forecast.item_id)\n",