diff --git a/autoformer/.typesafe b/autoformer/.typesafe new file mode 100644 index 0000000..e69de29 diff --git a/autoformer/estimator.py b/autoformer/estimator.py index 56a041a..75efd84 100644 --- a/autoformer/estimator.py +++ b/autoformer/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 ( diff --git a/autoformer/module.py b/autoformer/module.py index 51538b2..4191920 100644 --- a/autoformer/module.py +++ b/autoformer/module.py @@ -6,7 +6,7 @@ import torch.nn as nn import torch.nn.functional as F from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler diff --git a/etsformer/estimator.py b/etsformer/estimator.py index f50f11c..4d5601c 100644 --- a/etsformer/estimator.py +++ b/etsformer/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 ( diff --git a/etsformer/module.py b/etsformer/module.py index 36337f6..6901b7c 100644 --- a/etsformer/module.py +++ b/etsformer/module.py @@ -5,7 +5,7 @@ import torch.nn as nn from etsformer_pytorch import ETSFormer from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler diff --git a/hopfield/estimator.py b/hopfield/estimator.py index fe6d635..b90974a 100644 --- a/hopfield/estimator.py +++ b/hopfield/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 ( diff --git a/hopfield/hopfield_estimator.py b/hopfield/hopfield_estimator.py new file mode 100644 index 0000000..99f1e75 --- /dev/null +++ b/hopfield/hopfield_estimator.py @@ -0,0 +1,262 @@ +from typing import List, Optional + +import numpy as np +import torch +import torch.nn as nn + +from gluonts.core.component import validated +from gluonts.dataset.field_names import FieldName +from gluonts.time_feature import TimeFeature +from gluonts.torch.distributions import DistributionOutput +from gluonts.torch.util import copy_parameters +from gluonts.torch.model.predictor import PyTorchPredictor +from gluonts.model.predictor import Predictor +from gluonts.transform import ( + Transformation, + Chain, + InstanceSplitter, + InstanceSampler, + ValidationSplitSampler, + TestSplitSampler, + ExpectedNumInstanceSampler, + RemoveFields, + AddAgeFeature, + AsNumpyArray, + AddObservedValuesIndicator, + AddTimeFeatures, + VstackFeatures, + SetField, +) + +from pts import Trainer +from pts.model.utils import get_module_forward_input_names +from pts.feature import ( + fourier_time_features_from_frequency, + lags_for_fourier_time_features_from_frequency, +) +from pts.model import PyTorchEstimator +from pts.modules import StudentTOutput + +from .hopfield_network import ( + HopfieldTrainingNetwork, + HopfieldPredictionNetwork, +) + + +class HopfieldEstimator(PyTorchEstimator): + @validated() + def __init__( + self, + input_size: int, + freq: str, + prediction_length: int, + context_length: Optional[int] = None, + trainer: Trainer = Trainer(), + dropout_rate: float = 0.1, + cardinality: Optional[List[int]] = None, + embedding_dimension: List[int] = [20], + distr_output: DistributionOutput = StudentTOutput(), + d_model: int = 32, + dim_feedforward_scale: int = 4, + act_type: str = "gelu", + num_heads: int = 8, + num_encoder_layers: int = 3, + num_decoder_layers: int = 3, + scaling: bool = True, + lags_seq: Optional[List[int]] = None, + time_features: Optional[List[TimeFeature]] = None, + use_feat_dynamic_real: bool = False, + use_feat_static_cat: bool = False, + use_feat_static_real: bool = False, + num_parallel_samples: int = 100, + ) -> None: + super().__init__(trainer=trainer) + + self.input_size = input_size + self.freq = freq + self.prediction_length = prediction_length + self.context_length = ( + context_length if context_length is not None else prediction_length + ) + self.distr_output = distr_output + self.dropout_rate = dropout_rate + self.use_feat_dynamic_real = use_feat_dynamic_real + self.use_feat_static_cat = use_feat_static_cat + self.use_feat_static_real = use_feat_static_real + self.cardinality = cardinality if use_feat_static_cat else [1] + self.embedding_dimension = embedding_dimension + self.num_parallel_samples = num_parallel_samples + self.lags_seq = ( + lags_seq + if lags_seq is not None + else lags_for_fourier_time_features_from_frequency(freq_str=freq) + ) + self.time_features = ( + time_features + if time_features is not None + else fourier_time_features_from_frequency(self.freq) + ) + self.history_length = self.context_length + max(self.lags_seq) + self.scaling = scaling + + self.d_model = d_model + self.num_heads = num_heads + self.act_type = act_type + self.dim_feedforward_scale = dim_feedforward_scale + self.num_encoder_layers = num_encoder_layers + self.num_decoder_layers = num_decoder_layers + + self.train_sampler = ExpectedNumInstanceSampler( + num_instances=1.0, min_future=prediction_length + ) + self.validation_sampler = ValidationSplitSampler(min_future=prediction_length) + + def create_transformation(self) -> Transformation: + remove_field_names = [ + FieldName.FEAT_DYNAMIC_CAT, + ] + if not self.use_feat_dynamic_real: + remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL) + if not self.use_feat_static_real: + remove_field_names.append(FieldName.FEAT_STATIC_REAL) + return Chain( + [RemoveFields(field_names=remove_field_names)] + + ( + [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])] + if not self.use_feat_static_cat + else [] + ) + + ( + [SetField(output_field=FieldName.FEAT_STATIC_REAL, value=[0.0])] + if not self.use_feat_static_real + else [] + ) + + [ + AsNumpyArray( + field=FieldName.FEAT_STATIC_CAT, expected_ndim=1, dtype=np.long + ), + AsNumpyArray( + field=FieldName.FEAT_STATIC_REAL, + expected_ndim=1, + dtype=self.dtype, + ), + 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.use_feat_dynamic_real + else [] + ), + ), + ] + ) + + def create_instance_splitter(self, 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=self.history_length, + future_length=self.prediction_length, + time_series_fields=[ + FieldName.FEAT_TIME, + FieldName.OBSERVED_VALUES, + ], + ) + + def create_training_network(self, device: torch.device) -> HopfieldTrainingNetwork: + + training_network = HopfieldTrainingNetwork( + input_size=self.input_size, + num_heads=self.num_heads, + act_type=self.act_type, + dropout_rate=self.dropout_rate, + d_model=self.d_model, + dim_feedforward_scale=self.dim_feedforward_scale, + num_encoder_layers=self.num_encoder_layers, + num_decoder_layers=self.num_decoder_layers, + history_length=self.history_length, + context_length=self.context_length, + prediction_length=self.prediction_length, + distr_output=self.distr_output, + cardinality=self.cardinality, + embedding_dimension=self.embedding_dimension, + lags_seq=self.lags_seq, + scaling=self.scaling, + ).to(device) + + return training_network + + def create_predictor( + self, + transformation: Transformation, + trained_network: HopfieldTrainingNetwork, + device: torch.device, + ) -> Predictor: + + prediction_network = HopfieldPredictionNetwork( + input_size=self.input_size, + num_heads=self.num_heads, + act_type=self.act_type, + dropout_rate=self.dropout_rate, + d_model=self.d_model, + dim_feedforward_scale=self.dim_feedforward_scale, + num_encoder_layers=self.num_encoder_layers, + num_decoder_layers=self.num_decoder_layers, + history_length=self.history_length, + context_length=self.context_length, + prediction_length=self.prediction_length, + distr_output=self.distr_output, + cardinality=self.cardinality, + embedding_dimension=self.embedding_dimension, + lags_seq=self.lags_seq, + scaling=self.scaling, + num_parallel_samples=self.num_parallel_samples, + ).to(device) + + copy_parameters(trained_network, prediction_network) + input_names = get_module_forward_input_names(prediction_network) + prediction_splitter = self.create_instance_splitter("test") + + return PyTorchPredictor( + input_transform=transformation + prediction_splitter, + input_names=input_names, + prediction_net=prediction_network, + batch_size=self.trainer.batch_size, + freq=self.freq, + prediction_length=self.prediction_length, + device=device, + ) diff --git a/hopfield/hopfield_network.py b/hopfield/hopfield_network.py new file mode 100644 index 0000000..65eadb3 --- /dev/null +++ b/hopfield/hopfield_network.py @@ -0,0 +1,477 @@ +from typing import List, Optional, Tuple + +import torch +import torch.nn as nn + +from gluonts.core.component import validated +from gluonts.torch.distributions import DistributionOutput +from pts.modules import MeanScaler, NOPScaler, FeatureEmbedder + +from hflayers import Hopfield +from hflayers.transformer import HopfieldDecoderLayer, HopfieldEncoderLayer + + +def prod(xs): + p = 1 + for x in xs: + p *= x + return p + + +class HopfieldNetwork(nn.Module): + @validated() + def __init__( + self, + input_size: int, + d_model: int, + num_heads: int, + act_type: str, + dropout_rate: float, + dim_feedforward_scale: int, + num_encoder_layers: int, + num_decoder_layers: int, + history_length: int, + context_length: int, + prediction_length: int, + distr_output: DistributionOutput, + cardinality: List[int], + embedding_dimension: List[int], + lags_seq: List[int], + scaling: bool = True, + **kwargs, + ) -> None: + super().__init__(**kwargs) + + self.history_length = history_length + self.context_length = context_length + self.prediction_length = prediction_length + self.scaling = scaling + self.cardinality = cardinality + self.embedding_dimension = embedding_dimension + self.distr_output = distr_output + + assert len(set(lags_seq)) == len(lags_seq), "no duplicated lags allowed!" + lags_seq.sort() + + self.lags_seq = lags_seq + + self.target_shape = distr_output.event_shape + + # [B, T, input_size] -> [B, T, d_model] + # self.encoder_input = nn.Linear(input_size, d_model) + # self.decoder_input = nn.Linear(input_size, d_model) + + # [B, T, d_model] where d_model / num_heads is int + encoder_association = Hopfield(input_size=input_size, num_heads=num_heads) + encoder_layer = HopfieldEncoderLayer( + encoder_association, + dim_feedforward=dim_feedforward_scale * input_size, + dropout=dropout_rate, + activation=act_type, + ) + transformer_encoder = nn.TransformerEncoder( + encoder_layer, num_layers=num_encoder_layers + ) + + decoder_association_self = Hopfield(input_size=input_size, num_heads=num_heads) + decoder_association_cross = Hopfield(input_size=input_size, num_heads=num_heads) + decoder_layer = HopfieldDecoderLayer( + hopfield_association_self=decoder_association_self, + hopfield_association_cross=decoder_association_cross, + dim_feedforward=dim_feedforward_scale * input_size, + dropout=dropout_rate, + activation=act_type, + ) + transformer_decoder = nn.TransformerDecoder( + decoder_layer, num_layers=num_decoder_layers + ) + + self.transformer = nn.Transformer( + d_model=input_size, + nhead=num_heads, + custom_encoder=transformer_encoder, + custom_decoder=transformer_decoder, + batch_first=True, + ) + + self.proj_dist_args = distr_output.get_args_proj(input_size) + + self.embedder = FeatureEmbedder( + cardinalities=cardinality, + embedding_dims=embedding_dimension, + ) + + if scaling: + self.scaler = MeanScaler(keepdim=True) + else: + self.scaler = NOPScaler(keepdim=True) + + # mask + self.register_buffer( + "tgt_mask", + self.transformer.generate_square_subsequent_mask(prediction_length), + ) + + @staticmethod + def get_lagged_subsequences( + sequence: torch.Tensor, + sequence_length: int, + indices: List[int], + subsequences_length: int = 1, + ) -> 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). + sequence_length : int + length of sequence in the T (time) dimension (axis = 1). + indices : List[int] + list of lag indices to be used. + subsequences_length : int + length of the subsequences to be extracted. + 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, :]. + """ + 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}" + ) + assert all(lag_index >= 0 for lag_index in indices) + + 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 create_network_input( + self, + feat_static_cat: torch.Tensor, # (batch_size, num_features) + feat_static_real: torch.Tensor, + # (batch_size, num_features, history_length) + past_time_feat: torch.Tensor, + past_target: torch.Tensor, # (batch_size, history_length, 1) + past_observed_values: torch.Tensor, # (batch_size, history_length) + future_time_feat: Optional[ + torch.Tensor + ], # (batch_size, num_features, prediction_length) + # (batch_size, prediction_length) + future_target: Optional[torch.Tensor], + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Creates inputs for the transformer network. + All tensor arguments should have NTC layout. + """ + + if future_time_feat is None or future_target is None: + time_feat = past_time_feat[ + :, self.history_length - self.context_length :, ... + ] + sequence = past_target + sequence_length = self.history_length + subsequences_length = self.context_length + else: + time_feat = torch.cat( + ( + past_time_feat[:, self.history_length - self.context_length :, ...], + future_time_feat, + ), + dim=1, + ) + sequence = torch.cat((past_target, future_target), dim=1) + sequence_length = self.history_length + self.prediction_length + subsequences_length = self.context_length + self.prediction_length + + # (batch_size, sub_seq_len, *target_shape, num_lags) + lags = self.get_lagged_subsequences( + sequence=sequence, + sequence_length=sequence_length, + indices=self.lags_seq, + subsequences_length=subsequences_length, + ) + + # scale is computed on the context length last units of the past target + # scale shape is (batch_size, 1, *target_shape) + _, scale = self.scaler( + past_target[:, -self.context_length :, ...], + past_observed_values[:, -self.context_length :, ...], + ) + embedded_cat = self.embedder(feat_static_cat) + + # in addition to embedding features, use the log scale as it can help prediction too + # (batch_size, num_features + prod(target_shape)) + static_feat = torch.cat( + ( + embedded_cat, + feat_static_real, + torch.log(scale) + if len(self.target_shape) == 0 + else torch.log(scale.squeeze(1)), + ), + dim=1, + ) + + repeated_static_feat = static_feat.unsqueeze(1).expand( + -1, subsequences_length, -1 + ) + + # (batch_size, sub_seq_len, *target_shape, num_lags) + lags_scaled = lags / scale.unsqueeze(-1) + + # from (batch_size, sub_seq_len, *target_shape, num_lags) + # to (batch_size, sub_seq_len, prod(target_shape) * num_lags) + input_lags = lags_scaled.reshape( + (-1, subsequences_length, len(self.lags_seq) * prod(self.target_shape)) + ) + + # (batch_size, sub_seq_len, input_dim) + inputs = torch.cat((input_lags, time_feat, repeated_static_feat), dim=-1) + + return inputs, scale, static_feat + + +class HopfieldTrainingNetwork(HopfieldNetwork): + # noinspection PyMethodOverriding,PyPep8Naming + 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, + future_target: torch.Tensor, + ) -> torch.Tensor: + """ + Computes the loss for training Hopfield Transformer, all inputs tensors representing time series have NTC layout. + Parameters + ---------- + feat_static_cat : (batch_size, num_features) + feat_static_real: torch.Tensor, # (batch_size, num_features) + past_time_feat : (batch_size, history_length, num_features) + past_target : (batch_size, history_length, *target_shape) + past_observed_values : (batch_size, history_length, *target_shape, seq_len) + future_time_feat : (batch_size, prediction_length, num_features) + future_target : (batch_size, prediction_length, *target_shape) + Returns + ------- + Loss with shape (batch_size, context + prediction_length, 1) + """ + + # create the inputs for the encoder + inputs, scale, _ = self.create_network_input( + feat_static_cat=feat_static_cat, + feat_static_real=feat_static_real, + past_time_feat=past_time_feat, + past_target=past_target, + past_observed_values=past_observed_values, + future_time_feat=future_time_feat, + future_target=future_target, + ) + + enc_input = inputs[:, : self.context_length, ...] # F.slice_axis( + # inputs, axis=1, begin=0, end=self.context_length + # ) + dec_input = inputs[:, self.context_length :, ...] # F.slice_axis( + # inputs, axis=1, begin=self.context_length, end=None + # ) + + # pass through encoder [T, B, b_model] + enc_out = self.transformer.encoder( + # self.encoder_input(enc_input).permute(1, 0, 2) + enc_input + ) + + # input to decoder + dec_output = self.transformer.decoder( + # self.decoder_input(dec_input).permute(1, 0, 2), + dec_input, + enc_out, # memory + tgt_mask=self.tgt_mask, + ) + + # compute loss + # distr_args = self.proj_dist_args(dec_output.permute(1, 0, 2)) + distr_args = self.proj_dist_args(dec_output) + distr = self.distr_output.distribution(distr_args, scale=scale) + loss = -distr.log_prob(future_target) + + return loss.mean() + + +class HopfieldPredictionNetwork(HopfieldNetwork): + def __init__(self, num_parallel_samples: int = 100, **kwargs) -> None: + super().__init__(**kwargs) + self.num_parallel_samples = num_parallel_samples + + # for decoding the lags are shifted by one, + # at the first time-step of the decoder a lag of one corresponds to the last target value + self.shifted_lags = [l - 1 for l in self.lags_seq] + + def sampling_decoder( + self, + static_feat: torch.Tensor, + past_target: torch.Tensor, + time_feat: torch.Tensor, + scale: torch.Tensor, + enc_out: torch.Tensor, + ) -> torch.Tensor: + """ + Computes sample paths by decoding from the transformer. + Parameters + ---------- + static_feat : Tensor + static features. Shape: (batch_size, num_static_features). + past_target : Tensor + target history. Shape: (batch_size, history_length, 1). + time_feat : Tensor + time features. Shape: (batch_size, prediction_length, num_time_features). + scale : Tensor + tensor containing the scale of each element in the batch. Shape: (batch_size, ). + enc_out: Tensor + output of the encoder. Shape: (batch_size, num_cells) + Returns + -------- + sample_paths : Tensor + a tensor containing sampled paths. Shape: (batch_size, num_sample_paths, prediction_length). + """ + + # blows-up the dimension of each tensor to batch_size * self.num_parallel_samples for increasing parallelism + repeated_past_target = past_target.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + repeated_time_feat = time_feat.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + repeated_static_feat = static_feat.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ).unsqueeze(1) + + repeated_enc_out = enc_out.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 # 1 + ) + + repeated_scale = scale.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + future_samples = [] + + # for each future time-units we draw new samples for this time-unit and update the state + for k in range(self.prediction_length): + lags = self.get_lagged_subsequences( + sequence=repeated_past_target, + sequence_length=self.history_length + k, + indices=self.shifted_lags, + subsequences_length=1, + ) + + # (batch_size * num_samples, 1, *target_shape, num_lags) + lags_scaled = lags / repeated_scale.unsqueeze(1) + # lags_scaled = F.broadcast_div( + # lags, repeated_scale.expand_dims(axis=-1) + # ) + + # from (batch_size * num_samples, 1, *target_shape, num_lags) + # to (batch_size * num_samples, 1, prod(target_shape) * num_lags) + input_lags = lags_scaled.reshape( + shape=(-1, 1, prod(self.target_shape) * len(self.lags_seq)) + ) + + # (batch_size * num_samples, 1, prod(target_shape) * num_lags + num_time_features + num_static_features) + dec_input = torch.cat( + (input_lags, repeated_time_feat[:, k : k + 1, :], repeated_static_feat), + dim=-1, + ) + + dec_output = self.transformer.decoder( + # self.decoder_input(dec_input).permute(1, 0, 2), + dec_input, + repeated_enc_out, + ) + + # distr_args = self.proj_dist_args(dec_output.permute(1, 0, 2)) + distr_args = self.proj_dist_args(dec_output) + + # compute likelihood of target given the predicted parameters + distr = self.distr_output.distribution(distr_args, scale=repeated_scale) + + # (batch_size * num_samples, 1, *target_shape) + new_samples = distr.sample() + + # (batch_size * num_samples, seq_len, *target_shape) + repeated_past_target = torch.cat((repeated_past_target, new_samples), dim=1) + future_samples.append(new_samples) + + # reset cache of the decoder + # self.transformer.decoder.cache_reset() + + # (batch_size * num_samples, prediction_length, *target_shape) + samples = torch.cat(future_samples, dim=1) + + # (batch_size, num_samples, *target_shape, prediction_length) + return samples.reshape( + ( + (-1, self.num_parallel_samples) + + self.target_shape + + (self.prediction_length,) + ) + ) + + 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, + ) -> torch.Tensor: + """ + Predicts samples, all tensors should have NTC layout. + Parameters + ---------- + feat_static_cat : (batch_size, num_features) + feat_static_real : (batch_size, num_features) + past_time_feat : (batch_size, history_length, num_features) + past_target : (batch_size, history_length, *target_shape) + past_observed_values : (batch_size, history_length, *target_shape) + future_time_feat : (batch_size, prediction_length, num_features) + Returns predicted samples + ------- + """ + + # create the inputs for the encoder + inputs, scale, static_feat = self.create_network_input( + feat_static_cat=feat_static_cat, + feat_static_real=feat_static_real, + past_time_feat=past_time_feat, + past_target=past_target, + past_observed_values=past_observed_values, + future_time_feat=None, + future_target=None, + ) + + # pass through encoder + enc_out = self.transformer.encoder( + # self.encoder_input(inputs).permute(1, 0, 2) + inputs + ) + + return self.sampling_decoder( + past_target=past_target, + time_feat=future_time_feat, + static_feat=static_feat, + scale=scale, + enc_out=enc_out, + ) diff --git a/hopfield/module.py b/hopfield/module.py index f13a7e4..3a43abd 100644 --- a/hopfield/module.py +++ b/hopfield/module.py @@ -4,7 +4,7 @@ import torch import torch.nn as nn from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler from hflayers import Hopfield diff --git a/informer/estimator.py b/informer/estimator.py index 0b6655d..54df353 100644 --- a/informer/estimator.py +++ b/informer/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 ( diff --git a/informer/informer.ipynb b/informer/informer.ipynb index 01198fc..707ef33 100644 --- a/informer/informer.ipynb +++ b/informer/informer.ipynb @@ -18,7 +18,9 @@ "cell_type": "code", "execution_count": 2, "id": "b10c3dd3", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stderr", @@ -48,7 +50,28 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 37, + "id": "50025289", + "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": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 29, "id": "e772234f", "metadata": {}, "outputs": [], @@ -56,7 +79,7 @@ "estimator = InformerEstimator(\n", " freq=dataset.metadata.freq,\n", " prediction_length=dataset.metadata.prediction_length,\n", - " context_length=dataset.metadata.prediction_length*2,\n", + " context_length=dataset.metadata.prediction_length*7,\n", " \n", " # \n", " num_feat_static_cat=1,\n", @@ -79,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 30, "id": "22d804e4", "metadata": {}, "outputs": [ @@ -97,10 +120,10 @@ "HPU available: False, using: 0 HPUs\n", "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated 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", @@ -109,6 +132,8 @@ " 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", @@ -117,8 +142,8 @@ " 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/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed 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", @@ -127,13 +152,27 @@ " ..., 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/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in 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/.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", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq 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", @@ -144,32 +183,16 @@ "0 Non-trainable params\n", "84.3 K Total params\n", "0.337 Total estimated model params size (MB)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be 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/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed 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:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", " self._freq_base is None or self._freq_base == start.freq.base\n" ] @@ -177,7 +200,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6073d503e05041e6bd35f6bddb78b66d", + "model_id": "a02928a532e44e538c3b195f58a4520d", "version_major": 2, "version_minor": 0 }, @@ -192,56 +215,56 @@ "name": "stderr", "output_type": "stream", "text": [ - "Epoch 0, global step 100: 'train_loss' reached 6.61750 (best 6.61750), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=0-step=100.ckpt' as top 1\n", - "Epoch 1, global step 200: 'train_loss' reached 6.04776 (best 6.04776), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=1-step=200.ckpt' as top 1\n", - "Epoch 2, global step 300: 'train_loss' reached 5.84296 (best 5.84296), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=2-step=300.ckpt' as top 1\n", - "Epoch 3, global step 400: 'train_loss' reached 5.75401 (best 5.75401), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=3-step=400.ckpt' as top 1\n", - "Epoch 4, global step 500: 'train_loss' reached 5.63729 (best 5.63729), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=4-step=500.ckpt' as top 1\n", - "Epoch 5, global step 600: 'train_loss' reached 5.59724 (best 5.59724), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=5-step=600.ckpt' as top 1\n", - "Epoch 6, global step 700: 'train_loss' reached 5.58857 (best 5.58857), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=6-step=700.ckpt' as top 1\n", - "Epoch 7, global step 800: 'train_loss' reached 5.54154 (best 5.54154), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=7-step=800.ckpt' as top 1\n", - "Epoch 8, global step 900: 'train_loss' reached 5.49574 (best 5.49574), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=8-step=900.ckpt' as top 1\n", - "Epoch 9, global step 1000: 'train_loss' reached 5.44465 (best 5.44465), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=9-step=1000.ckpt' as top 1\n", - "Epoch 10, global step 1100: 'train_loss' reached 5.43125 (best 5.43125), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=10-step=1100.ckpt' as top 1\n", - "Epoch 11, global step 1200: 'train_loss' reached 5.41869 (best 5.41869), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=11-step=1200.ckpt' as top 1\n", - "Epoch 12, global step 1300: 'train_loss' reached 5.40992 (best 5.40992), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=12-step=1300.ckpt' as top 1\n", - "Epoch 13, global step 1400: 'train_loss' reached 5.37829 (best 5.37829), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=13-step=1400.ckpt' as top 1\n", - "Epoch 14, global step 1500: 'train_loss' reached 5.37632 (best 5.37632), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=14-step=1500.ckpt' as top 1\n", - "Epoch 15, global step 1600: 'train_loss' reached 5.33917 (best 5.33917), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=15-step=1600.ckpt' as top 1\n", - "Epoch 16, global step 1700: 'train_loss' reached 5.33322 (best 5.33322), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=16-step=1700.ckpt' as top 1\n", - "Epoch 17, global step 1800: 'train_loss' reached 5.31140 (best 5.31140), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/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' was not in top 1\n", + "Epoch 0, global step 100: 'train_loss' reached 6.52632 (best 6.52632), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=0-step=100.ckpt' as top 1\n", + "Epoch 1, global step 200: 'train_loss' reached 5.99229 (best 5.99229), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=1-step=200.ckpt' as top 1\n", + "Epoch 2, global step 300: 'train_loss' reached 5.83646 (best 5.83646), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=2-step=300.ckpt' as top 1\n", + "Epoch 3, global step 400: 'train_loss' reached 5.72107 (best 5.72107), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=3-step=400.ckpt' as top 1\n", + "Epoch 4, global step 500: 'train_loss' reached 5.63768 (best 5.63768), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=4-step=500.ckpt' as top 1\n", + "Epoch 5, global step 600: 'train_loss' reached 5.52803 (best 5.52803), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=5-step=600.ckpt' as top 1\n", + "Epoch 6, global step 700: 'train_loss' reached 5.52021 (best 5.52021), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=6-step=700.ckpt' as top 1\n", + "Epoch 7, global step 800: 'train_loss' reached 5.43709 (best 5.43709), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=7-step=800.ckpt' as top 1\n", + "Epoch 8, global step 900: 'train_loss' was not in top 1\n", + "Epoch 9, global step 1000: 'train_loss' reached 5.40288 (best 5.40288), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=9-step=1000.ckpt' as top 1\n", + "Epoch 10, global step 1100: 'train_loss' was not in top 1\n", + "Epoch 11, global step 1200: 'train_loss' was not in top 1\n", + "Epoch 12, global step 1300: 'train_loss' reached 5.37729 (best 5.37729), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=12-step=1300.ckpt' as top 1\n", + "Epoch 13, global step 1400: 'train_loss' reached 5.36585 (best 5.36585), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=13-step=1400.ckpt' as top 1\n", + "Epoch 14, global step 1500: 'train_loss' reached 5.31026 (best 5.31026), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=14-step=1500.ckpt' as top 1\n", + "Epoch 15, global step 1600: 'train_loss' was not in 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.30100 (best 5.30100), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=17-step=1800.ckpt' as top 1\n", + "Epoch 18, global step 1900: 'train_loss' reached 5.27683 (best 5.27683), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=18-step=1900.ckpt' as top 1\n", + "Epoch 19, global step 2000: 'train_loss' reached 5.25970 (best 5.25970), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/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.26691 (best 5.26691), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=21-step=2200.ckpt' as top 1\n", + "Epoch 21, global step 2200: 'train_loss' was not in top 1\n", "Epoch 22, global step 2300: 'train_loss' was not in 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.25179 (best 5.25179), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=24-step=2500.ckpt' as top 1\n", - "Epoch 25, global step 2600: 'train_loss' reached 5.24798 (best 5.24798), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=25-step=2600.ckpt' as top 1\n", - "Epoch 26, global step 2700: 'train_loss' reached 5.22891 (best 5.22891), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=26-step=2700.ckpt' as top 1\n", - "Epoch 27, global step 2800: 'train_loss' reached 5.20041 (best 5.20041), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/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' reached 5.19910 (best 5.19910), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=29-step=3000.ckpt' as top 1\n", - "Epoch 30, global step 3100: 'train_loss' was not in top 1\n", - "Epoch 31, global step 3200: 'train_loss' reached 5.18780 (best 5.18780), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=31-step=3200.ckpt' as top 1\n", - "Epoch 32, global step 3300: 'train_loss' reached 5.18232 (best 5.18232), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=32-step=3300.ckpt' as top 1\n", - "Epoch 33, global step 3400: 'train_loss' reached 5.18136 (best 5.18136), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=33-step=3400.ckpt' as top 1\n", - "Epoch 34, global step 3500: 'train_loss' reached 5.16795 (best 5.16795), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=34-step=3500.ckpt' as top 1\n", - "Epoch 35, global step 3600: 'train_loss' reached 5.15853 (best 5.15853), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=35-step=3600.ckpt' as top 1\n", + "Epoch 23, global step 2400: 'train_loss' reached 5.23428 (best 5.23428), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=23-step=2400.ckpt' as top 1\n", + "Epoch 24, global step 2500: 'train_loss' reached 5.22640 (best 5.22640), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/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.21977 (best 5.21977), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=26-step=2700.ckpt' as top 1\n", + "Epoch 27, global step 2800: 'train_loss' reached 5.20717 (best 5.20717), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=27-step=2800.ckpt' as top 1\n", + "Epoch 28, global step 2900: 'train_loss' reached 5.20179 (best 5.20179), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=28-step=2900.ckpt' as top 1\n", + "Epoch 29, global step 3000: 'train_loss' was not in top 1\n", + "Epoch 30, global step 3100: 'train_loss' reached 5.17813 (best 5.17813), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=30-step=3100.ckpt' as top 1\n", + "Epoch 31, global step 3200: 'train_loss' was not in top 1\n", + "Epoch 32, global step 3300: 'train_loss' was not in top 1\n", + "Epoch 33, global step 3400: 'train_loss' reached 5.16252 (best 5.16252), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=33-step=3400.ckpt' as top 1\n", + "Epoch 34, global step 3500: 'train_loss' reached 5.14503 (best 5.14503), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=34-step=3500.ckpt' as 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 37, global step 3800: 'train_loss' reached 5.13905 (best 5.13905), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=37-step=3800.ckpt' as top 1\n", "Epoch 38, global step 3900: 'train_loss' was not in top 1\n", - "Epoch 39, global step 4000: 'train_loss' was not in top 1\n", - "Epoch 40, global step 4100: 'train_loss' reached 5.15472 (best 5.15472), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=40-step=4100.ckpt' as top 1\n", + "Epoch 39, global step 4000: 'train_loss' reached 5.13161 (best 5.13161), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=39-step=4000.ckpt' as top 1\n", + "Epoch 40, global step 4100: 'train_loss' reached 5.11725 (best 5.11725), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=40-step=4100.ckpt' as top 1\n", "Epoch 41, global step 4200: 'train_loss' was not in 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.14292 (best 5.14292), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=43-step=4400.ckpt' as top 1\n", - "Epoch 44, global step 4500: 'train_loss' reached 5.11037 (best 5.11037), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=44-step=4500.ckpt' as top 1\n", - "Epoch 45, global step 4600: 'train_loss' was not in top 1\n", + "Epoch 43, global step 4400: 'train_loss' was not in top 1\n", + "Epoch 44, global step 4500: 'train_loss' was not in top 1\n", + "Epoch 45, global step 4600: 'train_loss' reached 5.09912 (best 5.09912), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_29/checkpoints/epoch=45-step=4600.ckpt' as 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' reached 5.09119 (best 5.09119), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=48-step=4900.ckpt' as top 1\n", - "Epoch 49, global step 5000: 'train_loss' reached 5.08685 (best 5.08685), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/informer/lightning_logs/version_28/checkpoints/epoch=49-step=5000.ckpt' as 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" ] } ], @@ -255,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 31, "id": "11a47d5a", "metadata": {}, "outputs": [], @@ -268,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 32, "id": "e4e94932", "metadata": {}, "outputs": [ @@ -276,12 +299,14 @@ "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:343: FutureWarning: Timestamp.freq is deprecated 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" + " ..., 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" ] } ], @@ -301,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 33, "id": "9985be71", "metadata": {}, "outputs": [], @@ -311,7 +336,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 34, "id": "cca60b1e", "metadata": {}, "outputs": [ @@ -319,17 +344,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Running evaluation: 2247it [00:00, 4083.04it/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", + "Running evaluation: 2247it [00:01, 1570.02it/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", @@ -352,6 +367,16 @@ " 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" ] @@ -363,59 +388,59 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 35, "id": "92389256", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'MSE': 1888823.0608803749,\n", - " 'abs_error': 9591290.831059933,\n", + "{'MSE': 2826393.0638119513,\n", + " 'abs_error': 9406683.103641033,\n", " 'abs_target_sum': 128632956.0,\n", " 'abs_target_mean': 2385.272140631954,\n", " 'seasonal_error': 189.49338196116761,\n", - " 'MASE': 0.9154653390940202,\n", - " 'MAPE': 0.1074732466564903,\n", - " 'sMAPE': 0.11906707750050609,\n", - " 'MSIS': 6.598265012752936,\n", - " 'QuantileLoss[0.1]': 3999428.6334216925,\n", - " 'Coverage[0.1]': 0.2343309597982495,\n", - " 'QuantileLoss[0.2]': 6374339.727818968,\n", - " 'Coverage[0.2]': 0.41968921524996294,\n", - " 'QuantileLoss[0.3]': 8000487.965688637,\n", - " 'Coverage[0.3]': 0.5595608960094942,\n", - " 'QuantileLoss[0.4]': 9068618.610809661,\n", - " 'Coverage[0.4]': 0.6701713395638629,\n", - " 'QuantileLoss[0.5]': 9591290.886452701,\n", - " 'Coverage[0.5]': 0.7554887998813232,\n", - " 'QuantileLoss[0.6]': 9447833.699609587,\n", - " 'Coverage[0.6]': 0.820260347129506,\n", - " 'QuantileLoss[0.7]': 8786171.793627966,\n", - " 'Coverage[0.7]': 0.877280818869604,\n", - " 'QuantileLoss[0.8]': 7443390.599792011,\n", - " 'Coverage[0.8]': 0.9237130989467439,\n", - " 'QuantileLoss[0.9]': 5049853.03397596,\n", - " 'Coverage[0.9]': 0.9628578845868567,\n", - " 'RMSE': 1374.3445932081136,\n", - " 'NRMSE': 0.5761793674595113,\n", - " 'ND': 0.07456324669286099,\n", - " 'wQuantileLoss[0.1]': 0.03109178827719463,\n", - " 'wQuantileLoss[0.2]': 0.04955448375001946,\n", - " 'wQuantileLoss[0.3]': 0.06219625370102384,\n", - " 'wQuantileLoss[0.4]': 0.0704999627841069,\n", - " 'wQuantileLoss[0.5]': 0.07456324712348755,\n", - " 'wQuantileLoss[0.6]': 0.07344800270009799,\n", - " 'wQuantileLoss[0.7]': 0.06830420497860569,\n", - " 'wQuantileLoss[0.8]': 0.05786534672958935,\n", - " 'wQuantileLoss[0.9]': 0.03925784799640272,\n", - " 'mean_absolute_QuantileLoss': 7529046.105688577,\n", - " 'mean_wQuantileLoss': 0.05853123756005869,\n", - " 'MAE_Coverage': 0.19148370667062262,\n", + " 'MASE': 0.7431191168044774,\n", + " 'MAPE': 0.09109633547159084,\n", + " 'sMAPE': 0.10563760783764822,\n", + " 'MSIS': 5.767997425106159,\n", + " 'QuantileLoss[0.1]': 3974763.955770738,\n", + " 'Coverage[0.1]': 0.12711392968402313,\n", + " 'QuantileLoss[0.2]': 6249950.183714624,\n", + " 'Coverage[0.2]': 0.248739059486723,\n", + " 'QuantileLoss[0.3]': 7793862.005873694,\n", + " 'Coverage[0.3]': 0.3646157840083074,\n", + " 'QuantileLoss[0.4]': 8841786.31629891,\n", + " 'Coverage[0.4]': 0.47763684913217624,\n", + " 'QuantileLoss[0.5]': 9406683.052603077,\n", + " 'Coverage[0.5]': 0.5858737576027296,\n", + " 'QuantileLoss[0.6]': 9485500.915407892,\n", + " 'Coverage[0.6]': 0.6767727340157247,\n", + " 'QuantileLoss[0.7]': 9009100.387483194,\n", + " 'Coverage[0.7]': 0.7680611185284083,\n", + " 'QuantileLoss[0.8]': 7785504.029701689,\n", + " 'Coverage[0.8]': 0.84961430054888,\n", + " 'QuantileLoss[0.9]': 5386472.509541044,\n", + " 'Coverage[0.9]': 0.9225634178905207,\n", + " 'RMSE': 1681.1879918117281,\n", + " 'NRMSE': 0.7048202019272796,\n", + " 'ND': 0.07312809559970801,\n", + " 'wQuantileLoss[0.1]': 0.03090004365421516,\n", + " 'wQuantileLoss[0.2]': 0.048587472278213244,\n", + " 'wQuantileLoss[0.3]': 0.06058993160254899,\n", + " 'wQuantileLoss[0.4]': 0.06873655547726751,\n", + " 'wQuantileLoss[0.5]': 0.07312809520293599,\n", + " 'wQuantileLoss[0.6]': 0.07374082980265098,\n", + " 'wQuantileLoss[0.7]': 0.07003726469197516,\n", + " 'wQuantileLoss[0.8]': 0.06052495621496632,\n", + " 'wQuantileLoss[0.9]': 0.04187474716464608,\n", + " 'mean_absolute_QuantileLoss': 7548180.372932762,\n", + " 'mean_wQuantileLoss': 0.05867998845437994,\n", + " 'MAE_Coverage': 0.05788788343305478,\n", " 'OWA': nan}" ] }, - "execution_count": 26, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -426,13 +451,13 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 36, "id": "23878611", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/informer/module.py b/informer/module.py index e42cab5..4890d64 100644 --- a/informer/module.py +++ b/informer/module.py @@ -7,7 +7,7 @@ import torch.nn as nn import torch.nn.functional as F from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler diff --git a/pyraformer/estimator.py b/pyraformer/estimator.py index bb23ca6..7c5a750 100644 --- a/pyraformer/estimator.py +++ b/pyraformer/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.time_feature import get_lags_for_frequency from gluonts.torch.util import IterableDataset @@ -79,7 +79,7 @@ class PyraformerEstimator(PyTorchLightningEstimator): n_layer: int = 4, enc_in: int = 1, # depends on dataset used CSCM: str = "Bottleneck_Construct", # [Bottleneck_Construct, Conv_Construct, MaxPooling_Construct, AvgPooling_Construct] - embed_type: str = "CustomEmbedding", #[DataEmbedding, CustomEmbedding] + embed_type: str = "CustomEmbedding", # [DataEmbedding, CustomEmbedding] truncate: bool = False, # loss: DistributionLoss = LossFactory, ignore_zero: bool = True, @@ -339,7 +339,7 @@ class PyraformerEstimator(PyTorchLightningEstimator): num_seq=self.num_seq, input_size=self.input_size, dropout=self.dropout, - d_model = self.d_model, + d_model=self.d_model, d_inner_hid=self.d_inner_hid, d_k=self.d_k, d_v=self.d_v, @@ -392,8 +392,8 @@ class PyraformerEstimator(PyTorchLightningEstimator): cardinality=self.cardinality, embedding_dimension=self.embedding_dimension, num_parallel_samples=self.num_parallel_samples, - embed_type = self.embed_type, - distr_output= self.distr_output, + embed_type=self.embed_type, + distr_output=self.distr_output, device=device, ) return PyraformerLightningModule(model=model, loss=self.loss) diff --git a/pyraformer/module.py b/pyraformer/module.py index a30d2eb..4e8d3bd 100644 --- a/pyraformer/module.py +++ b/pyraformer/module.py @@ -3,7 +3,7 @@ import torch import torch.nn as nn from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler @@ -151,7 +151,6 @@ class PyraformerSSModel(nn.Module): scaling, num_parallel_samples, device, - ): super().__init__() @@ -179,7 +178,7 @@ class PyraformerSSModel(nn.Module): # convert hidden vectors into two scalar self.mean_hidden = Predictor(4 * d_model, 1) self.var_hidden = Predictor(4 * d_model, 1) - + self.softplus = nn.Softplus() self.distr_output = distr_output @@ -512,7 +511,7 @@ class PyraformerLRModel(nn.Module): num_parallel_samples, embed_type, distr_output, - device + device, ): super().__init__() @@ -524,7 +523,7 @@ class PyraformerLRModel(nn.Module): self.distr_output = distr_output self.context_length = context_length self.lags_seq = lags_seq - + self.encoder = Encoder( # model, window_size, @@ -593,10 +592,10 @@ class PyraformerLRModel(nn.Module): ) return pred - + @property def _past_length(self) -> int: - return self.predict_step #+ max(0,self.lags_seq) + return self.predict_step # + max(0,self.lags_seq) @property def _number_of_features(self) -> int: diff --git a/reformer/estimator.py b/reformer/estimator.py index b19687c..37666ed 100644 --- a/reformer/estimator.py +++ b/reformer/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 ( diff --git a/reformer/module.py b/reformer/module.py index 1725342..dbad019 100644 --- a/reformer/module.py +++ b/reformer/module.py @@ -5,7 +5,7 @@ import torch import torch.nn as nn from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler from reformer_pytorch.reformer_pytorch import Reformer diff --git a/reformer/reformer.ipynb b/reformer/reformer.ipynb index 13ad5d5..d084464 100644 --- a/reformer/reformer.ipynb +++ b/reformer/reformer.ipynb @@ -25,6 +25,8 @@ "source": [ "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", "from gluonts.dataset.repository.datasets import get_dataset\n", + "from gluonts.torch.modules.loss import NegativeLogLikelihood\n", + "from gluonts.torch.distributions import NormalOutput\n", "\n", "from estimator import ReformerEstimator" ] @@ -48,7 +50,7 @@ { "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=)" + "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": 4, @@ -62,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "e772234f", "metadata": {}, "outputs": [], @@ -82,7 +84,12 @@ " num_decoder_layers=2,\n", " nhead=2,\n", " \n", + " \n", + " distr_output=NormalOutput(),\n", + " loss=NegativeLogLikelihood(beta=0.5),\n", + " \n", " # training params\n", + " num_parallel_samples=10,\n", " batch_size=128,\n", " num_batches_per_epoch=100,\n", " trainer_kwargs=dict(max_epochs=5, accelerator='gpu', gpus=1),\n", @@ -91,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "22d804e4", "metadata": {}, "outputs": [ @@ -99,10 +106,150 @@ "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", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", "GPU available: True, used: True\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", "TPU available: False, using: 0 TPU cores\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", "IPU available: False, using: 0 IPUs\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", "HPU available: False, using: 0 HPUs\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated 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/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be 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/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be 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:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\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", @@ -113,147 +260,13 @@ "113 K Trainable params\n", "0 Non-trainable params\n", "113 K Total params\n", - "0.452 Total estimated model params size (MB)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated 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:365: FutureWarning: Timestamp.freq is deprecated 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:365: 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/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated 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:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be 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:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n" + "0.452 Total estimated model params size (MB)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3f80fa4b9ab5484b9316352cd98010d1", + "model_id": "eb9c8dddf84c4c1faf3474ff4b9afdbb", "version_major": 2, "version_minor": 0 }, @@ -265,14 +278,56 @@ "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0, global step 100: 'train_loss' reached 6.33992 (best 6.33992), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_logs/version_14/checkpoints/epoch=0-step=100.ckpt' as top 1\n", - "Epoch 1, global step 200: 'train_loss' reached 5.93123 (best 5.93123), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_logs/version_14/checkpoints/epoch=1-step=200.ckpt' as top 1\n", - "Epoch 2, global step 300: 'train_loss' reached 5.80556 (best 5.80556), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_logs/version_14/checkpoints/epoch=2-step=300.ckpt' as top 1\n", - "Epoch 3, global step 400: 'train_loss' reached 5.64621 (best 5.64621), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_logs/version_14/checkpoints/epoch=3-step=400.ckpt' as top 1\n", - "Epoch 4, global step 500: 'train_loss' reached 5.54637 (best 5.54637), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_logs/version_14/checkpoints/epoch=4-step=500.ckpt' as top 1\n" + "ename": "ValueError", + "evalue": "Expected parameter df (Tensor of shape (128, 24)) of distribution Chi2() to satisfy the constraint GreaterThan(lower_bound=0.0), but found invalid values:\ntensor([[nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan],\n ...,\n [nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan]], device='cuda:0',\n grad_fn=)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\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:197\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 194\u001b[0m trainer_kwargs \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer_kwargs, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcallbacks\u001b[39m\u001b[38;5;124m\"\u001b[39m: callbacks}\n\u001b[1;32m 195\u001b[0m trainer \u001b[38;5;241m=\u001b[39m pl\u001b[38;5;241m.\u001b[39mTrainer(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mtrainer_kwargs)\n\u001b[0;32m--> 197\u001b[0m \u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 198\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtraining_network\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataloaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtraining_data_loader\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 200\u001b[0m \u001b[43m \u001b[49m\u001b[43mval_dataloaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidation_data_loader\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 201\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 202\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 204\u001b[0m logger\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLoading best model from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcheckpoint\u001b[38;5;241m.\u001b[39mbest_model_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 205\u001b[0m best_model \u001b[38;5;241m=\u001b[39m training_network\u001b[38;5;241m.\u001b[39mload_from_checkpoint(\n\u001b[1;32m 206\u001b[0m checkpoint\u001b[38;5;241m.\u001b[39mbest_model_path\n\u001b[1;32m 207\u001b[0m )\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:768\u001b[0m, in \u001b[0;36mTrainer.fit\u001b[0;34m(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)\u001b[0m\n\u001b[1;32m 749\u001b[0m \u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 750\u001b[0m \u001b[38;5;124;03mRuns the full optimization routine.\u001b[39;00m\n\u001b[1;32m 751\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 765\u001b[0m \u001b[38;5;124;03m datamodule: An instance of :class:`~pytorch_lightning.core.datamodule.LightningDataModule`.\u001b[39;00m\n\u001b[1;32m 766\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 767\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mmodel \u001b[38;5;241m=\u001b[39m model\n\u001b[0;32m--> 768\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_and_handle_interrupt\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 769\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit_impl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dataloaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataloaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdatamodule\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\n\u001b[1;32m 770\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:721\u001b[0m, in \u001b[0;36mTrainer._call_and_handle_interrupt\u001b[0;34m(self, trainer_fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mlauncher\u001b[38;5;241m.\u001b[39mlaunch(trainer_fn, \u001b[38;5;241m*\u001b[39margs, trainer\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 720\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 721\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtrainer_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 722\u001b[0m \u001b[38;5;66;03m# TODO: treat KeyboardInterrupt as BaseException (delete the code below) in v1.7\u001b[39;00m\n\u001b[1;32m 723\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exception:\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:809\u001b[0m, in \u001b[0;36mTrainer._fit_impl\u001b[0;34m(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)\u001b[0m\n\u001b[1;32m 805\u001b[0m ckpt_path \u001b[38;5;241m=\u001b[39m ckpt_path \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresume_from_checkpoint\n\u001b[1;32m 806\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ckpt_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__set_ckpt_path(\n\u001b[1;32m 807\u001b[0m ckpt_path, model_provided\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, model_connected\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlightning_module \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 808\u001b[0m )\n\u001b[0;32m--> 809\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mckpt_path\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[43mckpt_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mstopped\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:1234\u001b[0m, in \u001b[0;36mTrainer._run\u001b[0;34m(self, model, ckpt_path)\u001b[0m\n\u001b[1;32m 1230\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_checkpoint_connector\u001b[38;5;241m.\u001b[39mrestore_training_state()\n\u001b[1;32m 1232\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_checkpoint_connector\u001b[38;5;241m.\u001b[39mresume_end()\n\u001b[0;32m-> 1234\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run_stage\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1236\u001b[0m log\u001b[38;5;241m.\u001b[39mdetail(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: trainer tearing down\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 1237\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_teardown()\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:1321\u001b[0m, in \u001b[0;36mTrainer._run_stage\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpredicting:\n\u001b[1;32m 1320\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_run_predict()\n\u001b[0;32m-> 1321\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[43m_run_train\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:1351\u001b[0m, in \u001b[0;36mTrainer._run_train\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1349\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfit_loop\u001b[38;5;241m.\u001b[39mtrainer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\n\u001b[1;32m 1350\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mautograd\u001b[38;5;241m.\u001b[39mset_detect_anomaly(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_detect_anomaly):\n\u001b[0;32m-> 1351\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit_loop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/base.py:204\u001b[0m, in \u001b[0;36mLoop.run\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_start(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 204\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madvance\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_end()\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restarting \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/fit_loop.py:269\u001b[0m, in \u001b[0;36mFitLoop.advance\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 265\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data_fetcher\u001b[38;5;241m.\u001b[39msetup(\n\u001b[1;32m 266\u001b[0m dataloader, batch_to_device\u001b[38;5;241m=\u001b[39mpartial(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39m_call_strategy_hook, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbatch_to_device\u001b[39m\u001b[38;5;124m\"\u001b[39m, dataloader_idx\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m 267\u001b[0m )\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_training_epoch\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 269\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mepoch_loop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_fetcher\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/base.py:204\u001b[0m, in \u001b[0;36mLoop.run\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_start(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 204\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madvance\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_end()\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restarting \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/epoch/training_epoch_loop.py:208\u001b[0m, in \u001b[0;36mTrainingEpochLoop.advance\u001b[0;34m(self, data_fetcher)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbatch_progress\u001b[38;5;241m.\u001b[39mincrement_started()\n\u001b[1;32m 207\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrun_training_batch\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 208\u001b[0m batch_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbatch_loop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 210\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbatch_progress\u001b[38;5;241m.\u001b[39mincrement_processed()\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# update non-plateau LR schedulers\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;66;03m# update epoch-interval ones only when we are at the end of training epoch\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/base.py:204\u001b[0m, in \u001b[0;36mLoop.run\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_start(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 204\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madvance\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_end()\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restarting \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/batch/training_batch_loop.py:88\u001b[0m, in \u001b[0;36mTrainingBatchLoop.advance\u001b[0;34m(self, batch, batch_idx)\u001b[0m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39mlightning_module\u001b[38;5;241m.\u001b[39mautomatic_optimization:\n\u001b[1;32m 87\u001b[0m optimizers \u001b[38;5;241m=\u001b[39m _get_active_optimizers(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39moptimizers, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39moptimizer_frequencies, batch_idx)\n\u001b[0;32m---> 88\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_loop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43msplit_batch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 89\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 90\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmanual_loop\u001b[38;5;241m.\u001b[39mrun(split_batch, batch_idx)\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/base.py:204\u001b[0m, in \u001b[0;36mLoop.run\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_start(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 204\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madvance\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mon_advance_end()\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restarting \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:203\u001b[0m, in \u001b[0;36mOptimizerLoop.advance\u001b[0;34m(self, batch, *args, **kwargs)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madvance\u001b[39m(\u001b[38;5;28mself\u001b[39m, batch: Any, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m: \u001b[38;5;66;03m# type: ignore[override]\u001b[39;00m\n\u001b[0;32m--> 203\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run_optimization\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 204\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 205\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_batch_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimizers\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptim_progress\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_position\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 207\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 208\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result\u001b[38;5;241m.\u001b[39mloss \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 210\u001b[0m \u001b[38;5;66;03m# automatic optimization assumes a loss needs to be returned for extras to be considered as the batch\u001b[39;00m\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# would be skipped otherwise\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_outputs[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptimizer_idx] \u001b[38;5;241m=\u001b[39m result\u001b[38;5;241m.\u001b[39masdict()\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:256\u001b[0m, in \u001b[0;36mOptimizerLoop._run_optimization\u001b[0;34m(self, split_batch, batch_idx, optimizer, opt_idx)\u001b[0m\n\u001b[1;32m 249\u001b[0m closure()\n\u001b[1;32m 251\u001b[0m \u001b[38;5;66;03m# ------------------------------\u001b[39;00m\n\u001b[1;32m 252\u001b[0m \u001b[38;5;66;03m# BACKWARD PASS\u001b[39;00m\n\u001b[1;32m 253\u001b[0m \u001b[38;5;66;03m# ------------------------------\u001b[39;00m\n\u001b[1;32m 254\u001b[0m \u001b[38;5;66;03m# gradient update with accumulated gradients\u001b[39;00m\n\u001b[1;32m 255\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 256\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimizer_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopt_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 258\u001b[0m result \u001b[38;5;241m=\u001b[39m closure\u001b[38;5;241m.\u001b[39mconsume_result()\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result\u001b[38;5;241m.\u001b[39mloss \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 261\u001b[0m \u001b[38;5;66;03m# if no result, user decided to skip optimization\u001b[39;00m\n\u001b[1;32m 262\u001b[0m \u001b[38;5;66;03m# otherwise update running loss + reset accumulated loss\u001b[39;00m\n\u001b[1;32m 263\u001b[0m \u001b[38;5;66;03m# TODO: find proper way to handle updating running loss\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:369\u001b[0m, in \u001b[0;36mOptimizerLoop._optimizer_step\u001b[0;34m(self, optimizer, opt_idx, batch_idx, train_step_and_backward_closure)\u001b[0m\n\u001b[1;32m 366\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim_progress\u001b[38;5;241m.\u001b[39moptimizer\u001b[38;5;241m.\u001b[39mstep\u001b[38;5;241m.\u001b[39mincrement_ready()\n\u001b[1;32m 368\u001b[0m \u001b[38;5;66;03m# model hook\u001b[39;00m\n\u001b[0;32m--> 369\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_lightning_module_hook\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 370\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moptimizer_step\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 371\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcurrent_epoch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 372\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 373\u001b[0m \u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 374\u001b[0m \u001b[43m \u001b[49m\u001b[43mopt_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 375\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_step_and_backward_closure\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 376\u001b[0m \u001b[43m \u001b[49m\u001b[43mon_tpu\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43misinstance\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43maccelerator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mTPUAccelerator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 377\u001b[0m \u001b[43m \u001b[49m\u001b[43musing_native_amp\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[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mamp_backend\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mAMPType\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mNATIVE\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 378\u001b[0m \u001b[43m \u001b[49m\u001b[43musing_lbfgs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_lbfgs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 379\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 381\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m should_accumulate:\n\u001b[1;32m 382\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptim_progress\u001b[38;5;241m.\u001b[39moptimizer\u001b[38;5;241m.\u001b[39mstep\u001b[38;5;241m.\u001b[39mincrement_completed()\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:1593\u001b[0m, in \u001b[0;36mTrainer._call_lightning_module_hook\u001b[0;34m(self, hook_name, pl_module, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1590\u001b[0m pl_module\u001b[38;5;241m.\u001b[39m_current_fx_name \u001b[38;5;241m=\u001b[39m hook_name\n\u001b[1;32m 1592\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m[LightningModule]\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpl_module\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhook_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m-> 1593\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 1595\u001b[0m \u001b[38;5;66;03m# restore current_fx when nested context\u001b[39;00m\n\u001b[1;32m 1596\u001b[0m pl_module\u001b[38;5;241m.\u001b[39m_current_fx_name \u001b[38;5;241m=\u001b[39m prev_fx_name\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/core/lightning.py:1625\u001b[0m, in \u001b[0;36mLightningModule.optimizer_step\u001b[0;34m(self, epoch, batch_idx, optimizer, optimizer_idx, optimizer_closure, on_tpu, using_native_amp, using_lbfgs)\u001b[0m\n\u001b[1;32m 1543\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimizer_step\u001b[39m(\n\u001b[1;32m 1544\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 1545\u001b[0m epoch: \u001b[38;5;28mint\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1552\u001b[0m using_lbfgs: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 1553\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1554\u001b[0m \u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1555\u001b[0m \u001b[38;5;124;03m Override this method to adjust the default way the :class:`~pytorch_lightning.trainer.trainer.Trainer` calls\u001b[39;00m\n\u001b[1;32m 1556\u001b[0m \u001b[38;5;124;03m each optimizer.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1623\u001b[0m \n\u001b[1;32m 1624\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1625\u001b[0m \u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclosure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptimizer_closure\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/core/optimizer.py:168\u001b[0m, in \u001b[0;36mLightningOptimizer.step\u001b[0;34m(self, closure, **kwargs)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m MisconfigurationException(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWhen `optimizer.step(closure)` is called, the closure should be callable\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 167\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_strategy \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m--> 168\u001b[0m step_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_strategy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_step\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_optimizer\u001b[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[43m_optimizer_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\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\n\u001b[1;32m 170\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_on_after_step()\n\u001b[1;32m 172\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m step_output\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/strategies/strategy.py:193\u001b[0m, in \u001b[0;36mStrategy.optimizer_step\u001b[0;34m(self, optimizer, opt_idx, closure, model, **kwargs)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[38;5;124;03m\"\"\"Performs the actual optimizer step.\u001b[39;00m\n\u001b[1;32m 184\u001b[0m \n\u001b[1;32m 185\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 190\u001b[0m \u001b[38;5;124;03m **kwargs: Any extra arguments to ``optimizer.step``\u001b[39;00m\n\u001b[1;32m 191\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 192\u001b[0m model \u001b[38;5;241m=\u001b[39m model \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlightning_module\n\u001b[0;32m--> 193\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[43mprecision_plugin\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mopt_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\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\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/plugins/precision/precision_plugin.py:155\u001b[0m, in \u001b[0;36mPrecisionPlugin.optimizer_step\u001b[0;34m(self, model, optimizer, optimizer_idx, closure, **kwargs)\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(model, pl\u001b[38;5;241m.\u001b[39mLightningModule):\n\u001b[1;32m 154\u001b[0m closure \u001b[38;5;241m=\u001b[39m partial(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_wrap_closure, model, optimizer, optimizer_idx, closure)\n\u001b[0;32m--> 155\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclosure\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mclosure\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\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/optim/optimizer.py:88\u001b[0m, in \u001b[0;36mOptimizer._hook_for_profile..profile_hook_step..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 86\u001b[0m profile_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOptimizer.step#\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m.step\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(obj\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m)\n\u001b[1;32m 87\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mautograd\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mrecord_function(profile_name):\n\u001b[0;32m---> 88\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/autograd/grad_mode.py:27\u001b[0m, in \u001b[0;36m_DecoratorContextManager.__call__..decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclone():\n\u001b[0;32m---> 27\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/optim/adam.py:100\u001b[0m, in \u001b[0;36mAdam.step\u001b[0;34m(self, closure)\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m closure \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39menable_grad():\n\u001b[0;32m--> 100\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m group \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparam_groups:\n\u001b[1;32m 103\u001b[0m params_with_grad \u001b[38;5;241m=\u001b[39m []\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/plugins/precision/precision_plugin.py:140\u001b[0m, in \u001b[0;36mPrecisionPlugin._wrap_closure\u001b[0;34m(self, model, optimizer, optimizer_idx, closure)\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_wrap_closure\u001b[39m(\n\u001b[1;32m 128\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 129\u001b[0m model: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpl.LightningModule\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 132\u001b[0m closure: Callable[[], Any],\n\u001b[1;32m 133\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m 134\u001b[0m \u001b[38;5;124;03m\"\"\"This double-closure allows makes sure the ``closure`` is executed before the\u001b[39;00m\n\u001b[1;32m 135\u001b[0m \u001b[38;5;124;03m ``on_before_optimizer_step`` hook is called.\u001b[39;00m\n\u001b[1;32m 136\u001b[0m \n\u001b[1;32m 137\u001b[0m \u001b[38;5;124;03m The closure (generally) runs ``backward`` so this allows inspecting gradients in this hook. This structure is\u001b[39;00m\n\u001b[1;32m 138\u001b[0m \u001b[38;5;124;03m consistent with the ``PrecisionPlugin`` subclasses that cannot pass ``optimizer.step(closure)`` directly.\u001b[39;00m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 140\u001b[0m closure_result \u001b[38;5;241m=\u001b[39m \u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 141\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_after_closure(model, optimizer, optimizer_idx)\n\u001b[1;32m 142\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m closure_result\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:148\u001b[0m, in \u001b[0;36mClosure.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Optional[Tensor]:\n\u001b[0;32m--> 148\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result\u001b[38;5;241m.\u001b[39mloss\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:134\u001b[0m, in \u001b[0;36mClosure.closure\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mclosure\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ClosureResult:\n\u001b[0;32m--> 134\u001b[0m step_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_step_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m step_output\u001b[38;5;241m.\u001b[39mclosure_loss \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwarning_cache\u001b[38;5;241m.\u001b[39mwarn(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`training_step` returned `None`. If this was on purpose, ignore this warning...\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:427\u001b[0m, in \u001b[0;36mOptimizerLoop._training_step\u001b[0;34m(self, split_batch, batch_idx, opt_idx)\u001b[0m\n\u001b[1;32m 422\u001b[0m step_kwargs \u001b[38;5;241m=\u001b[39m _build_training_step_kwargs(\n\u001b[1;32m 423\u001b[0m lightning_module, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39moptimizers, split_batch, batch_idx, opt_idx, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_hiddens\n\u001b[1;32m 424\u001b[0m )\n\u001b[1;32m 426\u001b[0m \u001b[38;5;66;03m# manually capture logged metrics\u001b[39;00m\n\u001b[0;32m--> 427\u001b[0m training_step_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_strategy_hook\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtraining_step\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mstep_kwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 428\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mpost_training_step()\n\u001b[1;32m 430\u001b[0m model_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrainer\u001b[38;5;241m.\u001b[39m_call_lightning_module_hook(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtraining_step_end\u001b[39m\u001b[38;5;124m\"\u001b[39m, training_step_output)\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py:1763\u001b[0m, in \u001b[0;36mTrainer._call_strategy_hook\u001b[0;34m(self, hook_name, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1760\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[1;32m 1762\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mprofile(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m[Strategy]\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhook_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m-> 1763\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 1765\u001b[0m \u001b[38;5;66;03m# restore current_fx when nested context\u001b[39;00m\n\u001b[1;32m 1766\u001b[0m pl_module\u001b[38;5;241m.\u001b[39m_current_fx_name \u001b[38;5;241m=\u001b[39m prev_fx_name\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/strategies/strategy.py:333\u001b[0m, in \u001b[0;36mStrategy.training_step\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 328\u001b[0m \u001b[38;5;124;03m\"\"\"The actual training step.\u001b[39;00m\n\u001b[1;32m 329\u001b[0m \n\u001b[1;32m 330\u001b[0m \u001b[38;5;124;03mSee :meth:`~pytorch_lightning.core.lightning.LightningModule.training_step` for more details\u001b[39;00m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprecision_plugin\u001b[38;5;241m.\u001b[39mtrain_step_context():\n\u001b[0;32m--> 333\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[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining_step\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n", + "File \u001b[0;32m/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_module.py:25\u001b[0m, in \u001b[0;36mReformerLightningModule.training_step\u001b[0;34m(self, batch, batch_idx)\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtraining_step\u001b[39m(\u001b[38;5;28mself\u001b[39m, batch, batch_idx: \u001b[38;5;28mint\u001b[39m):\n\u001b[1;32m 24\u001b[0m \u001b[38;5;124;03m\"\"\"Execute training step\"\"\"\u001b[39;00m\n\u001b[0;32m---> 25\u001b[0m train_loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog(\n\u001b[1;32m 27\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrain_loss\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 28\u001b[0m train_loss,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 31\u001b[0m prog_bar\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 32\u001b[0m )\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m train_loss\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m/mnt/scratch/kashif/pytorch-transformer-ts/reformer/lightning_module.py:70\u001b[0m, in \u001b[0;36mReformerLightningModule.forward\u001b[0;34m(self, batch)\u001b[0m\n\u001b[1;32m 60\u001b[0m reformer_inputs, scale, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39mcreate_network_inputs(\n\u001b[1;32m 61\u001b[0m feat_static_cat,\n\u001b[1;32m 62\u001b[0m feat_static_real,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 67\u001b[0m future_target,\n\u001b[1;32m 68\u001b[0m )\n\u001b[1;32m 69\u001b[0m params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39moutput_params(reformer_inputs)\n\u001b[0;32m---> 70\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 72\u001b[0m loss_values \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss(distr, future_target)\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel\u001b[38;5;241m.\u001b[39mtarget_shape) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[0;32m/mnt/scratch/kashif/pytorch-transformer-ts/reformer/module.py:312\u001b[0m, in \u001b[0;36mReformerModel.output_distribution\u001b[0;34m(self, params, scale, trailing_n)\u001b[0m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m trailing_n \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 311\u001b[0m sliced_params \u001b[38;5;241m=\u001b[39m [p[:, \u001b[38;5;241m-\u001b[39mtrailing_n:] \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m params]\n\u001b[0;32m--> 312\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[43mdistr_output\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43msliced_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/modules/distribution_output.py:140\u001b[0m, in \u001b[0;36mDistributionOutput.distribution\u001b[0;34m(self, distr_args, loc, scale)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdistribution\u001b[39m(\n\u001b[1;32m 120\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 121\u001b[0m distr_args,\n\u001b[1;32m 122\u001b[0m loc: Optional[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 123\u001b[0m scale: Optional[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 124\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Distribution:\n\u001b[1;32m 125\u001b[0m \u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 126\u001b[0m \u001b[38;5;124;03m Construct the associated distribution, given the collection of\u001b[39;00m\n\u001b[1;32m 127\u001b[0m \u001b[38;5;124;03m constructor arguments and, optionally, a scale tensor.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[38;5;124;03m batch_shape+event_shape of the resulting distribution.\u001b[39;00m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 140\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_base_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 141\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m loc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m scale \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 142\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m distr\n", + "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/modules/distribution_output.py:117\u001b[0m, in \u001b[0;36mDistributionOutput._base_distribution\u001b[0;34m(self, distr_args)\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_base_distribution\u001b[39m(\u001b[38;5;28mself\u001b[39m, distr_args):\n\u001b[0;32m--> 117\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[43mdistr_cls\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/distributions/studentT.py:46\u001b[0m, in \u001b[0;36mStudentT.__init__\u001b[0;34m(self, df, loc, scale, validate_args)\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, df, loc\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.\u001b[39m, scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.\u001b[39m, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdf, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloc, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale \u001b[38;5;241m=\u001b[39m broadcast_all(df, loc, scale)\n\u001b[0;32m---> 46\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_chi2 \u001b[38;5;241m=\u001b[39m \u001b[43mChi2\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m batch_shape \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdf\u001b[38;5;241m.\u001b[39msize()\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28msuper\u001b[39m(StudentT, \u001b[38;5;28mself\u001b[39m)\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(batch_shape, validate_args\u001b[38;5;241m=\u001b[39mvalidate_args)\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/distributions/chi2.py:22\u001b[0m, in \u001b[0;36mChi2.__init__\u001b[0;34m(self, df, validate_args)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, df, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m---> 22\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mChi2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidate_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidate_args\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/distributions/gamma.py:48\u001b[0m, in \u001b[0;36mGamma.__init__\u001b[0;34m(self, concentration, rate, validate_args)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 47\u001b[0m batch_shape \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconcentration\u001b[38;5;241m.\u001b[39msize()\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mGamma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mbatch_shape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidate_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidate_args\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/distributions/distribution.py:55\u001b[0m, in \u001b[0;36mDistribution.__init__\u001b[0;34m(self, batch_shape, event_shape, validate_args)\u001b[0m\n\u001b[1;32m 53\u001b[0m valid \u001b[38;5;241m=\u001b[39m constraint\u001b[38;5;241m.\u001b[39mcheck(value)\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m valid\u001b[38;5;241m.\u001b[39mall():\n\u001b[0;32m---> 55\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 56\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExpected parameter \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mparam\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 57\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m(\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(value)\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m of shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtuple\u001b[39m(value\u001b[38;5;241m.\u001b[39mshape)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 58\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mof distribution \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mrepr\u001b[39m(\u001b[38;5;28mself\u001b[39m)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mto satisfy the constraint \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mrepr\u001b[39m(constraint)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbut found invalid values:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00mvalue\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 61\u001b[0m )\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28msuper\u001b[39m(Distribution, \u001b[38;5;28mself\u001b[39m)\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m()\n", + "\u001b[0;31mValueError\u001b[0m: Expected parameter df (Tensor of shape (128, 24)) of distribution Chi2() to satisfy the constraint GreaterThan(lower_bound=0.0), but found invalid values:\ntensor([[nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan],\n ...,\n [nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan],\n [nan, nan, nan, ..., nan, nan, nan]], device='cuda:0',\n grad_fn=)" ] } ], @@ -286,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "11a47d5a", "metadata": {}, "outputs": [], @@ -299,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "e4e94932", "metadata": {}, "outputs": [ @@ -324,40 +379,6 @@ "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", " assert self._freq_base is None or self._freq_base == start.freq.base, (\n" ] - }, - { - "ename": "AssertionError", - "evalue": "Sequence length (169) needs to be divisible by target bucket size x 2 - 192", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(forecast_it)\n", - "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/model/predictor.py:82\u001b[0m, in \u001b[0;36mPyTorchPredictor.predict\u001b[0;34m(self, dataset, num_samples)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprediction_net\u001b[38;5;241m.\u001b[39meval()\n\u001b[1;32m 81\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[0;32m---> 82\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mforecast_generator(\n\u001b[1;32m 83\u001b[0m inference_data_loader\u001b[38;5;241m=\u001b[39minference_data_loader,\n\u001b[1;32m 84\u001b[0m prediction_net\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprediction_net,\n\u001b[1;32m 85\u001b[0m input_names\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_names,\n\u001b[1;32m 86\u001b[0m freq\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfreq,\n\u001b[1;32m 87\u001b[0m output_transform\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_transform,\n\u001b[1;32m 88\u001b[0m num_samples\u001b[38;5;241m=\u001b[39mnum_samples,\n\u001b[1;32m 89\u001b[0m )\n", - "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/model/forecast_generator.py:179\u001b[0m, in \u001b[0;36mSampleForecastGenerator.__call__\u001b[0;34m(self, inference_data_loader, prediction_net, input_names, freq, output_transform, num_samples, **kwargs)\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m batch \u001b[38;5;129;01min\u001b[39;00m inference_data_loader:\n\u001b[1;32m 178\u001b[0m inputs \u001b[38;5;241m=\u001b[39m [batch[k] \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m input_names]\n\u001b[0;32m--> 179\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mpredict_to_numpy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprediction_net\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_transform \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 181\u001b[0m outputs \u001b[38;5;241m=\u001b[39m output_transform(batch, outputs)\n", - "File \u001b[0;32m/usr/lib/python3.8/functools.py:875\u001b[0m, in \u001b[0;36msingledispatch..wrapper\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m 871\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m args:\n\u001b[1;32m 872\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfuncname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m requires at least \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 873\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1 positional argument\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m--> 875\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdispatch\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__class__\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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[43mkw\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/gluon-ts-PR/src/gluonts/torch/model/predictor.py:38\u001b[0m, in \u001b[0;36m_\u001b[0;34m(prediction_net, inputs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;129m@predict_to_numpy\u001b[39m\u001b[38;5;241m.\u001b[39mregister(nn\u001b[38;5;241m.\u001b[39mModule)\n\u001b[1;32m 37\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_\u001b[39m(prediction_net: nn\u001b[38;5;241m.\u001b[39mModule, inputs: torch\u001b[38;5;241m.\u001b[39mTensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m np\u001b[38;5;241m.\u001b[39mndarray:\n\u001b[0;32m---> 38\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mprediction_net\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy()\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m/mnt/scratch/kashif/pytorch-transformer-ts/reformer/module.py:380\u001b[0m, in \u001b[0;36mReformerModel.forward\u001b[0;34m(self, feat_static_cat, feat_static_real, past_time_feat, past_target, past_observed_values, future_time_feat, num_parallel_samples)\u001b[0m\n\u001b[1;32m 372\u001b[0m reshaped_lagged_sequence \u001b[38;5;241m=\u001b[39m lagged_sequence\u001b[38;5;241m.\u001b[39mreshape(\n\u001b[1;32m 373\u001b[0m lags_shape[\u001b[38;5;241m0\u001b[39m], lags_shape[\u001b[38;5;241m1\u001b[39m], \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 374\u001b[0m )\n\u001b[1;32m 376\u001b[0m decoder_input \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat(\n\u001b[1;32m 377\u001b[0m (reshaped_lagged_sequence, repeated_features[:, : k \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m]), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 378\u001b[0m )\n\u001b[0;32m--> 380\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreformer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecoder\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdecoder_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_enc_out\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 382\u001b[0m params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparam_proj(output[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:])\n\u001b[1;32m 383\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_distribution(params, scale\u001b[38;5;241m=\u001b[39mrepeated_scale)\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reformer_pytorch.py:713\u001b[0m, in \u001b[0;36mReformer.forward\u001b[0;34m(self, x, **kwargs)\u001b[0m\n\u001b[1;32m 711\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 712\u001b[0m x \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat([x, x], dim \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m--> 713\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlayers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\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\n\u001b[1;32m 714\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mstack(x\u001b[38;5;241m.\u001b[39mchunk(\u001b[38;5;241m2\u001b[39m, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m))\u001b[38;5;241m.\u001b[39mmean(dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reversible.py:162\u001b[0m, in \u001b[0;36mReversibleSequence.forward\u001b[0;34m(self, x, arg_route, **kwargs)\u001b[0m\n\u001b[1;32m 159\u001b[0m x \u001b[38;5;241m=\u001b[39m block(x, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mblock_kwargs)\n\u001b[1;32m 160\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n\u001b[0;32m--> 162\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_ReversibleFunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblocks\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reversible.py:123\u001b[0m, in \u001b[0;36m_ReversibleFunction.forward\u001b[0;34m(ctx, x, blocks, kwargs)\u001b[0m\n\u001b[1;32m 121\u001b[0m ctx\u001b[38;5;241m.\u001b[39mkwargs \u001b[38;5;241m=\u001b[39m kwargs\n\u001b[1;32m 122\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m block \u001b[38;5;129;01min\u001b[39;00m blocks:\n\u001b[0;32m--> 123\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43mblock\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\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\n\u001b[1;32m 124\u001b[0m ctx\u001b[38;5;241m.\u001b[39my \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mdetach()\n\u001b[1;32m 125\u001b[0m ctx\u001b[38;5;241m.\u001b[39mblocks \u001b[38;5;241m=\u001b[39m blocks\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reversible.py:59\u001b[0m, in \u001b[0;36mReversibleBlock.forward\u001b[0;34m(self, x, f_args, g_args)\u001b[0m\n\u001b[1;32m 56\u001b[0m f_args[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_depth\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m g_args[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_depth\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdepth\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[0;32m---> 59\u001b[0m y1 \u001b[38;5;241m=\u001b[39m x1 \u001b[38;5;241m+\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mf\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrecord_rng\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[43mtraining\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[43mf_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 60\u001b[0m y2 \u001b[38;5;241m=\u001b[39m x2 \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mg(y1, record_rng\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mg_args)\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcat([y1, y2], dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reversible.py:27\u001b[0m, in \u001b[0;36mDeterministic.forward\u001b[0;34m(self, record_rng, set_rng, *args, **kwargs)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrecord_rng(\u001b[38;5;241m*\u001b[39margs)\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m set_rng:\n\u001b[0;32m---> 27\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[43mnet\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\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\n\u001b[1;32m 29\u001b[0m rng_devices \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 30\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcuda_in_fwd:\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reformer_pytorch.py:160\u001b[0m, in \u001b[0;36mPreNorm.forward\u001b[0;34m(self, x, **kwargs)\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 159\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnorm(x)\n\u001b[0;32m--> 160\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[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\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\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reformer_pytorch.py:578\u001b[0m, in \u001b[0;36mLSHSelfAttention.forward\u001b[0;34m(self, x, keys, input_mask, input_attn_mask, context_mask, pos_emb, **kwargs)\u001b[0m\n\u001b[1;32m 575\u001b[0m partial_attn_fn \u001b[38;5;241m=\u001b[39m partial(attn_fn, query_len \u001b[38;5;241m=\u001b[39m t, pos_emb \u001b[38;5;241m=\u001b[39m pos_emb, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 576\u001b[0m attn_fn_in_chunks \u001b[38;5;241m=\u001b[39m process_inputs_chunk(partial_attn_fn, chunks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mattn_chunks)\n\u001b[0;32m--> 578\u001b[0m out, attn, buckets \u001b[38;5;241m=\u001b[39m \u001b[43mattn_fn_in_chunks\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\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[43mmasks\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 580\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcallback \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 581\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcallback(attn\u001b[38;5;241m.\u001b[39mreshape(b, lsh_h, t, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m), buckets\u001b[38;5;241m.\u001b[39mreshape(b, lsh_h, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m))\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reformer_pytorch.py:41\u001b[0m, in \u001b[0;36mprocess_inputs_chunk..inner_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 39\u001b[0m chunked_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: x\u001b[38;5;241m.\u001b[39mchunk(chunks, dim\u001b[38;5;241m=\u001b[39mdim), \u001b[38;5;28mlist\u001b[39m(args) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlist\u001b[39m(values))))\n\u001b[1;32m 40\u001b[0m all_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: (x[:len_args], \u001b[38;5;28mdict\u001b[39m(\u001b[38;5;28mzip\u001b[39m(keys, x[len_args:]))), chunked_args)\n\u001b[0;32m---> 41\u001b[0m outputs \u001b[38;5;241m=\u001b[39m [fn(\u001b[38;5;241m*\u001b[39mc_args, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mc_kwargs) \u001b[38;5;28;01mfor\u001b[39;00m c_args, c_kwargs \u001b[38;5;129;01min\u001b[39;00m all_args]\n\u001b[1;32m 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mtuple\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: torch\u001b[38;5;241m.\u001b[39mcat(x, dim\u001b[38;5;241m=\u001b[39mdim), \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39moutputs)))\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reformer_pytorch.py:41\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 39\u001b[0m chunked_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: x\u001b[38;5;241m.\u001b[39mchunk(chunks, dim\u001b[38;5;241m=\u001b[39mdim), \u001b[38;5;28mlist\u001b[39m(args) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlist\u001b[39m(values))))\n\u001b[1;32m 40\u001b[0m all_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: (x[:len_args], \u001b[38;5;28mdict\u001b[39m(\u001b[38;5;28mzip\u001b[39m(keys, x[len_args:]))), chunked_args)\n\u001b[0;32m---> 41\u001b[0m outputs \u001b[38;5;241m=\u001b[39m [\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mc_args\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[43mc_kwargs\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m c_args, c_kwargs \u001b[38;5;129;01min\u001b[39;00m all_args]\n\u001b[1;32m 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mtuple\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: torch\u001b[38;5;241m.\u001b[39mcat(x, dim\u001b[38;5;241m=\u001b[39mdim), \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39moutputs)))\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;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\n\u001b[1;32m 1111\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/reformer_pytorch/reformer_pytorch.py:272\u001b[0m, in \u001b[0;36mLSHAttention.forward\u001b[0;34m(self, qk, v, query_len, input_mask, input_attn_mask, pos_emb, **kwargs)\u001b[0m\n\u001b[1;32m 269\u001b[0m is_reverse \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_reverse\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 270\u001b[0m depth \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_depth\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 272\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m seqlen \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbucket_size \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSequence length (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mseqlen\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) needs to be divisible by target bucket size x 2 - \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbucket_size \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 274\u001b[0m n_buckets \u001b[38;5;241m=\u001b[39m seqlen \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbucket_size\n\u001b[1;32m 275\u001b[0m buckets \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhash_vectors(n_buckets, qk, key_namespace\u001b[38;5;241m=\u001b[39mdepth, fetch\u001b[38;5;241m=\u001b[39mis_reverse, set_cache\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining)\n", - "\u001b[0;31mAssertionError\u001b[0m: Sequence length (169) needs to be divisible by target bucket size x 2 - 192" - ] } ], "source": [ @@ -366,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "17c5e570", "metadata": {}, "outputs": [], @@ -376,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "9985be71", "metadata": {}, "outputs": [], @@ -386,19 +407,49 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "cca60b1e", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'forecasts' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m agg_metrics, ts_metrics \u001b[38;5;241m=\u001b[39m evaluator(\u001b[38;5;28miter\u001b[39m(tss), \u001b[38;5;28miter\u001b[39m(forecasts))\n", - "\u001b[0;31mNameError\u001b[0m: name 'forecasts' is not defined" + "name": "stderr", + "output_type": "stream", + "text": [ + "Running evaluation: 2247it [00:00, 4784.80it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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" ] } ], @@ -408,59 +459,59 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 12, "id": "92389256", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'MSE': 2826393.0638119513,\n", - " 'abs_error': 9406683.103641033,\n", + "{'MSE': 2782145.785977615,\n", + " 'abs_error': 10299097.697694778,\n", " 'abs_target_sum': 128632956.0,\n", " 'abs_target_mean': 2385.272140631954,\n", " 'seasonal_error': 189.49338196116761,\n", - " 'MASE': 0.7431191168044774,\n", - " 'MAPE': 0.09109633547159084,\n", - " 'sMAPE': 0.10563760783764822,\n", - " 'MSIS': 5.767997425106159,\n", - " 'QuantileLoss[0.1]': 3974763.955770738,\n", - " 'Coverage[0.1]': 0.12711392968402313,\n", - " 'QuantileLoss[0.2]': 6249950.183714624,\n", - " 'Coverage[0.2]': 0.248739059486723,\n", - " 'QuantileLoss[0.3]': 7793862.005873694,\n", - " 'Coverage[0.3]': 0.3646157840083074,\n", - " 'QuantileLoss[0.4]': 8841786.31629891,\n", - " 'Coverage[0.4]': 0.47763684913217624,\n", - " 'QuantileLoss[0.5]': 9406683.052603077,\n", - " 'Coverage[0.5]': 0.5858737576027296,\n", - " 'QuantileLoss[0.6]': 9485500.915407892,\n", - " 'Coverage[0.6]': 0.6767727340157247,\n", - " 'QuantileLoss[0.7]': 9009100.387483194,\n", - " 'Coverage[0.7]': 0.7680611185284083,\n", - " 'QuantileLoss[0.8]': 7785504.029701689,\n", - " 'Coverage[0.8]': 0.84961430054888,\n", - " 'QuantileLoss[0.9]': 5386472.509541044,\n", - " 'Coverage[0.9]': 0.9225634178905207,\n", - " 'RMSE': 1681.1879918117281,\n", - " 'NRMSE': 0.7048202019272796,\n", - " 'ND': 0.07312809559970801,\n", - " 'wQuantileLoss[0.1]': 0.03090004365421516,\n", - " 'wQuantileLoss[0.2]': 0.048587472278213244,\n", - " 'wQuantileLoss[0.3]': 0.06058993160254899,\n", - " 'wQuantileLoss[0.4]': 0.06873655547726751,\n", - " 'wQuantileLoss[0.5]': 0.07312809520293599,\n", - " 'wQuantileLoss[0.6]': 0.07374082980265098,\n", - " 'wQuantileLoss[0.7]': 0.07003726469197516,\n", - " 'wQuantileLoss[0.8]': 0.06052495621496632,\n", - " 'wQuantileLoss[0.9]': 0.04187474716464608,\n", - " 'mean_absolute_QuantileLoss': 7548180.372932762,\n", - " 'mean_wQuantileLoss': 0.05867998845437994,\n", - " 'MAE_Coverage': 0.05788788343305478,\n", + " 'MASE': 0.8355449737938337,\n", + " 'MAPE': 0.11845675015385011,\n", + " 'sMAPE': 0.11662507229887349,\n", + " 'MSIS': 7.367189372225982,\n", + " 'QuantileLoss[0.1]': 4826191.387874294,\n", + " 'Coverage[0.1]': 0.04863892597537457,\n", + " 'QuantileLoss[0.2]': 7324073.983684538,\n", + " 'Coverage[0.2]': 0.10445408693072243,\n", + " 'QuantileLoss[0.3]': 8925673.672461458,\n", + " 'Coverage[0.3]': 0.1902722148049251,\n", + " 'QuantileLoss[0.4]': 9855426.705049125,\n", + " 'Coverage[0.4]': 0.31087746625129803,\n", + " 'QuantileLoss[0.5]': 10299097.778426602,\n", + " 'Coverage[0.5]': 0.4599280522177719,\n", + " 'QuantileLoss[0.6]': 10253443.335411768,\n", + " 'Coverage[0.6]': 0.602321614003857,\n", + " 'QuantileLoss[0.7]': 9653788.007655425,\n", + " 'Coverage[0.7]': 0.7441588785046729,\n", + " 'QuantileLoss[0.8]': 8329638.3399652075,\n", + " 'Coverage[0.8]': 0.8544726301735648,\n", + " 'QuantileLoss[0.9]': 5876505.665932485,\n", + " 'Coverage[0.9]': 0.9270323394155171,\n", + " 'RMSE': 1667.9765543848675,\n", + " 'NRMSE': 0.6992814471655859,\n", + " 'ND': 0.08006577799312004,\n", + " 'wQuantileLoss[0.1]': 0.037519089492698075,\n", + " 'wQuantileLoss[0.2]': 0.05693777249186855,\n", + " 'wQuantileLoss[0.3]': 0.06938870060998566,\n", + " 'wQuantileLoss[0.4]': 0.07661665417258332,\n", + " 'wQuantileLoss[0.5]': 0.08006577862073389,\n", + " 'wQuantileLoss[0.6]': 0.07971085835430672,\n", + " 'wQuantileLoss[0.7]': 0.07504910333908073,\n", + " 'wQuantileLoss[0.8]': 0.06475508764616439,\n", + " 'wQuantileLoss[0.9]': 0.0456842931132865,\n", + " 'mean_absolute_QuantileLoss': 8371537.652940101,\n", + " 'mean_wQuantileLoss': 0.0650808153156342,\n", + " 'MAE_Coverage': 0.05709052399083552,\n", " 'OWA': nan}" ] }, - "execution_count": 35, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -471,13 +522,13 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 13, "id": "23878611", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/requirements.txt b/requirements.txt index c563fd0..e962114 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,6 +1,6 @@ orjson torch -gluonts +https://github.com/awslabs/gluon-ts pytorch-lightning datasets xformers diff --git a/s4/s4.ipynb b/s4/s4.ipynb index c4bd5c0..78c817d 100644 --- a/s4/s4.ipynb +++ b/s4/s4.ipynb @@ -1,1438 +1,1708 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "c4c1a6b2", - "metadata": {}, - "outputs": [], - "source": [ - "# !pip install -U gluonts pytorch-lightning torch" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f61debcc", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "64e16862", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/.env/pytorch/lib/python3.8/site-packages/apex/pyprof/__init__.py:5: FutureWarning: pyprof will be removed by the end of June, 2022\n", - " warnings.warn(\"pyprof will be removed by the end of June, 2022\", FutureWarning)\n", - "WARNING:root:Pytorch pre-release version 1.12.0a0+git31d03c2 - assuming intent to test it\n" - ] - } - ], - "source": [ - "from typing import List, Optional, Iterable, Dict, Any, Tuple\n", - "from itertools import islice\n", - "import queue\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", - "from torch.optim.lr_scheduler import _LRScheduler, MultiplicativeLR\n", - "from torch.optim import Optimizer\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", - ")\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.distributions.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": 4, - "id": "c1fbb026", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:kernel:CUDA extension for cauchy multiplication found.\n", - "INFO:kernel:Pykeops installation found.\n" - ] - } - ], - "source": [ - "from s4 import S4" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "6ddc78b9", - "metadata": {}, - "outputs": [], - "source": [ - "class S4Model(nn.Module):\n", - " def __init__(\n", - " self,\n", - " freq: str,\n", - " \n", - " context_length: int,\n", - " prediction_length: int,\n", - " \n", - " num_feat_dynamic_real: int,\n", - " num_feat_static_real: int,\n", - " \n", - " num_feat_static_cat: int,\n", - " cardinality: List[int],\n", - " embedding_dimension: Optional[List[int]] = None,\n", - " \n", - " input_size: int = 1, # univariate input\n", - " \n", - " # S4 inputs\n", - " d_state: int = 64,\n", - " nhead: int = 1, # channels: can be interpreted as a number of \"heads\"\n", - " num_layers: int = 1, # Number of layers\n", - " dropout_rate: float = 0.2,\n", - " prenorm: bool = False, # Prenorm\n", - " activation: str = \"gelu\", # activation in between SS and FF\n", - " postact: str = \"glu\", # activation after FF\n", - " measure: str = \"fourier\",\n", - " trainable: Optional[Dict[str, bool]] = None,\n", - " \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", - " self.context_length = context_length\n", - " self.prediction_length = prediction_length\n", - " self.distr_output = distr_output\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", - " \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", - " self.lagged_s4 = LaggedS4(\n", - " input_size=input_size,\n", - " features_size=self._number_of_features,\n", - " lags_seq=[lag - 1 for lag in self.lags_seq],\n", - " \n", - " # S4 inputs\n", - " d_state=d_state,\n", - " channels=nhead,\n", - " prenorm=prenorm,\n", - " activation=activation,\n", - " postact=postact,\n", - " num_layers=num_layers,\n", - " dropout=dropout_rate,\n", - " #l_max=self._past_length + self.prediction_length,\n", - " measure=measure,\n", - " trainable=trainable,\n", - " )\n", - " \n", - " self.param_proj = distr_output.get_args_proj(input_size*len(self.lags_seq) + self._number_of_features)\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 unroll_lagged_s4(\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", - " state: Optional[torch.Tensor] = None,\n", - " ) -> Tuple[\n", - " Tuple[torch.Tensor, ...],\n", - " torch.Tensor,\n", - " torch.Tensor,\n", - " torch.Tensor,\n", - " Tuple[torch.Tensor, torch.Tensor],\n", - " ]:\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", - " prior_input = past_target[:, : -self.context_length] / scale\n", - " inputs = (\n", - " torch.cat((context, future_target[:, :-1]), dim=1) / scale\n", - " if future_target is not None\n", - " else context / scale\n", - " )\n", - "\n", - " unroll_length = (\n", - " self.context_length\n", - " if future_target is None\n", - " else self.context_length + future_target.shape[1] - 1\n", - " )\n", - " assert inputs.shape[1] == unroll_length\n", - "\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, unroll_length, -1\n", - " )\n", - "\n", - " time_feat = (\n", - " torch.cat(\n", - " (\n", - " past_time_feat[:, -self.context_length + 1 :, ...],\n", - " future_time_feat,\n", - " ),\n", - " dim=1,\n", - " )\n", - " if future_time_feat is not None\n", - " else past_time_feat[:, -self.context_length + 1 :, ...]\n", - " )\n", - "\n", - " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", - "\n", - " output, new_state = self.lagged_s4(prior_input, inputs, features, state)\n", - "\n", - " params = self.param_proj(output)\n", - " return params, scale, output, static_feat, new_state\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", - " # 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", - " if num_parallel_samples is None:\n", - " num_parallel_samples = self.num_parallel_samples\n", - " \n", - " for layer in self.lagged_s4.s4_layers:\n", - " layer.kernel.kernel.setup_step()\n", - " default_state = layer.kernel.default_state(*past_target.shape[:1])\n", - " \n", - " params, scale, _, static_feat, state = self.unroll_lagged_s4(\n", - " feat_static_cat,\n", - " feat_static_real,\n", - " past_time_feat,\n", - " past_target,\n", - " past_observed_values,\n", - " future_time_feat[:, :1],\n", - " state=default_state,\n", - " )\n", - "\n", - " repeated_scale = scale.repeat_interleave(\n", - " repeats=num_parallel_samples, dim=0\n", - " )\n", - " \n", - " repeated_static_feat = static_feat.repeat_interleave(\n", - " repeats=num_parallel_samples, dim=0\n", - " ).unsqueeze(dim=1)\n", - " \n", - " repeated_past_target = (\n", - " past_target.repeat_interleave(\n", - " repeats=num_parallel_samples, dim=0\n", - " )\n", - " / repeated_scale\n", - " )\n", - " \n", - " repeated_time_feat = future_time_feat.repeat_interleave(\n", - " repeats=num_parallel_samples, dim=0\n", - " )\n", - " \n", - " repeated_state = state.repeat_interleave(repeats=num_parallel_samples, dim=0)\n", - " \n", - " repeated_params = [\n", - " s.repeat_interleave(repeats=num_parallel_samples, dim=0)\n", - " for s in params\n", - " ]\n", - " \n", - " distr = self.output_distribution(\n", - " repeated_params, trailing_n=1, scale=repeated_scale\n", - " )\n", - " next_sample = distr.sample()\n", - " future_samples = [next_sample]\n", - " \n", - " for k in range(1, self.prediction_length):\n", - " scaled_next_sample = next_sample / repeated_scale\n", - " next_features = torch.cat(\n", - " (repeated_static_feat, repeated_time_feat[:, k : k + 1]),\n", - " dim=-1,\n", - " )\n", - "\n", - " output, repeated_state = self.lagged_s4(\n", - " repeated_past_target,\n", - " scaled_next_sample,\n", - " next_features,\n", - " repeated_state,\n", - " step=True,\n", - " )\n", - "\n", - " repeated_past_target = torch.cat(\n", - " (repeated_past_target, scaled_next_sample), dim=1\n", - " )\n", - "\n", - " params = self.param_proj(output)\n", - " \n", - " # hack: sometimes the params ie. output has nans\n", - " # replace nans with means of the params...\n", - " # params = [p.nan_to_num(nan=p.nanmean(0).item()) for p in params]\n", - " \n", - " distr = self.output_distribution(params, scale=repeated_scale)\n", - " next_sample = distr.sample()\n", - " future_samples.append(next_sample)\n", - "\n", - " future_samples_concat = torch.cat(future_samples, dim=1)\n", - "\n", - " return future_samples_concat.reshape(\n", - " (-1, self.num_parallel_samples, self.prediction_length)\n", - " + self.target_shape,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "725eb743", - "metadata": {}, - "outputs": [], - "source": [ - "class LaggedS4(nn.Module):\n", - " def __init__(\n", - " self,\n", - " input_size: int,\n", - " features_size: int,\n", - " lags_seq: List[int],\n", - " \n", - " #s4 inputs\n", - " d_state: int = 64,\n", - " channels: int = 1, # channels: can be interpreted as a number of \"heads\"\n", - " num_layers: int = 1, # Number of layers\n", - " l_max: int = 1, # max length or 1\n", - " dropout: float = 0.2,\n", - " prenorm: bool = False, # Prenorm flag\n", - " activation: str = \"gelu\", # activation in between SS and FF\n", - " postact: str = \"glu\", # activation after FF\n", - " measure: str = \"fourier\",\n", - " trainable: Optional[Dict[str, bool]] = None,\n", - " ) -> None:\n", - " super().__init__()\n", - " self.input_size = input_size\n", - " self.features_size = features_size\n", - " self.lags_seq = lags_seq\n", - " \n", - " d_model = input_size * len(self.lags_seq) + features_size\n", - " self.prenorm = prenorm\n", - " \n", - " self.s4_layers = nn.ModuleList()\n", - " self.norms = nn.ModuleList()\n", - " self.dropouts = nn.ModuleList()\n", - " for _ in range(num_layers):\n", - " self.s4_layers.append(\n", - " S4(\n", - " d_model=d_model,\n", - " d_state=d_state,\n", - " l_max=l_max,\n", - " channels=channels,\n", - " activation=activation,\n", - " dropout=dropout,\n", - " transposed=False, #[B, T, F]\n", - " postact=postact,\n", - " measure=measure,\n", - " trainable=trainable,\n", - " )\n", - " )\n", - " self.norms.append(nn.LayerNorm(d_model))\n", - " self.dropouts.append(nn.Dropout2d(dropout))\n", - "\n", - " def get_lagged_subsequences(\n", - " self,\n", - " sequence: torch.Tensor,\n", - " subsequences_length: int,\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", - " 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 = 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", - " input: torch.Tensor,\n", - " features: Optional[torch.Tensor],\n", - " ) -> None:\n", - " assert len(prior_input.shape) == len(input.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(input.shape) == 2 and self.input_size == 1) or input.shape[\n", - " -1\n", - " ] == self.input_size\n", - " assert (\n", - " features is None or features.shape[2] == self.features_size\n", - " ), f\"{features.shape[2]}, expected {self.features_size}\"\n", - "\n", - " def forward(\n", - " self,\n", - " prior_input: torch.Tensor,\n", - " inputs: torch.Tensor,\n", - " features: Optional[torch.Tensor] = None,\n", - " state: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,\n", - " step: bool = False,\n", - " ) -> Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\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=sequence,\n", - " subsequences_length=inputs.shape[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", - " if features is None:\n", - " s4_input = reshaped_lagged_sequence\n", - " else:\n", - " s4_input = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", - "\n", - " x = s4_input\n", - " for layer, norm, dropout in zip(self.s4_layers, self.norms, self.dropouts):\n", - " z = x\n", - " if self.prenorm:\n", - " # Prenorm\n", - " z = norm(z)\n", - " \n", - " if step:\n", - " z, state = layer.step(z.squeeze(), state)\n", - " z = z.unsqueeze(1)\n", - " else:\n", - " # Apply S4 block\n", - " z, state = layer(z, state)\n", - " \n", - " # Dropout on the output of the S4 block\n", - " z = dropout(z)\n", - "\n", - " # Residual connection\n", - " x = z + x\n", - "\n", - " if not self.prenorm:\n", - " # Postnorm\n", - " x = norm(x)\n", - "\n", - " return x, state" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d16da5e8", - "metadata": {}, - "outputs": [], - "source": [ - "class S4LightningModule(pl.LightningModule):\n", - " def __init__(\n", - " self,\n", - " model: S4Model,\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 _compute_loss(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", - " params, scale, _, _, _ = self.model.unroll_lagged_s4(\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", - " distr = self.model.output_distribution(params, scale)\n", - "\n", - " context_target = past_target[:, -self.model.context_length + 1 :]\n", - " target = torch.cat(\n", - " (context_target, future_target),\n", - " dim=1,\n", - " )\n", - " loss_values = self.loss(distr, target)\n", - "\n", - " context_observed = past_observed_values[\n", - " :, -self.model.context_length + 1 :\n", - " ]\n", - " observed_values = torch.cat(\n", - " (context_observed, future_observed_values), dim=1\n", - " )\n", - "\n", - " if len(self.model.target_shape) == 0:\n", - " loss_weights = observed_values\n", - " else:\n", - " loss_weights, _ = observed_values.min(dim=-1, keepdim=False)\n", - "\n", - " return weighted_average(loss_values, weights=loss_weights)\n", - "\n", - " def training_step(self, batch, batch_idx: int): # type: ignore\n", - " \"\"\"Execute training step\"\"\"\n", - " train_loss = self._compute_loss(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): # type: ignore\n", - " \"\"\"Execute validation step\"\"\"\n", - " val_loss = self._compute_loss(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", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "8247e81d", - "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": 9, - "id": "71ee8e4a", - "metadata": {}, - "outputs": [], - "source": [ - "class S4Estimator(PyTorchLightningEstimator):\n", - " def __init__(\n", - " self,\n", - " freq: str,\n", - " prediction_length: int,\n", - " context_length: Optional[int] = None,\n", - "\n", - " d_state: int = 64,\n", - " num_layers: int = 2,\n", - " nhead: int = 2,\n", - " prenorm: bool = False,\n", - " activation: str = \"gelu\",\n", - " postact: str = \"glu\",\n", - " dropout_rate: float = 0.1,\n", - " measure: str = \"fourier\",\n", - " trainable: Optional[Dict[str, bool]] = 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]] = None,\n", - " ) -> None:\n", - " default_trainer_kwargs = {\n", - " \"max_epochs\": 100,\n", - " #\"gradient_clip_val\": 10.0,\n", - " }\n", - " if trainer_kwargs is not None:\n", - " default_trainer_kwargs.update(trainer_kwargs)\n", - " super().__init__(trainer_kwargs=default_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.d_state = d_state\n", - " self.num_layers = num_layers\n", - " self.nhead = nhead\n", - " self.activation = activation\n", - " self.prenorm = prenorm\n", - " self.postact = postact\n", - " self.measure = measure\n", - " self.trainable = trainable\n", - " \n", - " self.dropout_rate = dropout_rate\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 = ExpectedNumInstanceSampler(\n", - " num_instances=1.0, min_future=prediction_length\n", - " )\n", - " self.validation_sampler = 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: S4LightningModule, 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: S4LightningModule,\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: S4LightningModule,\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_lightning_module(self) -> S4LightningModule:\n", - " model = S4Model(\n", - " freq=self.freq,\n", - " context_length=self.context_length,\n", - " prediction_length=self.prediction_length,\n", - " num_feat_dynamic_real=(\n", - " 1 + self.num_feat_dynamic_real + len(self.time_features)\n", - " ),\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", - " d_state=self.d_state,\n", - " num_layers=self.num_layers,\n", - " nhead=self.nhead,\n", - " activation=self.activation,\n", - " prenorm=self.prenorm,\n", - " postact=self.postact,\n", - " measure=self.measure,\n", - " trainable=self.trainable,\n", - " \n", - " distr_output=self.distr_output,\n", - " dropout_rate=self.dropout_rate,\n", - " lags_seq=self.lags_seq,\n", - " scaling=self.scaling,\n", - " num_parallel_samples=self.num_parallel_samples,\n", - " )\n", - "\n", - " return S4LightningModule(model=model, loss=self.loss)\n", - "\n", - " def create_predictor(\n", - " self,\n", - " transformation: Transformation,\n", - " module: S4LightningModule,\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(\n", - " \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e4eda7ef", - "metadata": {}, - "outputs": [], - "source": [ - "dataset = get_dataset(\"electricity\")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "63298518", - "metadata": {}, - "outputs": [], - "source": [ - "estimator = S4Estimator(\n", - " freq=dataset.metadata.freq,\n", - " prediction_length=dataset.metadata.prediction_length,\n", - " context_length=100*dataset.metadata.prediction_length,\n", - " measure=\"fourier\",\n", - " \n", - " nhead=1,\n", - " num_layers=3,\n", - " \n", - " batch_size=128,\n", - " num_batches_per_epoch=100,\n", - " trainer_kwargs=dict(max_epochs=10, gpus='1', precision=\"bf16\", logger=CSVLogger(\"logs\", name=\"transformer\")),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "7a7d7d5b", - "metadata": {}, - "outputs": [ - { - "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", - "Using bfloat16 Automatic Mixed Precision (AMP)\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/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated 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" - ] + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c4c1a6b2", + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install -U gluonts pytorch-lightning torch" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "f61debcc", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "64e16862", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Optional, Iterable, Dict, Any, Tuple\n", + "from itertools import islice\n", + "import queue\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", + "from datasets import load_dataset\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import DataLoader\n", + "from torch.optim.lr_scheduler import _LRScheduler, MultiplicativeLR\n", + "from torch.optim import Optimizer\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, ListDataset\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", + ")\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.distributions 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": 60, + "id": "c1fbb026", + "metadata": {}, + "outputs": [], + "source": [ + "from s4 import S4" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "6ddc78b9", + "metadata": {}, + "outputs": [], + "source": [ + "class S4Model(nn.Module):\n", + " def __init__(\n", + " self,\n", + " freq: str,\n", + " \n", + " context_length: int,\n", + " prediction_length: int,\n", + " \n", + " num_feat_dynamic_real: int,\n", + " num_feat_static_real: int,\n", + " \n", + " num_feat_static_cat: int,\n", + " cardinality: List[int],\n", + " embedding_dimension: Optional[List[int]] = None,\n", + " \n", + " input_size: int = 1, # univariate input\n", + " \n", + " # S4 inputs\n", + " d_state: int = 64,\n", + " nhead: int = 1, # channels: can be interpreted as a number of \"heads\"\n", + " num_layers: int = 1, # Number of layers\n", + " dropout_rate: float = 0.2,\n", + " prenorm: bool = False, # Prenorm\n", + " activation: str = \"gelu\", # activation in between SS and FF\n", + " postact: str = \"glu\", # activation after FF\n", + " measure: str = \"legs\",\n", + " trainable: Optional[Dict[str, bool]] = None,\n", + " \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", + " self.context_length = context_length\n", + " self.prediction_length = prediction_length\n", + " self.distr_output = distr_output\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", + " \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", + " self.lagged_s4 = LaggedS4(\n", + " input_size=input_size,\n", + " features_size=self._number_of_features,\n", + " lags_seq=[lag - 1 for lag in self.lags_seq],\n", + " \n", + " # S4 inputs\n", + " d_state=d_state,\n", + " channels=nhead,\n", + " prenorm=prenorm,\n", + " activation=activation,\n", + " postact=postact,\n", + " num_layers=num_layers,\n", + " dropout=dropout_rate,\n", + " #l_max=self._past_length + self.prediction_length,\n", + " measure=measure,\n", + " trainable=trainable,\n", + " )\n", + " \n", + " self.param_proj = distr_output.get_args_proj(input_size*len(self.lags_seq) + self._number_of_features)\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 unroll_lagged_s4(\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", + " state: Optional[torch.Tensor] = None,\n", + " ) -> Tuple[\n", + " Tuple[torch.Tensor, ...],\n", + " torch.Tensor,\n", + " torch.Tensor,\n", + " torch.Tensor,\n", + " Tuple[torch.Tensor, torch.Tensor],\n", + " ]:\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", + " prior_input = past_target[:, : -self.context_length] / scale\n", + " inputs = (\n", + " torch.cat((context, future_target[:, :-1]), dim=1) / scale\n", + " if future_target is not None\n", + " else context / scale\n", + " )\n", + "\n", + " unroll_length = (\n", + " self.context_length\n", + " if future_target is None\n", + " else self.context_length + future_target.shape[1] - 1\n", + " )\n", + " assert inputs.shape[1] == unroll_length\n", + "\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, unroll_length, -1\n", + " )\n", + "\n", + " time_feat = (\n", + " torch.cat(\n", + " (\n", + " past_time_feat[:, -self.context_length + 1 :, ...],\n", + " future_time_feat,\n", + " ),\n", + " dim=1,\n", + " )\n", + " if future_time_feat is not None\n", + " else past_time_feat[:, -self.context_length + 1 :, ...]\n", + " )\n", + "\n", + " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", + "\n", + " output, new_state = self.lagged_s4(prior_input, inputs, features, state)\n", + "\n", + " params = self.param_proj(output)\n", + " return params, scale, output, static_feat, new_state\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", + " # 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", + " if num_parallel_samples is None:\n", + " num_parallel_samples = self.num_parallel_samples\n", + " \n", + " for layer in self.lagged_s4.s4_layers:\n", + " layer.kernel.kernel.setup_step()\n", + " default_state = layer.kernel.default_state(*past_target.shape[:1])\n", + " \n", + " params, scale, _, static_feat, state = self.unroll_lagged_s4(\n", + " feat_static_cat,\n", + " feat_static_real,\n", + " past_time_feat,\n", + " past_target,\n", + " past_observed_values,\n", + " future_time_feat[:, :1],\n", + " state=default_state,\n", + " )\n", + "\n", + " repeated_scale = scale.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " )\n", + " \n", + " repeated_static_feat = static_feat.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " ).unsqueeze(dim=1)\n", + " \n", + " repeated_past_target = (\n", + " past_target.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " )\n", + " / repeated_scale\n", + " )\n", + " \n", + " repeated_time_feat = future_time_feat.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " )\n", + " \n", + " repeated_state = state.repeat_interleave(repeats=num_parallel_samples, dim=0)\n", + " \n", + " repeated_params = [\n", + " s.repeat_interleave(repeats=num_parallel_samples, dim=0)\n", + " for s in params\n", + " ]\n", + " \n", + " distr = self.output_distribution(\n", + " repeated_params, trailing_n=1, scale=repeated_scale\n", + " )\n", + " next_sample = distr.sample()\n", + " future_samples = [next_sample]\n", + " \n", + " for k in range(1, self.prediction_length):\n", + " scaled_next_sample = next_sample / repeated_scale\n", + " next_features = torch.cat(\n", + " (repeated_static_feat, repeated_time_feat[:, k : k + 1]),\n", + " dim=-1,\n", + " )\n", + "\n", + " output, repeated_state = self.lagged_s4(\n", + " repeated_past_target,\n", + " scaled_next_sample,\n", + " next_features,\n", + " repeated_state,\n", + " step=True,\n", + " )\n", + "\n", + " repeated_past_target = torch.cat(\n", + " (repeated_past_target, scaled_next_sample), dim=1\n", + " )\n", + "\n", + " params = self.param_proj(output)\n", + " \n", + " # hack: sometimes the params ie. output has nans\n", + " # replace nans with means of the params...\n", + " # params = [p.nan_to_num(nan=p.nanmean(0).item()) for p in params]\n", + " \n", + " distr = self.output_distribution(params, scale=repeated_scale)\n", + " next_sample = distr.sample()\n", + " future_samples.append(next_sample)\n", + "\n", + " future_samples_concat = torch.cat(future_samples, dim=1)\n", + "\n", + " return future_samples_concat.reshape(\n", + " (-1, self.num_parallel_samples, self.prediction_length)\n", + " + self.target_shape,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "725eb743", + "metadata": {}, + "outputs": [], + "source": [ + "class LaggedS4(nn.Module):\n", + " def __init__(\n", + " self,\n", + " input_size: int,\n", + " features_size: int,\n", + " lags_seq: List[int],\n", + " \n", + " #s4 inputs\n", + " d_state: int = 64,\n", + " channels: int = 1, # channels: can be interpreted as a number of \"heads\"\n", + " num_layers: int = 1, # Number of layers\n", + " l_max: int = 1, # max length or 1\n", + " dropout: float = 0.2,\n", + " prenorm: bool = False, # Prenorm flag\n", + " activation: str = \"gelu\", # activation in between SS and FF\n", + " postact: str = \"glu\", # activation after FF\n", + " measure: str = \"fourier\",\n", + " trainable: Optional[Dict[str, bool]] = None,\n", + " ) -> None:\n", + " super().__init__()\n", + " self.input_size = input_size\n", + " self.features_size = features_size\n", + " self.lags_seq = lags_seq\n", + " \n", + " d_model = input_size * len(self.lags_seq) + features_size\n", + " self.prenorm = prenorm\n", + " \n", + " self.s4_layers = nn.ModuleList()\n", + " self.norms = nn.ModuleList()\n", + " self.dropouts = nn.ModuleList()\n", + " for _ in range(num_layers):\n", + " self.s4_layers.append(\n", + " S4(\n", + " d_model=d_model,\n", + " d_state=d_state,\n", + " l_max=l_max,\n", + " channels=channels,\n", + " activation=activation,\n", + " dropout=dropout,\n", + " transposed=False, #[B, T, F]\n", + " postact=postact,\n", + " measure=measure,\n", + " trainable=trainable,\n", + " mode=\"nplr\",\n", + " n_ssm=1,\n", + " )\n", + " )\n", + " self.norms.append(nn.LayerNorm(d_model))\n", + " self.dropouts.append(nn.Dropout2d(dropout))\n", + "\n", + " def get_lagged_subsequences(\n", + " self,\n", + " sequence: torch.Tensor,\n", + " subsequences_length: int,\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", + " 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 = 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", + " input: torch.Tensor,\n", + " features: Optional[torch.Tensor],\n", + " ) -> None:\n", + " assert len(prior_input.shape) == len(input.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(input.shape) == 2 and self.input_size == 1) or input.shape[\n", + " -1\n", + " ] == self.input_size\n", + " assert (\n", + " features is None or features.shape[2] == self.features_size\n", + " ), f\"{features.shape[2]}, expected {self.features_size}\"\n", + "\n", + " def forward(\n", + " self,\n", + " prior_input: torch.Tensor,\n", + " inputs: torch.Tensor,\n", + " features: Optional[torch.Tensor] = None,\n", + " state: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,\n", + " step: bool = False,\n", + " ) -> Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\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=sequence,\n", + " subsequences_length=inputs.shape[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", + " if features is None:\n", + " s4_input = reshaped_lagged_sequence\n", + " else:\n", + " s4_input = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", + "\n", + " x = s4_input\n", + " for layer, norm, dropout in zip(self.s4_layers, self.norms, self.dropouts):\n", + " z = x\n", + " if self.prenorm:\n", + " # Prenorm\n", + " z = norm(z)\n", + " \n", + " if step:\n", + " z, state = layer.step(z.squeeze(), state)\n", + " z = z.unsqueeze(1)\n", + " else:\n", + " # Apply S4 block\n", + " z, state = layer(z, state)\n", + " \n", + " # Dropout on the output of the S4 block\n", + " z = dropout(z)\n", + "\n", + " # Residual connection\n", + " x = z + x\n", + "\n", + " if not self.prenorm:\n", + " # Postnorm\n", + " x = norm(x)\n", + "\n", + " return x, state" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "d16da5e8", + "metadata": {}, + "outputs": [], + "source": [ + "class S4LightningModule(pl.LightningModule):\n", + " def __init__(\n", + " self,\n", + " model: S4Model,\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 _compute_loss(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", + " params, scale, _, _, _ = self.model.unroll_lagged_s4(\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", + " distr = self.model.output_distribution(params, scale)\n", + "\n", + " context_target = past_target[:, -self.model.context_length + 1 :]\n", + " target = torch.cat(\n", + " (context_target, future_target),\n", + " dim=1,\n", + " )\n", + " loss_values = self.loss(distr, target)\n", + "\n", + " context_observed = past_observed_values[\n", + " :, -self.model.context_length + 1 :\n", + " ]\n", + " observed_values = torch.cat(\n", + " (context_observed, future_observed_values), dim=1\n", + " )\n", + "\n", + " if len(self.model.target_shape) == 0:\n", + " loss_weights = observed_values\n", + " else:\n", + " loss_weights, _ = observed_values.min(dim=-1, keepdim=False)\n", + "\n", + " return weighted_average(loss_values, weights=loss_weights)\n", + "\n", + " def training_step(self, batch, batch_idx: int): # type: ignore\n", + " \"\"\"Execute training step\"\"\"\n", + " train_loss = self._compute_loss(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): # type: ignore\n", + " \"\"\"Execute validation step\"\"\"\n", + " with torch.no_grad():\n", + " val_loss = self._compute_loss(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", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "8247e81d", + "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": 65, + "id": "71ee8e4a", + "metadata": {}, + "outputs": [], + "source": [ + "class S4Estimator(PyTorchLightningEstimator):\n", + " def __init__(\n", + " self,\n", + " freq: str,\n", + " prediction_length: int,\n", + " context_length: Optional[int] = None,\n", + "\n", + " d_state: int = 64,\n", + " num_layers: int = 2,\n", + " nhead: int = 2,\n", + " prenorm: bool = False,\n", + " activation: str = \"gelu\",\n", + " postact: str = \"glu\",\n", + " dropout_rate: float = 0.1,\n", + " measure: str = \"fourier\",\n", + " trainable: Optional[Dict[str, bool]] = 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]] = None,\n", + " ) -> None:\n", + " default_trainer_kwargs = {\n", + " \"max_epochs\": 100,\n", + " #\"gradient_clip_val\": 10.0,\n", + " }\n", + " if trainer_kwargs is not None:\n", + " default_trainer_kwargs.update(trainer_kwargs)\n", + " super().__init__(trainer_kwargs=default_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.d_state = d_state\n", + " self.num_layers = num_layers\n", + " self.nhead = nhead\n", + " self.activation = activation\n", + " self.prenorm = prenorm\n", + " self.postact = postact\n", + " self.measure = measure\n", + " self.trainable = trainable\n", + " \n", + " self.dropout_rate = dropout_rate\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 = ExpectedNumInstanceSampler(\n", + " num_instances=1.0, min_future=prediction_length\n", + " )\n", + " self.validation_sampler = 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: S4LightningModule, 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: S4LightningModule,\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: S4LightningModule,\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_lightning_module(self) -> S4LightningModule:\n", + " model = S4Model(\n", + " freq=self.freq,\n", + " context_length=self.context_length,\n", + " prediction_length=self.prediction_length,\n", + " num_feat_dynamic_real=(\n", + " 1 + self.num_feat_dynamic_real + len(self.time_features)\n", + " ),\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", + " d_state=self.d_state,\n", + " num_layers=self.num_layers,\n", + " nhead=self.nhead,\n", + " activation=self.activation,\n", + " prenorm=self.prenorm,\n", + " postact=self.postact,\n", + " measure=self.measure,\n", + " trainable=self.trainable,\n", + " \n", + " distr_output=self.distr_output,\n", + " dropout_rate=self.dropout_rate,\n", + " lags_seq=self.lags_seq,\n", + " scaling=self.scaling,\n", + " num_parallel_samples=self.num_parallel_samples,\n", + " )\n", + "\n", + " return S4LightningModule(model=model, loss=self.loss)\n", + "\n", + " def create_predictor(\n", + " self,\n", + " transformation: Transformation,\n", + " module: S4LightningModule,\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(\n", + " \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " ),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "8e536f9b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:datasets.builder:Reusing dataset electricity_load_diagrams (/home/kashif/.cache/huggingface/datasets/electricity_load_diagrams/lstnet/1.0.0/fe3dd01c39428ad92523a7ced0df3fdf669cb0548b3dd16fb9f7009381aa440f)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7606f567f1e84a618f591bd9ee057ee3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3 [00:00" + ] + }, + "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", + " ts[-4 * prediction_length:].plot(ax=ax, 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": null, + "id": "2c6e9fff", + "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" + } }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated 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:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert 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:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\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 | S4Model | 23.9 K\n", - "1 | loss | NegativeLogLikelihood | 0 \n", - "------------------------------------------------\n", - "23.9 K Trainable params\n", - "0 Non-trainable params\n", - "23.9 K Total params\n", - "0.096 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c6c2ba749fb54bbebe66fbb0fa34f501", - "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": [ - "Epoch 0, global step 100: 'train_loss' reached 6.80268 (best 6.80268), saving model to 'logs/transformer/version_326/checkpoints/epoch=0-step=100.ckpt' as top 1\n", - "Epoch 1, global step 200: 'train_loss' reached 5.97724 (best 5.97724), saving model to 'logs/transformer/version_326/checkpoints/epoch=1-step=200.ckpt' as top 1\n", - "Epoch 2, global step 300: 'train_loss' reached 5.72596 (best 5.72596), saving model to 'logs/transformer/version_326/checkpoints/epoch=2-step=300.ckpt' as top 1\n", - "Epoch 3, global step 400: 'train_loss' reached 5.54821 (best 5.54821), saving model to 'logs/transformer/version_326/checkpoints/epoch=3-step=400.ckpt' as top 1\n", - "Epoch 4, global step 500: 'train_loss' reached 5.48996 (best 5.48996), saving model to 'logs/transformer/version_326/checkpoints/epoch=4-step=500.ckpt' as top 1\n", - "Epoch 5, global step 600: 'train_loss' reached 5.40020 (best 5.40020), saving model to 'logs/transformer/version_326/checkpoints/epoch=5-step=600.ckpt' as top 1\n", - "Epoch 6, global step 700: 'train_loss' reached 5.36667 (best 5.36667), saving model to 'logs/transformer/version_326/checkpoints/epoch=6-step=700.ckpt' as top 1\n", - "Epoch 7, global step 800: 'train_loss' reached 5.31321 (best 5.31321), saving model to 'logs/transformer/version_326/checkpoints/epoch=7-step=800.ckpt' as top 1\n", - "Epoch 8, global step 900: 'train_loss' reached 5.29075 (best 5.29075), saving model to 'logs/transformer/version_326/checkpoints/epoch=8-step=900.ckpt' as top 1\n", - "Epoch 9, global step 1000: 'train_loss' was not in top 1\n" - ] - } - ], - "source": [ - "predictor = estimator.train(\n", - " training_data=dataset.train,\n", - " num_workers=8,\n", - " shuffle_buffer_length=1024\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "81eae2c6", - "metadata": {}, - "outputs": [], - "source": [ - "forecast_it, ts_it = make_evaluation_predictions(\n", - " dataset=dataset.test,\n", - " predictor=predictor,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "eee452cd", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated 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:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", - "/mnt/scratch/kashif/pytorch-transformer-forecast/krylov.py:118: UserWarning: floor_divide is deprecated, and will be removed in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values.\n", - "To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor'). (Triggered internally at /mnt/scratch/kashif/pytorch/aten/src/ATen/native/BinaryOps.cpp:576.)\n", - " L //= 2\n", - "/mnt/scratch/kashif/pytorch-transformer-forecast/kernel.py:1140: UserWarning: Casting complex values to real discards the imaginary part (Triggered internally at /mnt/scratch/kashif/pytorch/aten/src/ATen/native/Copy.cpp:240.)\n", - " return u.float(), state\n" - ] - } - ], - "source": [ - "forecasts = list(forecast_it)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "57b85112", - "metadata": {}, - "outputs": [], - "source": [ - "tss = list(ts_it)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "0be971a5", - "metadata": {}, - "outputs": [], - "source": [ - "evaluator = Evaluator()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "c8ea2a4c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Running evaluation: 2247it [00:00, 4590.10it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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:313: 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": 18, - "id": "943b8b7c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'MSE': 16747109.805273874,\n", - " 'abs_error': 33179613.89278412,\n", - " 'abs_target_sum': 128632956.0,\n", - " 'abs_target_mean': 2385.272140631954,\n", - " 'seasonal_error': 189.49338196116761,\n", - " 'MASE': 3.0259446149950957,\n", - " 'MAPE': 0.3554268814529896,\n", - " 'sMAPE': 0.2830898842278759,\n", - " 'MSIS': 32.65637303286821,\n", - " 'QuantileLoss[0.1]': 26881642.935654998,\n", - " 'Coverage[0.1]': 0.6553182020471741,\n", - " 'QuantileLoss[0.2]': 32171550.764535427,\n", - " 'Coverage[0.2]': 0.7410065272214805,\n", - " 'QuantileLoss[0.3]': 34225308.93104912,\n", - " 'Coverage[0.3]': 0.7942998071502745,\n", - " 'QuantileLoss[0.4]': 34387341.28364634,\n", - " 'Coverage[0.4]': 0.8323134549770064,\n", - " 'QuantileLoss[0.5]': 33179613.401385784,\n", - " 'Coverage[0.5]': 0.8615005192107995,\n", - " 'QuantileLoss[0.6]': 30535314.288769234,\n", - " 'Coverage[0.6]': 0.8851246105919003,\n", - " 'QuantileLoss[0.7]': 26795939.697389804,\n", - " 'Coverage[0.7]': 0.9090268506156357,\n", - " 'QuantileLoss[0.8]': 21610667.198691174,\n", - " 'Coverage[0.8]': 0.9338747960243287,\n", - " 'QuantileLoss[0.9]': 14396474.291173145,\n", - " 'Coverage[0.9]': 0.9592048657469219,\n", - " 'RMSE': 4092.323277219662,\n", - " 'NRMSE': 1.7156630505630448,\n", - " 'ND': 0.2579402271746295,\n", - " 'wQuantileLoss[0.1]': 0.20897943864133076,\n", - " 'wQuantileLoss[0.2]': 0.2501034864233037,\n", - " 'wQuantileLoss[0.3]': 0.2660695205593279,\n", - " 'wQuantileLoss[0.4]': 0.26732916938989054,\n", - " 'wQuantileLoss[0.5]': 0.2579402233544706,\n", - " 'wQuantileLoss[0.6]': 0.23738328993053098,\n", - " 'wQuantileLoss[0.7]': 0.20831317673668173,\n", - " 'wQuantileLoss[0.8]': 0.16800257003105157,\n", - " 'wQuantileLoss[0.9]': 0.11191901934659065,\n", - " 'mean_absolute_QuantileLoss': 28242650.310255006,\n", - " 'mean_wQuantileLoss': 0.21955998826813095,\n", - " 'MAE_Coverage': 0.3412966259539469,\n", - " 'OWA': nan}" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "agg_metrics" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "99c10cdc", - "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 * 20:], 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": null, - "id": "2c6e9fff", - "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 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/switch/switch.ipynb b/switch/switch.ipynb index 2a512a2..3d46fe9 100644 --- a/switch/switch.ipynb +++ b/switch/switch.ipynb @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 18, "id": "e772234f", "metadata": {}, "outputs": [], @@ -59,6 +59,7 @@ "estimator = SwitchTransformerEstimator(\n", " freq=dataset.metadata.freq,\n", " prediction_length=dataset.metadata.prediction_length,\n", + " context_length=8*dataset.metadata.prediction_length,\n", " num_feat_static_cat=1,\n", " cardinality=[321],\n", " embedding_dimension=[3],\n", @@ -67,20 +68,20 @@ " num_encoder_layers=2,\n", " num_decoder_layers=2,\n", " nhead=2,\n", - " n_experts = 4,\n", - " capacity_factor = 0.2,\n", + " n_experts=4,\n", + " capacity_factor=1.0,\n", " \n", " activation=\"relu\",\n", "\n", " batch_size=128,\n", " num_batches_per_epoch=100,\n", - " trainer_kwargs=dict(max_epochs=50, accelerator='gpu', gpus=1),\n", + " trainer_kwargs=dict(max_epochs=20, accelerator='gpu', gpus=1),\n", ")" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "id": "22d804e4", "metadata": {}, "outputs": [ @@ -114,7 +115,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "78ce8638ba8b45e59858e078aa08b6ba", + "model_id": "ea9100994cbc439b9a6c66b6beab4253", "version_major": 2, "version_minor": 0 }, @@ -139,56 +140,26 @@ " 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 0, global step 100: 'train_loss' reached 6.89574 (best 6.89574), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=0-step=100.ckpt' as top 1\n", + "Epoch 1, global step 200: 'train_loss' reached 6.07414 (best 6.07414), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=1-step=200.ckpt' as top 1\n", + "Epoch 2, global step 300: 'train_loss' reached 5.79265 (best 5.79265), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=2-step=300.ckpt' as top 1\n", + "Epoch 3, global step 400: 'train_loss' reached 5.67099 (best 5.67099), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=3-step=400.ckpt' as top 1\n", + "Epoch 4, global step 500: 'train_loss' reached 5.56751 (best 5.56751), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=4-step=500.ckpt' as top 1\n", + "Epoch 5, global step 600: 'train_loss' reached 5.53956 (best 5.53956), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=5-step=600.ckpt' as top 1\n", + "Epoch 6, global step 700: 'train_loss' reached 5.46131 (best 5.46131), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=6-step=700.ckpt' as top 1\n", + "Epoch 7, global step 800: 'train_loss' reached 5.45841 (best 5.45841), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=7-step=800.ckpt' as top 1\n", + "Epoch 8, global step 900: 'train_loss' reached 5.42569 (best 5.42569), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=8-step=900.ckpt' as top 1\n", + "Epoch 9, global step 1000: 'train_loss' reached 5.38103 (best 5.38103), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=9-step=1000.ckpt' as top 1\n", + "Epoch 10, global step 1100: 'train_loss' reached 5.37174 (best 5.37174), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=10-step=1100.ckpt' as top 1\n", + "Epoch 11, global step 1200: 'train_loss' reached 5.35499 (best 5.35499), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=11-step=1200.ckpt' as top 1\n", + "Epoch 12, global step 1300: 'train_loss' reached 5.33469 (best 5.33469), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=12-step=1300.ckpt' as 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 14, global step 1500: 'train_loss' reached 5.28044 (best 5.28044), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=14-step=1500.ckpt' as top 1\n", + "Epoch 15, global step 1600: 'train_loss' was not in 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 17, global step 1800: 'train_loss' reached 5.27935 (best 5.27935), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/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" + "Epoch 19, global step 2000: 'train_loss' reached 5.24220 (best 5.24220), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/switch/lightning_logs/version_3/checkpoints/epoch=19-step=2000.ckpt' as top 1\n" ] } ], @@ -202,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 20, "id": "11a47d5a", "metadata": {}, "outputs": [], @@ -215,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "id": "1492f7fb", "metadata": {}, "outputs": [], @@ -235,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 22, "id": "e00601c4", "metadata": {}, "outputs": [], @@ -245,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 23, "id": "9ed4c523", "metadata": {}, "outputs": [ @@ -253,7 +224,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Running evaluation: 2247it [00:00, 5481.81it/s]\n", + "\n", + "Running evaluation: 2247it [00:00, 4999.89it/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" ] @@ -266,7 +238,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "2cb4abe2", + "id": "d3efc8ff", "metadata": {}, "outputs": [ { diff --git a/template/template.py b/template/template.py index 9cee5e3..2aa356e 100644 --- a/template/template.py +++ b/template/template.py @@ -38,7 +38,7 @@ from gluonts.torch.util import ( ) from gluonts.torch.model.estimator import PyTorchLightningEstimator from gluonts.torch.model.predictor import PyTorchPredictor -from gluonts.torch.modules.distribution_output import ( +from gluonts.torch.distributions import ( DistributionOutput, StudentTOutput, ) @@ -60,11 +60,11 @@ class TransformerModel(nn.Module): cardinality: List[int], embedding_dimension: Optional[List[int]] = None, # Added transformer arguments - encoder = None, - decoder = None, - embeding = None, - target_embed = None , - generator = None, + encoder=None, + decoder=None, + embeding=None, + target_embed=None, + generator=None, ############################# dropout_rate: float = 0.1, distr_output: DistributionOutput = StudentTOutput(), @@ -73,7 +73,7 @@ class TransformerModel(nn.Module): num_parallel_samples: int = 100, ) -> None: super().__init__() - + self.context_length = context_length self.prediction_length = prediction_length self.distr_output = distr_output @@ -98,7 +98,7 @@ class TransformerModel(nn.Module): self.scaler = MeanScaler(dim=1, keepdim=True) else: self.scaler = NOPScaler(dim=1, keepdim=True) - + # Added transformer enc-decoder and mask initializer self.encoder = encoder self.decoder = decoder @@ -106,16 +106,14 @@ class TransformerModel(nn.Module): self.target_embed = target_embed self.generator = generator ######################## - - # TODO # add method that does the forward for training - + """ A build-in Encoder-Decoder architecture for TransformerModel class """ - + def forward(self, src, tgt, mask_source, mask_target): "Take in and process masked sourcerc and target sequences." memory = self.encoder(self.embeding(src), mask_source) @@ -124,12 +122,10 @@ class TransformerModel(nn.Module): def encode(self, src, mask_source): return self.encoder(self.src_embed(src), mask_source) - + def decode(self, memory, mask_source, tgt, mask_target): return self.decoder(self.tgt_embed(tgt), memory, mask_source, mask_target) - - - + @property def _number_of_features(self) -> int: return ( @@ -142,7 +138,7 @@ class TransformerModel(nn.Module): @property def _past_length(self) -> int: return self.context_length + max(self.lags_seq) - + # for prediction def forward( self, @@ -156,8 +152,5 @@ class TransformerModel(nn.Module): ) -> torch.Tensor: if num_parallel_samples is None: num_parallel_samples = self.num_parallel_samples - - # TODO - - \ No newline at end of file + # TODO diff --git a/template/ts-template.ipynb b/template/ts-template.ipynb index 496c2ff..9f24bb7 100644 --- a/template/ts-template.ipynb +++ b/template/ts-template.ipynb @@ -5,7 +5,7 @@ "id": "329d23e6", "metadata": {}, "source": [ - "# PyTorch Transformer Time Series Template\n", + "# PyTorch Transformer for Time Series Implementation\n", "\n", "The estimator consits of the:\n", "\n", @@ -106,7 +106,7 @@ ")\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", + "from gluonts.torch.distributions import (\n", " DistributionOutput,\n", " StudentTOutput,\n", ")\n", @@ -597,7 +597,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/tft/estimator.py b/tft/estimator.py index af86771..c4ac35d 100644 --- a/tft/estimator.py +++ b/tft/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 ( diff --git a/tft/module.py b/tft/module.py index c3d35b7..cfbc111 100644 --- a/tft/module.py +++ b/tft/module.py @@ -4,7 +4,7 @@ import torch import torch.nn as nn from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder as BaseFeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler diff --git a/tft/tft.ipynb b/tft/tft.ipynb index 648bb5e..df29e32 100644 --- a/tft/tft.ipynb +++ b/tft/tft.ipynb @@ -43,12 +43,33 @@ "metadata": {}, "outputs": [], "source": [ - "dataset = get_dataset(\"electricity\")" + "dataset = get_dataset(\"traffic\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "id": "23b40ca1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "TrainDatasets(metadata=MetaData(freq='H', target=None, feat_static_cat=[CategoricalFeatureInfo(name='feat_static_cat', cardinality='862')], feat_static_real=[], feat_dynamic_real=[], feat_dynamic_cat=[], prediction_length=24), train=, test=)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "f9b11457", "metadata": {}, "outputs": [], @@ -57,7 +78,9 @@ " freq=dataset.metadata.freq,\n", " prediction_length=dataset.metadata.prediction_length,\n", " num_feat_static_cat=1,\n", - " cardinality=[321],\n", + " cardinality=[862],\n", + " \n", + " scaling=False,\n", "\n", " batch_size=128,\n", " num_batches_per_epoch=100,\n", @@ -67,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 17, "id": "0dd19bd9", "metadata": {}, "outputs": [ @@ -75,162 +98,97 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/utilities/parsing.py:244: 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:244: 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", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", "TPU available: False, using: 0 TPU cores\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", "IPU available: False, using: 0 IPUs\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:122: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\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", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base = start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed 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/feature.py:343: FutureWarning: Timestamp.freq is deprecated 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/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in 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/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in 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:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " self._freq_base is None or self._freq_base == start.freq.base\n", - "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\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:340: FutureWarning: Timestamp.freq 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 | TFTModel | 104 K \n", + "0 | model | TFTModel | 121 K \n", "1 | loss | NegativeLogLikelihood | 0 \n", "------------------------------------------------\n", - "104 K Trainable params\n", + "121 K Trainable params\n", "0 Non-trainable params\n", - "104 K Total params\n", - "0.417 Total estimated model params size (MB)\n" + "121 K Total params\n", + "0.487 Total estimated model params size (MB)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated 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:384: FutureWarning: Timestamp.freq is deprecated and will be 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:343: FutureWarning: Timestamp.freq is deprecated and will 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/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\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:384: FutureWarning: Timestamp.freq is deprecated and will be 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:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\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" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dc17b4a76a774e88a9453da6a19b79d1", + "model_id": "6cb5a416a013489c9d6937aecaab7d2c", "version_major": 2, "version_minor": 0 }, @@ -245,56 +203,56 @@ "name": "stderr", "output_type": "stream", "text": [ - "Epoch 0, global step 99: train_loss reached 6.38547 (best 6.38547), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=0-step=99.ckpt\" as top 1\n", - "Epoch 1, global step 199: train_loss reached 5.69424 (best 5.69424), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=1-step=199.ckpt\" as top 1\n", - "Epoch 2, global step 299: train_loss reached 5.52260 (best 5.52260), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=2-step=299.ckpt\" as top 1\n", - "Epoch 3, global step 399: train_loss reached 5.43439 (best 5.43439), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=3-step=399.ckpt\" as top 1\n", - "Epoch 4, global step 499: train_loss reached 5.38715 (best 5.38715), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=4-step=499.ckpt\" as top 1\n", - "Epoch 5, global step 599: train_loss reached 5.28788 (best 5.28788), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=5-step=599.ckpt\" as top 1\n", - "Epoch 6, global step 699: train_loss was not in top 1\n", - "Epoch 7, global step 799: train_loss reached 5.27511 (best 5.27511), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=7-step=799.ckpt\" as top 1\n", - "Epoch 8, global step 899: train_loss reached 5.23092 (best 5.23092), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=8-step=899.ckpt\" as top 1\n", - "Epoch 9, global step 999: train_loss was not in top 1\n", - "Epoch 10, global step 1099: train_loss reached 5.21828 (best 5.21828), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=10-step=1099.ckpt\" as top 1\n", - "Epoch 11, global step 1199: train_loss reached 5.18606 (best 5.18606), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=11-step=1199.ckpt\" as top 1\n", - "Epoch 12, global step 1299: train_loss was not in top 1\n", - "Epoch 13, global step 1399: train_loss reached 5.17699 (best 5.17699), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=13-step=1399.ckpt\" as top 1\n", - "Epoch 14, global step 1499: train_loss reached 5.17665 (best 5.17665), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=14-step=1499.ckpt\" as top 1\n", - "Epoch 15, global step 1599: train_loss reached 5.15192 (best 5.15192), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=15-step=1599.ckpt\" as top 1\n", - "Epoch 16, global step 1699: train_loss reached 5.13906 (best 5.13906), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=16-step=1699.ckpt\" as top 1\n", - "Epoch 17, global step 1799: train_loss was not in top 1\n", - "Epoch 18, global step 1899: train_loss reached 5.13224 (best 5.13224), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=18-step=1899.ckpt\" as top 1\n", - "Epoch 19, global step 1999: train_loss was not in top 1\n", - "Epoch 20, global step 2099: train_loss reached 5.09653 (best 5.09653), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=20-step=2099.ckpt\" as top 1\n", - "Epoch 21, global step 2199: train_loss was not in top 1\n", - "Epoch 22, global step 2299: train_loss was not in top 1\n", - "Epoch 23, global step 2399: train_loss was not in top 1\n", - "Epoch 24, global step 2499: train_loss was not in top 1\n", - "Epoch 25, global step 2599: train_loss reached 5.09542 (best 5.09542), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=25-step=2599.ckpt\" as top 1\n", - "Epoch 26, global step 2699: train_loss reached 5.07425 (best 5.07425), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=26-step=2699.ckpt\" as top 1\n", - "Epoch 27, global step 2799: train_loss was not in top 1\n", - "Epoch 28, global step 2899: train_loss was not in top 1\n", - "Epoch 29, global step 2999: train_loss was not in top 1\n", - "Epoch 30, global step 3099: train_loss was not in top 1\n", - "Epoch 31, global step 3199: train_loss was not in top 1\n", - "Epoch 32, global step 3299: train_loss reached 5.06753 (best 5.06753), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=32-step=3299.ckpt\" as top 1\n", - "Epoch 33, global step 3399: train_loss was not in top 1\n", - "Epoch 34, global step 3499: train_loss was not in top 1\n", - "Epoch 35, global step 3599: train_loss reached 5.06716 (best 5.06716), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=35-step=3599.ckpt\" as top 1\n", - "Epoch 36, global step 3699: train_loss reached 5.05435 (best 5.05435), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=36-step=3699.ckpt\" as top 1\n", - "Epoch 37, global step 3799: train_loss was not in top 1\n", - "Epoch 38, global step 3899: train_loss reached 5.03846 (best 5.03846), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=38-step=3899.ckpt\" as top 1\n", - "Epoch 39, global step 3999: train_loss was not in top 1\n", - "Epoch 40, global step 4099: train_loss was not in top 1\n", - "Epoch 41, global step 4199: train_loss was not in top 1\n", - "Epoch 42, global step 4299: train_loss reached 5.03356 (best 5.03356), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=42-step=4299.ckpt\" as top 1\n", - "Epoch 43, global step 4399: train_loss was not in top 1\n", - "Epoch 44, global step 4499: train_loss was not in top 1\n", - "Epoch 45, global step 4599: train_loss was not in top 1\n", - "Epoch 46, global step 4699: train_loss reached 5.03011 (best 5.03011), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=46-step=4699.ckpt\" as top 1\n", - "Epoch 47, global step 4799: train_loss was not in top 1\n", - "Epoch 48, global step 4899: train_loss was not in top 1\n", - "Epoch 49, global step 4999: train_loss reached 5.01233 (best 5.01233), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_38/checkpoints/epoch=49-step=4999.ckpt\" as top 1\n" + "Epoch 0, global step 100: 'train_loss' reached -1.76367 (best -1.76367), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=0-step=100.ckpt' as top 1\n", + "Epoch 1, global step 200: 'train_loss' reached -2.67806 (best -2.67806), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=1-step=200.ckpt' as top 1\n", + "Epoch 2, global step 300: 'train_loss' reached -2.82263 (best -2.82263), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=2-step=300.ckpt' as top 1\n", + "Epoch 3, global step 400: 'train_loss' reached -2.91125 (best -2.91125), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=3-step=400.ckpt' as top 1\n", + "Epoch 4, global step 500: 'train_loss' reached -3.00680 (best -3.00680), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=4-step=500.ckpt' as top 1\n", + "Epoch 5, global step 600: 'train_loss' reached -3.03799 (best -3.03799), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=5-step=600.ckpt' as top 1\n", + "Epoch 6, global step 700: 'train_loss' reached -3.08277 (best -3.08277), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=6-step=700.ckpt' as top 1\n", + "Epoch 7, global step 800: 'train_loss' reached -3.11023 (best -3.11023), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=7-step=800.ckpt' as top 1\n", + "Epoch 8, global step 900: 'train_loss' reached -3.15504 (best -3.15504), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=8-step=900.ckpt' as top 1\n", + "Epoch 9, global step 1000: 'train_loss' reached -3.19840 (best -3.19840), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=9-step=1000.ckpt' as top 1\n", + "Epoch 10, global step 1100: 'train_loss' reached -3.23382 (best -3.23382), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=10-step=1100.ckpt' as top 1\n", + "Epoch 11, global step 1200: 'train_loss' reached -3.26279 (best -3.26279), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=11-step=1200.ckpt' as top 1\n", + "Epoch 12, global step 1300: 'train_loss' reached -3.29968 (best -3.29968), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=12-step=1300.ckpt' as top 1\n", + "Epoch 13, global step 1400: 'train_loss' was not in top 1\n", + "Epoch 14, global step 1500: 'train_loss' reached -3.37084 (best -3.37084), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=14-step=1500.ckpt' as top 1\n", + "Epoch 15, global step 1600: 'train_loss' was not in top 1\n", + "Epoch 16, global step 1700: 'train_loss' was not in top 1\n", + "Epoch 17, global step 1800: 'train_loss' reached -3.45659 (best -3.45659), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=17-step=1800.ckpt' as top 1\n", + "Epoch 18, global step 1900: 'train_loss' reached -3.47860 (best -3.47860), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=18-step=1900.ckpt' as top 1\n", + "Epoch 19, global step 2000: 'train_loss' reached -3.48826 (best -3.48826), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=19-step=2000.ckpt' as top 1\n", + "Epoch 20, global step 2100: 'train_loss' reached -3.51585 (best -3.51585), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=20-step=2100.ckpt' as top 1\n", + "Epoch 21, global step 2200: 'train_loss' reached -3.53465 (best -3.53465), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=21-step=2200.ckpt' as top 1\n", + "Epoch 22, global step 2300: 'train_loss' was not in top 1\n", + "Epoch 23, global step 2400: 'train_loss' was not in top 1\n", + "Epoch 24, global step 2500: 'train_loss' was not in top 1\n", + "Epoch 25, global step 2600: 'train_loss' reached -3.57969 (best -3.57969), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=25-step=2600.ckpt' as top 1\n", + "Epoch 26, global step 2700: 'train_loss' was not in top 1\n", + "Epoch 27, global step 2800: 'train_loss' reached -3.61853 (best -3.61853), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/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' reached -3.63641 (best -3.63641), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=30-step=3100.ckpt' as top 1\n", + "Epoch 31, global step 3200: 'train_loss' was not in top 1\n", + "Epoch 32, global step 3300: 'train_loss' reached -3.65598 (best -3.65598), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/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' reached -3.66342 (best -3.66342), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=35-step=3600.ckpt' as top 1\n", + "Epoch 36, global step 3700: 'train_loss' was not in top 1\n", + "Epoch 37, global step 3800: 'train_loss' reached -3.67218 (best -3.67218), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=37-step=3800.ckpt' as top 1\n", + "Epoch 38, global step 3900: 'train_loss' was not in top 1\n", + "Epoch 39, global step 4000: 'train_loss' reached -3.69459 (best -3.69459), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=39-step=4000.ckpt' as top 1\n", + "Epoch 40, global step 4100: 'train_loss' reached -3.69594 (best -3.69594), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=40-step=4100.ckpt' as top 1\n", + "Epoch 41, global step 4200: 'train_loss' reached -3.70282 (best -3.70282), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/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 -3.71828 (best -3.71828), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=43-step=4400.ckpt' as top 1\n", + "Epoch 44, global step 4500: 'train_loss' reached -3.71923 (best -3.71923), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=44-step=4500.ckpt' as top 1\n", + "Epoch 45, global step 4600: 'train_loss' was not in top 1\n", + "Epoch 46, global step 4700: 'train_loss' reached -3.72760 (best -3.72760), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=46-step=4700.ckpt' as top 1\n", + "Epoch 47, global step 4800: 'train_loss' reached -3.73313 (best -3.73313), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/tft/lightning_logs/version_40/checkpoints/epoch=47-step=4800.ckpt' as 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" ] } ], @@ -308,7 +266,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 18, "id": "47aef4a1", "metadata": {}, "outputs": [], @@ -321,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 19, "id": "148ba412", "metadata": {}, "outputs": [ @@ -329,14 +287,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " if isinstance(timestamp.freq, Tick):\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", - " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " return pd.Timestamp(\n", "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated 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", @@ -354,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "3ba0d994", "metadata": {}, "outputs": [], @@ -364,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 20, "id": "94b1eba7", "metadata": {}, "outputs": [], @@ -374,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 21, "id": "04223b08", "metadata": {}, "outputs": [ @@ -382,7 +332,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "Running evaluation: 2247it [00:00, 5399.22it/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: 6034it [00:00, 10921.04it/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", @@ -409,12 +365,6 @@ " 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" ] @@ -426,59 +376,59 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "af60a764", + "execution_count": 22, + "id": "0b10e846", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'MSE': 2288155.4595733206,\n", - " 'abs_error': 8677549.890345097,\n", - " 'abs_target_sum': 128632956.0,\n", - " 'abs_target_mean': 2385.272140631954,\n", - " 'seasonal_error': 189.49338196116761,\n", - " 'MASE': 0.7392301619000542,\n", - " 'MAPE': 0.0942166421951502,\n", - " 'sMAPE': 0.10727499540855988,\n", - " 'MSIS': 5.90130373159719,\n", - " 'QuantileLoss[0.1]': 3652603.570823352,\n", - " 'Coverage[0.1]': 0.09373609256786827,\n", - " 'QuantileLoss[0.2]': 5729977.868776519,\n", - " 'Coverage[0.2]': 0.21504598724224894,\n", - " 'QuantileLoss[0.3]': 7170568.846287252,\n", - " 'Coverage[0.3]': 0.342215546654799,\n", - " 'QuantileLoss[0.4]': 8147483.8875474585,\n", - " 'Coverage[0.4]': 0.46387776294318356,\n", - " 'QuantileLoss[0.5]': 8677549.828375284,\n", - " 'Coverage[0.5]': 0.5856697819314641,\n", - " 'QuantileLoss[0.6]': 8664060.21840468,\n", - " 'Coverage[0.6]': 0.6839860554813825,\n", - " 'QuantileLoss[0.7]': 8038668.19911083,\n", - " 'Coverage[0.7]': 0.7789645453196856,\n", - " 'QuantileLoss[0.8]': 6666073.66160029,\n", - " 'Coverage[0.8]': 0.8620753597389113,\n", - " 'QuantileLoss[0.9]': 4274899.861139778,\n", - " 'Coverage[0.9]': 0.9331886960391633,\n", - " 'RMSE': 1512.6650189560544,\n", - " 'NRMSE': 0.634168736216107,\n", - " 'ND': 0.06745977205363372,\n", - " 'wQuantileLoss[0.1]': 0.028395550288243022,\n", - " 'wQuantileLoss[0.2]': 0.04454517758867734,\n", - " 'wQuantileLoss[0.3]': 0.055744414722827734,\n", - " 'wQuantileLoss[0.4]': 0.06333900845400349,\n", - " 'wQuantileLoss[0.5]': 0.06745977157187684,\n", - " 'wQuantileLoss[0.6]': 0.06735490256792886,\n", - " 'wQuantileLoss[0.7]': 0.062493069032098045,\n", - " 'wQuantileLoss[0.8]': 0.0518224401342397,\n", - " 'wQuantileLoss[0.9]': 0.033233317448910824,\n", - " 'mean_absolute_QuantileLoss': 6780209.549118383,\n", - " 'mean_wQuantileLoss': 0.05270973908986732,\n", - " 'MAE_Coverage': 0.05236529364255222,\n", + "{'MSE': 0.000649330164079505,\n", + " 'abs_error': 1432.974686332047,\n", + " 'abs_target_sum': 8672.5710073933,\n", + " 'abs_target_mean': 0.0598868288545002,\n", + " 'seasonal_error': 0.015220711169889631,\n", + " 'MASE': 0.648407474736938,\n", + " 'MAPE': 0.2660992923204324,\n", + " 'sMAPE': 0.2139038286564818,\n", + " 'MSIS': 7.822711779756906,\n", + " 'QuantileLoss[0.1]': 758.046953115314,\n", + " 'Coverage[0.1]': 0.035451883769749205,\n", + " 'QuantileLoss[0.2]': 1091.1472629882426,\n", + " 'Coverage[0.2]': 0.07841674953043862,\n", + " 'QuantileLoss[0.3]': 1288.6517700438721,\n", + " 'Coverage[0.3]': 0.1443072588664236,\n", + " 'QuantileLoss[0.4]': 1394.0904395095831,\n", + " 'Coverage[0.4]': 0.23985609324936472,\n", + " 'QuantileLoss[0.5]': 1432.9746841261403,\n", + " 'Coverage[0.5]': 0.366036901999779,\n", + " 'QuantileLoss[0.6]': 1426.1454076143127,\n", + " 'Coverage[0.6]': 0.49707905203844877,\n", + " 'QuantileLoss[0.7]': 1358.4131771848538,\n", + " 'Coverage[0.7]': 0.6520481162302508,\n", + " 'QuantileLoss[0.8]': 1218.5885981488536,\n", + " 'Coverage[0.8]': 0.8036611976577173,\n", + " 'QuantileLoss[0.9]': 944.6292773525245,\n", + " 'Coverage[0.9]': 0.9196428571428571,\n", + " 'RMSE': 0.02548195761866629,\n", + " 'NRMSE': 0.4255018692102854,\n", + " 'ND': 0.16523066632841021,\n", + " 'wQuantileLoss[0.1]': 0.08740740807646137,\n", + " 'wQuantileLoss[0.2]': 0.12581589266413015,\n", + " 'wQuantileLoss[0.3]': 0.14858935936590273,\n", + " 'wQuantileLoss[0.4]': 0.16074707699955776,\n", + " 'wQuantileLoss[0.5]': 0.16523066607405582,\n", + " 'wQuantileLoss[0.6]': 0.16444320910126128,\n", + " 'wQuantileLoss[0.7]': 0.1566332724202335,\n", + " 'wQuantileLoss[0.8]': 0.14051065100649118,\n", + " 'wQuantileLoss[0.9]': 0.10892148090194191,\n", + " 'mean_absolute_QuantileLoss': 1212.5208411204105,\n", + " 'mean_wQuantileLoss': 0.1398110018455595,\n", + " 'MAE_Coverage': 0.09001199990179105,\n", " 'OWA': nan}" ] }, - "execution_count": 11, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -489,13 +439,76 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, + "id": "af60a764", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 0.0008602817230717296,\n", + " 'abs_error': 1617.4472325854003,\n", + " 'abs_target_sum': 8672.5710073933,\n", + " 'abs_target_mean': 0.0598868288545002,\n", + " 'seasonal_error': 0.015220711169889631,\n", + " 'MASE': 0.7225524827690298,\n", + " 'MAPE': 0.21059109221974529,\n", + " 'sMAPE': 0.17548061777599777,\n", + " 'MSIS': 7.981380574607891,\n", + " 'QuantileLoss[0.1]': 798.1957122146287,\n", + " 'Coverage[0.1]': 0.05049856369461938,\n", + " 'QuantileLoss[0.2]': 1163.7939581929065,\n", + " 'Coverage[0.2]': 0.1206703679151475,\n", + " 'QuantileLoss[0.3]': 1394.4469597546472,\n", + " 'Coverage[0.3]': 0.19998480830847423,\n", + " 'QuantileLoss[0.4]': 1541.6169008201734,\n", + " 'Coverage[0.4]': 0.2855209369130483,\n", + " 'QuantileLoss[0.5]': 1617.447230679832,\n", + " 'Coverage[0.5]': 0.37727184841453987,\n", + " 'QuantileLoss[0.6]': 1641.2588065576676,\n", + " 'Coverage[0.6]': 0.46351922439509446,\n", + " 'QuantileLoss[0.7]': 1565.8052165220274,\n", + " 'Coverage[0.7]': 0.5644956358413434,\n", + " 'QuantileLoss[0.8]': 1386.698439198728,\n", + " 'Coverage[0.8]': 0.6784195116561705,\n", + " 'QuantileLoss[0.9]': 1048.4756686581238,\n", + " 'Coverage[0.9]': 0.8173613412882555,\n", + " 'RMSE': 0.029330559542424854,\n", + " 'NRMSE': 0.489766449542449,\n", + " 'ND': 0.1865014689653782,\n", + " 'wQuantileLoss[0.1]': 0.09203680333480958,\n", + " 'wQuantileLoss[0.2]': 0.13419249691940038,\n", + " 'wQuantileLoss[0.3]': 0.16078818594461686,\n", + " 'wQuantileLoss[0.4]': 0.17775777211924315,\n", + " 'wQuantileLoss[0.5]': 0.18650146874565462,\n", + " 'wQuantileLoss[0.6]': 0.18924708776192287,\n", + " 'wQuantileLoss[0.7]': 0.18054683152057105,\n", + " 'wQuantileLoss[0.8]': 0.15989473456217057,\n", + " 'wQuantileLoss[0.9]': 0.12089559921323288,\n", + " 'mean_absolute_QuantileLoss': 1350.859876955415,\n", + " 'mean_wQuantileLoss': 0.15576233112462465,\n", + " 'MAE_Coverage': 0.10469530684147853,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "id": "c1914674", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -517,6 +530,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", diff --git a/transformer/estimator.py b/transformer/estimator.py index 2f5c95d..0dfddff 100644 --- a/transformer/estimator.py +++ b/transformer/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 ( diff --git a/transformer/module.py b/transformer/module.py index 5349268..dec6837 100644 --- a/transformer/module.py +++ b/transformer/module.py @@ -4,7 +4,7 @@ import torch import torch.nn as nn from gluonts.core.component import validated from gluonts.time_feature import get_lags_for_frequency -from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput +from gluonts.torch.distributions import DistributionOutput, StudentTOutput from gluonts.torch.modules.feature import FeatureEmbedder from gluonts.torch.modules.scaler import MeanScaler, NOPScaler diff --git a/xformers/xformers.ipynb b/xformers/xformers.ipynb index a5b3d16..eea8dff 100644 --- a/xformers/xformers.ipynb +++ b/xformers/xformers.ipynb @@ -1,1734 +1,1580 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "1e85a78b", - "metadata": {}, - "outputs": [], - "source": [ - "#!pip install -U gluonts pytorch-lightning torch" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "855dbf2e", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8dc0844c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "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", - "import queue\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", - "from datasets import load_dataset\n", - "\n", - "import torch\n", - "import torch.nn as nn\n", - "from torch.utils.data import DataLoader\n", - "from torch.optim.lr_scheduler import _LRScheduler, MultiplicativeLR\n", - "from torch.optim import Optimizer\n", - "\n", - "from xformers.factory.model_factory import xFormer, xFormerConfig\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, ListDataset\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", - ")\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.distributions.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": 4, - "id": "b8af6d90", - "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", - " attention_args: Dict[str, Any],\n", - " activation: str = \"gelu\",\n", - " dropout: float = 0.1,\n", - " reversible: bool = False,\n", - " hidden_layer_multiplier: int = 2,\n", - " use_rotary_embeddings: bool = False,\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 = 1,\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", - " attention_args[\"dropout\"] = dropout\n", - " attention_args[\"causal\"] = False\n", - " attention_args[\"seq_len\"] = self.context_length\n", - " attention_args[\"num_rules\"] = nhead\n", - "\n", - " xformer_config = [\n", - " # A list of the encoder blocks which constitute the Transformer.\n", - " # Note that a sequence of different encoder blocks can be used\n", - " {\n", - " \"reversible\": reversible, # Optionally make these layers reversible, to save memory\n", - " \"block_type\": \"encoder\",\n", - " \"num_layers\": num_encoder_layers, # Optional, this means that this config will repeat N times\n", - " \"dim_model\": d_model,\n", - " \"layer_norm_style\": \"pre\", # Optional, pre/post\n", - " \"position_encoding_config\": {\n", - " \"name\": \"sine\",\n", - " \"dim_model\": d_model,\n", - " },\n", - " \"multi_head_config\": {\n", - " \"use_rotary_embeddings\": use_rotary_embeddings,\n", - " \"num_heads\": nhead,\n", - " \"residual_dropout\": dropout,\n", - " \"attention\": attention_args,\n", - " },\n", - " \"feedforward_config\": {\n", - " \"name\": \"MLP\",\n", - " \"dropout\": dropout,\n", - " \"activation\": activation,\n", - " \"hidden_layer_multiplier\": hidden_layer_multiplier,\n", - " \"dim_model\": d_model,\n", - " },\n", - " },\n", - " ]\n", - " config = xFormerConfig(xformer_config)\n", - " # xformer encoder\n", - " self.encoder = xFormer.from_config(config)\n", - " \n", - " # causal vanilla transformer decoder\n", - " decoder_layer = nn.TransformerDecoderLayer(\n", - " d_model, \n", - " nhead, \n", - " dim_feedforward=d_model*hidden_layer_multiplier, \n", - " dropout=dropout,\n", - " activation=activation, \n", - " layer_norm_eps=1e-5, \n", - " batch_first=True, \n", - " norm_first=False,\n", - " )\n", - " decoder_norm = nn.LayerNorm(d_model, eps=1e-5)\n", - " self.decoder = nn.TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm)\n", - " \n", - " # causal decoder tgt mask for training\n", - " self.register_buffer(\n", - " \"tgt_mask\",\n", - " nn.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", - " \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", - " past_time_feat[:, self._past_length - self.context_length :, ...]\n", - " if future_time_feat is None or future_target is None\n", - " else torch.cat(\n", - " (\n", - " past_time_feat[:, self._past_length - self.context_length :, ...],\n", - " future_time_feat,\n", - " ),\n", - " dim=1,\n", - " )\n", - " )\n", - "\n", - " # target\n", - " context = past_target[:, -self.context_length :]\n", - " observed_context = past_observed_values[:, -self.context_length :] \n", - " # weights = torch.linspace(0.0001, 1, steps=observed_context.size(-1), device=observed_context.device)\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\n", - " if future_time_feat is None or future_target is None\n", - " else self.context_length + self.prediction_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", - " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", - " \n", - " #self._check_shapes(prior_input, inputs, features)\n", - " #sequence = torch.cat((prior_input, inputs), dim=1)\n", - "\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", - " if features is None:\n", - " transformer_inputs = reshaped_lagged_sequence\n", - " else:\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.encoder(src=enc_input)\n", - " dec_output = self.decoder(dec_input, enc_out, tgt_mask=self.tgt_mask)\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", - " 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", - " future_time_feat,\n", - " )\n", - " \n", - " enc_out = self.encoder(src=encoder_inputs)\n", - " \n", - " params = self.param_proj(enc_out)\n", - " distr = self.output_distribution(params, trailing_n=1)\n", - " \n", - " repeated_scale = scale.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - " repeated_static_feat = static_feat.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " ).unsqueeze(dim=1)\n", - " repeated_past_target = (\n", - " past_target.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - " / repeated_scale\n", - " )\n", - " repeated_time_feat = future_time_feat.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - " repeated_enc_out = enc_out.repeat_interleave(\n", - " repeats=self.num_parallel_samples, dim=0\n", - " )\n", - "\n", - " future_samples = []\n", - " \n", - " for k in range(self.prediction_length):\n", - " next_features = torch.cat(\n", - " (repeated_static_feat, repeated_time_feat[:, k : k + 1]),\n", - " dim=-1,\n", - " )\n", - " \n", - " lagged_sequence = self.get_lagged_subsequences(\n", - " sequence=repeated_past_target,\n", - " subsequences_length=1,\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, next_features), dim=-1)\n", - "\n", - " output = self.decoder(decoder_input, repeated_enc_out)\n", - " \n", - " params = self.param_proj(output)\n", - " distr = self.output_distribution(params)\n", - " next_sample = distr.sample()\n", - " \n", - " repeated_past_target = torch.cat(\n", - " (repeated_past_target, next_sample), dim=1\n", - " )\n", - " future_samples.append(next_sample)\n", - "\n", - " unscaled_future_samples = (\n", - " torch.cat(future_samples, dim=1) * repeated_scale\n", - " )\n", - " return unscaled_future_samples.reshape(\n", - " (-1, self.num_parallel_samples, self.prediction_length)\n", - " + self.target_shape,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "9b1529a8", - "metadata": {}, - "outputs": [], - "source": [ - "class TransformerLightningModule(pl.LightningModule):\n", - " def __init__(\n", - " self,\n", - " model: TransformerModel,\n", - " loss: DistributionLoss = NegativeLogLikelihood(),\n", - " lr: float = 5e-3,\n", - " weight_decay: float = 1e-6,\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.no_grad():\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": 16, - "id": "f7b4c72f", - "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": 17, - "id": "1937891a", - "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", - " attention_args = {\"name\": \"scaled_dot_product\"},\n", - " input_size: int = 1,\n", - " activation: str = \"gelu\",\n", - " dropout: float = 0.1,\n", - " use_rotary_embeddings = False,\n", - " reversible = False,\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", - " ) -> 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.dropout = dropout\n", - " self.attention_args = attention_args\n", - " self.use_rotary_embeddings = use_rotary_embeddings\n", - " self.reversible = reversible\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 = ExpectedNumInstanceSampler(\n", - " num_instances=1.0, min_future=prediction_length\n", - " )\n", - " self.validation_sampler = 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=np.long,\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", - " attention_args=self.attention_args,\n", - " use_rotary_embeddings=self.use_rotary_embeddings,\n", - " reversible=self.reversible,\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": 8, - "id": "7c8e5928", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:datasets.builder:Reusing dataset electricity_load_diagrams (/home/kashif/.cache/huggingface/datasets/electricity_load_diagrams/lstnet/1.0.0/fe3dd01c39428ad92523a7ced0df3fdf669cb0548b3dd16fb9f7009381aa440f)\n" - ] + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1e85a78b", + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install -U gluonts pytorch-lightning torch" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "855dbf2e", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8dc0844c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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", + "import queue\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", + "from datasets import load_dataset\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import DataLoader\n", + "from torch.optim.lr_scheduler import _LRScheduler, MultiplicativeLR\n", + "from torch.optim import Optimizer\n", + "\n", + "from xformers.factory.model_factory import xFormer, xFormerConfig\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, ListDataset\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", + ")\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.distributions 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": 38, + "id": "b8af6d90", + "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", + " attention_args: Dict[str, Any],\n", + " activation: str = \"gelu\",\n", + " dropout: float = 0.1,\n", + " reversible: bool = False,\n", + " hidden_layer_multiplier: int = 2,\n", + " use_rotary_embeddings: bool = False,\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 = 1,\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", + " attention_args[\"dropout\"] = dropout\n", + " attention_args[\"causal\"] = False\n", + " attention_args[\"seq_len\"] = self.context_length\n", + " attention_args[\"num_rules\"] = nhead\n", + " attention_args[\"attention_query_mask\"] = (torch.rand((context_length, 1)) < 0.5)\n", + " \n", + " \n", + " xformer_config = [\n", + " # A list of the encoder blocks which constitute the Transformer.\n", + " # Note that a sequence of different encoder blocks can be used\n", + " {\n", + " \"reversible\": reversible, # Optionally make these layers reversible, to save memory\n", + " \"block_type\": \"encoder\",\n", + " \"num_layers\": num_encoder_layers, # Optional, this means that this config will repeat N times\n", + " \"dim_model\": d_model,\n", + " \"layer_norm_style\": \"pre\", # Optional, pre/post\n", + " \"position_encoding_config\": {\n", + " \"name\": \"sine\",\n", + " \"dim_model\": d_model,\n", + " },\n", + " \"multi_head_config\": {\n", + " \"use_rotary_embeddings\": use_rotary_embeddings,\n", + " \"num_heads\": nhead,\n", + " \"residual_dropout\": dropout,\n", + " \"attention\": attention_args,\n", + " },\n", + " \"feedforward_config\": {\n", + " \"name\": \"MLP\",\n", + " \"dropout\": dropout,\n", + " \"activation\": activation,\n", + " \"hidden_layer_multiplier\": hidden_layer_multiplier,\n", + " \"dim_model\": d_model,\n", + " },\n", + " },\n", + " ]\n", + " config = xFormerConfig(xformer_config)\n", + " # xformer encoder\n", + " self.encoder = xFormer.from_config(config)\n", + " \n", + " # causal vanilla transformer decoder\n", + " decoder_layer = nn.TransformerDecoderLayer(\n", + " d_model, \n", + " nhead, \n", + " dim_feedforward=d_model*hidden_layer_multiplier, \n", + " dropout=dropout,\n", + " activation=activation, \n", + " layer_norm_eps=1e-5, \n", + " batch_first=True, \n", + " norm_first=False,\n", + " )\n", + " decoder_norm = nn.LayerNorm(d_model, eps=1e-5)\n", + " self.decoder = nn.TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm)\n", + " \n", + " # causal decoder tgt mask for training\n", + " self.register_buffer(\n", + " \"tgt_mask\",\n", + " nn.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", + " \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", + " past_time_feat[:, self._past_length - self.context_length :, ...]\n", + " if future_time_feat is None or future_target is None\n", + " else torch.cat(\n", + " (\n", + " past_time_feat[:, self._past_length - self.context_length :, ...],\n", + " future_time_feat,\n", + " ),\n", + " dim=1,\n", + " )\n", + " )\n", + "\n", + " # target\n", + " context = past_target[:, -self.context_length :]\n", + " observed_context = past_observed_values[:, -self.context_length :] \n", + " # weights = torch.linspace(0.0001, 1, steps=observed_context.size(-1), device=observed_context.device)\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\n", + " if future_time_feat is None or future_target is None\n", + " else self.context_length + self.prediction_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", + " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", + " \n", + " #self._check_shapes(prior_input, inputs, features)\n", + " #sequence = torch.cat((prior_input, inputs), dim=1)\n", + "\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", + " if features is None:\n", + " transformer_inputs = reshaped_lagged_sequence\n", + " else:\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.encoder(src=enc_input)\n", + " dec_output = self.decoder(dec_input, enc_out, tgt_mask=self.tgt_mask)\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", + " 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", + " future_time_feat,\n", + " )\n", + " \n", + " enc_out = self.encoder(src=encoder_inputs)\n", + " \n", + " params = self.param_proj(enc_out)\n", + " distr = self.output_distribution(params, trailing_n=1)\n", + " \n", + " repeated_scale = scale.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + " repeated_static_feat = static_feat.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " ).unsqueeze(dim=1)\n", + " repeated_past_target = (\n", + " past_target.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + " / repeated_scale\n", + " )\n", + " repeated_time_feat = future_time_feat.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + " repeated_enc_out = enc_out.repeat_interleave(\n", + " repeats=self.num_parallel_samples, dim=0\n", + " )\n", + "\n", + " future_samples = []\n", + " \n", + " for k in range(self.prediction_length):\n", + " next_features = torch.cat(\n", + " (repeated_static_feat, repeated_time_feat[:, k : k + 1]),\n", + " dim=-1,\n", + " )\n", + " \n", + " lagged_sequence = self.get_lagged_subsequences(\n", + " sequence=repeated_past_target,\n", + " subsequences_length=1,\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, next_features), dim=-1)\n", + "\n", + " output = self.decoder(decoder_input, repeated_enc_out)\n", + " \n", + " params = self.param_proj(output)\n", + " distr = self.output_distribution(params)\n", + " next_sample = distr.sample()\n", + " \n", + " repeated_past_target = torch.cat(\n", + " (repeated_past_target, next_sample), dim=1\n", + " )\n", + " future_samples.append(next_sample)\n", + "\n", + " unscaled_future_samples = (\n", + " torch.cat(future_samples, dim=1) * repeated_scale\n", + " )\n", + " return unscaled_future_samples.reshape(\n", + " (-1, self.num_parallel_samples, self.prediction_length)\n", + " + self.target_shape,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "9b1529a8", + "metadata": {}, + "outputs": [], + "source": [ + "class TransformerLightningModule(pl.LightningModule):\n", + " def __init__(\n", + " self,\n", + " model: TransformerModel,\n", + " loss: DistributionLoss = NegativeLogLikelihood(),\n", + " lr: float = 5e-3,\n", + " weight_decay: float = 1e-6,\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.no_grad():\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": 40, + "id": "f7b4c72f", + "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": 41, + "id": "1937891a", + "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", + " attention_args = {\"name\": \"scaled_dot_product\"},\n", + " input_size: int = 1,\n", + " activation: str = \"gelu\",\n", + " dropout: float = 0.1,\n", + " use_rotary_embeddings = False,\n", + " reversible = False,\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", + " ) -> 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.dropout = dropout\n", + " self.attention_args = attention_args\n", + " self.use_rotary_embeddings = use_rotary_embeddings\n", + " self.reversible = reversible\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 = ExpectedNumInstanceSampler(\n", + " num_instances=1.0, min_future=prediction_length\n", + " )\n", + " self.validation_sampler = 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=np.long,\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", + " attention_args=self.attention_args,\n", + " use_rotary_embeddings=self.use_rotary_embeddings,\n", + " reversible=self.reversible,\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": "7c8e5928", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4fa53b2d063447c7a5d0bd13f863b494", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading builder script: 0%| | 0.00/2.36k [00:00\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, (forecast, ts) \u001b[38;5;129;01min\u001b[39;00m islice(\u001b[38;5;28menumerate\u001b[39m(\u001b[38;5;28mzip\u001b[39m(forecasts, tss)), \u001b[38;5;241m9\u001b[39m):\n\u001b[1;32m 6\u001b[0m ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplot(\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m, idx\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m plt\u001b[38;5;241m.\u001b[39mplot(ts[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m4\u001b[39m \u001b[38;5;241m*\u001b[39m prediction_length:], label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtarget\u001b[39m\u001b[38;5;124m\"\u001b[39m, )\n\u001b[1;32m 9\u001b[0m forecast\u001b[38;5;241m.\u001b[39mplot( color\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mg\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 10\u001b[0m plt\u001b[38;5;241m.\u001b[39mxticks(rotation\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m60\u001b[39m)\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/pyplot.py:2769\u001b[0m, in \u001b[0;36mplot\u001b[0;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2767\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mplot)\n\u001b[1;32m 2768\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplot\u001b[39m(\u001b[38;5;241m*\u001b[39margs, scalex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, scaley\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m-> 2769\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2770\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscalex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscalex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscaley\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscaley\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2771\u001b[0m \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[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\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\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/axes/_axes.py:1634\u001b[0m, in \u001b[0;36mAxes.plot\u001b[0;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1632\u001b[0m lines \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_lines(\u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39mdata, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)]\n\u001b[1;32m 1633\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[0;32m-> 1634\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madd_line\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1635\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_request_autoscale_view(scalex\u001b[38;5;241m=\u001b[39mscalex, scaley\u001b[38;5;241m=\u001b[39mscaley)\n\u001b[1;32m 1636\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m lines\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/axes/_base.py:2288\u001b[0m, in \u001b[0;36m_AxesBase.add_line\u001b[0;34m(self, line)\u001b[0m\n\u001b[1;32m 2285\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m line\u001b[38;5;241m.\u001b[39mget_clip_path() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 2286\u001b[0m line\u001b[38;5;241m.\u001b[39mset_clip_path(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpatch)\n\u001b[0;32m-> 2288\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_line_limits\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2289\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m line\u001b[38;5;241m.\u001b[39mget_label():\n\u001b[1;32m 2290\u001b[0m line\u001b[38;5;241m.\u001b[39mset_label(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_child\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_children)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/axes/_base.py:2311\u001b[0m, in \u001b[0;36m_AxesBase._update_line_limits\u001b[0;34m(self, line)\u001b[0m\n\u001b[1;32m 2307\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_update_line_limits\u001b[39m(\u001b[38;5;28mself\u001b[39m, line):\n\u001b[1;32m 2308\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 2309\u001b[0m \u001b[38;5;124;03m Figures out the data limit of the given line, updating self.dataLim.\u001b[39;00m\n\u001b[1;32m 2310\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 2311\u001b[0m path \u001b[38;5;241m=\u001b[39m \u001b[43mline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_path\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2312\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m path\u001b[38;5;241m.\u001b[39mvertices\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 2313\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/lines.py:999\u001b[0m, in \u001b[0;36mLine2D.get_path\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 997\u001b[0m \u001b[38;5;124;03m\"\"\"Return the `~matplotlib.path.Path` associated with this line.\"\"\"\u001b[39;00m\n\u001b[1;32m 998\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_invalidy \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_invalidx:\n\u001b[0;32m--> 999\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrecache\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1000\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_path\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/lines.py:652\u001b[0m, in \u001b[0;36mLine2D.recache\u001b[0;34m(self, always)\u001b[0m\n\u001b[1;32m 650\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m always \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_invalidx:\n\u001b[1;32m 651\u001b[0m xconv \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconvert_xunits(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_xorig)\n\u001b[0;32m--> 652\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[43m_to_unmasked_float_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43mxconv\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mravel()\n\u001b[1;32m 653\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 654\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_x\n", + "File \u001b[0;32m~/.env/pytorch/lib/python3.8/site-packages/matplotlib/cbook/__init__.py:1298\u001b[0m, in \u001b[0;36m_to_unmasked_float_array\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 1296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39mma\u001b[38;5;241m.\u001b[39masarray(x, \u001b[38;5;28mfloat\u001b[39m)\u001b[38;5;241m.\u001b[39mfilled(np\u001b[38;5;241m.\u001b[39mnan)\n\u001b[1;32m 1297\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1298\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43masarray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: float() argument must be a string or a number, not 'Period'" + ] + }, + { + "data": { + "image/png": "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", + "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 * 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": 61, + "id": "59b42f21", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_prob_forecasts(ts_entry, forecast_entry):\n", + " plot_length = 100\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=\"upper left\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "35eda4db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index = 33\n", + "plot_prob_forecasts(tss[index], forecasts[index])" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "a1f978b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index = 33\n", + "plot_prob_forecasts(tss[index], forecasts[index])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cbc599e9", + "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" + } }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d0866a0a68c44da8b472b5dd17914bea", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/3 [00:00" - ] - }, - "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 * 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": 29, - "id": "59b42f21", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_prob_forecasts(ts_entry, forecast_entry):\n", - " plot_length = 100\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=\"upper left\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "id": "35eda4db", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAHCCAYAAABIV3WoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydeZgU5dW376f36dlnYBgYQEB2UFGJS0QdREQUFU0EYhZ91fjF15gYoygRI6ivMdEkGpe4JaLZFA3gvscxUYkouMsiyr7MMEzP2nvV8/1RXT3d0/us3TN1XxeXTtVT1dXV1V2/Ouc8vyOklBgYGBgYGBgYGPQepr4+AAMDAwMDAwODgYYhwAwMDAwMDAwMehlDgBkYGBgYGBgY9DKGADMwMDAwMDAw6GUMAWZgYGBgYGBg0MsYAszAwMDAwMDAoJex9PUBZEJJSYkcO3ZsXx9Gt9DW1kZ+fn5fH4ZBFmJcGwaJMK4Ng0QY10Z2sn79+nop5eB463JKgA0ZMoQPPvigrw+jW6ipqaG6urqvD8MgCzGuDYNEGNeGQSKMayM7EULsSLTOSEEaGBgYGBgYGPQyhgAzMDAwMDAwMOhlDAFmYGBgYGBgYNDLGALMwMDAwMDAwKCXMQSYgYGBgYGBgUEvYwgwAwMDAwMDA4NeJqdsKFLR3NxMXV0dgUCgrw8lJcXFxWzcuLGvD8MgCxno14bVaqWiooKioqK+PhQDAwODHqPfCLDm5mZqa2upqqoiLy8PIURfH1JSWlpaKCws7OvDMMhCBvK1IaXE4/GwZ88eAEOEGRgY9Fv6TQqyrq6OqqoqnE5n1osvAwOD+AghcDqdVFVVUVdX19eHY2BgYNBj9BsBFggEyMvL6+vDMDAw6Aby8vJyopTAwMDAoLP0GwEGGJEvA4N+gvFdNjAw6O/0KwFmYGBgYGBgYJALGAIsx1ixYgVCCFpbW/v6ULrMli1bWLZsGY2NjVHL+9N7NDAwMDAwiIchwAz6jC1btrB8+fIYAXbmmWeydu1anE5n3xyYgYGBgYFBD9NvbCgMeh5FUVAUBZvN1qOvM3jwYAYPHtyjr2FgYGBgYNCXGBGwLGTlypUcdthh2O12RowYwQ033EAwGIwas3HjRk488UTy8vIYP348q1evjlr/9ttvc+KJJ1JUVERRURHTpk3jqaeeihrzyCOPMGXKFOx2O4cccgi/+c1votZfdNFFTJ8+nTVr1jBlyhQcDgfvvfceQgheeOGFqLGKolBZWcnSpUsB2LRpE4sWLWLEiBE4nU6mTJnCXXfdhaqqANTU1HDWWWcBMHr0aIQQjBo1Coifgqyvr+fCCy+kvLwcp9NJdXU1H3zwQdQxjBo1imuuuYbf//73DB8+nNLSUhYtWhQVYQsEAlxzzTWMHDkSu93OsGHDOPfcc/H7/el8NAYGBgYp2dfk4dF3tmW0jSpVmrxN7GraxRcHvuC93e/h8rh66AgNsgEjApZlvPrqqyxcuJAf/OAH3HHHHXzyySfceOONHDx4kAceeCA8buHChfzv//4vv/jFL3jkkUc4//zzWb9+PUcccQTNzc3MmzePc845h1/+8pdIKfn000+jhMgdd9zBL37xCxYvXkx1dTXr16/nxhtvxOl08uMf/zg8bvv27SxevJhf/vKXVFZWMnr0aI455hhWrlzJmWeeGR731ltvUVtby6JFiwDYs2cPEyZM4Lvf/S6FhYV89NFH3HTTTXg8HpYsWcJRRx3FnXfeyTXXXMOqVasYOnQodrs94XmZP38+W7du5c4772TQoEHccccdzJw5kw8//JCxY8eGx61cuZLDDz+chx56iN27d3P11Vfzi1/8gvvvvx+AX/3qV/ztb3/j9ttvZ/To0ezfv58XX3wRRVG6/NkZGBgYAKz5cC+/fnkTZx8xjPKCxL9rOu/veZ8N+zYgkVHLSxwllOaV9tRhGvQx/VqALX/uc77Y29wnrz15WBE3nTUl4+1++ctfUl1dzWOPPQbA6aefDsCSJUvC0SWASy+9lGuuuQaAOXPmMHnyZH71q1/xxBNPsGXLFpqamrj33nvDjuqnnXZaeNvm5maWL1/O0qVLuemmmwCYPXs2brebW2+9lcsvvxyz2QzAwYMHef3115k2bVp4+0WLFrF8+XJ8Pl9YND355JNMmTKFqVOnAjBr1ixmzZoFaO7mM2bMwO128/DDD7NkyRKKioqYMGECAEceeWQ4+hWPl19+mXfeeYeamhpOPvlkAE455RRGjRrFHXfcwYMPPhgea7VaWbNmDRaLdml/8cUXPPHEE2EBtm7dOi644AIuvPDC8DYLFixI8akYGBgYpI/LrUXUW33BtATYlw1fxogvgGZf39y/DHoHIwWZRSiKwoYNGzj//POjli9cuBBVVVm7dm142bnnnhv+f5PJxDnnnMO6desAOPTQQykoKOCCCy7gmWeeiSlyX7t2LW1tbZx//vkEg8Hwv1NOOYXa2lp2794dHltVVRUlvkATLM3Nzbz88ssABINBVq1axcKFC8NjvF4vN910E2PHjsVut2O1WrnhhhvYtm1bTDo1FevWraOioiIsvgDy8/OZN28eb7/9dtTYmTNnhsUXwOTJk6P6g06bNo0VK1bwm9/8hk8++QQpY3/0DAwMDLqCq00TYC3e1L919e76hELLEGD9m34dAetMBKovqa+vJxAIMGTIkKjl+t8NDQ3hiFNFRUXUmIqKCvbt2wdAaWkpr732GsuWLWPBggWoqsppp53GPffcw5gxY6ivrwdgypT452fXrl0ccsghUa8dSVVVFTNmzODJJ5/knHPO4Y033qC+vj6cfgS47rrreOSRR7jppps46qijKCkp4ZlnnuHWW2/F6/VSUFCQ9nnZt29fzPvVj62hoSFqWUlJSdTfNpsNKSU+nw+r1crSpUsxmUzcf//9XHfddVRVVXHttdfy05/+NO3jMTAwMEiGy6098LX5Uguwba7EtWKGAOvfGBGwLGLQoEFYrdaYHni1tbUAlJWVhZd1HFNXV8fQoUPDfx933HG8/PLLNDY2smrVKrZs2cIFF1wQtZ/nn3+e999/P+bfEUccEd5PIkfyhQsX8txzz+HxeHjyySc58sgjGTduXHj9U089xZVXXsnixYs59dRTmT59elRkKhOGDh0aty9gbW1t1DlJB4fDwc0338z27dvZsmULCxcu5KqrrgpH8wwMDAy6SmNECjIVX7u+TrjOEGD9G0OAZRFms5mjjz46ZrbiypUrMZlMHH/88eFlkbMeVVXlmWee4ZhjjonZZ15eHmeddRYXX3wxX3zxBQDHH388eXl57N27l+nTp8f80+vGknH++efj8XhYvXo1q1evjop+AXg8nqiiekVReOKJJ6LG6HYWXq836Wsde+yx1NXV8e9//zu8zO1288ILLzBjxoyUx5qIcePGceedd2K328PnxsDAwKCruNIUYI3eRlzexDMdPUEPAcXoidpf6dcpyFxk+fLlzJkzh//5n/9h0aJFfPrpp9x444388Ic/ZPjw4eFxjzzyCDabjalTp/LII4+wdetW/vGPfwDwwgsv8Oc//5n58+czcuRI9uzZw4MPPsgpp5wCaGm6ZcuW8dOf/pQdO3Zw0kknoaoqW7Zs4c0334yxtIhHRUUF1dXVXHPNNTQ2NsYUss+ePZv77ruPsWPHUlZWxn333YfP54saoxfhP/jggyxatAin08lhhx0W81pz5szhm9/8JgsXLuT222+nvLycO++8E4/Hw7XXXpvR+T333HM5+uijOfLII8nLy+Ppp58mGAxy0kknZbQfAwMDg0Q0hlKQqWrAkkW/dJp9zZQ7y7vluAyyCyMClmWcdtppPPHEE3zwwQecddZZ3HXXXfz85z/n3nvvjRr3xBNPsHr1aubPn8/HH38cTgMCjB07FiEEv/jFLzjttNNYvHgxp59+On/+85/D2y9evJiHHnqIl156iXPOOYfvfOc7/O1vf+PEE09M+1gXLVrEvn37OO6442JmMd5zzz2ceOKJXHHFFVx88cVMnTqVJUuWRI055JBDuPPOO1m1ahUnnHBC2BcsHmvWrGH27NlcddVVnH/++Ugp+de//hVlQZEO3/zmN1mzZg0XXHAB55xzDuvXr+ef//wn06dPz2g/BgYGBvGQUtLo0QSYy+1JOjZdAWbQPxG5NAtswoQJcvPmzXHXbdy4kUmTJvXyEXWelpaWtFJ9BgMP49rQyLXvdG9QU1NDdXV1Xx+GQRKaPAGOWP4qAOdOz+P33z4l7rgWXwt/+/RvKfd3/PDjOaLyiJTjjGsjOxFCrJdSxn3CNyJgBgYGBgYG3YRegA+wp6kebzB+jeu2xvSc8o0IWP/FEGAGBgYGBgbdhG5BAeDxw6e1n8Ydl076EQwB1p8xBJiBgYGBgUE34YqIgPmCgk/rPsWvRPeadQfc7G/dn9b+DAHWfzEEmIGBgYGBQTehpyDz7eAPmPArfj6r+yxqTDLz1Y60+FuMjh39FEOAGRgYGBgYdBOuNi0FOagQfAHNyPqT2k8Iqu2WFOmmHwFUqdLqb+3egzTICgwBZmBgYGBg0E00uv0IAWUF4A9qt1hv0MvndZ+H/39f676M9mmkIfsnhgAzMDAwMDDoJlzuAMV5VvJsAn+wvZXbx7Ufo6gK2xu3o0o1o30aAqx/YjjhGxgYGBgYdBMut59Spw2HLYgv0B7jcAfcbKzfyK6mXRnv0xBg/RNDgBkYGBgYGHQTje4AJU4reVYtBSkliFAg7MN9Hyb0BUuGIcD6J0YKcoDz/PPPI4Rg+/btAGzfvh0hBM8//3zfHlgP09raihCCFStWhJeNGjWKa665Ju19rFu3jmXLlsUsX7ZsGYMGDeqGozQwMMg1whEwq/Z3ZBqyLdCGIpWM92kIsNwk1exVQ4AZRDF06FDWrl3LjBkz+vpQep3Vq1fzk5/8JO3x69atY/ny5THLL730Ul555ZXuPDQDA4McQY+AOWza33ohflcwBFhu4gkm7wVqpCANorDb7Rx33HF9fRgpURQFRVGw2Wzdtk+9mXlXGT58OMOHD++WfRkYGOQWegSMUATMFxAU5nVtnz7Fhy/ow26xd/0ADXoNd8CddL0RAcsiLrroIqZPn84LL7zA5MmTcTqdnHnmmTQ0NLB161ZmzpxJfn4+06dP55NPPonaVlVVbr/9dsaOHYvdbmf8+PE89thjUWOklCxbtoyKigoKCwv5wQ9+QHNz9JNVvBTk448/zowZMygrK6O0tJSZM2fywQcfxD321157jcMPP5z8/HxmzJjB559/nvQ919TUIITg1VdfZd68eeTn5zNy5EgeeOCBuPtfs2YNU6ZMweFw8N577wHwzDPPMH36dBwOB5WVlSxevJhAIBC1/T//+U/Gjx9PXl4eJ510Eps2bYo5lngpyH//+9/MnDmTgoICiouLqa6u5sMPP2TFihVceeWVAAghEEKEG+HGS0Fu27aN+fPnU1RURGFhIWeddRZbt26NGiOE4O6772b58uUMHjyYiooKrrjiCnw+X9JzaGBgkB34ggpuv0Kp04rDpqUe/YHuuc0aUbDco8sCTAhxvhDiWSHEHiFEqxBivRDiOxHri4QQy4UQ64QQTUKI/UKI1UKI8XH2VSyEeFQI4QqN/ZsQorxT76yfsnPnTn75y19y66238tBDD/Huu+9y2WWXsWjRIhYtWsTTTz9NMBhk0aJFUfnlK6+8kltvvZXLLruMF154gXPPPZeLL744Skj94Q9/4Oabb+ayyy7j6aefJi8vj8WLF6c8pu3bt/ODH/yAp556ir///e+MGDGCE088ka+/jjYT3LlzJ9deey033HAD//jHP6irq2PhwoVpuThfcsklHH744axatYozzjiDyy+/PKYObfv27SxevJglS5bw0ksvMXr0aFauXMl5553HMcccw7PPPstNN93EQw89xJIlS8LbbdiwgYULF3LEEUewatUqzjrrLBYsWJDymGpqapg1axZWq5XHHnuMJ598khNPPJE9e/Zw5pln8vOf/xyAtWvXsnbtWu6///64+/H5fMyaNYuNGzfy8MMPs2LFCrZt28bJJ59MQ0ND1Njf/va37Nu3j7/+9a9ce+21PPjgg9x9990pj9XAwKDvaQz1gSxx2sjTI2ARNWBdwRBguUcqAZZOCvJqYBvwM6AeOAP4uxBikJTyHmAk8EPgT8ANgBNYArwnhDhcShk553YlMB64FFCBXwNrgBPTf0v9m4aGBtauXcuhhx4KwCeffMIdd9zBY489xg9+8ANAi2SdeeaZbNq0iUmTJrF161b++Mc/8uijj3LhhRcCcOqpp7Jv3z6WL1/OvHnzUBSFX//61/y///f/uPXWWwGYM2cOs2fPZs+ePUmP6Ze//GX4/1VVZfbs2axbt46//vWvUesaGhp45513GDduXHjsueeey+bNm5k4cWLS15g7dy633XZb+Li++uorbr31VubNmxcec/DgQV5//XWmTZsWPg/XXnstP/jBD6LEj91u54orrmDJkiWUl5dz++23M378eFauXIkQgrlz5+L3+1m6dGnSY1qyZAlHHHEEr7zyCiI0jen0008Prx81ahRAypTto48+ys6dO9myZQtjxowB4Nhjj2XMmDE8+OCDUWJx1KhRPPDAAxQWFjJnzhzeeecdVq1alZZQNjAw6Fv0PpClThveUPmPz4iADVi6Q4CdJaWsj/j7X0KIYWjC7B40cXaolDJcbSaE+A+wE7gYWB5adjxwGnCylPLfoWV70ITaqVLK19N+V2ly1ctX8dH+j7p7t2kxrXIad51+V8bbjRo1Kiy+AMaOHQvAKaecErNsz549TJo0iTfeeAOTycS5555LMNje7mLWrFn84x//QFEUdu3axb59+zjnnHOiXu+8887j9deTn/qNGzfyi1/8gnfffZe6urrw8i1btsQcuy6+ACZPngzA7t27Uwqwc889N+a4fvKTn6AoCmazGYCqqqqw+NJff+fOnSxYsCDqfZ9yyil4vV4+++wzTj75ZNatW8eiRYvCIkrffzIB1tbWxnvvvcfdd98dtV1nWLduHUcddVRYfIFWJ3bCCSfw9ttvR4097bTTov6ePHlyTLrXwMAgO9EjYKVOK67QZEe/EQEbsHRZgHUQXzofAt8KrW+Ls02DEGIHMCxi8VygVhdfoXHrhBDbQuu6XYDlIiUlJVF/60Xmkcv1ZV6v5idTX1+PoigUFxfH3ee+ffvYv38/ABUVFVHrOv7dkZaWFk477TSGDBnC7373Ow455BAcDgeXXnpp+PVTHXvHcfGId1zBYJD6+nqGDBkCEP6vTn29dmmeccYZcfe5a5cWfN2/f3/G79vlciGlZOjQoSmPPRX79u2LOXbQ3s+OHTuilsU7h+mcPwMDg75Hb8Rd4rThCH1tjRqwgYsn0DOzII8HtiRaKYQYDIwF/hyxeCIQW/kMG0Prup3ORKBykbKyMiwWC++88w4mU+yXXRczQFQEK97fHVm7di27d+/mtddei4piNTU1dcORJz6Ouro6LBZLVDF7x0hUWVkZAA899FDcGYyjR48GoLKyMuP3XVpaislkYt++zHq2xWPo0KFxJyPU1taG34OBgUHu49IjYPlWHC3aMl832FCAIcBykbZATHwqioyvDCHELGA+8Nskw34LtAIrIpaVAo1xxrpC6ww6ySmnnIKiKDQ1NTF9+vSYfzabjREjRlBZWckzzzwTte2qVauS7tvj0RS83d4+/fndd98NG7d2F6tXr475++ijjw6nH+MxYcIEqqqq2L59e9z3XV6uze/4xje+wbPPPhs1GSDV+87Pz+fYY4/l8ccfTziJIN0I37HHHsv69evZtm1beNmePXt49913B6TfmoFBfyWyBsxiFlhMKv5A51KQUoIa0TKy1d+acQ9Jg76lWyNgQohRwN+BZ6SUKxKMuRz4HvAtKeXBTPafYH+XAZcBDB48mJqamrjjiouLaWlp6erL9RqKosQcbyAQQFXVqOX6zb2lpSUsBFpbWwFwu920tLQwbNgwLr74YhYuXMhVV13FkUceidfrZdOmTWzdupV7770XgJ/85CcsXbqUwsJCvvnNb/Lss8/yxRdfhPfZ0tISs++pU6dSUFDAxRdfzE9/+lP27t3Lr371K4YNG0YwGAwfa7xj77iveLjdWo78xRdf5Nprr+WEE07gueee47XXXuOJJ55Iun8gPPOzvr6e2bNnY7PZ2L59O88//zx/+ctfcDqd/PjHP+aUU07hvPPO4/vf/z4bN27kkUceCZ9ffZ9SSvx+f/jvX/7yl5x99tnMnj2b//mf/8HpdLJu3TqOPPJI5s6dy8iRIwH4zW9+w0knnURRURHjxo3D5/MhpQzv51vf+ha33347c+bM4YYbbsBsNnP77bdTXl7OBRdcEPN5R14bHfc1kPB6vQm/7wOV1tZW45xkMZ9s8mMzwX/f+Q9+nx+H2YRoyaO8LvNk09t7LPx7t4Xrj/FiCmm4N2vexCziP5Qa10b2YfMk96lM+6oQQpQBLwE7gO8mGHM2WmH+dVLK1R1Wu4DBcTYrDa2Li5TyIeAhgAkTJkjda6kjGzdupLCwMPmbyCJaWlpijtdqtWIymaKWOxwOAAoLCykoKAAI/9fpdIbHPvzww0ydOpWHH36Y//u//6OoqIjJkydzySWXhMdcf/31uN1uHnjgAf74xz9y9tlnc8cdd/Dd736XgoKCqNfQ911YWMhTTz3FNddcw3e+8x3GjRvHgw8+yG9+8xssFkt43/GOPd5xdsTpdALwpz/9ibvuuov77ruPsrIy7rvvPhYuXJj03IDmDzZkyBBuu+02/vrXv2I2mxkzZgzz5s2jvLwci8XCySefzBNPPMGSJUu44IILmD59OitXruSYY47B4XCE9ymEwGazhf8+/fTTee2117jxxhv54Q9/iM1m48gjj2ThwoXhWYrXXnstDzzwAMuWLeOkk06ipqYGu92OECK8n8LCQt544w2uvvpqfvzjHyOlpLq6mtWrV3PIIYdEvR+Hw4HZbA5v23FfAwmHw9Ft5rj9hZqaGhL9Bhr0PS8c+JhyVz3V1dW8vPVlrO97abb4OVjRkHrjDuzcXYrLZ2Ors4nyQq2E5LhxxzGieETc8ca1kV24A27+8ek/ko4R6Xg0CSGcaEXyQ4DjpZQxBTRCiBOA14A/Syl/HGf9zcAPpZRDOyz/Clgjpfx5quOYMGGC3Lx5c9x1GzduZNKkSSnfS7YQT4ANRGpqapg5cyaffvopU6dO7evDyQqMa0Mj177TvYFxk81uLn3sA3a73Lx81Um8vPVlbnraQ0GewvknxJvLlpw1/y1n024nZx1zkCkjtUzBiSNPZErFlLjjjWsju6h31/PMpme49OhL10spp8cbk44RqwV4ChgHnJ5AfE0BngNeBhI103sJqBRCzIjYbjowJrTOwMDAwMAgZ2nU2xCFsFk6XwPm8Wu35/2u9v0Zhfi5QyoLCkgvBXk/mvnqT4HyDs71HwLFaMKrFfgDcEzEbLVmKeUXAFLKtUKIV4HHhRDX0G7E+nZPeIAZGBgYGBj0Ji63nwmV7dFru1XS7Ek8kSgZ3pAAq220hpcZAix36C4BpjtDxuuHMhoYBeidh9/ssP4toDri74XA79HsKUzA8ySOmBkMAKqrq9NqVWRgYGCQ7TS6A5RERMDsVhV/szXJFonRI2C1LhtSghCGAMslukWASSlHpRiyHUgrxiqlbAT+J/TPwMDAwMCgXyClpNEToNTZLrhsFtlpJ3yv34TdquILmHC1WigrDBoCLIdIR4B1j0OcgYGBgYHBAKbZG0RRZUwNWGd6QSoq+IMmRlVoNkR6GjKgBlJ6SxlkB+l8ToYAMzAwMDAw6CKRbYh07FYVRRUElcz2pdd/DR/kw2ySUYX4Lf6B5wmYi6RywQdDgBkYGBgYGHQZV0Qjbh2bVatv9WfYjkiv/xKmFgYXB6IEWJO3e9vAGfQMRgTMwMDAwMCgF3DFi4BZtNZBmVpR6BEwv2ykstTP/katEB+MQvxcwagBMzAwMDAw6AUaw30gYyNgmTbk/upgLQCqaKGyxI8vYKKpTbOzMARY9hNQAgTUQMpxhgAzMDAwMDDoIq42PQXZtQhYq7+VjXU7AFBoprJUE3b7G7X9GgIs+0kn+gWGAMs61qxZw+GHH47dbmf06NH87ne/ixkjpeS2225jxIgR5OXlcdJJJ/HRRx+ltf9nnnmGww47DIfDweTJk3nyySej1re0tLBgwQKKi4s57rjj2LJlS9R6l8tFRUUFH3zwQaffY0/T2tqKEIIVK1aEl40aNYprrrkm7X2sW7eOZcuWxSxftmwZgwYN6oajTI+LLrqI6dPjdrFIykMPPcSaNWu6/4C6gZqaGoQQfPbZZ319KAYG3Uaj248QUJTX+QiYlJKa7TUEAto+gjQzqCiASbQX4rf6W7v5yA26G08wvZmqmbdozzEe+OCBPnndH03/UcbbvPPOO5x33nlcfPHF3Hnnnbz33ntcd911mEwmrrrqqvC422+/nVtuuYU77riDiRMn8rvf/Y5TTz2Vzz77jMrKyoT7f/vtt/nWt77F//7v//KHP/yBF198ke985zuUlpZy2mma3+7//d//sWXLFlauXMmKFSu46KKLePfdd8P7WLZsGfPmzeuUKOhLVq9eTXl5eeqBIdatW8fy5ctjRNill17KWWed1c1Hl5gbb7wRjyfzaecPPfQQU6dOZf78+d1/UAYGBjG43AGK86yYTe3RrvYIWHoC7OPaj9nfuh9VnQwo+NQmLGaiCvHTvbkb9B3pRsD6vQDLJW6++WZOOOEEHnnkEQBOO+00Ghsbufnmm/nf//1fbDYbXq+X22+/nSVLlvDjH2s9z48//nhGjRrFvffey6233ppw/7fccgsnnXQSf/jDHwCYOXMmn3/+OTfffHNYgL3++uvccMMNzJkzh2nTplFZWUlbWxv5+fls3LiRv/zlL3zxxRc9eh4URUFRFGw2W+rBaXLkkUd2y36GDx/O8OHDUw/sJg499NBee61E9MTnYWDQ33B16AMJYLNqAsyXhhnrAfcBNuzbAIBU8xAmL96Q2Kos9bNlTx5SQlANoqgKZlPnWhwZ9DxGCjIH+eijj5g9e3bUstNOOw2Xy8XatWsBePfdd2lubmbBggXhMfn5+Zx11lm89FLinuY+n48333wzajuARYsWsXbtWpqatKnNfr+fvLw8AJxOZ3gZwNVXX83ixYuTRtki0VNNr776KvPmzSM/P5+RI0fywAPRUUk9zbZmzRqmTJmCw+HgvffeA7SU6fTp03E4HFRWVrJ48WICgejixn/+85+MHz8+nI7dtGlTzLHES0H++9//ZubMmRQUFFBcXEx1dTUffvghK1as4MorrwRACIEQgurqaiB+CnLbtm3Mnz+foqIiCgsLOeuss9i6dWvUGCEEd999N7/4xS8YPHgwFRUVXHHFFfh8vqTnsGMKcsWKFQgh+PTTT5k9ezb5+flMnDiRVatWhcdUV1ezfv16HnvssfDxR6ZjH3nkEaZMmYLdbueQQw7hN7/5TdzX7Ph5CCF44YUXosYqikJlZSVLly4FYNOmTSxatIgRI0bgdDqZMmUKd911F6qqJn2fBga5jtaGKLrtkF23oUgRAQsoAd7a/haq1L4nquLEZHaHrQwqS/x4/Gaa3Zro8ga93X34Bt2IIcByEK/XGxNl0P/euHEjoN3gzGYz48aNixo3adKkuMJD56uvviIQCDBx4sSY7VRVDdd6HX300Tz88MMcPHiQu+++mzFjxlBaWsoLL7zAli1b+NnPfpbx+7rkkks4/PDDWbVqFWeccQaXX345zz//fNSY7du3s3jxYpYsWcJLL73E6NGjWblyJeeddx7HHHMMzz77LDfddBMPPfQQS5YsCW+3YcMGFi5cyBFHHMGqVas466yzYkRmPGpqapg1axZWq5XHHnuMJ598khNPPJE9e/Zw5pln8vOf/xyAtWvXsnbtWu6///64+/H5fMyaNYuNGzfy8MMPs2LFCrZt28bJJ59MQ0ND1Njf/va37N27l7/+9a9ce+21PPjgg9x9d7wWq6m54IILOPvss1m9ejXjxo1j0aJF7N69G4D777+fiRMncsYZZ4SP/8wzzwTgjjvu4PLLL2f+/Pk8//zzXH755dx4443ce++9UfuP93kcc8wxrFy5MmrcW2+9RW1tLYsWLQJgz549TJgwgfvvv58XX3yRH/7wh9x00038+te/7tT7NDDIFeJFwKxmCcikETBVqvxn539o9DaGl2kRMA9exYsqVYaUag+deiG+IcCyGyMFmYOMHTuW999/P2rZunXrAMI3c5fLRUFBAWZzdPi5tLQUt9uN3++PmypyuVwAlJSUxGwXuf6mm27i1FNPZdCgQRQUFPDPf/6TQCDAz3/+c+68807sdnvG72vu3LncdtttAMyZM4evvvqKW2+9lXnz5oXHHDx4kNdff51p06YBWjHqtddeyw9+8IMo8WO327niiitYsmQJ5eXl3H777YwfP56VK1cihGDu3Ln4/f5wRCYRS5Ys4YgjjuCVV15BCO3H8fTTTw+vHzVqFADHHXdc0v08+uij7Ny5ky1btjBmzBgAjj32WMaMGcODDz4YJRZHjRoVjkTNmTOHd955h1WrVrF48eKkrxGPn/3sZ1x88cWAJpqHDBnC888/z49+9CMmT55Mfn4+gwcPjjr+5uZmli9fztKlS7npppsAmD17Nm63m1tvvZXLL788fF11/DxAi5YuX74cn88Xvg6efPJJpkyZwtSpUwGYNWsWs2bNArTPcMaMGbjdbh5++OGoc2Fg0N9odAeYUFkYtUwIsFtkwgiYKlXe3PYm2xq3RS9X8jBZWpBS4gl4qCg2IYSk1mVlQpXHEGBZji7AWj3JY1xGBCyL+NGPfsSaNWt4+OGHcblcvPLKK+FZkCZT73xUo0aNYvPmzWzevJna2lpOO+007rnnHqqqqjj33HP5z3/+w+GHH87gwYO5/PLLw+nJZJx77rlRf5933nmsX78eRWnvz1FVVRV1s9+yZQs7d+5kwYIFBIPB8L9TTjkFr9cbnkG3bt06zj777LCI0vefjLa2Nt577z0uvPDCqO06w7p16zjqqKPC4gu0OrETTjiBt99+O2qsXmenM3ny5HDUKlMi91VeXk5FRUXKfa1du5a2tjbOP//8mHNaW1sbtX3HzwNgwYIFNDc38/LLLwMQDAZZtWoVCxcuDI/xer3cdNNNjB07FrvdjtVq5YYbbmDbtm0Eg8FOvVcDg1wgXgQMtDqweBEwRVV4/evXY8QXaBEwk0lLP7qDbixmGFTUXohvCLDsRhdg/3i7NOk4Q4BlERdffDGXX345l19+OWVlZZx33nnceOONAOG6q9LSUlpbW6PEC2gRLKfTmbBQWo906bVekdtFrgcwm82MHz8ep9PJgQMHuO2227jrrrvw+XwsWLCApUuX8uWXX7JhwwYeeuihlO+roqIi5u9gMEh9fX142ZAhQ6LG6OvOOOMMrFZr+N/o0aMB2LVrFwD79++Pu/9kuFwupJQMHTo05bGnYt++fTHHDtr76ZiC7Bh91CdVdIbO7Es/p1OmTIk6pzNnzgTaz6l+/B2pqqpixowZYeuSN954g/r6+nD6EeC6667jzjvv5LLLLuPFF1/k/fffD0cjO/teDQyyHV9Qwe1XokxYdezW2AiYoiq89vVr7GzaGXd/UtFSkNDe0ibSEd8QYNmNLsACKSZfGCnILMJsNnPvvfdyyy23sHv3bkaPHh2u69JTSRMnTkRRFLZu3cqECRPC227atCmmviuSQw89FKvVyqZNmzj55JOjtjOZTIwfPz7udjfeeCPnn38+hx12GB9//DGBQCBcY/X973+fN998MzwbMxF1dXUxf1sslqhi9o6RqLKyMkCzU4g3g1EXYpWVlXH3n4zS0lJMJhP79u1LOi4dhg4dyueffx6zvLa2NvwesgX9eJ5//vm4AivyekoUGVy4cCHXX389Ho+HJ598kiOPPDKqHvGpp57iyiuvjEqrdizcNzDobzSG+kCWxIuAWVR8EQIsoAR47evX2NuyN+6+pDQhpQOTORQBC93MK0sCfLq9gBaP2RBgWYyeNgYIKMkFmBEBy0JKS0s57LDDKCgo4P777+eb3/xmWFx985vfpKioiKeeeio83u1289xzzzF37tyE+7Tb7cycOTNqO9BqeI4//niKi4tjtvn44495+umnueWWW8LL/H5/OPrW1taG1BuUJWH16tUxfx999NExdWyRTJgwgaqqKrZv38706dNj/umeXt/4xjd49tlno44jckZgPPLz8zn22GN5/PHHEx5/ePLDrnqa3InTrMceeyzr169n27b2NMKePXt49913mTFjRtLj6EniRcSOP/548vLy2Lt3b9xzWlhYmGBv7Zx//vl4PB5Wr17N6tWro6JfAB6PJ6pOUFEUnnjiie55UwYGWYor3IYongCT+EOREG/QyytfvZJQfIGWfgTiRsAA9jdaDQGWxXiDXiTafcWIgOUQ//3vf3n77beZNm0azc3N/OMf/+CVV16JqiVyOBxcf/313HLLLZSWloaNWFVVDVsnADz++ONcfPHFfPXVVxxyyCGAFs2qrq7mqquuYv78+bz44ou8+OKL4Zqejlx11VUsXbo0HKmaMGECTqeTxYsXc8opp3Dfffel5S7/0ksvccMNN3DyySezatUqXnvtNZ555pmk25hMJn7729/y/e9/n+bmZubOnYvNZuPrr79mzZo1PP300zidTq677jqOPfZYFixYwCWXXMJnn33Gn/70p5THdPvtt3Pqqacyd+5cLrvsMvLz81m7di3Tp09n3rx5YcH74B/v5bRTZ3FoVUVUhEjnoosu4te//jVz587l5ptvxmw2s3z5cgYNGsT/+3//L+Vx9BQTJ07klVde4ZVXXqG8vJzRo0dTXl7OsmXL+OlPf8qOHTs46aSTwjNg33zzzRihHI+Kigqqq6u55ppraGxsjJlxOnv2bO677z7Gjh1LWVkZ9913X0qrDQODXKe9DVG8FKRKi8fCp7Wf8tH+j/Apyb8PqqIJMJNZi3zpxqsVxQEEmiO+IcCyl8gZkEYELIewWq08+eSTzJ8/n4suugi3280777zD4YcfHjXu+uuv54YbbuBXv/oV8+bNo7m5mddeey0qraSqKoqiREV4ZsyYwdNPP83rr7/OnDlzePbZZ/n73/8eUxwOWhRp3759XHHFFeFlDoeDJ554ghdffJHvfve7nHbaafzoR6kd/x955BE2bNgQtj647777OPvss1Nut3DhQp555hk++ugjzj//fM477zzuv/9+jjrqqHCEavr06TzxxBN8+OGHzJ8/nzVr1sS0V4rHSSedxGuvvYbb7eZ73/seCxcu5K233gqbrJ544on87Oqf8/c/Pci8U09OKKbsdjuvv/46EydO5JJLLuHCCy9k5MiR1NTU9GkKcunSpUyaNIkFCxbwjW98g+eeew6AxYsX89BDD/HSSy9xzjnn8J3vfIe//e1vnHjiiWnve9GiRezbt4/jjjsuPFtU55577uHEE0/kiiuu4OKLL2bq1KnG7EeDfo/eiDteCtKvNtPo8fLenvdSii+IjYDpN3SrRTKoKECtIcCiaPO39fUhRKF/XqqEYAoBJtJJIWULEyZMkJs3b467buPGjUyaNKmXj6jztLS0pJXyyWVqamqYOXMmn376adimIJdo8QbYVt9GSZ6VkeX5vfe6A+DaSIdc+073BjU1NWFTYIPs4e/v7eQXqz9l7ZJTGFqsCahHP3yUpzc+zVfbj8TXciTlo3+V1r58beNpqf0uxVUPYrXvZUj+EM6aoLU/e/79MrbVOrh5QYBvTf5W1HYD7dpo9jXznx3/Ic+axymjT+nrwwmzuX4zb25/E39Q8Ls1w9nx63nrpZRxe/cZKUgDgwQEFO3hRMmdZxQDA4M+IF4N2Du73qG2tRZh8iGlNnsxHdcbPQJm6hABA80R/7Md+dS1DNyG3KpU+Wj/R2zYt4GgGmSwc3BfH1IU6c6ABEOAGRgkJKiE2oKohgIzMDBITKPbj8NqwmGNnVgkTD7ABNIGIrVvolScoe3afcB09EL87QcGZmuv/a37+feOf9Pgabf4iewgkA2EBViK9CMYAqxbCCoqDW1+Bhfau2zs2Z+orq5Oa5ZkthLQBVgX3oOUkvpWPyV5VqwWo+TSwKA/4nIH4s6ABBAmTTSpqh2zKbUAU9U8QA0JN80zzBf0YbfYqSgJAJI9DaYB15C73l3Pmk1rYpYH1ACt/lYKbAW9f1BxaI+Apf69N+4I3UCzN8j+Zi+egJJ6sEHO0J6C7LwAC6qSfU0eGj2pf3gNDAxyk0a3P24BPoDJpBXMSzW9Nm56H0gh2n939JmQNoukME+hqc0y4Arx69oS+zu6PK5ePJLkZBIBMwRYNxBUtUiJPzgww8L9lYCqpyA7vw8llL5UjDSmgUG/RYuAxVpQAOFIVroCTFXywiasOpF1YFazJKiIASfADrQdSLjO5c1CAZZGDZghwLoB/ebqVwwB1p8IhiJgXUlB6tdG0BBgBgb9lkR9IAGEyEyA6RGwSHQzVgCLWRJUB147ogPuJAIsGyNghgDrHfQbdcCIgPUbpJQEFRWBQJWy07VsungzImAGBv2XRneAklQRMBlfoHUksg+kTmQEzDIAI2CqVKMK7zuSLRGwoBokoGqmvEYKspdoj4AZN9n+QkDRmknYQoXzna0DM1KQBgb9G1WVNCaLgIUK79NOQarOmBSkXgMGA1OANXgaUGXiAEe2RMCiXfCNIvxeQU8vGTVg/Qe9rs8eEmCdrQMzBJiBQf+mxRtElaSOgKmOtPanRcDcUcuiImCmgSfAktV/AfgUX1Satq+IEmBGCrJ30G/WAUXtku3CihUrEELE/HvggQeixkkpue222xgxYgR5eXmcdNJJfPTRR2m9xjPPPMNhhx2Gw+Fg8uTJMW17WlpaWLBgAcXFxRx33HFs2bIlar3L5aKiooIPPvig0++zp2ltbUUIwYoVK8LLRo0alVbfSp3//ncdf/zd7ditIQEW+lyXLVsW7o2ZDkoXU5AXXXQR06fHNVFOykMPPcSaNWs69Zo9TU1NDUIIPvvss74+FAODLpOsETdkVoQvpQkpHbERsI41YANNgCWp/9JJlqLsLTLpAwmGAOsWgorEJLRaoe4otv7Xv/7F2rVrw//OO++8qPW33347t9xyC9dddx3PPfccBQUFnHrqqezfvz/pft9++22+9a1vMXPmTF566SXOPPNMvvOd7/Dqq6+Gx/zf//0fW7ZsYeXKlYwePZqLLrooah/Lli1j3rx5nRIFfcnq1av5yU9+kvb4de+v44Hf/xq7RfPZ0c1YL730Ul555ZW099PVIvwbb7wxSkimSzYLMAOD/kRYgOUniIAJBUQgPQEWipKlrAFTB5YAq3fXpxyTDYasmUbA+pUR6wMfPJB6UDejSsneRg82ixl/UGHwbnv4pt2RH01P3bga4Bvf+AYFBfFN5bxeL7fffjtLlizhxz/+MQDHH388o0aN4t577+XWW29NuN9bbrmFk046iT/84Q8AzJw5k88//5ybb7453JD79ddf54YbbmDOnDlMmzaNyspK2trayM/PZ+PGjfzlL3/hiy++SOt9dBZFUVAUJdxwuzs48sgjMzuGUFSzYw3Y8OHDww2700EXbqqUqFIT6plw6KGHZjS+J+iJz8PAoL/Q6NaKrhP5gIE2EzKdInxVd8E3asDCqFLloPtgynHZUIjfMQJmMSd/8DYiYF1Ev8HazNqNtadrfd59912am5tZsGBBeFl+fj5nnXUWL730UsLtfD4fb775ZtR2AIsWLWLt2rU0NTUB4Pf7ycvTepE5nc7wMoCrr76axYsXU1lZmdax6qmmV199lXnz5pGfn8/IkSNjUqp6mm3NmjVMmTIFh8PBe++9B2gp0+nTp+NwOKisrGTx4sUEAoGo7f/5z38yfvz4cDp206ZNMccSLwX573//m5kzZ1JQUEBxcTHV1dV8+OGHrFixgqWLfw5AocPKESNKmXvaqUD8FOS2bduYP38+RUVFFBYWctZZZ7F161YAdGeSI0aUctddd/OLX/yCwYMHU1FRwRVXXIHP50t6DjumIPU09aeffsrs2bPJz89n4sSJrFq1Kjymurqa9evX89hjj4XT2JFRtEceeYQpU6Zgt9s55JBD+M1vfpPW5yGE4IUXXogaqygKlZWVLF26FIBNmzaxaNEiRowYgdPpZMqUKdx1112oXTFTMzDIYlKlIEErxE8vAqb3gYyuAfMpPhRVM/oeaAKswdOAIlObnGdDIX50BMyEzWIIsB5Frw0KR0q6YSbkoYceisViYcKECTz44INR6zZt2oTZbGbcuHFRyydNmhRXeOh89dVXBAIBJk6cGLOdqqrhWq+jjz6ahx9+mIMHD3L33XczZswYSktLeeGFF9iyZQs/+9nPMn4/l1xyCYcffjirVq3ijDPO4PLLL+f555+PGrN9+3YWL17MkiVLeOmllxg9ejQrV67kvPPO45hjjuHZZ5/lpptu4qGHHmLJkiXh7TZs2MDChQs54ogjWLVqFWeddVaMyIxHTU0Ns2bNwmq18thjj/Hkk09y4oknsmfPHs4880wuufxKAN76z9v85ZlXueN3f4i7H5/Px6xZs9i4cSMPP/wwK1asYNu2bZx88sk0NDREzZ78/e9/x969e/nrX//Ktddey4MPPsjdd9+d8fkEuOCCCzj77LNZvXo148aNY9GiRezevRuA+++/n4kTJ3LGGWeE09hnnnkmAHfccQeXX3458+fP5/nnn+fyyy/nxhtv5N57743af7zP45hjjmHlypVR49566y1qa2tZtGgRAHv27GHChAncf//9vPjii/zwhz/kpptu4te//nWn3qeBQbbjCkXAEhmxglYHlpYAU/JC4z2oUsUX1C0sZDgKNtCK8NNJP0J2RMAia/UCisCaIgLWr1KQfYEe8DKbBGYhCHahCH/o0KHccsstHHPMMSiKwhNPPMGPfvQj3G53WPi4XC4KCgowm6PTnKWlpbjdbvx+f9xUkculXZwlJSUx20Wuv+mmmzj11FMZNGgQBQUF/POf/yQQCPDzn/+cO++8E7s9vanUkcydO5fbbrsNgDlz5vDVV19x6623Mm/evPCYgwcP8vrrrzNt2jRA+8G59tpr+cEPfsD9998fHme327niiitYsmQJ5eXl3H777YwfP56VK1cihGDu3Ln4/f5wRCYRS5Ys4YgjjuCVV14J9+88/fTTw+uHDh8JaOndkn3NDCvJi7ufRx99lJ07d7JlyxbGjBkDwLHHHsuYMWN48MEHOf+SKxFo+x858pBwJGrOnDm88847rFq1isWLF6d7KsP87Gc/4+KLLwY00TxkyBCef/55fvSjHzF58mTy8/MZPHgwxx13XHib5uZmli9fztKlS7npppsAmD17Nm63m1tvvZXLL788fF11/DxAi5YuX74cn88Xvg6efPJJpkyZwtSpUwGYNWsWs2bNArTPcMaMGbjdbh5++OEo4Wxg0F9odPsxCShyJBdgahoCTA1FwBQa+bJ+Ez7Fx7Qh0xBC4A64KbAVYDFLAorAExgYAizVDEgdd8Ad7pnZV7QF2sL/HwgKLObkkX8jAtZF9AiYSQjMZlOXImBz5sxh6dKlnHbaacydO5fHHnuMBQsWcOutt/ZaCmfUqFFs3ryZzZs3U1tby2mnncY999xDVVUV5557Lv/5z384/PDDGTx4MJdffnk4PZmMc889N+rv8847j/Xr16Mo7WHlqqqqqJv9li1b2LlzJwsWLCAYDIb/nXLKKXi93vAMunXr1nH22WdHNUHvOGmhI21tbbz33ntceOGFCZun66llc2h9Ijf8devWcdRRR4XFF2h1YieccAJvv/02iiqxWrR9zJx1atS2kydPDketMkWv2QMoLy+noqIi5b7Wrl1LW1sb559/fsw5ra2tjdq+4+cBsGDBApqbm3n55ZcBCAaDrFq1ioULF4bHeL1ebrrpJsaOHYvdbsdqtXLDDTewbds2gsFgp96rgUE243L7Kc6zYjIlru9MPwLmJCB2saVpHZ6gFgULqtr3JhwBM0tA4FMCSb2x+gvpzIDU6esoWMcImMmU/DfPEGBdRNdFJgEWEwS7+Qvx7W9/m4aGBrZv3w5oEavW1tYo8QJaBMvpdCYslNYjXXqtV+R2kesBzGYz48ePx+l0cuDAAW677TbuuusufD4fCxYsYOnSpXz55Zds2LCBhx56KOV7qKioiPk7GAxSX98eWh4yZEjUGH3dGWecgdVqDf8bPXo0ALt27QJg//79cfefDJfLhZSSoUOHxl2vqBIVTXAJAYJ2QdaRffv2xRy7/n4aGhpQpcRm1r5mhUXFUWNsNhteb+eeYjtGMtPZl35Op0yZEnVOZ86cCbSfU/34O1JVVcWMGTPC1iVvvPEG9fX14fQjwHXXXcedd97JZZddxosvvsj7778fjkZ29r0aGGQzWh/I5AX2pjQFWFuwgf32xUgUhhZov09+RXvI1euL9MJuLQrW995XPUm6Bfg6fV0HFjlZIhAUmEyBJKONFGSXUaREEIqAmQRKQEu9JIqsZIq+H/2/EydORFEUtm7dyoQJE8LjNm3aFFPfFcmhhx6K1Wpl06ZNnHzyyVHbmUwmxo8fH3e7G2+8kfPPP5/DDjuMjz/+mEAgEK6x+v73v8+bb74Zno2ZiLq6upi/LRZLVDF7x/NVVlYGaHYK8WYw6kKssrIy7v6TUVpaislkYt++fXHXByJ6egohMJkEieZWDB06lM8//zxmeW1tLWVlZSiqDNcHdiE73S3o5/T555+PK7Air6dE1+/ChQu5/vrr8Xg8PPnkkxx55JFR9YhPPfUUV155ZVRatWPhvoFBf6LR7U9owqqjzYJMLsAavY3sDKzETDkTyw9BkQr7WvfhV/zkkx8WW7oAUxSBT/GRT373vJEsxOVxpVWAHx7fhxEwT8ATFZEMKCYQyTNEKSNgQojzhRDPCiH2CCFahRDrhRDfiTPuh0KIL4UQ3tCYWXHGVAkhVgshWoQQ9UKIe4UQzvTeXnaiWwsIITCbTEgpu3Um5NNPP82gQYM45JBDAPjmN79JUVERTz31VHiM2+3mueeeY+7cuQn3Y7fbmTlzZtR2oNXwHH/88RQXF8ds8/HHH/P0009zyy23hJf5/f5w9K2trS2u8ezBVh9b61rZ49J+MB77+0q21rWG//3tyaeZcvg0th30sLWulTZfbJh2woQJVFVVsX37dqZPnx7zr7y8HNAsO5599tmo44icERiP/Px8jj32WB5//PG4xx9UVKxW7YnW6/ViEiLhZ3rssceyfv16tm3bFl62Z88e3n33XU444QRUKbGadTPX3ksXxIuIHX/88eTl5bF3796457SwsDDlfs8//3w8Hg+rV69m9erVUdEvAI/HE1UnqNcyGhj0V1xtqSNgqVKQ9e56vnJ9hY0hDFNuwG6xYzNr+4yNgGnbDIQIWLoF+Dp9GQGLnAEJEFRESgGWTgTsamAb8DOgHjgD+LsQYpCU8h6AkCB7AFgGvA38D/C8EOIbUsrPQmOswCuAH1gElAC/C/33e2kcR1aiShnO/VtC/1Wk7FRo8Vvf+hbHHHMMhx9+OIqi8OSTT/Lkk0/yhz/8AZNJu4k7HA6uv/56brnlFkpLS5k4cSK/+93vUFWVK6+8Mryvxx9/nIsvvpivvvoqLN5uvPFGqqurueqqq5g/fz4vvvgiL774YrimpyNXXXUVS5cuDUeqJkyYgNPpZPHixZxyyincd999cd3l61v9qFKiB1He+tdr/O5Xyzn2+Bm88sKzvPPWv3jw8ScwCa3noj+oJ/zaMZlM/Pa3v+X73/8+zc3NzJ07F5vNxtdff82aNWt4+umncTqdXHfddRx77LEsWLCASy65hM8++4w//elPKc/17bffzqmnnsrcuXO57LLLyM/PZ+3atUyfPp0TZp7G6EO1qM7dd9/NoUccS1lJMSOOi43EXXTRRfz6179m7ty53HzzzZjNZpYvX86gQYO49IeXsd+nTdAAEkbReoKJEyfyyiuv8Morr1BeXs7o0aMpLy9n2bJl/PSnP2XHjh2cdNJJ4Rmwb775JqtXr06534qKCqqrq7nmmmtobGyMmXE6e/Zs7rvvPsaOHUtZWRn33XdfSqsNA4NcptHtZ9LQoqRjhMkH0oqUZs2YNYIWfws7mnZQZC9ikO8nCJMWTTMLMyZhCguw9giY9iA3EGZCZlL/BX1rxtpRgPmDArs1+eeTjk44S0oZKUP/JYQYhibM7gktWwY8JqW8BUAI8RZwJHA97eLq28AkYKyUcltoXAB4QgixXEr5ZRrHknWoKmFzzbAAU2SnkrsTJkzgz3/+M7t27UJKyeTJk3n88cf5/ve/HzXu+uuvR1VVfvWrX3Hw4EGmT5/Oa6+9FpVWUlUVRVGiIjwzZszg6aefZunSpfzxj39k9OjR/P3vf48q6NZZtWoV+/bt44orrggvczgcPPHEE1x++eX86U9/4tvf/jY/+lG0uWxQUfEFFSqLHeGZgyv+/CfuuusuVjx4X/imfNn3tcLtxpCHTowCQ0t3FRUVcdttt/HnP/8Zs9nMmDFjmDdvXrjWbfr06TzxxBMsWbKE+fPnM336dJ588kmOOeaYpOf6pJNO4rXXXuPGG2/ke9/7HjabjSOPPJL58+cTUFWOOvabXHPNNdx9993s37+fY44/gf++85+Y/djtdl5//XWuvvpqLrnkEqSUVFdX889//pPiklL217akLOTvCZYuXRqexNDc3Myjjz7KRRddxOLFixk2bBi///3v+e1vf4vD4WD8+PFRhfSpWLRoET/84Q857rjjGDVqVNS6e+65hx/96EdcccUV5OXlceGFF3Luuedy2WWXdfM7NDDIDrQasBQpyHA7IluUyaqUkj3Ne7CarBxaeijNe0oQZm0mnRACm9nWHgELRteABUMpyP5MujMgdVr8LQTVIBZT71dXRdZ/gVYDZiW5ABOd6V0ohLgWuFVKaRdCjAG+AuZKKV+OGPNL4KdSyvLQ348D46WUx0WMsQHNwLV6NC0ZEyZMkJs3b467buPGjUyaNCnj95IItz+IP6gmdTcG2Ly/BYfVxCHl+ahS8tmeJoYUORhSlLzxaktLS1opn1yj2RNg+8E2xgwu4IO1bzNz5kw+/fTTsE1BovFjKwpw2rKjJHFPo4dGt58pw7S07NcHWlEljK2I350gEW5/kK11rYwqz6euxYdJwJjBqffRX6+NTOnu73R/oKamhurq6r4+DIMQ3oDCxBtf5to5E7hi5tiodZc+eykf7f9IG9cyjdYD51I64veYrY3hMY3eRr5yfcXI4pEMdg6mYedPsTp2UVihlVF82fAlQSXIpMGTKLAVsGjqIr7e72Dl24P5XnUt5x5+BEcPOxrof9eGlJI/ffin8CzQdPnWpG8xOH9wDx1VYj7c9yHv7Xkv/PdvV1fhLN7AJ9ctWy+ljNu7r7OzII8H9C7NeuV3RxfQjUCZEGJwxLioMVJKP5p4S1w93kfUt/jY05g6v66oMhz5MgmB1WzCH+z/U4MT4fYrCAR51vjtmDqip+d6uoNAJgQVFaup/athNolORa/092QyCSymxHVkBgYGuUl7G6LURfgQ3ZBbSsmelj3YzXYG5Q0Krc+L6gNpM9vwqx1TkHp/2f6dgnR5XRmLL327viAyAialVoSvklxDZCzAQsX184Hfhhbp/gWNHYa6OqwvjTNGH1caZ3mfElC1YvpE9gOgfYGCqoo54mZtM5vwKwNZgAVxWE1hYZUKPX2b7Dz3NgFFYjG3H79JiE4dX6SXmNkQYAYG/Y6GNk0claVRhA9EzYRs8DTgDXqpKqxCCIGUJqSah8kcLcCCahBVqihSwRv0DpgUZKYF+Dp9VYgfWQMWVHT3gm60oRBCjAL+DjwjpVyR4fF1CiHEZcBlAIMHD6ampibuuOLiYlpaWrrtdf0BTUQ1NrdgNccXE/oNVQn4aWnRTrSQKt4gKY9FUZRuPd5sQEqJ269SYBW0tLRw9NFH09zcDCQ+H4HQOWzzeDFlyY+JP6jiMLcfsxJUCaoy48+rza+9N6+nDTUo095Hf7w2OoPX6034fR+otLa2Gucki/jioFZQv+PLL6g5GF0ec6I8kaPLtPTgXpuNv+yH2c6zOLTES0ANsLx+OSMdI7l62NWYhAl3wMQ9wDcLjuDoskMBWGdax4qWFZxVcBaV9kpK60sxebTbdl5DES1bWqjZUQP0v2ujzd9GebA84+1qD9ZSs7Wm+w8oBS3eFspV7XhbQ6XNx+YfyadJtklbgAkhyoCXgB3AdyNW6XKzmOgIV2mH9a7QmI6UAh8nel0p5UPAQ6DVgCXKcW/cuLFb62bUFs2w1ObIoyBBiwlvQIGWFvKdDgpDT0Btqpe2Fi/5BQXh6E48+mOdj8evoDa3UFyQFz4fqQgqKrQ0Y7XZKSzsuxYSOlJKlKZmnPl2Cgu1Or5W1UNLwJ/x5+Vt8YHHQ1FhAX7hp8mf+rqA/nltdAaHwxHXA24g09/qfHKd1k/2wvsfcsoJxzB+SPR39tJnL+Wjho8ACPoHAVfySvNb2NXPqG2rpSHQQHlhOY+6Hg2NKQd+wn+9/+KjBu223eLXHsT+0fAPiuxFzB03F2fBIUAeroJWlJEFVE+qBvrftbFm0xoOtqZvwqpTbC/m7MPO7oEjSoxf8fPoh48iQ7PJmtrMgJP3ve8k3S6tFGTIq+t5wAbMk1JGzrfU67o61nFNBBqklAcixkWNCRXhjyG2fqxPUdV2Ly9/ktZCQT3FFJFus1kEkpCwGGC4/Vq+3mlLr/4LIi0asiM9F1QlEhkV9TQLgZQy42MM14AJ0T5D1khDGhj0G1yhFGQ6PmCg1YApqsL+1v0U2gopsrfbV8hQH8ioFKQp1gvMbGpPQfZXHzApZadTkM2+5l5v0VTXVhcWX6B5tAGIFE746RixWoCngHHA6VLKKJtxKeXXaAX550dsYwr9/VLE0JeAbwghDolYdjZgB+IbUWVIZ2Z0xiOoRrrZJv4gldA6S6QAC5luDsRCfLdfwWIyhc9BOgghkhqd9jb6522JeA+6z1umdWCqlJhNukmvIcAyobu+ywYGPUlDW5pF+CZNQKmqndq2WoJqkKrCqqgxugDrWIQP7QLMG/BiHQBF+I3exk4V4ANIZK/7gdW21kb9HQhq94/uqAG7H8189adAuRAiMin7oZTSh+YD9lchxHbgHeBCNMF2QcTYp4EbgFVCiBvR0pG/B/7eHR5gVqsVj8eD09l1Y/2AEqlkEwspPQJmiSjCt4baziSLnPVX3H4Fp82ccRsms6lzRe49gf7ZWzsU4UPmUTpFlWEPMEOAZYbH48FqTX5TMzDoa1xuP4UOS7jbRSJEyBE9oASp9dZS4igh3xbdQkhVtHtXZARMCIHVZI2OgEUU4QdUrSG3SfSvts6ZGrB2xOVxUZZX1k1Hk5ratg4CLBQB645ekLpL591x1o0Gtksp/yGEKACuA24EPkdLVX6mD5RSBoQQpwP3AisBH/AEcG0ax5CSiooK9uzZQ1VVFXl5eV3qxagLKyEEwXRSkBE3a6vZhGDgRcB0A9bS/MxvmiYhULIk4qGnjiN/UPWPN9OssqK2d0kwBFh6SCnxeDzs2bMnbr9KA4NswuX2U5afut5VCIkQXuqD76NKNSb6BfEjYEC0GWvA3R4BC93kvUEvTmtOd/SLobPpR53etqKIjYCll4JMKcCklKPSOQAp5cPAwynG7EazsOh2ioq0XPrevXsJBJK/6VS0+oI0ugPYzIKDgOdAfFPVRncAtz/I5pa8qOX1TV6aLSZcSb6YXq8XhyO5WWsu4Q0oWguiQhsHLenXgAFhk1J3Xd8X4Td7ArR4g1ia88KtlMLvzWXHbkn/SfNAi1b3oTTYCaoqtU0+/PVW8u3Jv3b97dpIBy3lKBBCi2YPGTIk/J02MMhWGtr8Keu/dDzm92hUP2CwczAOS+z3W1XyABVhik4r2sy2sMWBJ+hBCDCbZL8WYB0FTab0phVFo7cxxg4k0BM2FNlOUVFRt/xo//61LfzhXztZ9I0RvPTZfj76ZWyrHoCf/ONDPtrVxL8XHxW1fNmDa1FUydOXH5HwNWpqavrVDK87XtnEA2/t5NNlp2XsaH/bn96j2RvkmSum9czBZcA1T33MO1tdrF3S/pmu3+Hih39/lxX/8w2qJ1Skva+f3fVvRpQ5efgH02j2Bjhr2assPXMSl04bk3S7/nZtpMMFD/+XYSV53Hl+4u+MgUG24XL7qShM/bDkC/o4YLkfG0MZXlQZd4xmwupFiOgouc1so9HbqNn86A25Owiw/sTelr0xKb1M6c0IWDyx2ObT6te6XIQ/EDnQ6qPMaWN4qZNGdwCPX4k7LlH4eUSZk10ud5wt+i8bdjQyaWhhp9oJFTmstHq7FrXsLmqbvVR0aCNVEIpYtfniXweJaPEGKQpZmBTaLZhNApfe+9IgTF2zl3e/Osg7W7uWdjAw6G1cbYGUBfiqVPm68WtAoZL/SVivpSrOmPQjaAJMIgmqwSg3/KDaPwXYe7vfSz0oBbpg7Q3iicVWv/Y7nyoCZgiwOBxo8TG40M7QYu1GvK8p/lTfg61+yuMIsOGledQ2+/AFM7th5ypBReXj3Y0cNbJzDQ0KHRZavJ2b8dLd7G/yUlkUnQrNt2spVf2pJl2avQEKHZp4E0JQkmcNty4xaOfNzdrE6n1NXupbs8OM18AgHRra/Cld8Hc378YdcFMhLsCqDk84rqMLvk7kTEif4kNRFczm/hkB2964vcvRL9BEb5OvqRuOKDX7W/fHLPP4jQhYp2kXYFpt176m+Bd4Q5uf0ngRsFItH7/H1T89WjqyubYFt1/ptAArsGePAKtt9lKZIALWmoEAU1VJqy9IUV7703Gx00qjxxBgHXljYx26k8tne3rnRzNbWLrmU+55o8uTwA36AG9AwRNQ4t4DdBo8DRxwH2BI/hAKxcSoXpAd0VKQsZmTjlYUeiF+fxNgUkrW7VnXbfs76M7cxDVTAkogbr2ZO5Q1MyJgneBAi4/BBZERsNgLXEpJgztxBAxg9wARYBt2NgJ0IQJmxRNQ+ty81uNXaPYGGVIcLcDywynI9AVYiy+IlFDkaE/JluRZaTIiYFF4Awpvb63nrCOGAfD53uY+PqLeI6CoPL1+N/8xUq85iV5OkGgWpMvjYkfTDgqsBVq/R5MvqQBTldQRMNAEmKUfCrAvG76kwdOQcL3L40q6viOZjO0sHQ1Ydbx+FUQgpp6vI4YA64CUkgOtWgSsUhdgjbFfija/gj+oJqwBAwZMHdiHO1wMKrAxoiwv9eA46Gm6TCJMPcH+Zu2HrGMEzGo2YbOYMjq+5lCkqyiijVWp02bUgHXgvW0NuP0K86dVMarcyae7B04EbNO+FrwBNeymbpBbNCRxwW/xtfDGtjcwCROjS0cjhNAEmEwVAYu915iFGZMwhQWYJ+jpd0X4qlR5f8/7Scfsb9vPK1tfoS3QltY+D3p6PgIWL/0I4A2qKaNfYAiwGJq9QfxBlcGFdhxWM2X5NvY1x17gDa2Jn36GFDmwmsWAiYB9uKuRI0eWdtp7rSAkwPo6Dbk/FOkcUhQ7q6nAbslIgOnvpSivPQJW7DRqwDryr421OKwmjj+0nClVxXw6gFKQG3ZqqQtDlOcmrpALfrx7wG/X/pZmXzNjSsaEI1h6BCxebbiUpoQCTAgR4wXW3yJgXxz4Itz3MhEH3QdpC7Tx6levElBS/472Rgqyrq0u7nJfsN18NxmGAOuA7t00ONQYemixI24E7GCbNi7el89sEgwryWNXQ/+PgDW0+dlW39bp9CO0p+n6WoDVNicWYPl2c0YpyGZvbASsJM9Gk1EDFkZKyb821zFj7CAcVjOHVRWzp9EzYCJC7QIskDWdIAzSp8GtR8BiZ0H+4sRfMOfQORTa2xt0a/0gTSBjx0tV+82Jl4KEaDNWT8DTr2ZBBtUg6/euTzlON2c96D7Iv7b/K2W/xxZ/S/ic9RSJJgwEgqkL8MEQYDGEBVhBhACLUwOWKv8/vDRvQETAPgzdRI4aWdLpfRSGREpLH1tR6AKssjiOALNZaM3AhiKcgowowi9xWmn1BZO2txpIbK1rZVeDh1Mmao73h1UVA/DZ3oERBdMFmKLKPn/4MMicRl2AxbkH2Mw2qoqi3e4jG3J3RCq6C378h3ab2YZfDUXAgv0rAvZJ7Sd4gsnvlapUo7y9djXt4r+7/5ty3z0ZBWvyNsU996pUCSpmMFKQmXOgtWMELC+uADsYSkGW58fP6Y8odbJ7ANSAbdjpwmISHD68pNP7KMySCNj+Zi8Fdkt41mMkBXZLZkX4ofdSGFmEH3pSNqJgGm9s0sL3p0zUzG2nDNNMlAdCGvJAi49dDR4mVmoREiMNmXvoNWAleem1X9MFmBpHgKmhNkTJImBBNYgq1fYIWD8QYL6gj4/2f5RynMvjQlGjH4C/OPAFn9V9lmALjZ6sA0sU/Wr1tyJVixEB6wwdU5CVxQ6aPFrLoUjCBZgJeh8OL82jvtUfs11/QzNgLSLPlln7oUh0wdPi6/sI2JCi+II6326hLYPPMm4KMlSs22jcbAH418Y6pgwrCkccS5zaRI7P9/T/mZB65PjUSVr0r8G4JnIOV5uf4jwrlhSNuHVMIkkELE4fSJMwhVsWRc6E7FgD5lf8KdNx2cqXDV+mlSZM1Jz7vT3vsatpV8LtejIClqgAv83fhpQ2owasMxxo8WE1C4pDTzXDSrQvwP4OUbAGtx+b2RQ3WgLtMyH7sxdYuwFrSZf2o6cgW/s6AtbkjZt+hMyL8Js9cSJgoWvKKMTXROgHOxqYNTG6tdNhA6QQf8PORqxmwYnjBgEMmLq3/kSDO5BWI26dcAoyzkxIVYmOgFlMFmaPmU1lgda2KFKAeYJ6BKx9+1yNgjV50/uuJxJSUspQl4EE2/VkBCxBv8rWQCtStSJEgGZf8odJQ4B1QPcA02f0VRbFN2NtaNXaECWa+Te8tP9bUYQNWA/pfAE+tIuU5j4vwvcxJEFft84U4Ttt5qinYz0FaQgweGvLAVQJp4QiQDpThhWzs8Hd7/3SNux0MXlYcdjsucEQYDmHq82fsg1RJElrwFRnaIwHu9nO6WNPZ0TxCPKt+QDYTBFu+EFflA0F5K4Aa/W3pjWu3pPYK6/R25hwXYOnoUdaEgWUQEKfMS0CZkWYAknFIRgCLAbdA0xHj4DFCLC2+H0gdUYMADPWL0KmmXrxdGexW0xYzaJPa8BUVWopyAQRsHy7JaNekC3eQFT6EbRZkIDhho/mfj+owMbhHa4d/Vr6vB8X4gcUlU9CkWO9hMGoAcs90mlDFEkyAaZFwFTy7SbOHH9mOPKVbwsJsIgIWFANYjIpBFVT2NKiPwswVapJTVWTRdGCajBlFKozJDJghVANmLQBvpSfiyHAOqC3IdLRLQk6WlEcTCHABhfasVtM/dqKYk+jByGgqrRzBqw6QggKHVZa+7AGrMHtJ6jKGBNWnYJQDVi6T1PNnmCUBxhASb4eARvYN9ugolKzuY6ZEyowmaIjyFNDAqw/pyF1A9ajRpZSYLdgNQtc/Tzi1x9pdMdvRZeI5BGwPEwmH2dNOJOyvLLwcj0CJoTAarK210uFZtjpE6pzVYCl8v4CLcLVsQA/Er/iT2rO2hNpyGT9KtsCbaBaCZoaUtbmGQKsAx0FmMNqpjyOGavLnVyACSGo6udWFHsbPQwusGO3dL4AX6evG3InM2EFLQImZXuPr1Q0x4mAFdotmE1iwKcg1+9w0ewNMmtSRcy6snwbVSV5fNaPWxLp9hNHHaKZF5c6bUYNWA7SkOIe0JFkAsxCMYV5ZorsRVHL9QgYRHuBSbTfkFyeCRlUg2kdt+7/lYxkacieKMRPVP8F0OJrRUorAVI3FTcEWASKKmlo84U9wHQq45ix6jVgyagqyWNvHBPX/sLeRi/DSroW/dLpawGWzAMMMu8H2eINRhXggybKi/OsNHoG9s32X5vqsJoFM8YNjrt+alVRv27KvWGniyFFdoaFrrVSp82oAcsxPH4Fb0CN24YoEUIoQDBuEX6+pQKnLTa6rkfAoIMAC82ozGUBlnb9VzoCzNOYcF1PRMASOeADtPk0w10/8WduRmIIsAgOtvlQJVERMIg1Y/UFFVp8wZQCrMTZv53P9zR6upx+1CmwW/p0FuT+sAt+fBuKArsW5Ut3JmSzNxBlwqpTkme0I3pjUx3HjSlPOIN46rBittW3ha08+hsbdro4KqJ1V2m+1agByzGSueAnI15DbovJgpBO8myx6ap8W374OtEFmJQSifb6uSzAWnyp04+QXgSrNyNgTd6mhMax2iQJTUgH5EFMIrnE6pcCTFVlp9zGO3qA6XQ0Y9VvoKkEWJHD0ucz+3oKKaUmwLotAmbt0xtubZMXkyAm+qmTb9MjYGmmID2xKUjQ+kH2Z1Geih0H29ha1xo2X43H1OFaHdgX/TANqRuwRrbuKss3ImC5hqstsQt+MuIJsEOKD8Hrt+CII8A6eoFJJEE1iCK1+1EutyNKtwA/nQhWo68x4brubEnU4Glg3Z51Cde3F+CDX7rIsyS/P/ZLAfant7dx8m/ezLi/WiIB1tGMtd0FP4UAy7PS4g30yDTYvqa+1Y8/qHajAOvbFGRdi4/yAntCU0U9WpNOBExKSbM3tggftHTTQI52/OdLLZ0wc0ISATYs1JKoH6Yh2+u/SsLLSp22AR8VzTVStaJLhMnsxu85FF/r1PAMxjFlY/D4TXEFGLSnISNnQqpyYKQgm7xNBNXUv7nJImBA0lmUqVClyteur3l287Os/HwlX7m+Sji2zd+GVLUHb5/aODAF2Jub69jb5OXr+sQzI+LR3gcyug6ooxWF/rSa6stX6LAQUCTeQG66FCdDr23rthowu6VPe0F6Agr5Sdz8M6kB8wQUFFWGDWYjGegpyF0uNzaziUPKnQnHDC60U1nk6LcCzGoWTBnWbr9Rlq+JcqMhd+4Q7oSSQQ0YQP6gFzCZW2ipO5+mvZdCYAxVhSPwBUxxU5AABbYCoIMVBdq9KJDDAiydGZDJ/L8i8QQ8Sc9BZ9OQG/Zt4G+f/I1Xv3qVvS17U45v9beCtCIJEJCt4ehlIvqdAFNUyce7GoHMvYT0PpCDCqO/VLoZqz5T7mCbNi51ClK7AffHWpZ2AZb8AksXzYYifZuH7sYfVLFZEn8dwgIsjXZEugt+whTkABZgtU1eKorsCQ2Mdab2U0f8D3c0MmVYMQ5ru9gvddpQZf/8neivuNJ8CO+I1b6XkqoHKRi8GjVYTP2uC1m9VosGJxJgTqv2sBIpwBSp/f4qOSzA0omApVOAr5O0DqwThfjNvmbW7VmX1OKiI7oLfkDsAyDPOsAiYJv3t9AWsgr4dHeGAqzFR4HdgtMWnTrqGAFL98unF2H3ZWSnp9gTEmDDSxJHMjKh0GFBzcDmobtJJcAySUGG+0DGSUGW5Nlo8QU7VaPYH9jf7E3otRbJ1Koivq5vy6j9U7YTUFQ+2dMYVf8F7f1kjTqw3KHBHUAIwi3rMkEIiaPwI0pH/IEjDt3Nzjqt5CXPniAFGbKiMAszJmHSImAhAZbLEbB0BFgmkavuLsRPZjWRCL0PZFDsBhh4KUi9xmJIkT3jJ+iOHmA6Hc1YG9r8CNHeXDkRRSEbgiZP/7mJ6Oxp9JBvM8cVGZ2hIHSu+qoOzK+o2JI01c0PzYJMJwWpC+54KUj9ZjtQC/Hrmn0Juw1EclhVMVLCxn39pxB/475mvAGVIzv0TtXTWAO5NjDX0Btxm03JI7nJyLdbOX2aymWn72fm4Y2MGxZ/Zl2BVUtBCiHCMyGDaigCprY35M4lpJQpBZiUMqPIVTJH/M7UgCUzW01Eqz8UATNp6coBl4LcsNPFoAIbsycP4Yu9zRnVVeh9IDvS0Yz1YJufkjS+fIX9PAVZVZqXMpWULuGG3H3khu9LlYK06RGw1BG69hRkrDgtHsANuaWU7G/2Juy3GYnekijTKHY2s2FHuwFrJHok3dU28K6JXMXlzqwNUTzGlI7RuoDkKRw7vgWbJf69Sk9BQrsVhV9qabFARD/IVK7r2YQ74E55vE2+JgJK+t8Jl9eVcF1ADaTd+Ftnf+v+jMZDex/IgNiNRdiwmJIHKPqdAPtwZyNHjizlsKpiWnxBdmTQCqhjH8hIIs1YU7ng6xSHokPN/TDasafR020F+ND3Dbm1FGTiInyTSeC0pdeQuz0FGacIP/Sj3TQAzVhbfEHcfoXK4vjfsUgqihwMLrTzWT/qCblhZ2OUAauOHgFrMCJgOYMrwzZE8RhTOiatcTFu+KqfgKrd1yIbcifqTZiNdHf6Ebp3JmRQDWYcNZNS0hbQU5B7caRIP0I/E2ANbX621bdx1MjScE+5TGZS1SdIQUK0F9jBVj/l+alvInoRdl/aK/QU3emCD+3Roj5LQQaTpyBBb8idThF+SIAlmAUJAzMCVpui3VNHDqsq7lczITsasOq0R8AMAZYrNLQFMp4BGUmRvYiK/MRWLJHkW6PNWINqEJ+izSAM5mgErLsL8EHrwZgsYpZJOvNA24GMz6c7GIrqqVYCpt3YU6QfoZ8JsA91j52RJYyrKMRmNqX9A+4NKDR7g0kEmCPKhiKdCFh/TUG6/UEa2vzd5gEGUGAPpSD7sAbMniQFCSG3/rQiYNqYjq2IILLep39dE+mgdxtIpwgftJmQW+taw/57uUxdi5fdLk9MAT6A02bGZjYZEbAcwtXmpyw/8wJ8nXSjXwBmkxmHud2MFYgfAcshv8nutKDQkVLS5Et8v88kotaZ+q82v5YWDqoKqmjGYUl9fXRPBXWWsGGnC4tJcPjwEmwWExOHFqZdiF/fqnuAJRBgJe1mrA1tfqaPSi3AHFYTVrMI1wT1F/Y2ajfS7hRgheEIWN8Ik1SzIEETYOmmIG0WU5TVgE6xU4+ADbybbW2z9h1L1G+zI1OHFaFKuPrJj2Nmm42vLOSSGaO7/Rh7ig07GoFoA1YdIYTWjsiIgOUEUkoa3P4uRcAOLT00o/H5tnw8QU+7FUWoCL+/RsCklJ2auejyuhjkHBR3XSYRsM7MgNTfkx6ddFhSZ8n6lwDb0cikoUXkhQw1p1YV8/zHe5FSpiwWT+SCrzM0dNPY2+jB5fandMEH7Ye1yGHtdzYU3W3CCpECLJtTkOa0WhE1e4Jx04+gGc6axMCcBVnbnFkK8pjRZUwYUshHIV8/nVZfkJXrd/E/3xyFqQuz0HqTrw5oP86ThhbFXa91SBh410Qu4gko+INqp2vAyvLKKM2LjYQmI9+aTz312Ex6BMyPyaTmrABL1Qey2dfcqZmdyerAmn3NBJQAVnPqyFRXImA+qc3cTjUDEvqRAAsqKh/vbuT8o4eHl00dVszf39vJrgYPI5M4b0M6AkwTG5v2t6DK9A34ivKs/a4fpO4B1l2NuEGbZShEH0bAlPQiYHr0Lxkt3kDcGZCgFfMXD1A3/P1NXorzrHEjg/Eocdp45WcnxSx/6N9fcduLm2jzB+NafWQjrjY/eVZzjMegTlm+zYiA5QjhTiidjIBlkn7U0QvxI81Y801KuBck5JYASxUB64xxKiS3otD3W1lQmXRMi68FdyD9yXs6+nvyq40gTdjNqSNg/aYGbHNtC26/EjXFOzyVPY00pO6CnyoC9nmoQXC6AqzQYel3syD3NnowmwRDEpyrzmAyCQpsFlr6yHgznRRkvt2SnhO+N0hhEoPGEqeNxn52TaRDuiasqcjFyS2p6kZL821GDVgCapu9/OfLA319GGF0u5DORsC6IsCEEFhNVvyKH3OHCJgi+8bEujOkEmDxCvAD3uEogeI4o9tJNRMynbRmZ6JfECHAZAMWBqdl0dRvBNiGnY0AUUWu4ysLsJpFWlPZD7T4ECKxsNLTJnpRf9oRMIe13xXh73F5qCxyJGxc3Vn6siF32gIszVmQiSJgACVO6wCtAfOmZcKailyc3HIwlQBzGjVg8ZBScsXfNvA/j76Pp4+6ZHSkIdyIO7Poa3leOXPHzaXIHj8NnQy9ITeAxWRBURWECOZkCjKgBPApvqRjOgolKQXN+7+H2zUr6XbNvuak5yGdyFpn6r+g3YfMz0FsDElrm34jwD7c4WJQgZ3hEWkxu8XM+CGFac2EPNDio8xpw5pAVOhmrF9kGAEryus7UdFTaB5g3dMDMpICR9805JZSpnTCh0xmQQbieoDpDNSG3PubvFQWdT1q2tf1gp0hlXdgWSgqqhgNuaNY89EePtjhIqhKNu7Pjq4IulBO1QlFx2l1MmPkDOZPnE9VYVWnXjNSgJlNZoIyiDBFCzBFzQ6Bmop0ZkB2NFVVg6VINQ8lEL/APjxOqknTkHVtdSlfuzMRML/ip8XfgpSSgKzHSvLj1Ok3Akzz2CmJCfsdFmrqm2qKbqI2RJEMLXFwMPTlKy9IMwVpt/a/FGRT95qw6ugNuXsbf6gvY8oImM2CN6ASTNHHscUbTBEBs9E4wIxYg4pKfasv7QL8ZPT1jNnOoHkHJk9BStk/TZs7S4s3wG0vbmLMIE18ZIsnnN4yKlUNmNVkZVrlNM6ffD4TB03sUteQSDNWi8lCUA3GRMAkslO1S71NqvSjX/HHvI+gbygAir+cjrfyjvf2ZGnIend90giXoioZ+48BuDwuTXypAaQIYBPlaW3XLwTYwVYf2w+6Y1p8gDYTstEdCBeOJyKZC75OZVG76Eh3CnJRniWnUiWpUFTJvkZvt1pQ6PRVCtIf1ARVKh+wcD/IFKkQLQWZOAI2EIvw61v9qDL9GZDJKOyHNWD6OqMOrJ17/rWV+lYfv184jfJ8W9a0pXK1+TGJ+J0uIjlz/JlMHzY9rVl3qYg0YzULsxbtEoEoAQZaCi7bSSXA4kWwgr5hAEjpQCr5YaG05eAWPtz/YVQz8lR1YJ/UfpJw3QF35gas0O6yrx+HjQEkwPRp6vFMDtN1xE/UBzISPe2WbzOnPZOryGHFG1DDN/lc50CLj6AqeywC1pcCLJ1ZkJC8IbcvqOALqkl/nEudNlq8wZSRtP5EpiasySjq47ZVmeLxK3gCStKi7bBBr1EHBsDWuhb+/PY2Fk4fwREjSphaVcxne7NDXDS4/ZQ4bSl7AafqA5gJkWasegQMEYiaBQmp7R2ygVTH2OhrjFkW9A9FEsBjWs+2xq/5uPZjdjTtwBv0xkT+Ugmwr11fJzyGztZ/dRRgdlNJWtulJcCEEGOFEA8KIT4RQihCiJo4Y4YKIR4VQuwRQrQKIT4UQnw3zrjJQog3hBBuIcReIcTNQoj01EwC2g1YY2dITKwsxGISSWdCSinTSkHqBpJlaaYfof0pKZfSJckIW1D0gAArsPdRBExPQabRigiSC7CWJC74OiUhM9aB5AW2P9RFIl0T1mTo36lcSdfpUa1kKchwBMwQYEgpWfbsFzhtZq6dMwGAqVVFfFnbgjfQ93VOrrYApc7etz/R05AWkwWJRJGtMRGwdOqr+ppMI2BSainIurxrqLPfREvgAOXOciaUT2Dy4MkAUZ5h8QRc1P6QfFb3Wdx1nZ0BGSnAhHRgFunVuqYbAZsCnAFsBrZ0XCmEMAHPAicDi4FzgP8CfxVCnBcxrhR4HZChMTcDPweWp3kccdmwo5HJw4riRqUcVjPjhhTy2Z7ET08tviC+oJpSgA0LeYFl4v/S102mu5ue8ADTKeqjIvxMI2DJ6tSS9YHU0QXYQLKiyNSENRl2i9ZhIldSkA2t+qy5xL8b+jXhMlKQvPzZft7eWs81cyZQHspKHFZVTFCVbNrf9wIj3VZ03Y3TqnlZmk3afS5IU6wAy4UIWAqR2FGAqcFS/NKFl68oCpzHodYrOaT4EApsBVhMFkzCFCXAmrypa7431m+M2zeyMxEwKSUNXk2A+RQfVjkMkym936Z0BdhzUsoRUsrzgc/jrB8PTAd+KqX8m5TyDSnl5cCHwMKIcT8C8oDzpJSvSSkfQBNfVwshMp+bS7sBa7z0o87UYUV8lqQQP5UJq044ApbBl0+/EefK03oqesIFX6fQYcEX7P10rS9NAdYeAUv8FK4L7aK8xBGw4gHYkLu22YvFJNLqIJEKIUQoXZ0b5+9gm/b7kk4N2EB3w/f4FW55/gsmDS3igmNGhpdPGZZeKUlv4AqlIHubAlsBABah/bbEFWD9IALWMYIV9A3FY3ofgGJxLDIYbfFgM9uixFRQDaY8D37Fz6b6TTHH1RZoS3X4MbT4W8Kv7w16sajDEab0vsdpCTApU1al6Y/7Hb8djUDkFTIXeEVKGRmOegJNlJ2czrF0RDdgPXJkScIxhw0v5mCbP1yH0pGwAEtVA6ZHwPLTn0rfnoLMjaf1VOxxeSjOs4ajQd2Jvs/evrGGI2BptCKC7oiAaT/eTQNoJuT+Zi8VhfZuax3Ul55xmRKeNZdEgOVZzdgtpgFfA3Z/zVb2Nnm5+ZwpUT6Dw0vzKHFas0aAddYFvyvoVhR6BEwVLXTMyGZ7Eb6UMtyyJ9H6ju8h6B+Gx/weDkseDqsJJRBd4G4z2/Cr0d+bVI74oBXjRwZlulr/pUoVv+LHKqsQIr3vcXcV4X8GvAfcLIQYJ4QoEkJcBJwAPBAxbiIQJTullDsBd2hdxsQzYO2IXoifaBZNuhGwIcV2hIBBGdSAtacg+8eT7d7GnrGggPbZbb1tRZFuBCydIvz2GrBkRfihdFNb/7gm0qG7TFh1CvsoXd0ZDrbqNWCJf1+EEJTl2wZ0DdjBVh8PvvU15x5ZxTdGlUWtE0KELYX6EimlVgPWFylIm5aC1Iv7FWJrwFr9rSnTb31JW6ANSeLja/G3xPiZ+XwleE2fU2wvwmw9iBIoQ8r2920z2WL6RqYqxNdfa3vj9vDfXa3/8gU1HWGV3RwBS4XUPvG5of1tQYuEPQRcLKX8V8TQUrSoWEdcoXUZ8+EOF4MLow1YOzKpsgiTSBy+TleA2S1m7lo4je8ee0jax5drBcOp2NPooaoHTFih7ww2060By0+nBiwkCpKlIEvytB/vgVQDppmwdt91U9RHM2Y7Q0ObH7NJJL0mQG/IPXAF2I4GN35F5expw+KunzKsmC21LfiCfVeI3+ZX8Ctqxi743UGBNZSCDAkwlbYYAaZKNau9wDpTgN8aqAOhUuwoxmw9CFhQg+0T7mxmG0E1GGUfkY4AA/i49uPw/3fXDEiLWoUQ6f22d0seKVSE/zhQjlbzVYdWtP8nIcRBKeXLXdj3ZcBlAIMHD6ampiZq/Tub3YwsNPHWW28l3c+wfMFbn27jKNu+mHXrN/sxC/jwvXdSmuUVA183wtdpHr8nqKn9Dz/fTKW7favW1taY95IL7Khvo8rm6ZFj/+qg9sP6n/9+QH15lybGZsSnB7Qb+eeffIx/V+LX9SvaZ/npxi3U+LfHHfPhNu0G+vH7/2WzJf61pEqJAD7e+CU1wR0x63P12kjGnoY2xjh93fa+fK1e9repOXGePtvqI99Cyt8o/B6270v+2ffHa0Pnozrte7ht46eIfbHfQ1NTkIAi+ccLNYwq7r3fh0gOuLWbfO3Or6mp2ZV0rN/np1xJzw8qHUplKZVllXgVL1fXXc1QWwkNrSZKa8sxCbAELZTXlfPu2+9iNWVnk3qf4qPcl/ic5AfzGV42PPx3k8/MrWIldpHPlUOuZG+rk7/Xw6mO7zKmWBM8a8Va/tL6F+YXzmewbTAAVmGluC5530iAQF2A1/e+rrV3ciuUp+nfFclp5tNQyhReOfAKX/M1VjmMmYUlTC6bhgkT7/Juwm27q5BnXujfeCnll6FlNUKIEcBvAF2AudA0TEdKQ+tikFI+hBZNY8KECbK6ujq8rqHNT+3Lr3HxyeOoPvnQpAd4TN1H/OfLeiK313n+wMcMaahn5syZSffRGVRVYnrjRSqqRlJdPSG8vKamJu6xZDPN3gCel1/lmCljU57vzjBoTxO/fv9tDp04heopyTvWdyeBL2ph/Qcc943pHBbHykRHSon5jZdCn2X8jPkHvs2Yv/yKObOqk4r54v+8SknFMKqrp8asy8VrIxmtviDel1/hqEljqa7unuvm+QMfs3dr/O9ztvH3nR8wNOCmuvqkpOOe3ruBL/Y2J31P/e3aiOTg+t2w4WNmnXgch5Tnx6wfc9DN/R+9iX3oOKojCvR7k092N8K/3+H4ow6nenLyfn8vb32ZvY17u+21FVXh0Y8eDacYdwa+pACoK2/AapGU15VzsOIgR4w+gvHl47vtdbuTD/d9yLY92xKuf3vn22xqaK9S8raOx2P+gCJrCStcK1CDBcC1vNjwAXnKe0B73dvfDv6NQnshAHazne8f8f20jqm0rJRJFZNYvWl1xu/Hr/j5yyd/QUrJ9pbtWIQdE05q3M+wVmzCbk6eVeuuGrCJgDtCfOl8CET+4m6iQ61XSKQ56VAblg5b67Rw5qShqSdQHlZVzIEWX3g6fCTpeIB1FpNJUGC39IsU5L5G7dz1XA1YdqcghRDk28xJa8CavQEKHZaUkVQt3ZT710Q66N+5yuLu+47lUhF+urYFZfm2Ae2Er6dfE80wHFGWR5HD0qd1YHqNXl/UgJlNZhwWB0IILCYLKlqqMZfMWFNaUPiiP9tWrwlVNFHi0MoXhLkVIbxRhfg2s/ZZRNaB+RRf2qnYr11f87Ur3ZxWNHoLItBSkHazJgB7uwh/B+AUQkzosPxoYHvE3y8Bc4QQhRHLFgIeIEV8PpZdDdoJHlHmTDn2sCSO+AdafAxKMQOyKxTlWfuFD9ieRu1894QHGES2mOnlWZCKlvpMJcBAb8idxIYiRRsiHa0d0cC42dY2dZ8HmI7eNzQXmlenK8BKnTaaPIEB1SEhkkZ3QKuVS2BiLITQHPH7UIClM6O1JwmbsQoLitS+V7lkRZFpDVhzoA6kieI8rf5NCMKF+DrxBBikPyNUlWrS9kTJ0Ou/ICTATFowqFuL8IUQTiHEt4UQ3waqgMH630IIJ/AisBNYI4T4jhDiVCHE74EFwH0Ru3oA8AGrQmMuA5YBv+tgTZEWu10ehGhvEZSMSUOLEALe3FyH2uFHO50+kF2hKIc8i5KxJxQB6wkXfEjP6DQeW+taeGLdzk6/broRMNAK8ZNHwIIpi61BM94cKE743dmGSEe/SfdF8/ZMaXCnHwGTcmB1SIjE5fZTkmdNGj2eWlXMpn0tBPpIpDaEZi73hQ0FRFtRKGiejLnUDzKZAOvYhFtKaFW3kCdGRLV10gRYewTMJEyYhTnGiiKT85BsZmYyDnoOApr3mCIVbKIEIO0i/HQjYBXAU6F/xwGTI/6ukFK2ALPQ7Ch+C6wBTkEzXv2jvhMppSs0zgw8h2bC+nvgpjSPI4pdLjdDCh3YLakLMvPtFk6bPIS//ncn8+9/h3XbNOWqqJKDPSzACh0Wmj3Zf6NIxR6XB6tZpPRL6yw2iwm7xZRxaukva3ewZPWnMcI6XdL1AYOQAPMns6EIUGhPHQErGUANufd3owu+Tq4YHAcVlUZ3IL0IWNiMdWBERjvS6A6EOwIkYmpVMX5FZUtt30R5XKEZrclajfUkugCzmCwoUpu9n0tu+MmOrePMRa/fRsC0g0Lr0KjlJutB1GAJUrbf923mWCuK3ogEujxa6Xq4CbfQzByEKb3vcFpXkZRyO9GGqvHGbAXOT2NfX6CJsy6z2+VOaj/RkT9+92jWfLSH37y8mQUPrmXu1EouPXE0qkxtQdEVivKs4XRpLrO30cPQ4rxuM9OMR6Ej83Tt3iav9rTkD6aV/utIuj5goKcgkxmxBhk1KHVKvMRpGzApyLpmH4V2S9jGozvoq3rBTNHr/MrT8A4M+8MNEGHeEZfbH25KnojIUhLdHb83aXD7KXVae/Q3MBl6CtJsMicUYG2BNqSUKetQextf0EdATXxtd6z/anRr3+2SvDygfTuz7SBgQgmUYbEdABIIsB4WolEtiEIeYDZRrh1pN0fAspJdDZ606r90TCbBeUcN581rqvn57PG8teUA3/rjWiC1C35XyCXPomRoJqw94wGm0xmDTb3Rc2fPsd6M255WCjJ1EX46IrDEqQnNgVDvs7+pe01Yoe/qBTMlXLSdRspKHzNQzVhd7kDKFj+HlDkpsFuS9vbtSRr7qA2RTmRD7nYBFj1GlWrKWqu+IGULog4RsCb/QSzqEPId0cELzQuMmEL83hZgkS2IPEEPAoFVasfU3SnIrCOoqOxv9mYUAdPJs5m5ctY4aq6pZuH0ERTYLUxMYyZlZynK6x+zIDUT1vQFb2codCSPMMVjX5NWC9HZc5xxCjJJEX6LNxg2303G0JAg2VKbfT+U3c3+5u41YYXciYDpYiqdHpjhfpADVIA1hqJLyTCZBFOGFfXZTMiGtr5pQ6QTTkEKCypBJMGYCBhkZyF+KgHW7G0X1apUcas7cTIVkzn6O55IgClSiXLR7+lzEFmA7wl4cFgcQGi2Zm864fcF+5q8KKpkRGnnBUFFkYNff/twPls+h9GDYn1nuotCh5WWHJmxlYiAolLb7O0xF3ydTO0FfEGF+lCrl64IMItJpJVWSJaCDCoqrb5gWvUhp04agtkkeObjPRkfb65R2+zt1voviBBgvux+sNEFWFlaKchQBGyApKY74nL707J3mFpVzMZ9zX0SPdbaEPWdyWlMP0jaCKixv1vZWIifShBFNuFu8bUgCVJoGR4zzmTyIcwtKa0o3AE3QbXnHtD0AnwAd9CN0+pESiugIIQmBK3mFA8UPXZ0PcwulxaW7EwErLfJpRlbidjf5EWVPWdBoVNoz2zGaG2TL/z/nbX68AfVtOq/oH0WZLx+a/rnm04KsrzAzknjBvHcR3s7PXkgF1BUSV2Lr1s9wCCyxVd2f6ca2rTrM52oSZ7NTJ7VPCAjYN6AgjegpizCB60OzBdU2Xqg96PH6c5ozZTpw6bz7cnfZsbIGYwtG0uBrSDuOH15uB2RaMHXsSM32VmInywC1rEJd6PHjZAOCu3xH9w6zoTUhU7HGrOePA96AX5ACRBUg+RZ8pCqNaoAvyK/Iuk+claA7W7Q0k6Z1ID1Ff2hH+TeRu1895QJq06Bw0JrBkJKTz9C5+uB/Er6AqzAbiGoynDhfiS6GEgnBQkw/8gq9jZ5Wbe9IfXgHOVgmw9FlT0XAcv6GjDt+NI17ix1WgdkEX7YhDUvvQgYwKe7ezcNqTXiTj1RoDMMcg5ikHMQUyumcuqYU/ne4d/j+4d/n0HOQVHjdDNWswhFwEQLnngCLAtTkMnEUGQTbiklTb5GHOo0bI66uOM7CjCbKb4XWE+eBz0C5glq96A8ax5S2qLqvyoLknd0yVkBtsvlxmwS4VqabEaPgDVn+c0iGXubekeAZZqC3NfU3tmgKynIdOq/APJt2g9fvEJ8/fNNd4r67MlDcNrMPPNR/01D6hHK7hZgdosZWycsS3qbhjYfRQ4L1jSvr9J824CMgLl0oZpGBGz0oHycNjOf7+3dNFurL0hQlT0iwMrzYnsQ5tvyKbbHzvTMt+aHI2AKrXj7QQQs0oDVE/QQkG7ylOlYbPvjjjdbDyKVQlRVi6wnMmPtqfPgV/zh9+MJhASYJQ9Ua9QMyMr8firAdrs8VBY5sKT5w9aXtHsWZffNIhl7XNpF1lMmrDqFDiut/mDaabkoAdZLKUggbiG+LsDStcJw2jRvuhc+2Yev41SmfkJPmLDqFDksWd9h4mCbn/IMZlgP1HZEjSnaEEVi7qNCfFeG0cx0sZvt4R6GHXFaYzM8+bb89how0RJfgGVhBCypAIuwoNBTkQWmMQn9tDoW4gshsJqssW74/p4R6Q2ehnAZijvoxmqyYjVbkdIaLsC3mCwxEcyOZL96ScCuBjcjyrK//gvaU1LZni5Jxp5GL+X5NhzW1Ka3XaHQbkFKkpqdRrK/yUOhw0Ke1dzp8+vLMAUJ8ev52lOQ6ftdzT+yimZvkJrNB9LeJpcIC7AeiFQX5kCHiYa21DP7Iil1DtAImFsXN+mdq6lVxXyxt7lXJzY1hNsQdW8RflleWcJ1cQVYRARMpTVuOUSbvw1VZo/FjSrVpL0ZIy0o3AE3FjkYh92TcHy8mZBWc6wA66kIWMcZkHlWTYtoKUjtGAY5B4WFciJyVoDtdnkY3oUZkL1JOAKW5U/rydA8wHpe8GZqL7C3ycuw4ryQ1UcXImDppiD1CFgcgdiSYQQMYMbYQQwqsPXbNGRtkxeToEd6reZCBEzrA5lhBGxACrD0/dIApg4rxhNQ+LoXC/FdGXi6ZUK5Mzb9qJMwAhauAWvGH4wVoRKZVV5gbf62pO1+IiNg3mAAizoSi21fwvFmawOgovj7xgtMF2BSSrxBr5Z+hFARvnYfGFIwJOV+clKA+YIKtS3eLllQ9Ca6qMjlInzNA6w3BJgeLUw3AualsthBkcPa6Ro7f1BNy4QV2gVY3AiYN/1ZkDoWs4l5hw/j9Y11OV0jmIjaZi+DC+2Ye8A5PFciYOl4gOmUOm0DxqA3kvYUZHrfncOGhwrxezENGbYU6eYUZLz6L51EETAhBGZhTijAILusKNJtwq0JGg9WORyLfW/C8UIomCyNqB2sKAJqIGqGek+lYnUB5g16kciICJg1XISfqv4LclSA7W3UWs/kggUF5I5pZDL2NnoY2sMeYKDNgoT007X7mjR3/kKHpUsCLNMUZNwi/JDALsiwT9w504bhD6q8/Gn8gtNcpidMWHUynbDR20gp0/a20tFTcI05/LDWGVzuAE6bOa2+vgBjBuXjsJp61RHflUGdWiZ0JgIGWo1RMgGWTYX4bYG2hOsim3AH1AASBatahdme/Pcw3kxIVaoosr0mLqgGk6Y+O4OUMizA9BmQTov2OUlVS0EKIVJaUECOCjC9r2IuWFCAFuXIt5lzNsIRVFTcfqVHZv90pN1gM/WNVTdhrSzKoyiv8+2eMrGhyLcnnwVZaLdkHO2ZNqKEQ8qdrOmHacieMGHV6Uzbqt6kxRckoMiMI2Aw8Nzw0+kDGYnFbGJYSR61Ld7Ug7sJl1trxF3UjY24BaJTNWCgWVKooiWmFZFONhXiJ4uARdZ/6U2trZRjMvkSbKGhCzA94NVbMyGbfc1hg1d3wI1AhFzwAWkFU4ASRwl2S+rSg5wUYLtDM/JyJQIGWiF+rqYg3aFZNk5bzxbgQ7tlRzpiSrc4GFoSSkH2gg1FexF+nJlH3vRc8DsihOCcaVWs/fpguK9lf0FPEfcEhVneY7WhNfOUlT52oNWBNboDaacfdcp6ecJCQ1uAUqetW5tcFzuKwwX18XBYHAiiX0+/sWvtiFoJxGlFBFkWAfMnjoBFWlDoAsxuKk25T7P1IFI6kIpmTptIgHVlJmSjt5Ha1lp2Ne3iq4av+OLAF3xc+3F4vSeotSDSrwk9BZlO+hGg+6R8L7LL5cZqFj32ZN0TdCVF1td4/JrYyOsFAZZJk2XdhHVosUMrwu9VG4rY12p0B9I2Ye3I/GnD+MMbX/Lcx3sZ16k9ZB8ev0KzN9hj39MihxW3XyGoqFlpR3MwgzZEOuEI2ACzosg0AgaaHYSeDekNDrT4un0GZLL6L9AezvKseVFpNF1oaBGw1ri9ICGHImARLYi8QS8m6cBqTi1NImdCmiyt7W74Sve44XuDXp7+4umkYzwBT5SFiO6EX1GQOv0IORoB29Xgpqokr0cKe3uKoix/Wk+GWxdgPWxBARERpjTOle4BNrQ4L1yQHa9FUCq0FGR6781qNmGzmGIEWJM7wLtf1YddujNlzOACDh9e3K/SkLUhC4qeTEFC9tZWhou2MxAW4YbcA8wNv9MRsF4SqltqW3hzcx3HjE6cLuwMqXyiIDYNaRImbGYbFpMFhVaCcXpBQnYV4SerAesYAbMyDJM5tbDuaEVhNWnXT3e54UdaTcQjoAQIqIH2+i9pAiwZRcByUoDlkgWFTlFe52fp9TXukOVCb6QgnTYzZpNI66baLsC0FGRAkXgDmc8eyyQFCfEbcv/j/Z24/Qr/c8KojF9fZ/60Kj7f28ze1v4xA64nTVgh+wWYqxOz5nQRMtBSkJ2JgJXkW3G1de6hKxOklCx79nMK7Baunj2hW/edrABfJ14dmM1s0yJguEk0YdYdcIfb+/Q16brge4NeLOpwTObEgk3HZGkCEYgyY7WZbfjV7qkBSyXAIlsQgVaAD2C3iITGuh3JUQGWOyasOoWOzvtU9TW603Kerecz1kIICuzpFVfva/JQ5LCQb7eEzU87I3J9GaQgQSvEj4yABRSVFe9s55uHljNlWOciYADzjhiKScDavbl5nXSkNmzC2v0eYNCers7WBxs9BVmeQQrSYTXjtA2shtyKKmnyBDIyrAUtAuZXVNr8PSsyXvx0P+9+dZBrThvfqxYUOvEEmN1sxyIsICRBVYlJu+lkQxpSlWq4XU9HpJThGi1FVQioAazqqLQEmBASs6UhZiZkdxXh670eExHVggit/gugOC99bZJzAszj12a+5VwELAc8ixKhpyB7IwIGWoQpnVmQ+5q8DC3WLvbwzbgThfj+oJK2DxhAvs0SVYT/4qf72N/s5dITR2f82pFUFDo4bHgJWxuz46m1q+gTCnquBiy7I2ANbT7sFlPGqftS58BqR9TsCSBl5vYOur1HT4pVtz/IrS98weShRVxw7CHdum+HxRG2lEhG3AiYxdbeD1J68SnxZwxmQyF+MhPWyCbc4RmQ6nBEGgIMYq0o4rnhu4OdiwS6PK6k6z1BDxaTJVx7RkiAlealr01yToDtdmm54VyaAQmEi8R7OlzeE/RmDRik7++0r6ndm6y94XnmN+NMbChAE4h6BExKyZ/e3saYwflUj0+v8DIZQ4scNPly7xqJx/5mL/k2c1gcdzeZTNjoCxraApTnZz5rrmyANeQOu+BnWOBe1gsTFu57cyv7mrzcfM6Ubq85Tif6BYkjYOF+kNKHL5hAgGVBBCzt+i9FE2AWmV4KEnQBVoaU2mdjM9sIKNFpaSllxudBlSoub3IB5g64w/VfoBXgA5Tnp5d+hJwUYLoFRe5FwBRVhsVMLuHp5QhYutHC/U1ehoYsDvTZh51JR2VcA+awhFsRvb/dxSe7m7hkxmhM3fADPaTITmM/EWA96QEGRKSdszcClskMSJ3SfNuAKsLX32tnI2A9VS+3rb6Nh/+9jfOOrGL6qO4tvof06r8gcQ1YOAKGNxw96ki2RMASEesBJrDKoRkJMLCgBksA7bxIZNinSyfT89DkbUoaNQu3ILLmRSzTrsfSvNRRTZ2cE2C7XLoJa25FwLK9XiUZ7SnI3nEtSScCppuw6inIok62ewoqKqokwxqw9iL8R/7zNaVOK+cdOTyj101ERZEDd7C97i6XqW329agAy/4IWGZ9IHVKndYBZUPRmGEfSB29ZqwnzpWUkuXPfY7NYuL6uRO7ff/QDRGwUD9IBU9CAZYNMyEzMWG1iQIEVoQpPQFWUaI9rAb9g4EkZqwZRsBSFeCHWxBZIgRYKAJmyyCQm3MCbLfLg91iYnAPNPftSfSn9WytV0mGPguyt1KQBY7YWYYd0U1YdZPPogx7SOr4Q1OIMkpB2rQU5Pb6Nl7bWMv3jjuk2zzSBhdq13Vdc3IX6FygJ01YIftnQR5s81OWYWE5hGrABlQKUhPQGRfhhyNg3S/A39hYR83mA1x16jgqeughotsiYNKTuAYsC1KQyQRYZJpPE2DaOUkVARtRPIJ54+cxf+o3AIniHwYkMWPNUIhmOgMS2ovwreb0Mxg5Z8S6q8HN8NK8bnUj7g2KulAk3te0z4LMnhow3YR1mB4B62QK0h8MCbAMUpD5dgttPoVH39mG1WTi+8d3X3GuHjGqa/Eysjy30uyRqKqkrqVnU5BWswmH1ZS1ETBXJyNgZfk2WrxBAoqKNQsNZrubxk72WCxyWDGJ9u27C29AYfnznzO2ooALvzmqW/etYxImSh2p3d4hQQTMElEDhhtvEIjz85wVKcgkNWB6BExKiS/ow2keDCgIU2xETwjBqJJRTBsyLUK8SkoLfLT5hgIRXmBdtKJIKcACnugWRLSnIK2W9AVYzn27d7ncOVf/Be1P67magrSYREZRoq6Qjqmq7gGmR1jsFhM2syljq4+wAMuoCN9Mmz/Iyg92c/a0YVQUdp/IqAhFwGpzPALW4PYTUCSVRT0bqc7WdkTegEKbX8nIgkInPLtvgKQhO9tj0WQSPRItfH1jLbsaPNxw5qQeE8AljpKwgEqFxWQJR3Z07GY7JmFCYEWhDW8g/jnwBD0x9VC9TaIIWJu/LRyp8it+JDJc/xUvvjK6ZDSzRs+KiRwOLVUI+rQImMVkQSBi3fC7OQXpDrpxWByYRPv1IXQBlkEELOcE2G6XJ+fqv6A9QpONN4tUuP1Kr0W/QJtlGFAkvmBiQ9JIE1bQno460+7J1wkBlm+3ICV4AgqXzOia9URHdAFW14tNhnuC/WGB3LPf1aIsbfGli4LONLDXZ/c1DpBCfJc7QEmetVNZDW3CQvcKsH2N2rV71Mj0IlSdId36L53IWiOIaEck7KiiFbc/8bXS13VgiYrwO6YfAazqiIQWFOPK4jdpqyz1oypFqMH8djPWLtSAeYPepFE70CJgkelHgDxzCdCPI2Cq1H6URuRgBCyXU5Aev9JrMyAhPX+nSBPW8HZ5mUdD9BqwjHzAQq85Y+wgJg0tyuj1UlHqtGEWUNeS2xGwvY2hFHFJz/ZrzdYIWEMnXPB1dDuGgVIH1uj2Z9yGSKfUae3283Sg1YfNYso4IpcJ6dZ/6XT0CwsLMDQB5g0m/g70ZRpSlWpUH8tIYmdAgiWBCavT6qSqqCrufipLtXtq0K+lIeMJsIASSGgG25FU0a+gGiSgBmJEcb6lBACrOf1OJjklwIIhYZnbKcjsu1mkwh1Qem0GJKQ3uy3ShFWnyGHJWOB2pgZMj2p0d/QLtLRKsV2EXeRzlXAboh4swge9yX32facaOuGCr1PWw/YK2YarLdCpSCFo30VXNxfhH2jxMbjA3qN1xl2NgNktWqTcImyotIStguLR5GtKuK6ncQfcCU1YoyJgihezMCOUirgC7NDSQ6PSfZEMKdG+J3oaMp4Ag/SjYOnUf0FsbZ7DUoxAkknWOrcEmKp9kLmYgnRYzdgsphyNgAVx9NIMSIhoyJ1kJmSkCatOoSPzfpudqQE7dXIFf73kWKonDM7otdKlxC44kPMRMC9Ws2BQJ4rQMyFbO0x0JQI2KDTDu741t6+BdHG5/RkX4OuU5Xd/14ADLb7wbOSeoqsRMLtZOz6zsKGKFnzBxAKsL1OQST3API3h//cGvTgsDqSSjzDFRszGlcdPPwLYrZJCp5ugXohvthJQY2uI040EplP/BbGi2CycWC0ybv1aInJMgGn/zcUIGGg3i2x8Wk+Fu5dTkOnYC0SasOoU5aXnoB9JZ2wo7BYzM8YN6rEn5BK7yHkbiv1NHoYUObrFnDYZ6XZN6G30PpBlnRAWpU4bZlPui/B0aXRn3gdSpzTfRqPb360dRnpagOVZ8uLObEy1TSThFKTJiipa8QUTv/++FGCZeIA5zE6kdMREwMqd5ZTlJTfCHVISINjBiiKgRj+YpXse0omARbUgQqtBNklHRvVfkIMCLN9m7vSXta/R2hFl39N6KjyB3hZgyVOQHU1YdYoc1l5JQfY0JXZBbY4X4e9t8oYtQnqSwk6knXsDV5s2s684L/PfKrNJUJ5vGzACzOX2h2d+ZkqZ00ZAkSl9AzPhQGvPCrBMo18QGwEzm8xYTBbMwoJCC75A4rqjPo2AJShmbwu0hb3LgmqQoBrEbtbqaTsKsETF95EML1dRgyWoihObqfNmrOm0IPIEPTGCuMBWgKKaMpoBCTkowIaXOnPOA0ynsBMCIRvw+JVeM2GF1PVyHU1YdYryeicF2dMU2wWN7kDStEK209MmrDpFDiu+oBr+HLOFg21+Sp3WTkcABxfaB4QA8/gVfEG100X4+nbdVQcWUFQa2vw9avSdaf0XxEbAQEtDWkwWEAGkFKgy/negxdfSZz2IE0XAOqYfAWxCi3JFzoI0CROHlh6a8nWG6oX4vqFdcsNv9jWnbEHkCXhiIpjF9mICQYHVktnvUPbcddIgqMqcrP/SKcrSdEkq+ioF2ZrgXO3tYMIa3s5uwRvI7GbcGRuKnqbEod20c/UGLKXUUsQ9PAMSItPV2fVg09Dm63RhOYQE2ACoAXN1sg2RTnjCQjfVgR1s1faTbRGwuG74FlvYSyyoyoQiS5FKSluFniITCwobWk1tZARseNHwGLuHeEQW4nfFDf+g+2DS9Q2eBiSSAltB1PISRwkBRQyMCFiu0pkITTag+YD13ixIvQg/kVjd3xR/hl2711r657gzNhQ9TYldE2C5asZ6sM2PX1EZ2oMu+DqFnWxB1dO42gKdKsDXGVwwMCJg7QKs8zVgoKV8uwP9nPekABvkHJTxNon6QVrCAkxJGAGDvktDJoyARdR/+YI+BAKLrACiBVg66UcAh03idLQR9A/FbDJjEqYYAeYOuJNGtwAavInrv6SU7GvdR54lj2J7cdQ6LQLWz1OQKjC8NJcjYNaMndqzAY8/2KsRMIvZhNNmTiik9AhYvCJ8yMzqo70GrPfeXyp0AXYgR+vAesuEFbK3H+TBNl+nLCh0BhXaqW/1oap9kzrqLXSz2U7PgnR2r2XHgVbt2u0pAWYSJkocJRlvl2fNi7Fh0PpBasuCqpLQ7gGyT4B1jIDZLXakWgi0pyDtFjsji0em/Vrlxe0zIW1mW4wbvpQy6aQASF6A3+BpwKf4GFo4NKYMqthRTEARWPpzET7keAQsS127kyGlxB3o3Row0KJgiQpr9zd5Y0xYAQrtmZvdZmMNWIldO5ZcNWPtLRNWSM8zri9oaPN3OQIWUCRNOVgzmgldTUF2d9umcASsh2rAShwlCf2sUhHjBWa2YwnVGCpZGAHT7h3pmbA6zJoFBSKAENpneWjpoWm3awKoKlNRg2WoSp7mBaZm7gXW4I4vwCKjXyX2kpj1xQ6tBszWnyNgkJseYDpFeVb8QTXc3DoX8AVVpOy9Rtw6yewF9jZ6GVYSex10pt2TP1Tonk0CrNCmzYTLVTPW3jJhhcioZ/YIFUWVNHoCnbKg0NEjMP3dC8wVioB1NgVZ5LBgNonuF2A9FAFLZaeQjI5pSJvFhsWsCbCgTN47t8nb+2asiUxY3QE3vqB2nqWUeBXNA0xV8qP6QI4tG5vR6x0SKq0L+iuxmW34gr6MvMCStSBq8IaiXwWx0S+b2Ua+NV+rAevPRfiQ+xEwyL50STJ0h+XeTEECjBlcwHvbGuLOBNzf7Il7c+/MzbgzPmA9jUkIBhXYctYLrLdMWCGixVcWfac0X6rOmbDq6AKgv9eBNYZSh51NQQohQu2IukeAH2jxUeiw9JjxdHcKMLvZjtmsR8CCSSNgmTaj7g7SST/qVhSRAgy0SGFFfkVGr1dZqv0GBH3DcFqcKFLJyAvM5YlvPyGlZF9LKPoVJ31cZNfsMwJBgaUnImBCiLFCiAeFEJ8IIRQhRE2CcYcJIZ4XQjQJIVqEEOuEEEd3GDNZCPGGEMIthNgrhLhZCJHW1W6CTvnqZAuF4ZtF9jytp8Id6BsBduHxo6hv9fHsR3tj1u2P04YIIs5vZ1KQWeQDBjCkyJGzKcjeMmGF7KwBC7vgdyGNFRZgAyAClm8zd+kBSGtH1F01YD3rAVbq6HyD77gCTCggLSjSjyKTtCPqgwhYomhSPAsKh8WBVPMRJm2bdIvvI8mzq9htrQR9w8IzJzumQJMJ0YOe+DMgXV5XwugXEC7IDygmbD1UAzYFOAPYDGyJN0AIMQ14F2gEFgLnA88BeRFjSoHXAQmcA9wM/BxYns5BZFGQolPoEZpsulmkwuPXjrU3Z0ECnDC2nImVhfzp7W1RYeR2E9Y4ETBHJyJgIQFmNWeXt1xFoT1nU5C9ZcIKkTNms+ehpisu+DoDJgLWhTZEOqXd2I5I7wPZU3R3CtJkkpgoQJG+pBEwn+ILp/16i3QL8EEruI+MgGVSfB9JSWELQd/QcL1cRwG2r3VfwkhXvOV69MthcSScPFHsKEZVQVF7KAIGPCelHCGlPB/4PMGYB0LjvielfDn07xYp5dsRY36EJsjOk1K+JqV8AE18XS2EKEp1EJZeeKLuSYo6EaHpa9x6CrKXi/CFEFw8YzSb9rfwztb2JxPdhDWeAMu3WTCJzASuT1GxWUxZZ+47uNCRszff3jJhhcgZs9nzUOPqQh9InUK7BbvFlLPXQLpoLvhdy2qUObV2RN1BT7Yhspgs4XRVZ4gXAQMwywKC0p9UgEHvpyHTsaDwBr1hR39dgJmFmWJHcdxtUzGk1IcaLEfgxG62hxtn6/iCPl7c+mLUMejEi4C5vC68ipdhBcMS3iN0DzCgZ1oRSZn8kxVCTAaOBe5Jsau5wCtSyshE7BNoouzkVMcxKC+7bpKZoheJ51QKMiTAersIH+CcacMYVGDnkbe/Di9rt6CIjbCYTCLjbgP+oIo9y9KPAEOK7Bxs8xNQssvhPRWq2nsmrDqdaUHVk+gRsK7YUAghBoQbvssd6JJhLYQiYN1UA1bf6u8xAVbiKOnSg15MBCxkOGoiHxUvqlQJqokfRHo7DZnIhDVmBqTFAdIG0oowuylyFHV6puhIvRDfNxSn1RlunB2JJ+DhxS+jRVi8FkTpRL8g5AEWEmA2c98U4R8b+m+pEOJjIURQCPGVEOKSDuMmApsiF0gpdwLu0Lqk5HgArL3FTg55gXn6UIDZLWZ+cPwh1Gw+wNY67elN95hKdIMvdFgy9gHLpgJ8nYpC7f3l2g24wd17Jqw62daQW68B66qwGAhu+N2SgnRacXVDQ263P0irL5iVMyAhSQSMfBSp/S4mEj3Q+1YU8WrAPAFPOO0opQwLMFXRel2azK1dqpMbPVi7xwZ9w3BanfgVf1xR6g64efHLF8OiNF4LonSiX0IIiuxFBILa+o4+YKkEd3fdeSpD/30c+BswG3gZeEQIcUbEuFK0GrGOuELr+jVFWepZlAxPHxXh63z32JHYLSb+9PZ2ILEJq06Rw5qZE37WCjDtxzXXCvH3NeoCuffsYgodFlp82fOdamjzU2i3dPm6Gghu+FoErIspyHwbiiq7PBO2viXUhqiHasC6W4DZLHoELA+FkABL0nKotwVYvBRkZJQpqAZRpILDHCnA2rp0nvIdEou1BcU3NFyI3zENqaOLsGZfc1wD1gPuA9jN9qTRr3xrPlazlUBQ+653dMLXRXIiuquyWpd5j0gpfxP6/zeFEJOAJcCLnd6xEJcBlwEMHjyYmpqarhxnnyKlxCTg081fUTXMnxPvZcMe7cb2yYYP2O/sG6FyfKWJpz/YyfEF9azf6iffCuvefTvuWNXnYef+1rTP7a69XpSAmlWfRWtrK/VNnwHwr3c/oHFI706A6AobarWb4N6tn1NzYFOK0d1DwO3F1Siz5jPctM1Lnrnr11SgxceehmDUflpb07+2sx1VSpo9AZrq9lJTU9/p/dSGfqNe/td/GJLf+d+oL13aw+a+bZupaf2q0/vR8fv8lCvtfR/rmuqo2VTTpX2Wu9v3V045l5RdwvJ9L+HBxyDzIApbCrF74t/0Gw82UrO9a6+fCQ63AzvRx5IfzOeSMi0xtrVtK5/wCWeXno1D+Qb/BOaXzmaCdGCr63xU9NACEwc8k1g4+FKub7iew22Hc0rZKQnHm/ebGWQaxOiy0eFlftXPNfuvobqsmvPKz0u4rc1ko6iuiNZm7borby2gvK5dKFtNyR8uuuuXXZe1b3ZY/i/gZx3GxauuK43YRxRSyoeAhwAmTJggq6uru3SgfU3Rf16ltGIYBQX15MJ72bV2O3z6OTNPPKFHp2cnY/jkFk793b/Zbh6OyG9iRLmb6uqT4o79284P2NWQeH1Hnty9nmKllerqlCWIvUZNTQ3fOOo4lq19g8GHjKP6uEP6+pDSZse72+HDz5l3yoxeu16e3ruBz/c2Z8336ZGt71FlDVJdfUKX9vNRcAs1u7/khBNPwhqqU6ypqcma99lVGtr8yFdeY9rkcVSfMDr1BgmQm+p4+NP3GXfYkRw1svOJFO9n++C9Dcw64RtMGda5IvBIXt76Mnsb2210Tj/sdArthV3a558//PP/b++9wyS57zr/17c658k7u7NpVmFXq1WyZdmSJbySbLAFlowjBg5jY3yRcFyC4wDDc/yAOx/hzHHGYOPjsA0YOAcc5IBWVnCWrLwKu9pd7c6Gyalz1ff3R3X1dPd093TPdKqez+t55tntrurub89UV737E96fshmHH/v+x8hZ45hGiov5izzhfYIbxm6o+tiYP8Y9195T9/nPL59nZ2znltYIdir0/z7+f9fd/9CZh3hm7hkAZpK26P566uvoZA64h8+tfoLIZT+46SJ8ACueZG7+Cv5m4TN4DS/3Ld7Hi+rFpp5jObNMXuc5ZZ3iI3Mfqbnf4dHD3DJ2CzM6AARJDS8xO7oWtd4/sL/u67QqpPFM4d/KhKfCHuHocJyKWi+l1B4gTEVtWL/SbIqs2yS7ZMRayuVjMW4/OMpffuMUp2dXa6YfofmC7F5NQQ5H/CgF0y6zoji/aJuwDm+hA7BZmm28aDezq9ktWVA4jMYCaN26OYe9xlbHEDk444i22gnZThd8n+HbsviC6nVghrLXmzSTdVOQK9mVup2SpmXy1HQtk4PmqOkBllko/j+dT6NQ+D3+YgrS781sqVMUYNegCRiYmXG7EL/GOKR6OB2jUX+07n5OerJYhF/hhF9tiHoprbryPIwdwaqM890JPFZy+4vADymlSo/EdwAp4P4WraWniYeaKxLvNsUuyA7bUFTy3tsOMLOS5flLK3WHPMdDzRVkZ83eFGBej8FINOC+GrBFe0pBJ0xYHZr9m7eb+S3OgXRwapH6tQ7MEUwDW6wBc2rIttoJOb2cwVAw3IYJDlut/3Ko1gnpUfYX0lVztW4RvkbXHcVzcfUiF1cutmSdNT3AUuUeYEFvEKUUlhVGqTSD4eiWLYEmR+1rVT5rO+Kn8+kNLToqWc4uE/aFN5xFuWbCWijCr6gBq5zfWUlDKUilVBjbiBVgAogrpd5auP0FrXVSKfVbwH9TSi0A3wHeAvwA5fYSHwJ+HvgHpdTvAQeA9wO/X2FN0bf0Wsv8RqRyJgGv0dELajVuucw2Zj1+YZldG0TAljN5TEvjaWDNmbzVcy74Dm40Yz2/mGZnvLPzWuNBH1nTnrHarhEyjaK1tgdxb8GCwqHfzVjnV505kK2JgG3VDX96JcNQJNDQeaNZBkOt6TGr6oZfqLNaNVdZsaoLH4elzFLN9N65pXMsZ5fJmTl8nq2J4mpCsLQDEmwB5rwfbUZQnuSWOiAddsRDGJ4l2xE/FkKjy15rIyxtsZpdbWgUkvO7LBbhV3RBtioCNgZ8qvDzKuBwye0xAK31HwK/DPws8Hng1cBbtdYPOE+itZ7Hjop5sF3yfxP4A+A3GlyH67FtEtwjwJLZfFfTjw5KKd572wGg/pBnx+pjpcGISK+mIMEWYG6LgHXaAwx6axzRYipH1rRakoLtewHWohRkLODFa6gtu+G304S1bREwrx+vsn9/STNZNwIG9Tshzy2fA2qP5GmGahGwSt+tjJkh4LV/344JayuEqlKKcHim6AUG6x3x67GaXUWjN0w/eg0vEZ+dOi0asVZGwHwtiIBprU+xvr6r2n6/D/z+Bvs8zfpU5bbBrgHLY2vQ3ieVtQh3eAxRLe65fheLqRw/dGS85j6lZreJBlIb2bxFoEcF2I54kCen3BMYdkxYO+WC77AmwHJdaxRx+OozlwB4+b6tX0hGnBRkn3qBLSTtL6IDW3TCV0oxGNn6PEg3CjC7BswP2o6AZa0sWTNbNGmtZDFT3Yw1b+W5tGofu7PJWcajtc+xjVCtBqxsCHd+bQg32ALM411sSQQMIBZOsbKyB78RxFBGTSuKajRa/5UIJIrp0lTGADRBX3dqwIQGiYfcloLMd8WEtRo+j8HP3DpZ9FOrRrzJgee9WgMGdgRsZiVD3iVu+I4Ja6fmQDrEAs7fvPsRsM98/xx7hkJb6sZzCPo8xIPevo6AeQxFLLD1L3hDYX8xorZZ2jkHsp01YN6C1UHStKM89aJgtWrAzi+fL9ZJdSICVjqEG5wUZGsiYACDUQu0D23FCHlDVR3xa7GcXSbsDeM16h+Xpanc1YyHcMDCqLiUbFQD1ptXnj4mFvSymjUxra25NneKZNbsiRRko8SbnDaQ7eEasNF4EK3XRtv0Oo4Ja6cjYE7Us9vdxZeW0zz0wgxvun6iZbNF+3kc0Xwyx0DI15Lf1WDEV6wp2wxaa6ZX2hMBC3gCDdcfbUT1CJgXtGLVtIVXvU7IWhEwJ/0IdgRsq1QTgWVDuM2CAPPY5zjLjODzpjeMOjXKWNw+p1v5gWInZCOTEpz6r2hg43WUCrBk2iAcWP9FWSJgPYYToXHLNKJk1ux6B2QzNDtvs5drwHY4bvhL7rgAn99gSkG76JUasM89dh5Lwz3XT7TsOftZgNljiLaWfnQYDPu3VAO2mMqRM3VbBFirol9QRYB5AxhGHoNoMQJWqwMRakfAppbX/MpaEQGrJgIXUgvF/6fzaXyGD4/hQVtBwEM02LqgxM6EnYI1cwOEfCEsbZX5p9XCqf+K+Te2DBkIDKw9LuMhEigfZeQ1vBs2M/TmlaePcQRCMu+OCFgqa/ZMCrIR1sY9NRgB6+UUZGGe4qVld3RCnnfmdHY6BVlSA9ZNPvP9cxyZiHP5WGu+xQOMxoJ9WwM2n8xuuQDfYas1YO30AGtVWg2qpyCVymPoKKuFNFu9CFjOyq2rh8qaWaZXp4u381Z+S4O7k7nkOtuHTD5DKr/2usUh3NjpR4B4qHXnYacRyMoPEvY2XojfaP0XQDy45le2mjaIBMsFWCNRz9688vQxToosmXOHAOuVLshGWRt43kQEzNOb78+ZB3nRNRGwzpuwgm3ECt2NgJ2cXuHxs4u8qYXRL3D/PMiX5pJ86P4TWFVKLhaSuS0P4nZwasCqvU4jFAVYG2rAWhkBC3rtonKHgCcAKo9BjBUnBblBJ2RlGnJqeQpN+e9tK1GwahG40u7L0iHcAJZlC7DBSOuavfxe8HhXMfMDazMh8xsX4q9kVwh5QxvWf8GaBxhAslADVspG9V8gAqzjOBeLpEtSkKmsScjXG12QjVAUYH2QghwtDuR2SwSs8yasANGA8zfv3ofq09+fQil443W7Wvq8o7EAK5k8yaxLThgVfPaxKX73i8c59tylddvsCFiLUpARP5Zu/HNfiRNl7PUUJJRf2O0IWM6OgDVQhA/rrSjOLZ1bt89W6sCqvX7pa+atPJa2yjogAUairS1dCAZWsXKDGMog6A1uGAGztMVKdqWhiQVhX7jYaZrLK7J5iYC5gnjIvlik3JKCzLmrCN/rMYj4PQ1FQ7TWPZ2C9HkMhiN+13iBdcOEFSh20nWru1hrzacfPcctlw2zI97ai4gjCGaW3dGIUclMQdj8+QPls/i01swnc0UT1a0yVLCymE9uUoC1MQXZagEW8UeK/w94A4UUZGytC7JOChKqCLDlKgJsCxGwaq/vpPZgfQekI8DGY5F1j9sK0WAaMz8AQNi78Uiipuq/CiOIAFYz9vVjXQRsAw8wEAHWcZwaJfekIN0lwKBxq49swd6hV33AwL4gXHKJG/75xVTHTVgdYsHujSN69KUFzswlW1p871A0Y11xxzFQycyKLRwfPjHLU1Nrqa9UziSbt1pWhO+kMjc7N3N6OYPfaxRLRFpFyBsqCo1WPqeD3+NHGTk8REkWUpD1ivChXICl82nmUnPr9tlKBGyjFGQ1CwqgJdMjSklETKx8Aq0VIV+InJUjb9U+RzjrbqT+qyz9mLavjxIBcwHOCWfZBQLMtDSZvOWqInxofNpANm8LsF61oQDbjNUNETDL0lxczHTcgsIh1sUh95959BwBr8Hr6xgEbxa3z4OcWc5w5Y4oYb+Hjzy4FgVzIlWtKsJ3hp9vthDf8QBrlX2IQ6ujX1ARAXNqwHSMlGVbLeStfNnIn0pKxVC19CPYEatGugYrMS2zagF/mQAz0xjKwFfwL7PMCB5PmlafhoeiGvBgmfGGHPGXs8uN13+VeYDZC6/sgmxEgLmnuKdPiAa8RPwe5tO9L8BSud4YxN0s9rzNjaMhRQHWwxGwsViAZy/UHqDbK8yudseE1aFbEbCcafGPj5/ntVftqGsQvFncPo5oZiXDgdEIt1w2wse/dZr/9PpD7IgHi0KpVTVgzvDzzVpRtMsDrB0CrDQC5vP4MAwTQ8cAjalNvMrLana1ZuStTIBVST86zKXm6jriL6QXODF3gqXMUvEnmUuuK+iHcvuLdD5NwLMmdi0zjN/X+hT7WNy+blm5AUL+GcCeRxkPxNft69R/jYZHG3rushRkMQImRfg9j1KKnQMh5lwgwJzCXzemIJczjacge1qAxQNMr2R63rj3wmJ3TFgdYkFvQ3/zVvPgCzPMrma55/rWFt87DEX8GMrdAmwkGuDdr95P3tL85TdOASVjiFpoQwFbjID1uAWFQ2kEDMDvURjYaTPTsr80r+RqpyGTuWQxFVcrAgYwk5ypu47vTn2X70x9h2dnn+X8ynlWc6tVxZdpmWVO9KUdkGCnIEN+c93jtsqOhB1fMvMD+Dw+fIavpiO+IxwbKcAHykRcslgDJilIV7AzEXSFAEtlCxGwHpkF2SixoLe5CFiPpyBNS2+6tqVTTBVMWLsXAWss6tlqPvPoORIhH0cPjrXl+T2GYjgacKUXWN60mE/mGIkG2Dcc4QcP7+Dj3zpDKmu2bBC3Q8Tvwe8xtlSE78YIGIDfqwoRMIrCqpFOyNXsak1nfKhfB5Y1s5xaONXQepcyS0UXescQtVSAWWaEWKj118NE2AI0Zs4WwY4jfjWcCF0j9V8ew1NWqL+a8RDwWXgr4hRShN+j7EwEXZWCdF0ELOhrrgaslyNgLrGi6HYELB7ydrwGbDWT596nLnLXNTvbegy51QvM+dIwUjiG33vbARaSOf7+kbMsJFubglRKMRD2bSoCljMt5pLZlnuAKVRbBNg6M1avwqPtmqScZX8GGhFg9dKPUL8T8sTciboF7WWvla1dgA+2AEuEWn+N8XrA51vFKnRChnwh0vn0OpNYaK7+Kx6Il9UKrqbXu+CDRMB6lvFEiMWMJtfjQ5aTxQiYywRYyK4H2mj2V8YFAmw0VnDD73Ez1vOLafwF24xuYBfhb/w3byVfefoiqZzJm9qUfnRw6zgiJ2o3Ujgmbtw3yHW7E3z0wReL801blYIEO127mRqwudUsWrfegiLijxS9olrJ+nFEHrzajsA6hfONWFGUjh+qxlxqrubn6dnZZxtd7rr6LyjpgNQKbYWJtilwHgomMfOFCFjBEb9yEkDR/2sD+wmlFMPhYa4auars/tW0QbiiA9Jn+BoSc+7KLfUJuxJBNHBxKc3uwdYMaW0HTgoy7MIifNPSJLMmkUDtQ9wNNWA74u6IgJ1fTLEjEei4CatDLOglb2nSuc507a5m8vzp108yMRDiFftbH+UoZTQW4PmLvd+IUYljQeFEwJRS/MxtB/j5Tz7KZx+bstOGLfzsDYY3N46oXR5g7Yh+ge39VXbbpzBI4MFXFGCNWFHUq/8CO525lFkq6/hzHnth5ULD661rQWGFAINIlUHWrSAWyrGSHADWhOv5lfMEPAEsLCxtkbfyaHTVAdzxQJyJ2AS7YrvYGdtZtbEhmfEwEi+Pvjc6fF0EWBdw0jQXFntbgDkRsLDrasDWBnLXFWCFCFigh2vARl0ykPv8YrrjMyBLWRtHlGu7AMuZFv/q44/w7IUl/vxdN7ZddI7G7BqwTkb3WsGsEwErSe294cg4uxJBTk6vMjHQ2uNlKOLnmQtLG+9YgdsEmN/jR6GKBe8hrweFQcQz1HAE7OzS2TJz1FrMpmbXCbDnZp9rar2lEbBMPoPf4y+OU3JMWCsL2FvFYNTk3KU4Wnvwe/yEvCGWMksYykApZf+LIuqPEveXd0eGvCHefvXbN3yN1YzBvooIWCP1XyACrCvsKpx4phZ7O6rhdEGG/L0rUKrhTBtYSuXZmai9nxtqwAJeDwNhHxddEAF72d7Wd3w1SrxkBNVYi93oS9Fa8yv/8AT3PzfN77z5Gu44tKNtr+UwGg2QMzWLXXL63ywzRQG2lobzeQx++tX7+f++cJzBSGttOwYjm6sBa9ccyMFg+z4Pfo+fjGmvO1D4whExRlgyTwGQzNqeYLV8zRbSCw29zmxylgODB8rua1aAVdaAVdZ/wXoX+VYxHFWAgZWP4/HNc3j0cMOPHY1sbElhWpDOrp8D2WgErHevPH3MWgRs4+Gg3cStXZDxkmhIPdwgwAB2xII9HQFzTFi7GQGLF6Oe7e2E/P2vPMfffe8sv3DnFbzzpr1tfS0Ht3qBzaxkCXiN4qxOh3e8Yi8Rv6dlHZAOg2E/i6lc05Yt7ZoDWZkqbCWlIibss3+PYTVSjICZ2mxo+PRGVBbin18+v26UUT201qxkVor/T5tpgp5yCwpoXwRsPGGfF5yRRM0wFtm4szmZqe6C34gHGEgErCvEgz6CHpha6O2oRtKlNWCNDuR2Qw0Y2F5gveyG75iw7uxSBySs/c3bacb68W+d5oP/9ALvuHEPv/jaK9r2OpW4VoAt2x5glVGYRMjHH//4y4iHWhwBCxcGcqeamzE5vZwhFvQSdNF5LuANQOFwCHp9gElIjZCzcljawlAGq9nVhiMxtai0omim+B7sVKip7euIs7YyDzDLrruqNDFtFYNR+3mt3CCEXtxg73J2RDaObq+mHRd8iYC5iqGgKrbu9ypFJ3zXdUEWoiEb+EK5wQcMen8epHMcd1eANRb13Cxfefoiv/bpJ7n94Ci//aNHWj6yph5r8yDdJcCmVzJl6cdSbj80xsv3tTZFt1k3/HZ5gLWTgGdtvfZA7hxBZafMGq0Da4TSkUR5K8/J+ZNNPb5eAT6AVw+g0AT97RFg8ZAJWE1HwAxlMBIe2XA/xwW/MoLXaA1Yb195+pihoMF5F6QgDdXbw6qr0XcpyHiwp4uwHRPW7hbhty8C9sKlFX7uk49wzUSC//UTL8PbYcHu1gjY7Eq2rAC/3WzWDd+ZA+kmStObfo8fjDx+bMHQaCdkozhRsFMLp5qeD7mhAFODhAIW7epjMQwI+JNY+ebE/lBoCJ9n4wit44K/mUHcIAKsawwGFed7PAKWzJqE/d6OfttvBWspyPoX44xbUpAxuwh7sy7f7aYYARvofgpyqQ2F6t84MUM6Z/HBd76sKx3BsYCXgNdwnQBzxhB1Cmcgd7NTI9o1B7KdlEXAPAGUyhOgIgK2gRlrozh1YM/ONJd+hPUCzFBGmT+WYSXaVoDvEAmlMXMDTT2mkfovsF3wYX0KVQRYjzMUVEyvZIpRmF4klcu7qi7CIeiz/YU2uhiv2VD09nscK5ixXuzRNOTUYgq/xyheALtBxO/FUO2JgJ1dsN/f7sHuRPiUUq4zY7UszexqlpFY544Jp6tyockvKq5MQVZEwJTK4dXlEbBWpCDBjoAlc0nOLp1t+rGVJqxBb7DsC722Im0rwHeIh3NFN/xGaaT+C+wUpM9j4feWZycaLcIXAdYlhoIKrXvbYNOOgPW2OKlFI+OI3JOCdMxYe/MCfGEx3VUTVgDDUEQD7RlHNLWQZudAsKvvz/ECcwsLhW7E4UgHU5Dh5mvAktk8K5m8+wRYRQ0YKo+FPXC6HRGw52afqzpoeyPqWVAA5POhtkfAhqIay4yjrcaj141YUICdgqy2fomA9ThDQftk3stpSFcLsJB3wxSkWwTYzoJv3Nn56oNku83Z+VTXhnCXcmA0ykMnZrGatCHYiKmFVMtNQ5vFbfMgix5gHRQ24YKzfjM1YDPL9r5urgHzGT6UypO3FH6Pv+U1YHOpuaa9vxycCJhpmeSsXJkFRTwQJ5XxNBwBu2XPLQwEB5pew1jcPr+b+TqmkCWEfWHigfjGO1KYA1lR/+X3+PEYjV03e/vK08cMBe1ffS8LsFTWdF0HpEMs6Ns4BWmaeAyFp4uRjUbYGQ8S8BqcmmnNN9pWc3o2yf7hSLeXwU/fsp8XLq1w//PTLX3ec/Oponlyt3BbCrKaCWu7UUoxFPY3VQM2vWKff90cAVNKYRjmOgGWzCerDp5ulryVZy411/Tj0vl0cS2OaWxpBGwktIN0ztPQGKJ9iX1cu+Nabhi/oel1DMfs83ujhfiN1n+B7YJfGQFrNP0IIsC6xlCoEAFb6N1OyFTOxRGwYGMRsF63oAA7vTY5EuHFHhRgq5k8MysZ9g53f6TWXdfsZEc8wEceaM7vpx450+LicronBNhcMku+xdG9duHMgex0ZGkw4me+iRRku8YQtZtKk1ePYZUJMK01WmuSue5FzTfqgBzwTwAbm7BGfBFun7wdgCuGr9hwaHYlAxH7+Ru1omhGgCWrRMCa8V7r/atPnxLy2jUrvRwBS2ZNQj53evXGQ76GbCh6Pf3oMDkS4WQPCrAzc/YJfl8PCDC/1+Bdt+znwRdmeOZ88zMBq3FhMY3WsLsHBJjWsJx1iQBbXj8HshMMRXzNRcDcKsA8FQLMY5HXtgDTaPKW/eWzVXVgm6GyAB/KhWPA2AlANFRbgCkUd0zeURRuhjK4fvz6ptYRDZooZdpmrA3QqACztF0DFgmIAHMlOxPBnvYCS2Xz7o6AbWTEarpLgJ2ZTZI3e6tr9vRsQYANdT8FCfDjN+0l5PPw0QdbEwU7V4hQdz0CVhAyixmXCLCVDB5DkWix2/1GDIT9TXVBTi9nMBQdbRZoBZURMK+hyVuqKMyclF+rOiE3Q2UELOAJFIdwewwP2bRd6D4ar/33umHnDUzEJ8ruOzRyiIiv8fONUhAKpBqKgBnKYDTcWAF+KmOgUYQrLCgaNWEFEWBdZTwR7Gk3fDsC5lYBtnEXZMYlKUiwBVje0pyd7y3BfmbOPsH3QgoS7Avw227czWe+P9WSDuOpggCb6JIFhYMToVl0SQRsdiXLcMTf8c7RobC/qS7I6ZUMQxF/z9eBVlLZTej16GIKElrvBbYZKjsgS0XjSGiEmSU/Po9FIlI9AjYeHefGXTeuu99jeLhu/Lqm1hINZRqyohgODzdcQF+cA1npgi81YO5gVyLEVA8LMDcX4cdDPrJ5i3Sudng7m7dc4/J/YNT+xtdrdWCnZ5MMhH0dj3TU492vniRnWfzVN05v+bnOzTsu/90zmYUSAeaiCFin049g14AtpnINR4qnl7uzzq3iNbzFaBKAz0NVAdaqTsjN4KQgtdZkzExZ2nQsMsb0oo/RRI5qPt9+j587J+8se4+lHB49vE6E1mMgYjZkxtqo/xeUzIHcpAkriADrKuOJIDM9asZqF3C6uwgf6htzuqkGzOky7LU6sDNzSfYN9Ub0y2FyJMJrr9rB//3m6boCvBGmFlOMRP1dNyQecWEKspMWFA5DYR9aw2KDExHcaMLqUCpofB7Ia4XH8OBRnpabsW4GJwVpahNLW2XrHQmPFgVYNW7deyuxQO1ie6/h5dod1za8luGYPfhbW/W7cpvrgKweARMB5hJ2JoJo3ZsO5zlTY1ratQLMGc5cLw3pphqwoYifeNDLizPd+0ZbjdOzSfb2gAVFJe+9dZL5ZI5/eOTclp7n7Hz3PcDAnu4QD3pdJMCyHbWgcCjOg2wwDelqAVbqBea1I2Ba0xYvsGbJW3lSeTt67KzF7107HiLeXaSyHsZqCLDJgckNX+PI2JF1zQi1GIk5XmADdfdrSoAVImBSA+ZSHIPNCz0owFJZW9WHujD7rhXEQxvPBnSLDQXYXj+To1FOzfSOGWvOtDi3kOq5CBjATZNDXDOR4CMPntySMevUQvc9wBxGYwFX1IBprZnuUgrSeU2nO7cey+kc0yuZ4qgvt1EqPvxeBSjAUybAuhUBW84so7V9rGbydkOAs96IL0IyOQBQNQI2EBxoaBC23+PnyNiRhtbjWFFYddKQEV+EqD/a0POBXQNmKE3QJylIV+LUlUz1oBdYMmen7twaAYsXImD9koIEONBjXmBTCylMS/dMAX4pSinee9skJ6ZXuf+5zRmzaq2ZWui+B5jDaCzgigjYSiZPNm91JQL28n2DDEf8fPybZzbc92++8xI5U3PXNeMdWFnrKZsH6bULqbT2lgmwdD6NabV31mI1SgvwnY5Mpz5tNGKnH6G6AGsmCnXNjmvKhnvXYiBiXwfMOmasY9HGXxdsE9ZI0FxXwyZF+C7BEWC92AmZdCJgLu2C7LcUJNi1TecWUluua2oVp4oWFL0nwMA2Zh2PB/nzB09u6vHzyRypnNkTKUiA0VjQFQLMMWHtRgQs6PPwk6/ax9eOX+LEdO30W960+NjDp7hp/xDX7h7o3AJbSGkRetA5j1k+/B4/pjYxLROtNYuZxY6vrdQDLGtm8ShPUSiNRka5tOgjFsoT8q+vf25GgAW9QQ6NHNpwv3DAwjDydVOQzRTgg23CWumCH/AEGu6iBBFgXSUW9PWsGetaCtKdAmwtBblBBMwlKUiwBRjAqdneiIKdKaxjXw/WgAH4PLYx60MvzPLCpeWNH1DBVI94gDmMRu0ImJPa6VXWxhB1p7bqJ1+1D7/XqOsF9+WnL3J2PsXP3LZxrVGv4kSUAPw++zzmRMBgLfK02TmOW6HUAyxjZsrWOhYeq1uA36gPl8NEbGLDfZSCcDBdNwXZjPADuwi/0gW/mfovaFCAKaUuV0r9qVLqcaWUqZQ6tsH+f6CU0kqpD1TZdlgp9TWlVFIpNaWU+i2llDuv8i2gV81YnQiY21OQdSNgLktBOgLsxeneEGCnZ5MEvAZjPVzE/LrD9kn1yXPNO+M7Jqy7u+wB5nBgNELaXFtXr+K44A93IQUJdqr2R6+f4O8fOVtzMPefP3CSfcNhXntVc1GPXqK0Bizotc/TWnuL9ztpyOdnnydnNm5O2wpKBVjWzBbXZCiDweAIM0u+qgX4hjIYDg839VqNCqd4OFczAuYxPAyHmnvd1fT6OZDN1H9B4xGwq4G7gGeBunJaKXUY+Blg3RlPKTUIfBXQwD3AbwH/DvjNxpfcX/SqGWsy6+4asLDfg8dQdccRZVwqwHrFiuL0XJK9Q+GOm202w56hMIba3O/M8QDrlQjYNRMJAJ481/mUUjM4EbBOz4Es5T23TpLOWXzi2+trwb53ep5Hzizw7lv2u86AtZSyFKRTKqJ967zAMmaGE/MnOro2R4BprcnkM8UOyMHQIMvJMJZWVSNgQ6Ghhmq6Son4Iw0Jn8GIVXMg90hopKnUodZ2Ef5WTFihcQH2Oa31Hq3124CnNtj3g8AfAfNVtv0LIAS8WWv9Fa31h7DF1y8ppeKNLrqf6FUzVqfOyK2zIJVSxILeun5AWdM9RqwAkYCXHfFAzxTin5lN9sQMyHoEvB52D4Y39TubWkgR9BkMhnvDZPbgeAyPgid6XoBlUcq2TukWB8dj3HbFCB97+BSZfPlF8qMPvkgs6OVtN+7p0upaQ2kRvnOe1tqL1/CiUEUBBvDMzDMdW5elraL9Rd7Ko9HFCJiTfoTqBfjNph+bedxo3EBbISxzfddrs+nHTE5hWmpLg7ihQQGmtW7IKVQp9VbgEPC7NXZ5A3Cv1ro0OvbX2KLsNY28Rr/Rq2asbk9BQmEcUR/VgIEdBesFAaa15sxckr09MgOyHvbvrHk/pHMLtgeYqmbV3QWCPg+7osam0qmdZGYlw2DYj7fLn6333naA6eUM//jY+eJ9L80l+eKT5/nxV+4lEnDnl0uH0hSk48Zu5WMopco6IQFmk7NcXLnYkXWtZlexCpLBqUMrCrDIGJcWfRhKMxyrIsAimxNgjQioohVFRRoyHohzePRwU69XNGHdggcYtLAIXykVAv4H8Mta61pXiEPA8dI7tNZngGRh27Zj10BvmrH2gwBLhHz1I2AuS0ECTI5Ee0KATS9nSOXMno+AQUGATa82XbzeSx5gDvvjBk+eW+zpQnx7DFH3ol8OP3DFCFeMRfnzB18s/r4+9vApDKX46Vv2d3dxLaA0AjYYLdgs5Ow6pkoBBp2LgpVaUBRNWAtpUWcE0XA8RzV93mwkqpnHrVlRDBTvGw2P8sYr31jXdb8aq2n7uhjeggs+tLYL8leA88Bf1dlnEFiocv98Ydu2YzzRm2asThdk0OUCrJ9sKMD2AptbzbLQxMDhdnC6YHTZix5glRwYjbCaNZkuFIc3yrmFdM9YUDjsixvMrmZ7snPaYWYly3Ck+40ZjhfcM+eX+MaJWZbTOf7mOy/xw9fuZGeit/6um6HciFUT85l1BdiL8y+SyrW/gaPUgqLUAyzgDRAPxO0OyPj687JHeRgKDW3qNRuJnCXCjhmrLTX2JPZw1xV3NR21AkhmCnMgK4rwm60Ba0kMVik1Cfx74Hbd4q9mSqn3Ae8DGB0d5dixY618+q6xsrLCsWPHOLdi/wG/9vAjrJ7qnZD40y/YH97vPPygawtVMytpzi9bVY8ZS9ujlqZeOsOxYxc6v7g6OMdG1W2X7G9xf//lB7hsoHvi+MFz9gn04gtPcux8b4vYpRn7xPsPX32IQ0ON/c6yprZLAxYucOzYXDuX1xQ7fBlA8df3PsTLdvTO+aKUl6aTTMaNnjhXD5qamB9+7zPf5fCwh5VMnutDcz2xtq1iaYvh1Frn3lgIUuZh/tnQMJ/Pf57Ppz7PTw38FD5jrYYxcimyKcHRDDfkbuDg0EEAPp76OMueZd438j78Hj++83GWUl72ey2GL5V3HfoMH1+//+ubft2x1Bimru2RqDUMB01I3sm/uPxlJIJRmN3ki03bn73dK3FiJTr3+aXnedGobX9SSas+wb8LfBF4Vik1ULjPAAKF24sFYTYPJKo8fpDqRftorT8MfBjg4MGD+ujRoy1acnc5duwYR48eZTmd41cf/DKDE5Mcfc1l3V5WkW+knsH/4inuvOP2bi9l09w79wQvPn2BasdMKmvCvV/i4BWX9dTvHdaOjWrsmV7hjx65n8G9Bzn6st2dXVgJj3z5WQz1Am/+oaM9H0W8fD7JB757H4ndV3D0pr0NPebFmVX4yjFeff1hjr68e7/nSjJfuw9DJWFwD0ePHuz2cqqSvO9eDl+2m6NHr+72UgD4Gf0cf/jV5zmb9HDT5BDvvufmbi+pJZiWyZ898mfF2wPBYU7OaD4y9xFmsjMA/NnMn5WlKqP+KG+/+u0Yqn2f2XtP3MtLiy8B8FzyOSzD4iNzH+FlO1/GqPdVQJjIrkVmx8qjuEfGjnDr3ls3/bpfOfGVDbs9Dx9c5IHHjvBw2sdNezervuDSdByFj/TELNmS+MRd195FxN94XWyr/goHgTdjiyjnZw/wbwr/d5zSjlNR66WU2gOEqagN2y7Egj5iPWjGmsqarjVhdXBqwKoFZZ2mB7cV4e8ZDOMxVNfrwE7PJdmZCPW8+AK709jvNZr6nTkWFBM94gHmEPAorhiL9WwnZDpnspLJd82EtRqOMevsapb33upe49VKPIanzLJhOGSirQiWGSqmJ50UoMNKdqUojtrBdHKas0tni7dLTVjtAvzCOKItjiCqRiOPv/nyGJeNp3jw6QQrqfrnrpklLxcXqndAJ9MeQgGLyuRQt4rw3wvcXvFzEfjbwv+dYWxfBH5IKVVa8fYOIAXc36K1uI7xHjRjTWVNVxfgg+2GnzM1qSqjezKmfZ8bBEQpfq/BnsFQ173ATrvAgsLBMBT7h8OcbMLA1nHB77UaMIAjEwmenOrNTkinzq6bHmCVjEQD/MQr93LVzjh3uth4tRqldWDDhY48Mze8zguslKenn27ber519lvFL7xa66IJq1KK0fAo00s+gj6TWGj9OXmzFhTFxzdQB2YogzuvW8C0FPc9MVBzvwvzPv7yn3bwqQdHsKoUVa1mjHUeYAFPoOnIYkMpSKVUGNuIFexoVrxgOQHwBa31d6s8Jg28pLU+VnL3h4CfB/5BKfV7wAHg/cDvV1hTbCt2DoR6LgKWzPVHBAxgMZUj7C8/1IsRMJcJMFjr6usmZ+aS/NDV7rmYTY5EeOFS41YU5xZSKAU74us9g7rNkYk4f//IWS4upXtufY4Ja7dc8GvxG2/sjXRoqwl4A6zm7HPBWNhWCmZuGH/ANqCtJsCmVqZYTC+SCFarBto8L86/yIWVtXranGVHufxeP2FvmIA3wPSCPYKo0tnFZ/gYCA5s6fVHw6MoFJr6ZehDsTw3XbnMN47Huf7ACntGyn9HC6sePvXQKJYFK2kvZy4F2L+jPJK4mvYQDm7NBR8aj4CNAZ8q/LwKOFxyu+G4odZ6HrgT8ACfwzZh/QPgNxpfcv+xMx7sOQGWypquHcTtUCrAKnEEmJuMWB0cK4puWREsp3PMrWZ7dgZkNSZHopyZS5I3G/PbO7eQYkcs2JMC3XHEf+Js76UhZ7s4iHs7UhoBGwkqwO6ENJSBz/BVFWBa65ZYUsyveHE+TqZl8u2pb5dtz+TXPMCi/ihaw/RS9RmQo5HRLfvt+TyNi7ibDy0RC+X5yqODZRGuVMbgbx8cxTThJ2+/hN9r8dRL64VVNRf8tgkwrfUprbWq8XOqxmP2a63/fZX7n9Za36G1Dmmtd2qtf03rOq0L24CdA71nxprM5l2fgiwKsGQVAWa6swYMYHI0QipncnGpOVuFVnF61rag2DfkjhQk2PYdOVMztdDYFx3bA6y3oksOV+2MoxQ8OdV7Aqw4iLuH54P2E6UF9n6vB8M3X9eKwmGr8yHTWcWff3mcJ0/bX8KenH6yzH4Cyi0oIv4Ii0kP2bxRdQbkVtOPDo3Wkfm9mjuvW+DSop/vn4wCkDMVf/fQCIurXt7y6hnGB3McnEjx3NkwFcMUWE0bWzZhhdb6gAmbZGei98xY7SL83mxzbxRHgC2l17vhuzkFeaA4E7J5d/dWcMZFHmAOk6PN/c6mFlJMDPbm+4sEvFw2Gu3JmZDFFGQXxxBtJ0ojYIYy8PnmGhJgGTPDyfmTm37dpZQX01IsJT2kcikeu/DYun1KTVij/iiX6owg2moBvkMzTvoHJ1LsHU1z/5MJVtMGn/3WEOfm/Nz9ytliWvLqvatk8gYvnF8TV9m8ImcaWzZhBRFgPYFjCtiuNGTetJpOVyWzJuFtkIJ0owBzhnJ3qxOyGAFzVQqy8d+ZZdmRsl6NgIGdhuzFTsiZlSyxoHdtOLTQVkojYADh0Cpmbhit18YR1Tr3H5/ZvPHAato+b6ayBt87/72qQi9jZvAZPgxlEPVHmS50QI5UMWHd7AiiSpoRckrB666fJ5tX/MVXx3l+Kszrrl/g4MRaQ9zesQzRoMlTZ9bEVbLw3tdFwJo0YQURYD3BzoR9om9XJ+SP/snD/MFXn2/qMamc+7sgGxJgLkxBjseDBH1G1wrxT8+uMhzxE3XRLL3hiJ9Y0NuQAJtZzZA1rZ7sgHS4eleci0sZLi33TtQcYHolI/VfHaQ0AgaQiGRA+7HMGH6PH40mb1WfhzudnGY6OV1120Y4o3iWUnmenX226j5ZM1sUiBF/hOlFHwORPAFfuSAMeoPEA/FNraOS4dBwU52Io4k8N16+wkraw6sOLvHyy8sj5IaCq/YkOXE+RCprP29xDqREwPqDnQPti4DlTIunphZ54dLyxjuX0A8+YLFgbQGWMd0bAbNtFbo3lPv0bNJV6Uewx9IcaHCQedEDrIcFmFOI/1SPDeae7ZE5kNuFygjYSGy9FUWlF1gpx6c3FwVzBNjF5eWaEbZMfs0DLOqL2iOIEusjZa2q/wLbG63ZcUavObLAj912idccqR5RvnrvKpZWPHvWPh+sOmOIgmsCLOKLsCu2q+n1uu/q04dEA15iAS8X2iDALi6lsXR1EVKPZB90QXoMRSzgZanPUpBgzzfslgA7M5d0VQG+w+RIpCEvMKdQv9cGcZdytdMJ2WNpyJmVrETAOkhlBGx8wO4kNHPDxW216sAATsyfqLsdYDG9yFdOfIX7XryPB888yDfPfpMTM3bkzIkKVWJpi5yVK64h6Ikxt+xta/3XZp/P64H9OzLrrDEcdgzkGI7limnIZHEQt30NCfvC3H3w7qYHeoMIsJ5h50CwaP7YSpyLyUKVTsBaWJbuixQkQLzghl+Jm20owBYTZ+aS5Bq0VWgVmbzJ1GKKvS6q/3KYHIkytZgiXcWYtxTnc9jLAiwa8HJgJNJzhfgzkoLsKJURsJ2JMKjshmasDnkrz/OztctTtNY8cOYBTi+e5sT8CY7PHOfJS09ycdn+jFhm9c9IaQG+3+NnORlBo6p3QLao/suh1YJOKTi8N8lLM0EWk55i9C8cMAl5Q7zxyjdu2lPNnVefPmQ8EeJCG7ogzy3YBdPNRMDShZ5bt3dBwto4okrWasDcKTInR6LkLc3Z+c5OUDg7n0Jrd1lQOEyORtB6rYmgFucWUsQC3mINYa9yZCLRUwIsZ1osJHMiwDpI0FveKDIQTOApdEJ6DA8e5dkwwlWvGP/p6afLzFUdrLxt3aCt+gIs4AkQ8UXqdkC2MgXZjucDuHqPHTl/5kyY1YxBwGcRDQR548E3Mhga3PTzigDrEXYlgg17FDWD85zVvLBqkczaAqwfImA1BZiLa8CgtKuvs1YUZ4odkO4TYAca/J2dW0j1dPTL4ZqJBFOLaWZXuuMHV4ljwtprLvj9TGUK0mN4CAYWG7KicJhPz3N++fy6+5cyS3xn6jtVH2OZjgALovX63J1TdxbwBgoF+H68hsVgtLwhIOKLNDW8uhGGQkNlMzI3i8Ien2Qog4GoycRQhqdeCrOa9hANWrzxyjc2XW9WiTuvPn3IeMI2Y81UOr5tkXOFdMpyJt+wC3gq60TA+kOA9WUNmOMF1uFOyNOz9uu5rQgfYH/RP63+7+zcfKrnhnBX4+oJu3OsV+ZCFk1YJQLWMZw0YymxcAorN4jWRkMCDFjnjO+kHmt1UNoCzAIMtLXeriWbt1/TZ/gKFhQ+RhL5dcOrW51+BLvhZiQ8suXnmYhP8JbDb+E9N7yHuw/ezV3XjjK96OfcbJB9g4MMh4e3/BruvPr0IXsKpo/nWpxSKn2+aoak1XCGV/d1BMzlAmww4mcg7Ot4If7puSRhv6enhi03SjTgZSwW2NC+Y2qxd13wS7l6l1130itpSEeAjcYkAtYpKmvAAAZjOcCDlRsk5AuRyqdqCimH0wunSeXWrhXPzDxTNSoGoLUHbYUxfHP27SppyIxpd0AqpYj6oywlPQxE1q+hFUKpGq2oAzs4fBAAr+FlV2wX/+LWm/AaipW0wXiiNVE7d159+hDHqbvVF9SpwlBhaLwOrK9SkOENUpAu9AFzmGzQVqGVnJlNsncovOW5bd1io9/ZaibPQjLnihRkIuRj33C4Z2ZCzsgcyI7jzHwsZSy2NpR7MGjXJy2kF+o+j6lNnpt9DrBTj98+9+2a+1qmfa3y+qYLt9d/VrJmtpgejfgjJDPrneOBLafwarHVOjC/x8/k4GTZfcPRAD9wpf28rTrG3Xv16TMOtMHdXGvNuYUU+wsdawvJjUPRYM+BBPrCzToR8pHJW+s63zKFCJjP404hAd0RYKfnbAHmVjay73A6IHvZA6yUIxOJnpkJWRxDJAKso1RGwSYGbUFm5oYJeUP4PX7m0/MbPs/x2eNY2uLBMw/WjZg5Bfgevy3AakXAHAEW9kRJ5zyE/OtLYNolwLYaAbt86PKqdWT3XG97fYkA6zMGwn4Gw74N61OaYTGVI5k1ObzTrhVZaDAClipGwNzfBRkP2u+hsg4sm7fwew3XRnIALhuNcn4xzXJ680N1m8GytO0B5sL6L4fJkQizq9maTSnnXCbArplIcHY+xfxqY1+u2snsSoagzyDSB5FzN1HZCbkjHkMZ9kgipRSDwUGWM8sbpiGXM8vc9+J9TC1P1d3PKcD31IiAmZZJ3srj99qpaI+yrz+Ob5aDR3la5oBfSSKYWNeg0AyHRg5Vvf8HD4/z6suHufmyrdd/gQiwnmJyJNLS8TLOxeTwLvsgr1aMXo1+SkHGa4wjyuRNAi5OPwIcGreN/5672NyUg81ycTlNNm+50gPMYXLEvni8OFv9c+Z0DbuhCB/giFMH1gNRMMeE1c1fatxIpdAIeAP4/PPFTsjB4CAazWJ642PkxYUXN9xHm/Z5x+u/ZN+2yr+QlVpQKKVQliPAyrMQA8GBpsYGNctlQ5dt6nGDwcGaEbSQ38PH3/sqXrG/NZE7d1+B+ozJkWhLU0pOAX4xAtagFUWxC7JPUpCwXoA5ETA3c7AgwJ453xkBVhzC7eIU5Eb2HecWkngMxVis94vwAY44nZA9MJJITFi7Q7VOSGcoN9hO7T7D11AashHWImCzhdvlX1ZKTVhD3hDprJ2FqIyAtSv96HD16NWbetzBkYMtXklt3H0F6jMOjEa4sJRmNdNYt+JGOPUsVxUEWONF+Pbr90MErJ8F2MRAiFjAy7MXOiPAnGHxbokOVWPvUBhDUTPSPLWQZjwexFPZL9+jDIT97B8O851Tc91eCtPLIsC6QWUKEiARSWOZCbRldyIOhgZZyixhWlu3ObLMKMpIoowcykitqwEreoB5AkT90eK4olCHBdhweJjx6HhTjzGUwZXDV7ZpRVVer2OvJGyI8+38VI30SLOcW0jh9xrsiAeIBryNR8ByhRlXfVAD5giwpYo6qazpfgGmlOLgeIzjFzoT/VhK2cK81x3i6+H3GuwZCtestXSLB1gpRw+O8dALM8XIdbewU5BiQdFpqllRDBeHctsip5iGzGw9VW3loxgeO4JcS4ApFF7DS9QfJZlZG91TSrsFGDQfBdsT30PY17kIv7uvQH2G063YqjTk1EKaiYEQSqmafljVSBUiYG6dk1hKMQKWrBIBc3kNGMChnTGOX1hGa93213KK/WNBdwvzet2j5xZSrinAd7jj0BiZvMU3Ts50bQ2WpZlblQhYN6hWbL5zwD63OWnIiC/SsjSkZa4JMMOTWp+CzGeL9V+2ACtEwPydjYCBXQcW8jb+ea5VfN8u3H8F6iP2j9jKu1WF+KUXE1uANWpDYRLyeTBckoapx1oRfnlatx9SkAAHx+Msp/NMLbZ+jFUly+k8Aa9BwOvu1LQjwCpF633PXmJqMVWMRLuFVx4YIuz38LVnLnVtDXPJLJZGImBdoFoEbPegfZ8jwJRSDAQHWEwvbjkNaZlRDG9pBKw8YpQxM8UOSEeABXwWpd93vYaXWCC2pXU0gqGMhkVV0Btk38C+Nq+oHPdfgfqIsN/LzkSwZREwe6adXR8wUMOQtBrJnNkX9V8APo/dFr+uBqwPUpAAVxUK8Z/tQBpyKZ0jFnRv+tHhwEiEZNbk0vLaDMXHzy7wrz/+CId3xnnPrZN1Ht17BLwebrtihH86fqkjkdBqXCh8ARhPuCt62A9Ui4ANhMIY3rWZkLCWhlzKbP5coXWhBqwkBVmtCL/UhDWV8XQl/ehw9djVKDYOJlwxdEVbuzKr4f4rUJ8xORJpiRdYJm8yvZwpOnonQr6muiD7YQ6kQ7xK+jXTJynIKzvYCbmUzhd91dxM0Yqi8Dk7PbvKez72HYYifv7i3a8gGnDfe7zz0A7OL6Y53qGGjEqchh83jHDqN6pFwJRSBANLZQIs6o/iNbxbSkNq7Qftx/CsYGkLZSTLasDyVh5Tm8XOzKgvWnDB73z60SHqjzYU2ep0+hFEgPUckyMRTk6vbPmbrPON1ElBNhUBy+b7JgIG1edB9ksKMh70MTEQ6kgn5HI67/r6Lygf+zW7kuFdH/02eUvzf95zk2vsJyo5esgekfJPx7uThryw5ETA3Pn7czO1DEej4WSZACumITOLWHq9K30j6IIFRYZTPHbxMV7M/xFzxidZydgp/VIPMCiMIcquH0PUSQEGGxfjj4RHWjJcu1ncfwXqMyZHIiyl88w3GK2qheMB5giweMjXuBN+ziLUBx2QDvGQr6oTfj80GQBctbMznZDLfZKC3BkPEvAaPDW1yHv+z3c5v5jmI++6kctGo91e2qYZiwW5dneCrz1zsSuvP7WQxudRjESkCL/TVIuAAQxGc2grXJYiHAwOYmlr02lIKx/FZJmX0l/FozwEjEGWvJ/j2bnjPHHpCc4tnwPA7/Xj8/gIeoOkMuvHEDkzKjvFnsQeEoFE1W2GMrh+/PqOrqf42l15VaEmB0brG0U2yrliSqAQAQv5yVaZiViNVDZPuA9MWB2qRsD6pAYMbEPWE9OrZPLttSHolwiYYSgmRyL81TfP8MTZBf7nO2/g5fs6+428HdxxaIxHX1pgdiWz8c4t5sJiih3xYF807riNWhGwscKUn9IoWMwfw6M8zKc2l4Y08xFm/B8gr1NcNngZ+8J3sif9V+yNXk3YF2Y5s4xCEfAEiPgiaE3XU5AOh0cPr7tvMDjIjx76US4furzj6wERYD2HU59ycoudkI4A21moyXDsGBqpA0v2WQ1YIuRb7wPWJzVgAIfG45iW5sSl9g7mXkrliPdBBAzWPPd+654j/NDVzZk19ip3HtqB1nDs2emOv/b5xTS7pAC/KwS8gapF5hOD9pelamnIhczCptKQlzLPkvZ8j92xy4j4IxhGCoMoA77LuHzocq7bcR1Xj15d9ADL5BSWVmUpyIAnQMTf+U7jQyOHygZsX7vjWt56+K2MRkY7vhaH/rgC9RG7B0N4DbXlTsiphRSjsUDRMmAgXBBgDVhR9FsRfj/XgMHaTMh2pyH7JQIG8K9vv5w/eMd1/OSrOtt23k6u3hVnLBboSh3Y+cW01H91kWrjiOyGCBMzN1J2v5OGXM40Vze6mF5kOvcdIvnbGQnb6TzlsceTOYX4HsNTTInaLvj2daTUBb8b0S+wherlQ5cT88e4++Dd3LLnFjxGd69z/XEF6iN8HoO9Q+EWCLB0maFkLUPSaiSzZt+lIJNZk5y5dhLopxTk5EgEv8doayF+zrRI5cy+qAEDODKR4Edv2N3tZbQUw1DccWiMrz83TTa/uSLrzaC15sJiuhhtFzpPtTowv9eDz19uRQEQC9hpyOlk45HSTD7Diwsv4mcHI9ZPYRROncqwMy2WtT76GfFFiias4ZIasMFQZ+u/Srlx1428/eq3syu2q2trKKU/rkB9Rj2n7kapdPQupiAbKMTvxy5IKJ8Haacg++M9ej0Gl49FeaaNAmwlbRvZ9ksErF+549AYy5k83+3gbMjZ1SxZ02JnXARYt6hVBxYKrmBmxyhtqjeUwVhkjMXMIqlcasPntrTFyfmTAOzkPXg8a+dRw2M/Xpvrx/eUuuCXpiC7FQEDe00+T+98iRQB1oNMjkQ4NbuKZW3OikJrXWbCCrWHUlcjlTP7qguypgDrkwgY2COJ2mnGuiwCzBW8+vIR/F6Dr3UwDelY3ux02QinfqJWJ+T48CxmbpRsstzjaiwyhqEMLqxc2PC5zy6dJZlPsn9gP15zf3EMEYAy7L995TxIoGIOZPdTkL1I/1yB+ojJ0QjpnFX01mmW2dUs2bxVFgFzasA2SkHmTIucqfsqAhYP2aLBEWC2X01/CbCrxuNcXMowv9rYuKlmcZoY4i4exL0diAS83HxgmPs6KMAcE9adUgPWNWpFwA7vncfju8jq7OvR1tpn12t4GQ2PMpeeI5Ov3TW7kl1hOjnNWGSMgeBA2RxIAKUslEqvc8MHxwW/MAdSBFhV+ucK1Ec4HVqbTUM6HmC7SgRYNODFY6gNI2Cpgk1FqM9qwGBNgGULtWD94gMGthUF0DYn9KU+GcS9HbjzqjFOzqxycnprVjaN4nxR3CldkF2jphdYKE505PNY+UGSC7eWbdsR2YFCcWG1ehRMa82ZxTP4DB+7orvQWpXNgXRQnuS6CFjpIG6vx8LvtbM5YV+YoFeEukP/XIH6iAOOFcUmBdjUwnoBppSyxxFt0AWZyhYEWB9FwBwB5pixOgXK/WJDAXYKEtrXCemkIPvFhqKfuf3gGNA5V3zHhHU4IoO4u0WtCNhAcABf6DSByOOkFl+NmVsrgPd5fIyER5hNzhYd7Eu5lLxEKp9iT3wPHsNTEFmesggYgFFlHmTIG8JQBsmsR9KPdeifK1AfsSMeIOTz8OImvcAcD7Ddg+UfCtuOIV/3scmCAOuvFGQNAdZHEbDRaIChiL9tnZBSA+Ye9gyFObgj1jEBdmExxXhCTFi7Sa0IWMAbIOwLEx7+MmCxOvtDZdt3RHag0VxcLZ+gkDWzTC1PEQ/EGQgOAPYQbmCdAFOe1LoIWNRv75vKGGUu+CLAyumfK1AfoZQqdEJuLoVwbiFF2O8pRn4c7IHc9SNgyax9oe0nAVYrBdlPAkwpxaHxWM1OyGze4rOPTWFusrFjuZiClAiYG7jjqjG+/eLcOgPidjC1mGZnXNKP3aReWm8oNITHu0x48H6yyavIJtdc3wPeAEOhIWaSM+SttS/nZ5fOorVmT3wPStnC2srXEGBGap0NhSPAbBf83uiA7EX65wrUZ0yObt6KYqpgQeF8cBwSVWYiVrKWguyfSEfA6yHoM9YEWB+mIMGuA3vuwnLV7tn/fewEP//JR7n/uc1FRSQC5i5ee9UYeUt3ZDakeIB1n1opSKA4ZDqU+CYe3wwrs29A67Uv2OORcSxtcWnVPjcsZZaYT88zHh0vE3a1ImCGJ4WuSEFGfHYdczJTnoLs9AzIXqe/rkB9xIGRCC/NpzZlqGhbUKz/RjoQ3nggdz+mIKHcDb8fU5Bgd0KmciZn5pJl9780l+RPjr0AwONnFzf13EupHCGfB1+fidZ+5YY9g0wMhPj0o1NtfR3Lsk1YxQW/u1RzwncYDdujdpQyiQx/ASs3Qmrx5uL2kC/EQGCAS6uXyFt5ziyeIeAJMB4tH9HlCDBVWYRv2ClIrde+8BdTkFlJQdZDzqY9yuRIBNPSvDSf3HjnCqYW0lUFWLWRPJX0YxcklL/3TJ8KsIM1RhL9188/jaEUO+IBnjy3uSL9fhpDtB0wDMU91+/iwRdmmGnjcO65pJiw9gL1UpDDoTUnfH/4BP7wMyTnX4OZjxfvH4+OY2qTZ2efJWNm2JvYi6HKz4/ajILKolT58WQYKcBAW2tRuKg/St6EbH4tBRnzx3rKBLUXaOgKpJS6XCn1p0qpx5VSplLqWMX2nUqp/66UekwptaKUekkp9X+UUuv8/pVSE0qp/6eUWlZKzSil/lgptd5Gd5tTtKJoshA/mc0zt5pdV4APMFAQIfUMXvuxCxLs7r1+rgEDuHJHDKXKrSjuf26ae5+6yL+543JuPjDMk+c2FwFbzuREgLmMN90wgWlp/vGx9kXBzi+ICWsvUKsIH+zRQ6XbI8NfAhSpEluKiD9CzB8jnU8zGBwkHoivex7HA6yismXdPEiobsIq0a/1NHoFuhq4C3gWeK7K9pcDPwp8Engj8B+AVwIPK6Wizk5KKR9wL7AP+DHgF4C3AR/e5Pr7ls16gU0VToi7qtRkxEM+tF6r56lGf6cg7fftpCADfZZOC/k9TA5HOH7eFmDZvMVvfvYp9g+Hee9tkxyZSHBhKc30cvMRETsCJt9e3cSVO2JctTPO//t+GwXYopiw9gL1asAARkJrA7k9vgX84WfJrBxB67Vz4ER8gpg/xu549RmplSasDoYzD7KkDiziL5kDKQKsJo1egT6ntd6jtX4b8FSV7Q8Ch7TWv6u1vk9r/dfA3dhC6y0l+70VuAp4i9b681rrjwM/B/y4UuqKzb+N/mMg7Gco4m/aC6zoAVbFFHEgbNcJ1EtDFrsgff0V7ShtQOjXGjCw05DPXrQF2EcfepGTM6v8xt1XE/B6ODKRAODJqeajYEvpvLjgu5A3Xb+Lx15a2PJs2VqcXxQT1l7A5/GhqG0D4hTiOwSij6OtCLnUZcX7Ir4IVw5fWbOezMpXF2DKmQdZiIB5DS9Bb7DEBd/+Ut/NIdy9SkNXIK113UpwrfWC1jpfcd9zQBIoTUO+AfiO1vrFkvs+DWSB1zeylu3EZqwoHA+wiSopyLWB3LWtKPo2BblNBNih8TinZld5cWaV//m153ntVTuKxpxX77LTCk9uohB/OSUpSDdy9/W7UAo+8/1zbXn+84tiwtorVHa9lzISHim77Q+/gDKSZFaubfj5q7ngg12ED2BZdiVR0YIiKynIjWjbFUgpdS0QpjxleQg4Xrqf1joLnChsE0qwBVjzETBDwY4qRbHFeZD1ImA5E6+h+k6cJEI+ljN5TEv3bQ0Y2BEwreFf/tX3yFuaX/+Rw8VtsaCPAyMRnthEHdhSOk9cBJjr2JkI8arJYT7z/Sm03pwHXD3EhLV3qBcBqxRgSpkEIk+TWT2EtjYWz1p70FakegrSiYAVUpARv2NBsZaCVCixoKhCW86oSikD+CPgeeCzJZsGgYUqD5kvbKv2XO8D3gcwOjrKsWPHWrnUrrGysrLxe1nKcnEpx5e+eh9Bb2MnuEeOZxgIKB564Ovrtp1btoXHw999DPNc9T/9Cy9m8Bm6b37PDtPnbNH5xa8e4/EZO8r3/e99lwuR3hNhDR0bNVhK2n/j4xeWuecyHyef+DYnS7aPetN872Sy6edfTGaYv3SBY8fmNrUuoTVs5tg4FM7xjZNZ/uKz/8SBRGsj28+cThGCvjtfuBEjZzB8abjqtmGG+dmhn8ViLZn1ki/AJ571c7P651w9VL/bfinr4X8Dt8Wv4/qhy8u2mRZ84DTcEHg1rx66hqA3SPRSFOZ8GGh2zQ/iMzw88PUHtvwe+412faX9HeBm4DVa6y1ZMWutP0yhSP/gwYP66NGjW19dD3Ds2DE2ei+p4fP83fOPsPuqlxXrdzbifz/7DQ7s0Bw9esu6bZeW0vzqQ19jYvIKjr5qX9XHf2HmMWJz0xuuzW3Mfu8snzj+GEdedhPJF+fg8ce59ZZXsXuw9xpwGzk2amFZmvd/814Gw35+912vWZdKfs44wbe+cJxrX3ELQw2mjbJ5i9yXvsjVV0xy9KiUanaTzRwbN6RyfPyZr/KSMc57jl7d0vX8+rfv44a9Axw9ekNLn1dons/e+1lmh2drbv/C819ganmtIUNrheH5Re69MMc31cfrPncuswv45zycvpfvzT27brtSv8J3V57h+NyXePnOl3PD2A3MvjRIMGAwv2OWscgYR686utm31re0/Ou/UupfYXdBvktr/a2KzfNANSUxWNgmlLB/E52QU4vVTVhhbSZivRTk+T41VSwdR5Tp4xSkYSg+8Lbr+NBPvrxqHZ8j5JtJQzpjiKQI350kQj7uODTG5x6bIm82b+xcCzFh7S3q1YBBuR+Yvb8mEHuCXOoyLDNS97G6xhii4nN5UujKGrCMUaz/cpzxhXJaegVSSr0F+CDwH7XWf1Nll+NU1HoppfzAASpqwwTYP9ycADMtzfmFdNUCfICgr3wkTzVOzybZO9R7UaGtUio+12wo+qvRwOGua3Zyze7qEdOrdxU6IZsSYDKGyO286YZdzKxkeehE7QhJszgmrNU6roXOU68GDNbXgYHdDQkeMiv1I6PFMUQVRfgxf4x9iX1EAoqhwG7edvhtXF5IUdpjiOxyD6cuTCinZQJMKXUU+DjwQa31B2rs9kXgFUqp0vzX3UAA+FKr1tIvhPwediWCfP25aWYbcLOeXs6Qt3TNCBjUH8idMy3OLaTYN9x/AixRRYD1YwRsIxIhH/uGw00JsCUZxO16jh4cIxb08plHW9cN6ZiwSgSsN6h0rq+k0ooCwOu/hMd/YcNuyGpzIG/deyvvOPIOXnfZ6xiOBFE6SiKYKEbiSscQSQSsOo064YeVUm9VSr0VmABGnduFbVdh20kcB/5GKfWqkp/LSp7q7wr7/INS6i6l1DuBPwY+obV+vqXvrE94z62TPPrSAkf/+zH+9P4TpHNmzX2LFhR1BuMOhPw1I2BTCylMS7NvqP8+LCLA1jiyK9FkClIiYG4n6PPww9fs5N6nLhStZraKY8IqEbDewGPUj+gnAomqHl+B6OPkM3swc7VtIiwzijKSKGUfO8PhYQ4OHyxuD/kt0tny82lpCjLs678v9a2g0SvQGPCpws+rgMMlt8ewXe8TwHXAw8A3Sn5+zXmSQkH+64GXgL/FFl9/T6HLUVjPe287wL2/eBuvmBzid754nNf9wf18/vHzVVvK1wRY7YM9EfaxkKwuwE7P2p0we/s4AraUzpE1TTyGwrNNW+ePTCQ4O5+qGQmtZLkYARMB5mbuuX6C1azJV5652JLnc0xYJQLWG3hUfQGmlKrqxRWIPgFYZFauqfnYShf8m3ffXFZzFvRbpEoEmKXtCJikIOvT0BlVa30K6iaYP1b4aeS5zgJvamRfwebysRgf/elX8MDz0/z255/hX3/iEa7bM8DBHdGy/Z6/ZH9Aqo0hckiEfLw0V73l+HTh/n5MQQZ9Bn6PUZyF6e+zMUTNcI3jiH9uiVuvWF8XUslSIQIWlxSkq3nl5BA7E0E+/eg57r5u3Zjepjm/mMbvMcSEtUfYKAIGduTqwsqF8sd5l/AGT5NZuZbQwP3rZj1CuQv+gcEDjEfHy7aH/CbprIHWoBSFaJgiJEX4ddm+VyEXctsVo3z+52/jd998DauZPA88P1P2c2ExzdGDo3VrdZyB3NU4M7uK32uwI9Z/32iVUkU3/Gze2rbpRyhxxG9wJNGyCLC+wDAUd1+3i68/N83camPRz3qcX0yxIxEQE9YeQaE2FDrVCvEBgtHHMXMj5LPVhbkTAfMaXm6auGn94/0WGkUmZx8LayashdnCkoKsiuQUXIbHUPzYTXv5sZv2burxdhF+7RTk3qFw355QEyEvi6kciZBvWwuwwYif3YOhhuvAnBFOUUlBup57rp/gT79+ks8/PsU/u3n/lp7r/GJaZkD2GAPBAVZztbvmS4dyl+KPPA0zP0xm+Vp8gfXD2y0zivKucO2Oa4s2E6U4xfbprEHQb5LMFMYQ+S28hpeAt/6w8O3K9r0KbVMGwj5SOZNMfn0h7pm5JPv60ILCIVGI/mXy1rZOQYKdhmy0E3I5nSfi92zbmrl+4qqdMa7cEeXT319/kW2W84spdkr9V08xEByouz0RTOA11n+RMjxp/OHnyKweQevyc6O2/KADhPw5rt1RvVsyWBBgTh1Y6RgiST/WZntfhbYhiRpmrFprzswl+7IA3yFeEGDZvEVgG0fAwC7EPz2brOsJ57CczokFRZ+glOKe6yf43un5mrWgjWBZmouLGYmA9RgbCTBDGesMWR2C8UfQZozV2TdQ2uPlWFBcMbqjqniDtQhYqjCAO1UQYKGAKQX4ddjeV6FtSCJsF8wuVVx4p1cyJLPmtoiAbfcaMFhzxH+qgTqw5XSeeEjSj/3CPdfbdT6f+f7mPcFmV20TVomA9RYbCTCo7gcG4A8/TyjxIOmlm0gt3Fa83xFgk0O1bSqCJSlIYC0FGbCk/qsO2/sqtA1xImCVdWBnZp0OyP79tpII+VhM5siaIsCOOIX4DaQhlzMSAesndg+GuWn/EJ/+/lRVOxsHy9Icv7BUdduFggWFCLDeohEBVqsQHyA89FUC0cdJzr+W9PJ1AGgzBkAkWHuMVagyBZk1CPgsPIZ0QNZje1+FtiEDNVKQ/ewB5pAI+VjO5EnnzG1fAzYcDbArEeTJc9UvsKUsp/PiAdZn3HPDLl64tMJTU7X//v/rvhd4/R8+wHdOza3bNlUwYZUUZG8RC8Rqpgkd6gkwpTTR0U/jC51gZfoessnL2B09DEAkWNvAtzIClsoYhPziAbYR2/sqtA2pFQE7PZfEULC7xhzJfiAR8qE1zK/mtn0EDOw0ZCMRsKWURMD6jR++Zic+j6qZhnxpLskf3/cCAH/+wMl12y+ICWvPkghUnwPrMBAcqOsZppRJbMff4PFfYuXSj5FZvQyldNHTqxoeA/xeq6QI3yODuBtArkLbjIFw9QjYmdlVdiZCBLz9OaAa1gZyT69kRIBhC7CTM6tFp/taSASs/xgI+3nNlWN89rEpTGt9GvK3P/8MhlK85WW7+fLTFzk9W25tMLWYEhPWHqWRQvxqjvhl+xgZdu75f0QCihMXQkQCFhs1QZe64ZeOIZIIWG3kKrTNcCIZC5UpyLlkXzrgl+JE/+ZWs9s+BQlrjvhP10lDgQiwfuVNN+zi4lKGb56cLbv/geen+dJTF/g3d1zOf3r9QbyG4i8eOlW2z4XFtJiw9igN1YHV8ANzMJTBD175St5x2wxBn0kslN/wOUvnQZaOIZIi/NrIVWib4TEU8aB3XRfkmdntI8Bg+w7iLsXphKxnyJrOmWRNS1zw+5DXXrWDaMDLpx9dS0Nm8xbv/+xT7B8O897bJhmLB7n7ugn+9rsvsVhStiAmrL3LYGhww31qdUI63DRxE2ORMUbieX7qjkvcdeP8hs/pCDCt7RSkU5gvKcjayFVoG2IP5F4bRbKSyTO7mmXvUH9/UEpFhAgwGI0F2BEP1K0DWxtDJBGwfiPo8/D6I+N86ckLpHN2tOJjD7/IielVfv2Nh4vlCD9z6yTJrMknv3Om+FgxYe1dGomA7Uvs45qxa6q62u8f2M+RsSPF20OxPKOJjf0CnRRkNq8wLUU4YBHwBBqaUbldkavQNmQg5C+rAXPqO/o+AhZeE2Db3YjV4ZqJBE/WSUEuFerDpAi/P3nT9RMsZ/L80/FLXFxK80dffZ47D41xx6EdxX0O74rz6suH+dhDp8iZlpiw9jiNCLCQL8Qrd7+Sd1z9Du4+eHdRjMUCMX5g3w9s6nVDBQFWOgdS6r/qI19rtyGJkK+sBszxANvbxyasUJGClBowAA6MRvn68zNorVFqfT2PEwGTGrD+5ObLhhmLBfj0o+f48lMXyJmaX3/j4XX7vffWA7z7Y9/hC0+c55bLRsSEtYfxGl4ivkjdmZAOSinGImOMRca4aeImclYOv2dzjRXBQgrSMWENyRiiDZGr0DYkEfaV1XOcnnNMWPtbgJXOM5QUpM2uRJBs3mJmJVt1+7JEwPoaj6F443W7+NrxS3z6+1P889ccqGrG/JorRzkwGuHPHjjJ+aIHmAiwXqWROrBKlFKbFl8AIb+JRrGwan9ZCwcsiYBtgFyFtiHOSB6H07NJhiL+vr/IKqWKUTARYDYTg7bonlpIVd1erAGTUUR9y5uun8C0NBMDIf7V0cur7mMYip+5dZInzy3xmcIgb0lB9i6NpCFbjWPGOrvsCDBTImAbIFehbchAIQXpjCE5M7fa9+lHh6IA80hhKMCuATuKUVuASQSs3zkyEednb5vkA2+7jpC/9ufizTfsZjDs4y+/cQqAnQMSAetVuiHAnK7HuWX7XCFzIDdGBNg2JBHyYVqa1azd+XR6G1hQOMQlAlbGxIAdxTi3QQRMasD6F6UUv/rDh7n5svrWBCG/h5981T5ypsbvMRgKiwlrr9LNCNjcshePofF5tKQgN0CuQtsQxw1/IZklm7eYWkixb7tFwESAAfbvI+L31BRgS6kcSkHULwJMgH928z78HoPxRFBMWHuYrkbAVryEAyZKiQfYRshZdRuSKBnInTM1loa9VQpv+xHHz0oEmI1Sil0DIc7N1xBg6TxRv1cutgIAY7Eg/+r2y0jnas8FFLpP1B/Fa3jJWxs72LcKR4DlTYNwwH5dSUHWRwTYNiQRslMHi8kc08sZoP87IB0c8RkQG4oiE4MhphZrpyDjIan/Etb4xdde2e0lCA0wEBxgJjnTsddzUpBgizGFEgG2AXIV2oaURsDOOBYUkoLctuwaCDG1kK66bTmdk/ovQXAhnU5Degzwe20RFg6YhH3hqt6CwhpyFdqGFGvAUjlOzyYJ+TyMxgJdXlVnEAG2nomBEHOrWZLZ9ekKGcQtCO5kMNi8F9hWcaJg0gHZGHIV2oaURsBOzybZO7R9vqms2VDIoe/gdEJWi4ItpXNiQSEILqSbhfghMWFtCLkKbUPCfg8+j2IhmeP07Cp7t0n9F0gErBq7igJsfR2YRMAEwZ1004pCTFgbQ65C2xDHEX4hmeXMXHLb1H8B7Cm817H49ki5NoJjxlrNimI5nSMuETBBcB2JYKLjrxkqSUFKBGxjRIBtUxIhH89dXCaTt7ZNByTAkYkE3/yVOzk0Hu/2UnqG8XgQQ62PgGmtJQImCC7Fa3iJ+WMdfc1iBMxvSg1YA4gA26YkQj6ePr8EUHX4bj8zLkOEy/B6DMbjwXVeYOmcRd7SUgMmCC6l02nIshowSUFuiAiwbcpA2F80U9xOETChOhODoXUpyKXiHEiJgAmCG+m0AIsGTRSaaNCUFGQDyJl1mzJQKEb3GKpYhC1sX3YNhHjkzHzZfcsiwATB1XRagF2zf5UdA1mCfi0RsAaQCNg2xXE3nxgI4RNLhm3ProEQ5xfSmJYu3rdUGMQtTviC4E46LcD8Xs3ukSwe5SHglUanjZAr7zbFMWOV9KMAthDPW7o4mgpsCwpYm58pCIK76IYVBSDpxwYRAbZNcfyw9m4jCwqhNo4Za2kd2FoKUiJgguBGIv4IPqPzn1/pgGwMEWDbFImACaXsqirA7AiY1IAJgnvZk9jT8deU+q/GEAG2TVmLgMkHRVgzYy31AltKSQRMENzOVSNXdfw1JQXZGCLAtik37h/inTft4ZbLh7u9FKEHiAV9xIPeMgG2nM5jKIj4PV1cmSAIW2FPYg/xQGeNpyUC1hgNCTCl1OVKqT9VSj2ulDKVUseq7KOUUv9ZKfWSUiqllPq6Uur6KvsdVkp9TSmVVEpNKaV+SyklZ/gOEw/6+J03XytjZoQiE4PhMjPW5cIg7u0yqF0Q+pV2RMHq1ZZJBKwxGo2AXQ3cBTwLPFdjn18Gfg34PeCNwArwVaXUuLODUmoQ+CqggXuA3wL+HfCbm1m8IAitY2IguK4GTOq/BMH9HBo5hKFal/DyKA/3HLqHRKD6vEkpwm+MRv8in9Na79Favw14qnKjUiqILcB+R2v9x1rrrwJvwxZa/6Zk138BhIA3a62/orX+ELb4+iWllAznE4Qusmug3A1/KZ2X+i9B6ANCvhD7B/a37PleMfEKRsIj3Lzn5qrbJQXZGA0JMK21tcEutwBx4G9LHrMKfA54Q8l+bwDu1Vovldz319ii7DWNrEUQhPYwMRBiOZ0vjiBaSuckAiYIfcLh0cMteZ7x6DjX7bgOgP0D+9kd371uH0lBNkarYpKHABN4vuL+ZwrbSvc7XrqD1voMkKzYTxCEDuNYUZxfSAN2ClJqBAWhP9gd373lYnyv4eWOyTvK6kJv2XMLirXbAU8AryFf3BqhVQJsEFjRWpsV988DYaWUv2S/hSqPny9sEwShS6x5gSUBuwhfXPAFoX/YajH+zbtvXifihkJDZdE1qf9qnJ4/uyql3ge8D2B0dJRjx451d0EtYmVlpW/ei9BaunVszKftSoNj334c44KP+ZUUi7MX5TjtIeS8IdSikWNDa81IagSNrrpdoWpu83v8TK9Mc+zp9a+h0YymRrG0hd/j59hM/XUINq0SYPNAVCnlqYiCDQJJrXW2ZL9qbRODhW3r0Fp/GPgwwMGDB/XRo0dbtOTucuzYMfrlvQitpVvHhmVp/uMDXyQytofXvOYg6S9/kasu28/Rowc7vhahOnLeEGrR6LHxlRNf4cT8iXX3X7fjOm6auImp5SmOzxzn1MIpzMLlPOAJ8Par3163tuvxi4/z8EsPc3D4IEcnN16H0DoBdhzwAJdjW1U4VNZ8Haei1ksptQcIV+wnCEKHMQzFzkSIc/MpklkT09JShC8Ifcbh0cNlAizoDXL7/tvZN7APsI1b9yT2kMlnODF/guMzxzkydmTDwvojY0d4evppSUE2QavOrg8DS9jWE/8VQCkVxvYD+3DJfl8E/oNSKqa1Xi7c9w4gBdzforUIgrBJdg0EmVpIFTshxYZCEPqLifgEiUCCxcwi49FxXnfgdVXFVcAb4PDo4Ya7Jw1lcPPum1nOLm+8swA0KMAKYuquws0JIK6Uemvh9he01kml1O8Cv6aUmseOZv0SdpH/B0ue6kPAzwP/oJT6PeAA8H7g9yusKQRB6AK7BkJ848RscRB3PCQRMEHoNw6PHiZjZnjFrle0dNLFvoF9rGZXW/Z8/U6jZ9cx4FMV9zm3J4FTwO9iC65fAYaB7wKv01pfdB6gtZ5XSt0J/DG2R9gC8AfYIkwQhC6zeyDExaU086t22aZEwASh/7hu/Lq2Pbd4gDVOQwJMa30KqCuTtdYa+O3CT739ngbuaHB9giB0kF0DISwNz19aAZAaMEEQhDbRuuFQgiC4HscL7PgFuyJAfMAEQRDagwgwQRCKTAwWBNh5u5BWUpCCIAjtQQSYIAhFdiVsAfbsBVuAySgiQRCE9iACTBCEIiG/h+GIn+VMHq+hCPrkFCEIgtAO5OwqCEIZTh1YLOhtaYu6IAiCsIYIMEEQytg1EASk/ksQBKGdiAATBKGMiQF7lIhYUAiCILQPEWCCIJThRMCkAF8QBKF9iAATBKGM3YNrNWCCIAhCexABJghCGWtF+BIBEwRBaBciwARBKKO0C1IQBEFoDyLABEEoYzji5/KxKId3xru9FEEQhL5FvuIKglCGUoqv/tJrur0MQRCEvkYiYIIgCIIgCB1GBJggCIIgCEKHEQEmCIIgCILQYUSACYIgCIIgdBgRYIIgCIIgCB1GBJggCIIgCEKHEQEmCIIgCILQYUSACYIgCIIgdBgRYIIgCIIgCB1GBJggCIIgCEKHEQEmCIIgCILQYUSACYIgCIIgdBgRYIIgCIIgCB1GBJggCIIgCEKHEQEmCIIgCILQYUSACYIgCIIgdBilte72GhpGKbUMPNvtdbSIBLDY7UUIPYkcG0It5NgQaiHHRm9yUGsdq7bB2+mVbJFntdY3dnsRrUAp9WGt9fu6vQ6h95BjQ6iFHBtCLeTY6E2UUt+ttU1SkN3jc91egNCzyLEh1EKODaEWcmy4DLelIL/bLxEwQRAEQRD6m3q6xW0RsA93ewGCIAiCIAgNUlO3uEqAaa1dIcCUUm9TSn1WKXVOKbWilPqeUuqddfb/BaWUVkr9XSfXKXSHRo4PpdSxwjFR+RPs1rqF9tPouUMptU8p9Uml1JxSKqmUekwp9fpurFnoDBsdG0qp/TXOGVop1S/Na66jnm5xWxG+W/gl4EXg3wIzwF3AJ5RSI1rrD5buqJQaA94PTHd6kULXaPT4uA/4zxWPzXRmiUKX2PDYUErtAb4BPAa8G1gFrgdC3Viw0DE2OjbOAzdXPCYEfBn4YicXKjSGq2rA3ELhAzFTcd8ngJu11pMV938E8AN7gBmt9Vs7t1KhGzRyfCiljiHHw7ajwWPjr4EJ4DVaa6sLyxS6QDPXlZLtbwP+FniV1vpbHVim0ASuSkG6hcoPSYFHgV2ldyilbgLeDvxyJ9Yl9AaNHh/C9mOjY0MplQDeDPyJiK/txSbPG+8ETor46k1EgHWOm4HnnBtKKQV8EPhvWutzXVuV0CuUHR8FfrBQ35NUSt2rlLq2GwsTuk7psfEywAdopdRDSqmcUuqsUupXCucUYXtR7bwBgFIqDrwB+OuOrkhoGBFgHUApdSfwJuB/lNz9bmAH8IFurEnoHWocH/cDvwD8EPA+YC/wgFJqf6fXJ3SPKsfGeOHfPwUeAH4Q+CjwX4F/2en1Cd2jxnmjlDcBQUSA9SxSA9ZmChfMbwEPa61/tHBfAvtby89prf+2cN8xpOZn21Ht+Kix3zhwHPiY1voXO7M6oZvUOHf8OPBx4G+01j9Wsu9Hgddprfd0Y61CZ2nkvKGU+iKwR2t9pJNrExpHImBtRCk1hN19chr4iZJN/xk4A3xZKTWglBrA7kj1FW57Or5YoePUOT7WobW+ADyEnYIS+pw6x8Z84d/7Kh7yT8DuQtpJ6GMaOW8opYaB1wKf7ODShCYRG4o2oZQKA/+I3eH4I1rrZMnmg8CNrJ1MS5kHbgMebPsiha6xwfFRC134EfqYDY6NZ5zdKh9W+FcK8/uYJs4bb8W+vkv6sYeRCFgbUEp5gU8BVwCv11pfqtjlvwC3V/w8Bny98P8nOrdaodM0cHxUe8w4cCvwvTYvT+giGx0bWutTwFPAHRUPvRM4obVe6cQ6hc7T5HnjncC3tdYnOrI4YVNIBKw9/Am2Sd4vAMOFcLDDo1rrJysfoJRawK4BO9aRFQrdpO7xgR0h/R3sk+1p7AL8X8GObvxhR1cqdJqNzh0Z4NeAv1dK/Xdsk82jwD8DfqrDaxU6SyPHBkqpXdhZlH/X+SUKzSBF+G1AKXUK2Fdj82ThW2zlY44hRfjbgo2ODyAH/BlwAzAMLAPHgF/VWh/vwBKFLtHouUMp9ZPArwKXYdeTfkBr/aFOrFHoDk0cG7+I3Rm5R2s91ZHFCZtCBJggCIIgCEKHkRowQRAEQRCEDiMCTBAEQRAEocOIABMEQRAEQegwIsAEQRAEQRA6jAgwQRAEQRCEDiMCbIsopd6vlNJKqedrbH++sP39HV6aIAiCIAg9igiw1pAGJpVSN5beqZR6BbC/sF0QBEEQBAEQAdYqVrGH4f5Yxf0/Vrh/teMrEgRBEAShZxEB1jr+Gni7UkoBFP59OxXDUJVSNyulPquUOq+UWlVKfV8p9RMl24eUUmml1E9XPE4ppU4qpf6g/W9FEARBEIR2IgKsdfwDsAN7YDLYs7hGC/eXsg94CPgZ4I3A3wN/oZR6J4DWeg74f8BPVzzuKPaYmo+2fumCIAiCIHQSGcbdIrTWC0qpL2GnHR8o/PslrfViISjm7FeMiBWiZF8HdgM/C3yysOkjwJeVUge01icL970b+J7W+om2vxlBEARBENqKRMBay18Db1VKBYC3UpF+BFBKDSql/qdS6jT20OUc8D7gypLdvgacBt5VeEwMeAvwF+1dviAIgiAInUAEWGv5LBAFfhuIAJ+rss/HgHcA/x34QeAV2GnFoLODtiek/wXwrpJaMg/wiTauXRAEQRCEDiEpyBaitV5VSv0j8G+BT2mty7oflVJB4EeAf621/lDJ/dWE8F8AvwHcjl0P9mmt9Xy71i4IgiAIQucQAdZ6/jcQAD5UZVsAO+qYce4opBfvBnTpjlrrl5RSXwZ+E7uw//XtWrAgCIIgCJ1FBFiL0VofA47V2LaolPoO8OtKqSXAAn4ZWATiVR7yEeBTwFngK+1YryAIgiAInUdqwDrPjwMngb8E/gjbhuIva+z7j0Ae+D9aa6szyxMEQRAEod0ou95b6EWUUndhi7ArtdYvdHs9giAIgiC0BhFgPYhSahdwBfBB4IzW+ke6vCRBEARBEFqIpCB7k/dhe4GlgZ/r8loEQRAEQWgxEgETBEEQBEHoMBIBEwRBEARB6DAiwJpEKfU2pdRnlVLnlFIrSqnvOYO0K/b7WaXU80qpdGGfOyu2jxZGEn1bKZVVSp1q4LV/QSmllVJ/18K3JAiCIAhChxEB1jy/BKxgu93fDdwHfEIpVazVKgiyRH7ONAAAAqVJREFUD2HbS7wBeAr4R6XUkZLnmcAeSXQB+P5GL6qUGgPeD0y34k0IgiAIgtA9pAasSZRSI1rrmYr7PgHcrLWeLNx+FnhIa/2ewm0DeAx4TGv9k859jreXUuoDwFu11vvrvO5HAD+wB5jRWr+15W9OEARBEISOIBGwJqkUXwUeBXYBKKUOAFcCf1vyGAvb0f4NFfc1hFLqJuyB3L+8uVULgiAIgtBLiABrDTcDzxX+f6jw7/GKfZ4BhpRSo808sVJKYfuB/Tet9bktrVIQBEEQhJ5ABNgWKRTXvwn4H4W7Bgv/LlTsOl+xvVHeDewAPrCJ5QmCIAiC0IPIMO4toJTaD3wC+IzW+mNteP4E8DvAz2mtU61+fkEQBEEQuoNEwDaJUmoI+CJwGviJkk1OpCtR8ZDBiu2N8J+BM8CXlVIDSqkBbNHsK9z2NL1wQRAEQRC6jkTANoFSKow9JNsP/IjWOlmy2an9OoQtzii5Pae1bsZG4iBwI9VF2zxwG/BgE88nCIIgCEIPIAKsSZRSXuyOxiuAW7TWl0q3a61PKqWeA94G3Ft4jFG4/cUmX+6/AH9Ycd8fAovAbwBPNPl8giAIgiD0ACLAmudPgLuAXwCGlVLDJdse1VpnsA1T/6rgbv8Q8C5swfbjpU+klHK8vK4EwiW379daT2utn6x8caXUArYP2LFWvSFBEARBEDqLGLE2SUFU7auxeVJrfaqw388C/wnbOPUp4D9orb9W8Vy1fvm31xJYSqljiBGrIAiCILgaEWCCIAiCIAgdRrogBUEQBEEQOowIMEEQBEEQhA4jAkwQBEEQBKHDiAATBEEQBEHoMCLABEEQBEEQOowIMEEQBEEQhA4jAkwQBEEQBKHDiAATBEEQBEHoMCLABEEQBEEQOsz/DwRvoXQk6oj6AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "index = 33\n", - "plot_prob_forecasts(tss[index], forecasts[index])" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "a1f978b1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "index = 33\n", - "plot_prob_forecasts(tss[index], forecasts[index])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ddce0d39", - "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 + "nbformat": 4, + "nbformat_minor": 5 }