From f6e7d77fe427782a76ec4a0263c24f4f0750c8fd Mon Sep 17 00:00:00 2001 From: Kashif Rasul Date: Mon, 28 Nov 2022 19:51:58 +0100 Subject: [PATCH] initial torchscale models --- requirements.txt | 2 + torchscale/__init__.py | 10 + torchscale/estimator.py | 295 +++++++++++ torchscale/lightning_module.py | 81 +++ torchscale/module.py | 623 ++++++++++++++++++++++ torchscale/torchscale-electricity.ipynb | 668 ++++++++++++++++++++++++ 6 files changed, 1679 insertions(+) create mode 100644 torchscale/__init__.py create mode 100644 torchscale/estimator.py create mode 100644 torchscale/lightning_module.py create mode 100644 torchscale/module.py create mode 100644 torchscale/torchscale-electricity.ipynb diff --git a/requirements.txt b/requirements.txt index d995cfa..2abba8b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -11,3 +11,5 @@ einops opt_einsum pykeops scipy +apex +torchscale diff --git a/torchscale/__init__.py b/torchscale/__init__.py new file mode 100644 index 0000000..eadd0f0 --- /dev/null +++ b/torchscale/__init__.py @@ -0,0 +1,10 @@ +# + +from .estimator import TorchscaleEstimator +from .lightning_module import TorchscaleightningModule +from .module import TorchscaleModel + +__all__ = [ + "TorchscaleModel", + "TorchscaleightningModule", + "TorchscaleEstimator", +] diff --git a/torchscale/estimator.py b/torchscale/estimator.py new file mode 100644 index 0000000..1d5157f --- /dev/null +++ b/torchscale/estimator.py @@ -0,0 +1,295 @@ +# + +from typing import Any, Dict, Iterable, List, Optional + +import torch +from torch.utils.data import DataLoader + +import numpy as np + +from gluonts.core.component import validated +from gluonts.dataset.common import Dataset +from gluonts.dataset.field_names import FieldName +from gluonts.itertools import Cyclic, IterableSlice, PseudoShuffled +from gluonts.time_feature import TimeFeature, time_features_from_frequency_str +from gluonts.torch.model.estimator import PyTorchLightningEstimator +from gluonts.torch.model.predictor import PyTorchPredictor +from gluonts.torch.distributions import DistributionOutput, StudentTOutput +from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood +from gluonts.torch.util import IterableDataset +from gluonts.transform import ( + AddAgeFeature, + AddObservedValuesIndicator, + AddTimeFeatures, + AsNumpyArray, + Chain, + ExpectedNumInstanceSampler, + InstanceSplitter, + RemoveFields, + SelectFields, + SetField, + TestSplitSampler, + Transformation, + ValidationSplitSampler, + VstackFeatures, +) +from torchscale.architecture.config import EncoderDecoderConfig + +from lightning_module import TorchscaleLightningModule +from module import TorchscaleModel + +# + +PREDICTION_INPUT_NAMES = [ + "feat_static_cat", + "feat_static_real", + "past_time_feat", + "past_target", + "past_observed_values", + "future_time_feat", +] + +TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [ + "future_target", + "future_observed_values", +] + + +class TorchscaleEstimator(PyTorchLightningEstimator): + @validated() + def __init__( + self, + freq: str, + prediction_length: int, + # Torchscale arguments + enc_dec_config: EncoderDecoderConfig, + input_size: int = 1, + context_length: Optional[int] = None, + num_feat_dynamic_real: int = 0, + num_feat_static_cat: int = 0, + num_feat_static_real: int = 0, + cardinality: Optional[List[int]] = None, + embedding_dimension: Optional[List[int]] = None, + distr_output: DistributionOutput = StudentTOutput(), + loss: DistributionLoss = NegativeLogLikelihood(), + scaling: bool = True, + lags_seq: Optional[List[int]] = None, + time_features: Optional[List[TimeFeature]] = None, + num_parallel_samples: int = 100, + batch_size: int = 32, + num_batches_per_epoch: int = 50, + trainer_kwargs: Optional[Dict[str, Any]] = dict(), + ) -> None: + trainer_kwargs = { + "max_epochs": 100, + **trainer_kwargs, + } + super().__init__(trainer_kwargs=trainer_kwargs) + + self.freq = freq + self.context_length = ( + context_length if context_length is not None else prediction_length + ) + self.prediction_length = prediction_length + self.distr_output = distr_output + self.loss = loss + + self.enc_dec_config = enc_dec_config + + self.input_size = input_size + self.num_feat_dynamic_real = num_feat_dynamic_real + self.num_feat_static_cat = num_feat_static_cat + self.num_feat_static_real = num_feat_static_real + self.cardinality = ( + cardinality if cardinality and num_feat_static_cat > 0 else [1] + ) + self.embedding_dimension = embedding_dimension + self.scaling = scaling + self.lags_seq = lags_seq + self.time_features = ( + time_features + if time_features is not None + else time_features_from_frequency_str(self.freq) + ) + + self.num_parallel_samples = num_parallel_samples + self.batch_size = batch_size + self.num_batches_per_epoch = num_batches_per_epoch + + self.train_sampler = 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 = [] + if self.num_feat_static_real == 0: + remove_field_names.append(FieldName.FEAT_STATIC_REAL) + if self.num_feat_dynamic_real == 0: + remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL) + + return Chain( + [RemoveFields(field_names=remove_field_names)] + + ( + [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])] + if not self.num_feat_static_cat > 0 + else [] + ) + + ( + [SetField(output_field=FieldName.FEAT_STATIC_REAL, value=[0.0])] + if not self.num_feat_static_real > 0 + else [] + ) + + [ + AsNumpyArray( + field=FieldName.FEAT_STATIC_CAT, + expected_ndim=1, + dtype=np.long, + ), + AsNumpyArray( + field=FieldName.FEAT_STATIC_REAL, + expected_ndim=1, + ), + AsNumpyArray( + field=FieldName.TARGET, + # in the following line, we add 1 for the time dimension + expected_ndim=1 + len(self.distr_output.event_shape), + ), + AddObservedValuesIndicator( + target_field=FieldName.TARGET, + output_field=FieldName.OBSERVED_VALUES, + ), + AddTimeFeatures( + start_field=FieldName.START, + target_field=FieldName.TARGET, + output_field=FieldName.FEAT_TIME, + time_features=self.time_features, + pred_length=self.prediction_length, + ), + AddAgeFeature( + target_field=FieldName.TARGET, + output_field=FieldName.FEAT_AGE, + pred_length=self.prediction_length, + log_scale=True, + ), + VstackFeatures( + output_field=FieldName.FEAT_TIME, + input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE] + + ( + [FieldName.FEAT_DYNAMIC_REAL] + if self.num_feat_dynamic_real > 0 + else [] + ), + ), + ] + ) + + def _create_instance_splitter(self, module: TorchscaleLightningModule, mode: str): + assert mode in ["training", "validation", "test"] + + instance_sampler = { + "training": self.train_sampler, + "validation": self.validation_sampler, + "test": TestSplitSampler(), + }[mode] + + return InstanceSplitter( + target_field=FieldName.TARGET, + is_pad_field=FieldName.IS_PAD, + start_field=FieldName.START, + forecast_start_field=FieldName.FORECAST_START, + instance_sampler=instance_sampler, + past_length=module.model._past_length, + future_length=self.prediction_length, + time_series_fields=[ + FieldName.FEAT_TIME, + FieldName.OBSERVED_VALUES, + ], + dummy_value=self.distr_output.value_in_support, + ) + + def create_training_data_loader( + self, + data: Dataset, + module: TorchscaleLightningModule, + shuffle_buffer_length: Optional[int] = None, + **kwargs, + ) -> Iterable: + transformation = self._create_instance_splitter( + module, "training" + ) + SelectFields(TRAINING_INPUT_NAMES) + + training_instances = transformation.apply( + Cyclic(data) + if shuffle_buffer_length is None + else PseudoShuffled( + Cyclic(data), shuffle_buffer_length=shuffle_buffer_length + ) + ) + + return IterableSlice( + iter( + DataLoader( + IterableDataset(training_instances), + batch_size=self.batch_size, + **kwargs, + ) + ), + self.num_batches_per_epoch, + ) + + def create_validation_data_loader( + self, + data: Dataset, + module: TorchscaleLightningModule, + **kwargs, + ) -> Iterable: + transformation = self._create_instance_splitter( + module, "validation" + ) + SelectFields(TRAINING_INPUT_NAMES) + + validation_instances = transformation.apply(data) + + return DataLoader( + IterableDataset(validation_instances), + batch_size=self.batch_size, + **kwargs, + ) + + def create_predictor( + self, + transformation: Transformation, + module: TorchscaleLightningModule, + ) -> PyTorchPredictor: + prediction_splitter = self._create_instance_splitter(module, "test") + + return PyTorchPredictor( + input_transform=transformation + prediction_splitter, + input_names=PREDICTION_INPUT_NAMES, + prediction_net=module.model, + batch_size=self.batch_size, + prediction_length=self.prediction_length, + device=torch.device("cuda" if torch.cuda.is_available() else "cpu"), + ) + + def create_lightning_module(self) -> TorchscaleLightningModule: + model = TorchscaleModel( + freq=self.freq, + context_length=self.context_length, + prediction_length=self.prediction_length, + num_feat_dynamic_real=1 + + self.num_feat_dynamic_real + + len(self.time_features), + num_feat_static_real=max(1, self.num_feat_static_real), + num_feat_static_cat=max(1, self.num_feat_static_cat), + cardinality=self.cardinality, + embedding_dimension=self.embedding_dimension, + # torchscale configs + enc_dec_config=self.enc_dec_config, + # univariate input + input_size=self.input_size, + distr_output=self.distr_output, + lags_seq=self.lags_seq, + scaling=self.scaling, + num_parallel_samples=self.num_parallel_samples, + ) + + return TorchscaleLightningModule(model=model, loss=self.loss) diff --git a/torchscale/lightning_module.py b/torchscale/lightning_module.py new file mode 100644 index 0000000..5917fde --- /dev/null +++ b/torchscale/lightning_module.py @@ -0,0 +1,81 @@ +import pytorch_lightning as pl +import torch + +from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood +from gluonts.torch.util import weighted_average + +from module import TorchscaleModel + + +class TorchscaleLightningModule(pl.LightningModule): + def __init__( + self, + model: TorchscaleModel, + loss: DistributionLoss = NegativeLogLikelihood(), + lr: float = 5e-3, + weight_decay: float = 1e-6, + ) -> None: + super().__init__() + self.save_hyperparameters() + self.model = model + self.loss = loss + self.lr = lr + self.weight_decay = weight_decay + + def training_step(self, batch, batch_idx: int): + """Execute training step""" + train_loss = self(batch) + self.log( + "train_loss", + train_loss, + on_epoch=True, + on_step=False, + prog_bar=True, + ) + return train_loss + + def validation_step(self, batch, batch_idx: int): + """Execute validation step""" + with torch.no_grad(): + val_loss = self(batch) + self.log("val_loss", val_loss, on_epoch=True, on_step=False, prog_bar=True) + return val_loss + + def configure_optimizers(self): + """Returns the optimizer to use""" + return torch.optim.Adam( + self.model.parameters(), + lr=self.lr, + weight_decay=self.weight_decay, + ) + + def forward(self, batch): + feat_static_cat = batch["feat_static_cat"] + feat_static_real = batch["feat_static_real"] + past_time_feat = batch["past_time_feat"] + past_target = batch["past_target"] + future_time_feat = batch["future_time_feat"] + future_target = batch["future_target"] + past_observed_values = batch["past_observed_values"] + future_observed_values = batch["future_observed_values"] + + transformer_inputs, scale, _ = self.model.create_network_inputs( + feat_static_cat, + feat_static_real, + past_time_feat, + past_target, + past_observed_values, + future_time_feat, + future_target, + ) + params = self.model.output_params(transformer_inputs) + distr = self.model.output_distribution(params, scale) + + loss_values = self.loss(distr, future_target) + + if len(self.model.target_shape) == 0: + loss_weights = future_observed_values + else: + loss_weights, _ = future_observed_values.min(dim=-1, keepdim=False) + + return weighted_average(loss_values, weights=loss_weights) diff --git a/torchscale/module.py b/torchscale/module.py new file mode 100644 index 0000000..8699826 --- /dev/null +++ b/torchscale/module.py @@ -0,0 +1,623 @@ +from typing import List, Optional, Dict, Any +import math + +import torch +import torch.nn as nn +from gluonts.core.component import validated +from gluonts.time_feature import get_lags_for_frequency +from gluonts.torch.distributions import DistributionOutput, StudentTOutput +from gluonts.torch.modules.feature import FeatureEmbedder +from gluonts.torch.modules.scaler import MeanScaler, NOPScaler + +from apex.normalization import FusedLayerNorm as LayerNorm + +from torchscale.architecture.config import EncoderDecoderConfig +from torchscale.component.relative_position_bias import RelativePositionBias +from torchscale.architecture.encoder import EncoderLayer +from torchscale.architecture.decoder import DecoderLayer +from torchscale.component.multiway_network import MultiwayWrapper +from torchscale.architecture.utils import init_bert_params + + +class Encoder(nn.Module): + def __init__(self, args, is_moe_layer=False, is_encoder_decoder=True): + super().__init__() + + self.dropout_module = torch.nn.Dropout(args.dropout, inplace=True) + + embed_dim = args.encoder_embed_dim + + self.layers = nn.ModuleList([]) + moe_freq = args.moe_freq + for i in range(args.encoder_layers): + is_moe_layer = moe_freq != 0 and (i + 1) % moe_freq == 0 + self.layers.append( + self.build_encoder_layer( + args, + depth=i, + is_moe_layer=is_moe_layer, + is_encoder_decoder=is_encoder_decoder, + ) + ) + self.num_layers = len(self.layers) + + if args.encoder_normalize_before: + self.layer_norm = MultiwayWrapper(args, LayerNorm(embed_dim)) + else: + self.layer_norm = None + + if args.rel_pos_buckets > 0 and args.max_rel_pos > 0: + self.relative_position = RelativePositionBias( + num_buckets=args.rel_pos_buckets, + max_distance=args.max_rel_pos, + n_heads=args.encoder_attention_heads, + ) + else: + self.relative_position = None + + if args.bert_init: + self.apply(init_bert_params) + + if args.deepnorm: + if is_encoder_decoder: + init_scale = ( + math.pow( + math.pow(args.encoder_layers, 4) * args.decoder_layers, 0.0625 + ) + / 1.15 + ) + else: + init_scale = math.pow(8.0 * args.encoder_layers, 0.25) + for name, p in self.named_parameters(): + if ( + "fc1" in name + or "fc2" in name + or "out_proj" in name + or "v_proj" in name + ): + p.data.div_(init_scale) + + if args.subln: + if is_encoder_decoder: + init_scale = math.sqrt( + math.log(3 * args.decoder_layers) + * math.log(2 * args.encoder_layers) + / 3 + ) + else: + init_scale = math.sqrt(math.log(args.encoder_layers * 2)) + for name, p in self.named_parameters(): + if ( + "fc1" in name + or "fc2" in name + or "out_proj" in name + or "v_proj" in name + ): + p.data.mul_(init_scale) + + def build_encoder_layer( + self, args, depth, is_moe_layer=False, is_encoder_decoder=False + ): + layer = EncoderLayer( + args, + depth, + is_moe_layer=is_moe_layer, + is_encoder_decoder=is_encoder_decoder, + ) + return layer + + def forward(self, enc_input, encoder_padding_mask=None): + x = enc_input.transpose(0, 1) # (B, T, C) -> (T, B, C) + + rel_pos_bias = None + if self.relative_position is not None: + rel_pos_bias = self.relative_position( + batch_size=x.size(1), qlen=x.size(0), klen=x.size(0) + ) + + for layer in self.layers: + x, _ = layer( + x, encoder_padding_mask=encoder_padding_mask, rel_pos=rel_pos_bias + ) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + return x # (T, B, C) + + +class Decoder(nn.Module): + def __init__(self, args, is_encoder_decoder=True): + super().__init__() + + embed_dim = args.decoder_embed_dim + + self.dropout_module = torch.nn.Dropout(args.dropout, inplace=True) + + if args.layernorm_embedding: + self.layernorm_embedding = LayerNorm(embed_dim) + else: + self.layernorm_embedding = None + + self.layers = nn.ModuleList([]) + + moe_freq = args.moe_freq + for i in range(args.decoder_layers): + is_moe_layer = moe_freq != 0 and (i + 1) % moe_freq == 0 + self.layers.append( + self.build_decoder_layer( + args, + depth=i, + is_moe_layer=is_moe_layer, + is_encoder_decoder=is_encoder_decoder, + ) + ) + + self.num_layers = len(self.layers) + + if args.decoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + self.self_attn_relative_position = None + self.cross_attn_relative_position = None + + if args.rel_pos_buckets > 0 and args.max_rel_pos > 0: + self.self_attn_relative_position = RelativePositionBias( + num_buckets=args.rel_pos_buckets, + max_distance=args.max_rel_pos, + n_heads=args.decoder_attention_heads, + ) + if is_encoder_decoder: + self.cross_attn_relative_position = RelativePositionBias( + num_buckets=args.rel_pos_buckets, + max_distance=args.max_rel_pos, + n_heads=args.decoder_attention_heads, + ) + + if args.bert_init: + self.apply(init_bert_params) + + if args.deepnorm: + if is_encoder_decoder: + init_scale = math.pow(12.0 * args.decoder_layers, 0.25) + else: + init_scale = math.pow(8.0 * args.decoder_layers, 0.25) + for name, p in self.named_parameters(): + if ( + "fc1" in name + or "fc2" in name + or "out_proj" in name + or "v_proj" in name + ): + p.data.div_(init_scale) + + if args.subln: + if is_encoder_decoder: + init_scale = math.sqrt(math.log(args.decoder_layers * 3)) + else: + init_scale = math.sqrt(math.log(args.decoder_layers * 2)) + for name, p in self.named_parameters(): + if "encoder_attn" in name: + continue + if ( + "fc1" in name + or "fc2" in name + or "out_proj" in name + or "v_proj" in name + ): + p.data.mul_(init_scale) + + def build_decoder_layer( + self, args, depth, is_moe_layer=False, is_encoder_decoder=False + ): + layer = DecoderLayer( + args, + depth, + is_moe_layer=is_moe_layer, + is_encoder_decoder=is_encoder_decoder, + ) + + return layer + + def forward(self, dec_input, encoder_out, incremental_state=None): + x = dec_input.transpose(0, 1) # (B, T, C) -> (T, B, C) + + # relative position + self_attn_rel_pos_bias = None + slen = dec_input.size(1) + if self.self_attn_relative_position is not None: + self_attn_rel_pos_bias = self.self_attn_relative_position( + batch_size=x.size(1), qlen=slen, klen=slen + ) + if incremental_state is not None: + self_attn_rel_pos_bias = self_attn_rel_pos_bias[:, -1:, :] + cross_attn_rel_pos_bias = None + if self.cross_attn_relative_position is not None: + cross_attn_rel_pos_bias = self.cross_attn_relative_position( + batch_size=x.size(1), + qlen=slen, + klen=encoder_out["encoder_out"].size(0), + ) + if incremental_state is not None: + cross_attn_rel_pos_bias = cross_attn_rel_pos_bias[:, -1:, :] + + # decoder layers + for idx, layer in enumerate(self.layers): + if incremental_state is None: + self_attn_mask = torch.triu( + torch.zeros([x.size(0), x.size(0)]) + .float() + .fill_(float("-inf")) + .type_as(x), + 1, + ) + else: + self_attn_mask = None + if idx not in incremental_state: + incremental_state[idx] = {} + + x, _, _, _ = layer( + x, + encoder_out, + None, + incremental_state[idx] if incremental_state is not None else None, + self_attn_mask=self_attn_mask, + self_attn_padding_mask=None, + self_attn_rel_pos=self_attn_rel_pos_bias, + cross_attn_rel_pos=cross_attn_rel_pos_bias, + ) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + return x.transpose(0, 1) + + +class TorchscaleModel(nn.Module): + @validated() + def __init__( + self, + freq: str, + context_length: int, + prediction_length: int, + num_feat_dynamic_real: int, + num_feat_static_real: int, + num_feat_static_cat: int, + cardinality: List[int], + # torchscale config + enc_dec_config: EncoderDecoderConfig, + input_size: int = 1, + embedding_dimension: Optional[List[int]] = None, + distr_output: DistributionOutput = StudentTOutput(), + lags_seq: Optional[List[int]] = None, + scaling: bool = True, + num_parallel_samples: int = 1, + ) -> None: + super().__init__() + + self.input_size = input_size + + self.target_shape = distr_output.event_shape + self.num_feat_dynamic_real = num_feat_dynamic_real + self.num_feat_static_cat = num_feat_static_cat + self.num_feat_static_real = num_feat_static_real + self.embedding_dimension = ( + embedding_dimension + if embedding_dimension is not None or cardinality is None + else [min(50, (cat + 1) // 2) for cat in cardinality] + ) + self.lags_seq = lags_seq or get_lags_for_frequency(freq_str=freq) + self.num_parallel_samples = num_parallel_samples + self.history_length = context_length + max(self.lags_seq) + self.embedder = FeatureEmbedder( + cardinalities=cardinality, + embedding_dims=self.embedding_dimension, + ) + if scaling: + self.scaler = MeanScaler(dim=1, keepdim=True) + else: + self.scaler = NOPScaler(dim=1, keepdim=True) + + # total feature size + d_model = self.input_size * len(self.lags_seq) + self._number_of_features + + self.context_length = context_length + self.prediction_length = prediction_length + self.distr_output = distr_output + self.param_proj = distr_output.get_args_proj(d_model) + + enc_dec_config.encoder_embed_dim = d_model + enc_dec_config.decoder_embed_dim = d_model + + self.encoder = Encoder(enc_dec_config) + self.decoder = Decoder(enc_dec_config) + + # attention_args["dropout"] = dropout + # attention_args["causal"] = False + # attention_args["seq_len"] = self.context_length + # attention_args["num_rules"] = nhead + # attention_args["attention_query_mask"] = torch.rand((context_length, 1)) < 0.5 + + # xformer_config = [ + # # A list of the encoder blocks which constitute the Transformer. + # # Note that a sequence of different encoder blocks can be used + # { + # "reversible": reversible, # Optionally make these layers reversible, to save memory + # "block_type": "encoder", + # "num_layers": num_encoder_layers, # Optional, this means that this config will repeat N times + # "dim_model": d_model, + # "residual_norm_style": residual_norm_style, # Optional, pre/post + # "position_encoding_config": { + # "name": "sine", + # "dim_model": d_model, + # }, + # "multi_head_config": { + # "use_rotary_embeddings": use_rotary_embeddings, + # "num_heads": nhead, + # "residual_dropout": dropout, + # "attention": attention_args, + # }, + # "feedforward_config": { + # "name": "MLP", + # "dropout": dropout, + # "activation": activation, + # "hidden_layer_multiplier": hidden_layer_multiplier, + # "dim_model": d_model, + # }, + # }, + # ] + # config = xFormerConfig(xformer_config) + # # xformer encoder + # self.encoder = xFormer.from_config(config) + + # # causal vanilla transformer decoder + # decoder_layer = nn.TransformerDecoderLayer( + # d_model, + # nhead, + # dim_feedforward=d_model * hidden_layer_multiplier, + # dropout=dropout, + # activation=activation, + # layer_norm_eps=1e-5, + # batch_first=True, + # norm_first=False, + # ) + # decoder_norm = nn.LayerNorm(d_model, eps=1e-5) + # self.decoder = nn.TransformerDecoder( + # decoder_layer, num_decoder_layers, decoder_norm + # ) + + # causal decoder tgt mask for training + self.register_buffer( + "tgt_mask", + nn.Transformer.generate_square_subsequent_mask(prediction_length), + ) + + @property + def _number_of_features(self) -> int: + return ( + sum(self.embedding_dimension) + + self.num_feat_dynamic_real + + self.num_feat_static_real + + self.input_size # the log(scale) + ) + + @property + def _past_length(self) -> int: + return self.context_length + max(self.lags_seq) + + def get_lagged_subsequences( + self, sequence: torch.Tensor, subsequences_length: int, shift: int = 0 + ) -> torch.Tensor: + """ + Returns lagged subsequences of a given sequence. + Parameters + ---------- + sequence : Tensor + the sequence from which lagged subsequences should be extracted. + Shape: (N, T, C). + subsequences_length : int + length of the subsequences to be extracted. + shift: int + shift the lags by this amount back. + Returns + -------- + lagged : Tensor + a tensor of shape (N, S, C, I), where S = subsequences_length and + I = len(indices), containing lagged subsequences. Specifically, + lagged[i, j, :, k] = sequence[i, -indices[k]-S+j, :]. + """ + sequence_length = sequence.shape[1] + indices = [l - shift for l in self.lags_seq] + + assert max(indices) + subsequences_length <= sequence_length, ( + f"lags cannot go further than history length, found lag {max(indices)} " + f"while history length is only {sequence_length}" + ) + + lagged_values = [] + for lag_index in indices: + begin_index = -lag_index - subsequences_length + end_index = -lag_index if lag_index > 0 else None + lagged_values.append(sequence[:, begin_index:end_index, ...]) + return torch.stack(lagged_values, dim=-1) + + def create_network_inputs( + self, + feat_static_cat: torch.Tensor, + feat_static_real: torch.Tensor, + past_time_feat: torch.Tensor, + past_target: torch.Tensor, + past_observed_values: torch.Tensor, + future_time_feat: Optional[torch.Tensor] = None, + future_target: Optional[torch.Tensor] = None, + ): + # time feature + time_feat = ( + past_time_feat[:, self._past_length - self.context_length :, ...] + if future_time_feat is None or future_target is None + else torch.cat( + ( + past_time_feat[:, self._past_length - self.context_length :, ...], + future_time_feat, + ), + dim=1, + ) + ) + + # target + context = past_target[:, -self.context_length :] + observed_context = past_observed_values[:, -self.context_length :] + # weights = torch.linspace(0.0001, 1, steps=observed_context.size(-1), device=observed_context.device) + _, scale = self.scaler(context, observed_context) + + inputs = ( + torch.cat((past_target, future_target), dim=1) / scale + if future_target is not None + else past_target / scale + ) + + inputs_length = ( + self._past_length + self.prediction_length + if future_target is not None + else self._past_length + ) + assert inputs.shape[1] == inputs_length + + subsequences_length = ( + self.context_length + if future_time_feat is None or future_target is None + else self.context_length + self.prediction_length + ) + + # embeddings + embedded_cat = self.embedder(feat_static_cat) + log_scale = scale.log() if self.input_size == 1 else scale.squeeze(1).log() + static_feat = torch.cat( + (embedded_cat, feat_static_real, log_scale), + dim=1, + ) + expanded_static_feat = static_feat.unsqueeze(1).expand( + -1, time_feat.shape[1], -1 + ) + + features = torch.cat((expanded_static_feat, time_feat), dim=-1) + + # self._check_shapes(prior_input, inputs, features) + # sequence = torch.cat((prior_input, inputs), dim=1) + + lagged_sequence = self.get_lagged_subsequences( + sequence=inputs, + subsequences_length=subsequences_length, + ) + + lags_shape = lagged_sequence.shape + reshaped_lagged_sequence = lagged_sequence.reshape( + lags_shape[0], lags_shape[1], -1 + ) + + if features is None: + transformer_inputs = reshaped_lagged_sequence + else: + transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1) + + return transformer_inputs, scale, static_feat + + def output_params(self, transformer_inputs): + enc_input = transformer_inputs[:, : self.context_length, ...] + dec_input = transformer_inputs[:, self.context_length :, ...] + + enc_out = self.encoder(enc_input) + dec_output = self.decoder(dec_input, enc_out) + + return self.param_proj(dec_output) + + @torch.jit.ignore + def output_distribution( + self, params, scale=None, trailing_n=None + ) -> torch.distributions.Distribution: + sliced_params = params + if trailing_n is not None: + sliced_params = [p[:, -trailing_n:] for p in params] + return self.distr_output.distribution(sliced_params, scale=scale) + + # for prediction + def forward( + self, + feat_static_cat: torch.Tensor, + feat_static_real: torch.Tensor, + past_time_feat: torch.Tensor, + past_target: torch.Tensor, + past_observed_values: torch.Tensor, + future_time_feat: torch.Tensor, + num_parallel_samples: Optional[int] = None, + ) -> torch.Tensor: + if num_parallel_samples is None: + num_parallel_samples = self.num_parallel_samples + + encoder_inputs, scale, static_feat = self.create_network_inputs( + feat_static_cat, + feat_static_real, + past_time_feat, + past_target, + past_observed_values, + future_time_feat, + ) + + enc_out = self.encoder(src=encoder_inputs) + + params = self.param_proj(enc_out.transpose(0, 1)) # (B, T, D) + distr = self.output_distribution(params, trailing_n=1) + + repeated_scale = scale.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + repeated_static_feat = static_feat.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ).unsqueeze(dim=1) + repeated_past_target = ( + past_target.repeat_interleave(repeats=self.num_parallel_samples, dim=0) + / repeated_scale + ) + repeated_time_feat = future_time_feat.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + repeated_enc_out = enc_out.repeat_interleave( + repeats=self.num_parallel_samples, dim=0 + ) + + future_samples = [] + + for k in range(self.prediction_length): + next_features = torch.cat( + (repeated_static_feat, repeated_time_feat[:, k : k + 1]), + dim=-1, + ) + + lagged_sequence = self.get_lagged_subsequences( + sequence=repeated_past_target, + subsequences_length=1, + shift=1, + ) + + lags_shape = lagged_sequence.shape + reshaped_lagged_sequence = lagged_sequence.reshape( + lags_shape[0], lags_shape[1], -1 + ) + + decoder_input = torch.cat((reshaped_lagged_sequence, next_features), dim=-1) + + output = self.decoder(decoder_input, repeated_enc_out) + + params = self.param_proj(output) + distr = self.output_distribution(params) + next_sample = distr.sample() + + repeated_past_target = torch.cat((repeated_past_target, next_sample), dim=1) + future_samples.append(next_sample) + + unscaled_future_samples = torch.cat(future_samples, dim=1) * repeated_scale + return unscaled_future_samples.reshape( + (-1, self.num_parallel_samples, self.prediction_length) + self.target_shape, + ) diff --git a/torchscale/torchscale-electricity.ipynb b/torchscale/torchscale-electricity.ipynb new file mode 100644 index 0000000..1e37d18 --- /dev/null +++ b/torchscale/torchscale-electricity.ipynb @@ -0,0 +1,668 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7c64affd", + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import islice" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8aa55868", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "import pandas as pd\n", + "from sklearn.manifold import TSNE" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6a730716", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-11-28 19:48:37.174077: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: SSE3 SSE4.1 SSE4.2 AVX AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "from gluonts.dataset.repository.datasets import get_dataset\n", + "from gluonts.dataset.common import ListDataset\n", + "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", + "from pytorch_lightning.loggers import CSVLogger\n", + "from datasets import load_dataset\n", + "from torchscale.architecture.config import EncoderDecoderConfig\n", + "\n", + "from estimator import TorchscaleEstimator" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fc889c9f", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = get_dataset(\"electricity\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "666105d9", + "metadata": {}, + "outputs": [], + "source": [ + "enc_dec_config = EncoderDecoderConfig(\n", + " encoder_attention_heads=2,\n", + " decoder_attention_heads=2,\n", + " encoder_layers=4,\n", + " decoder_layers=4,\n", + " encoder_ffn_embed_dim=32,\n", + " decoder_ffn_embed_dim=32,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1717d0d2", + "metadata": {}, + "outputs": [], + "source": [ + "estimator = TorchscaleEstimator(\n", + " freq=dataset.metadata.freq,\n", + " prediction_length=dataset.metadata.prediction_length,\n", + " context_length=dataset.metadata.prediction_length*6,\n", + " \n", + " scaling=True,\n", + " num_feat_static_cat=len(dataset.metadata.feat_static_cat),\n", + " cardinality=[int(cat_feat_info.cardinality) for cat_feat_info in dataset.metadata.feat_static_cat],\n", + " embedding_dimension=[5],\n", + " \n", + " enc_dec_config=enc_dec_config,\n", + " \n", + " batch_size=256,\n", + " num_batches_per_epoch=100,\n", + " trainer_kwargs=dict(gpus=\"1\", max_epochs=50, logger=CSVLogger(\".\", \"lightning_logs/\")),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c77b420c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/utilities/parsing.py:262: UserWarning: Attribute 'model' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['model'])`.\n", + " rank_zero_warn(\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/accelerator_connector.py:446: LightningDeprecationWarning: Setting `Trainer(gpus='1')` is deprecated in v1.7 and will be removed in v2.0. Please use `Trainer(accelerator='gpu', devices='1')` instead.\n", + " rank_zero_deprecation(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/utilities/parsing.py:101: UserWarning: attribute 'model' removed from hparams because it cannot be pickled\n", + " rank_zero_warn(f\"attribute '{k}' removed from hparams because it cannot be pickled\")\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/configuration_validator.py:108: PossibleUserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------\n", + "0 | model | TorchscaleModel | 165 K \n", + "------------------------------------------\n", + "165 K Trainable params\n", + "0 Non-trainable params\n", + "165 K Total params\n", + "0.661 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "093dab1c2d694f2b879622f8a21f139e", + "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.82088 (best 6.82088), saving model to './lightning_logs/version_10/checkpoints/epoch=0-step=100.ckpt' as top 1\n", + "Epoch 1, global step 200: 'train_loss' reached 5.84754 (best 5.84754), saving model to './lightning_logs/version_10/checkpoints/epoch=1-step=200.ckpt' as top 1\n", + "Epoch 2, global step 300: 'train_loss' reached 5.61930 (best 5.61930), saving model to './lightning_logs/version_10/checkpoints/epoch=2-step=300.ckpt' as top 1\n", + "Epoch 3, global step 400: 'train_loss' reached 5.47171 (best 5.47171), saving model to './lightning_logs/version_10/checkpoints/epoch=3-step=400.ckpt' as top 1\n", + "Epoch 4, global step 500: 'train_loss' reached 5.35223 (best 5.35223), saving model to './lightning_logs/version_10/checkpoints/epoch=4-step=500.ckpt' as top 1\n", + "Epoch 5, global step 600: 'train_loss' reached 5.30912 (best 5.30912), saving model to './lightning_logs/version_10/checkpoints/epoch=5-step=600.ckpt' as top 1\n", + "Epoch 6, global step 700: 'train_loss' reached 5.25711 (best 5.25711), saving model to './lightning_logs/version_10/checkpoints/epoch=6-step=700.ckpt' as top 1\n", + "Epoch 7, global step 800: 'train_loss' was not in top 1\n", + "Epoch 8, global step 900: 'train_loss' reached 5.22801 (best 5.22801), saving model to './lightning_logs/version_10/checkpoints/epoch=8-step=900.ckpt' as top 1\n", + "Epoch 9, global step 1000: 'train_loss' reached 5.16079 (best 5.16079), saving model to './lightning_logs/version_10/checkpoints/epoch=9-step=1000.ckpt' as top 1\n", + "Epoch 10, global step 1100: 'train_loss' was not in top 1\n" + ] + } + ], + "source": [ + "predictor = estimator.train(\n", + " training_data=dataset.train,\n", + " shuffle_buffer_length=1024,\n", + " num_workers=8,\n", + " cache_data=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f8a362b6", + "metadata": {}, + "outputs": [], + "source": [ + "forecast_it, ts_it = make_evaluation_predictions(\n", + " dataset=dataset.test,\n", + " predictor=predictor,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5fdc12da", + "metadata": {}, + "outputs": [], + "source": [ + "forecasts = list(forecast_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4b7d3409", + "metadata": {}, + "outputs": [], + "source": [ + "tss = list(ts_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9b154bde", + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = Evaluator()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0fdec8a7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Running evaluation: 2247it [00:00, 3399.98it/s]\n", + "/home/kashif/.env/pytorch/lib/python3.10/site-packages/pandas/core/dtypes/astype.py:170: UserWarning: Warning: converting a masked element to nan.\n", + " return arr.astype(dtype, copy=True)\n" + ] + } + ], + "source": [ + "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7f28f4d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 10018107.873432416,\n", + " 'abs_error': 26035099.499095917,\n", + " 'abs_target_sum': 128632956.0,\n", + " 'abs_target_mean': 2385.272140631954,\n", + " 'seasonal_error': 189.49338196116761,\n", + " 'MASE': 2.4701614804361784,\n", + " 'MAPE': 0.25477670689181103,\n", + " 'sMAPE': 0.24819572961811426,\n", + " 'MSIS': 20.209983280943216,\n", + " 'QuantileLoss[0.1]': 11107718.37581723,\n", + " 'Coverage[0.1]': 0.1886774959204866,\n", + " 'QuantileLoss[0.2]': 17534385.729109436,\n", + " 'Coverage[0.2]': 0.2506860999851654,\n", + " 'QuantileLoss[0.3]': 21799774.12036043,\n", + " 'Coverage[0.3]': 0.29637665034861294,\n", + " 'QuantileLoss[0.4]': 24542475.651297044,\n", + " 'Coverage[0.4]': 0.3366525738021065,\n", + " 'QuantileLoss[0.5]': 26035099.4930306,\n", + " 'Coverage[0.5]': 0.37475893784305,\n", + " 'QuantileLoss[0.6]': 26299950.11746931,\n", + " 'Coverage[0.6]': 0.4088785046728972,\n", + " 'QuantileLoss[0.7]': 24979193.32426689,\n", + " 'Coverage[0.7]': 0.4523809523809524,\n", + " 'QuantileLoss[0.8]': 21707479.345738567,\n", + " 'Coverage[0.8]': 0.5081590268506158,\n", + " 'QuantileLoss[0.9]': 15351255.969729993,\n", + " 'Coverage[0.9]': 0.6027110221035455,\n", + " 'RMSE': 3165.1394714028665,\n", + " 'NRMSE': 1.3269510918633773,\n", + " 'ND': 0.20239836126517932,\n", + " 'wQuantileLoss[0.1]': 0.08635204166354717,\n", + " 'wQuantileLoss[0.2]': 0.13631332338432334,\n", + " 'wQuantileLoss[0.3]': 0.16947269811913854,\n", + " 'wQuantileLoss[0.4]': 0.19079461760403799,\n", + " 'wQuantileLoss[0.5]': 0.2023983612180272,\n", + " 'wQuantileLoss[0.6]': 0.2044573252088626,\n", + " 'wQuantileLoss[0.7]': 0.1941896859174012,\n", + " 'wQuantileLoss[0.8]': 0.16875519323165183,\n", + " 'wQuantileLoss[0.9]': 0.11934154704281222,\n", + " 'mean_absolute_QuantileLoss': 21039703.56964661,\n", + " 'mean_wQuantileLoss': 0.1635638659322002,\n", + " 'MAE_Coverage': 0.15104954754487465,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "cc3f804d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 15))\n", + "date_formater = mdates.DateFormatter('%b, %d')\n", + "plt.rcParams.update({'font.size': 15})\n", + "\n", + "for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 9):\n", + " ax = plt.subplot(3, 3, idx+1)\n", + "\n", + " plt.plot(ts[-4 * dataset.metadata.prediction_length:].to_timestamp(), label=\"target\", )\n", + " forecast.plot( color='g')\n", + " plt.xticks(rotation=60)\n", + " ax.xaxis.set_major_formatter(date_formater)\n", + " ax.set_title(forecast.item_id)\n", + "\n", + "plt.gcf().tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6f03bfd2", + "metadata": {}, + "outputs": [], + "source": [ + "metrics = pd.read_csv(\"lightning_logs/version_86/metrics.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "8e76b769", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
train_perplexityepochstepval_losstrain_loss
02.042362049NaNNaN
12.050069099NaNNaN
22.7432270149NaNNaN
32.4409840199NaNNaN
4NaN01994.355846NaN
..................
29580.659866499899NaNNaN
29682.568138499949NaNNaN
29781.211136499999NaNNaN
298NaN4999991.084462NaN
299NaN499999NaN1.707654
\n", + "

300 rows × 5 columns

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