pytorch-transformer-ts/perceiverar/perceiverar.ipynb

In [1]:

%matplotlib inline
from matplotlib import pyplot as plt
import matplotlib.dates as mdates

from itertools import islice

In [2]:

from gluonts.evaluation import make_evaluation_predictions, Evaluator
from gluonts.dataset.repository.datasets import get_dataset

from estimator import PerceiverAREstimator

In [3]:

dataset = get_dataset("electricity")

In [4]:

estimator = PerceiverAREstimator(
    depth=2,
    heads=2,
    freq=dataset.metadata.freq,
    prediction_length=dataset.metadata.prediction_length,
    context_length=dataset.metadata.prediction_length*10,
    num_feat_static_cat=1,
    cardinality=[321],
    embedding_dimension=[3],

    batch_size=128,
    num_batches_per_epoch=100,
    trainer_kwargs=dict(max_epochs=50, accelerator='gpu', devices=1,),
)

In [5]:

predictor = estimator.train(
    training_data=dataset.train,
    validation_data=dataset.test,
    num_workers=8,
    shuffle_buffer_length=4000,
)

/home/kashif/.env/pytorch/lib/python3.10/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'])`.
  rank_zero_warn(
Using bfloat16 Automatic Mixed Precision (AMP)
GPU available: True (cuda), used: True
TPU available: False, using: 0 TPU cores
IPU available: False, using: 0 IPUs
HPU available: False, using: 0 HPUs
LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]

  | Name  | Type             | Params
-------------------------------------------
0 | model | PerceiverARModel | 55.3 K
-------------------------------------------
55.3 K    Trainable params
0         Non-trainable params
55.3 K    Total params
0.221     Total estimated model params size (MB)

Sanity Checking: 0it [00:00, ?it/s]

Training: 0it [00:00, ?it/s]

Validation: 0it [00:00, ?it/s]

Epoch 0, global step 100: 'val_loss' reached 5.44867 (best 5.44867), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/perceiverar/lightning_logs/version_32/checkpoints/epoch=0-step=100.ckpt' as top 1

Validation: 0it [00:00, ?it/s]

Epoch 1, global step 200: 'val_loss' reached 5.35806 (best 5.35806), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/perceiverar/lightning_logs/version_32/checkpoints/epoch=1-step=200.ckpt' as top 1

Validation: 0it [00:00, ?it/s]

Epoch 2, global step 300: 'val_loss' was not in top 1

Validation: 0it [00:00, ?it/s]

Epoch 3, global step 400: 'val_loss' was not in top 1

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb Cell 5 in <cell line: 1>()
----> <a href='vscode-notebook-cell://ssh-remote%2Brirs7fpdysrvpdl8.myfritz.net/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb#W4sdnNjb2RlLXJlbW90ZQ%3D%3D?line=0'>1</a> predictor = estimator.train(
      <a href='vscode-notebook-cell://ssh-remote%2Brirs7fpdysrvpdl8.myfritz.net/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb#W4sdnNjb2RlLXJlbW90ZQ%3D%3D?line=1'>2</a>     training_data=dataset.train,
      <a href='vscode-notebook-cell://ssh-remote%2Brirs7fpdysrvpdl8.myfritz.net/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb#W4sdnNjb2RlLXJlbW90ZQ%3D%3D?line=2'>3</a>     validation_data=dataset.test,
      <a href='vscode-notebook-cell://ssh-remote%2Brirs7fpdysrvpdl8.myfritz.net/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb#W4sdnNjb2RlLXJlbW90ZQ%3D%3D?line=3'>4</a>     num_workers=8,
      <a href='vscode-notebook-cell://ssh-remote%2Brirs7fpdysrvpdl8.myfritz.net/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb#W4sdnNjb2RlLXJlbW90ZQ%3D%3D?line=4'>5</a>     shuffle_buffer_length=1024
      <a href='vscode-notebook-cell://ssh-remote%2Brirs7fpdysrvpdl8.myfritz.net/home/kashif/scratch/pytorch-transformer-ts/perceiverar/perceiverar.ipynb#W4sdnNjb2RlLXJlbW90ZQ%3D%3D?line=5'>6</a> )

File ~/gluon-ts-PR/src/gluonts/torch/model/estimator.py:230, in PyTorchLightningEstimator.train(self, training_data, validation_data, num_workers, shuffle_buffer_length, cache_data, ckpt_path, **kwargs)
    220 def train(
    221     self,
    222     training_data: Dataset,
   (...)
    228     **kwargs,
    229 ) -> PyTorchPredictor:
--> 230     return self.train_model(
    231         training_data,
    232         validation_data,
    233         num_workers=num_workers,
    234         shuffle_buffer_length=shuffle_buffer_length,
    235         cache_data=cache_data,
    236         ckpt_path=ckpt_path,
    237         **kwargs,
    238     ).predictor

File ~/gluon-ts-PR/src/gluonts/torch/model/estimator.py:197, in PyTorchLightningEstimator.train_model(self, training_data, validation_data, num_workers, shuffle_buffer_length, cache_data, ckpt_path, **kwargs)
    194 trainer_kwargs = {**self.trainer_kwargs, "callbacks": callbacks}
    195 trainer = pl.Trainer(**trainer_kwargs)
--> 197 trainer.fit(
    198     model=training_network,
    199     train_dataloaders=training_data_loader,
    200     val_dataloaders=validation_data_loader,
    201     ckpt_path=ckpt_path,
    202 )
    204 logger.info(f"Loading best model from {checkpoint.best_model_path}")
    205 best_model = training_network.load_from_checkpoint(
    206     checkpoint.best_model_path
    207 )

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:696, in Trainer.fit(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)
    677 r"""
    678 Runs the full optimization routine.
    679 
   (...)
    693     datamodule: An instance of :class:`~pytorch_lightning.core.datamodule.LightningDataModule`.
    694 """
    695 self.strategy.model = model
--> 696 self._call_and_handle_interrupt(
    697     self._fit_impl, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path
    698 )

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:650, in Trainer._call_and_handle_interrupt(self, trainer_fn, *args, **kwargs)
    648         return self.strategy.launcher.launch(trainer_fn, *args, trainer=self, **kwargs)
    649     else:
--> 650         return trainer_fn(*args, **kwargs)
    651 # TODO(awaelchli): Unify both exceptions below, where `KeyboardError` doesn't re-raise
    652 except KeyboardInterrupt as exception:

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:737, in Trainer._fit_impl(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)
    733 ckpt_path = ckpt_path or self.resume_from_checkpoint
    734 self._ckpt_path = self.__set_ckpt_path(
    735     ckpt_path, model_provided=True, model_connected=self.lightning_module is not None
    736 )
--> 737 results = self._run(model, ckpt_path=self.ckpt_path)
    739 assert self.state.stopped
    740 self.training = False

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1168, in Trainer._run(self, model, ckpt_path)
   1164 self._checkpoint_connector.restore_training_state()
   1166 self._checkpoint_connector.resume_end()
-> 1168 results = self._run_stage()
   1170 log.detail(f"{self.__class__.__name__}: trainer tearing down")
   1171 self._teardown()

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1254, in Trainer._run_stage(self)
   1252 if self.predicting:
   1253     return self._run_predict()
-> 1254 return self._run_train()

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1285, in Trainer._run_train(self)
   1282 self.fit_loop.trainer = self
   1284 with torch.autograd.set_detect_anomaly(self._detect_anomaly):
-> 1285     self.fit_loop.run()

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/loop.py:200, in Loop.run(self, *args, **kwargs)
    198 try:
    199     self.on_advance_start(*args, **kwargs)
--> 200     self.advance(*args, **kwargs)
    201     self.on_advance_end()
    202     self._restarting = False

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/fit_loop.py:270, in FitLoop.advance(self)
    266 self._data_fetcher.setup(
    267     dataloader, batch_to_device=partial(self.trainer._call_strategy_hook, "batch_to_device", dataloader_idx=0)
    268 )
    269 with self.trainer.profiler.profile("run_training_epoch"):
--> 270     self._outputs = self.epoch_loop.run(self._data_fetcher)

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/loop.py:200, in Loop.run(self, *args, **kwargs)
    198 try:
    199     self.on_advance_start(*args, **kwargs)
--> 200     self.advance(*args, **kwargs)
    201     self.on_advance_end()
    202     self._restarting = False

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/epoch/training_epoch_loop.py:203, in TrainingEpochLoop.advance(self, data_fetcher)
    200     self.batch_progress.increment_started()
    202     with self.trainer.profiler.profile("run_training_batch"):
--> 203         batch_output = self.batch_loop.run(kwargs)
    205 self.batch_progress.increment_processed()
    207 # update non-plateau LR schedulers
    208 # update epoch-interval ones only when we are at the end of training epoch

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/loop.py:200, in Loop.run(self, *args, **kwargs)
    198 try:
    199     self.on_advance_start(*args, **kwargs)
--> 200     self.advance(*args, **kwargs)
    201     self.on_advance_end()
    202     self._restarting = False

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/batch/training_batch_loop.py:87, in TrainingBatchLoop.advance(self, kwargs)
     83 if self.trainer.lightning_module.automatic_optimization:
     84     optimizers = _get_active_optimizers(
     85         self.trainer.optimizers, self.trainer.optimizer_frequencies, kwargs.get("batch_idx", 0)
     86     )
---> 87     outputs = self.optimizer_loop.run(optimizers, kwargs)
     88 else:
     89     outputs = self.manual_loop.run(kwargs)

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/loop.py:200, in Loop.run(self, *args, **kwargs)
    198 try:
    199     self.on_advance_start(*args, **kwargs)
--> 200     self.advance(*args, **kwargs)
    201     self.on_advance_end()
    202     self._restarting = False

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:201, in OptimizerLoop.advance(self, optimizers, kwargs)
    198 def advance(self, optimizers: List[Tuple[int, Optimizer]], kwargs: OrderedDict) -> None:  # type: ignore[override]
    199     kwargs = self._build_kwargs(kwargs, self.optimizer_idx, self._hiddens)
--> 201     result = self._run_optimization(kwargs, self._optimizers[self.optim_progress.optimizer_position])
    202     if result.loss is not None:
    203         # automatic optimization assumes a loss needs to be returned for extras to be considered as the batch
    204         # would be skipped otherwise
    205         self._outputs[self.optimizer_idx] = result.asdict()

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:248, in OptimizerLoop._run_optimization(self, kwargs, optimizer)
    240         closure()
    242 # ------------------------------
    243 # BACKWARD PASS
    244 # ------------------------------
    245 # gradient update with accumulated gradients
    246 else:
    247     # the `batch_idx` is optional with inter-batch parallelism
--> 248     self._optimizer_step(optimizer, opt_idx, kwargs.get("batch_idx", 0), closure)
    250 result = closure.consume_result()
    252 if result.loss is not None:
    253     # if no result, user decided to skip optimization
    254     # otherwise update running loss + reset accumulated loss
    255     # TODO: find proper way to handle updating running loss

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:358, in OptimizerLoop._optimizer_step(self, optimizer, opt_idx, batch_idx, train_step_and_backward_closure)
    355     self.optim_progress.optimizer.step.increment_ready()
    357 # model hook
--> 358 self.trainer._call_lightning_module_hook(
    359     "optimizer_step",
    360     self.trainer.current_epoch,
    361     batch_idx,
    362     optimizer,
    363     opt_idx,
    364     train_step_and_backward_closure,
    365     on_tpu=isinstance(self.trainer.accelerator, TPUAccelerator),
    366     using_native_amp=(self.trainer.amp_backend == AMPType.NATIVE),
    367     using_lbfgs=is_lbfgs,
    368 )
    370 if not should_accumulate:
    371     self.optim_progress.optimizer.step.increment_completed()

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1552, in Trainer._call_lightning_module_hook(self, hook_name, pl_module, *args, **kwargs)
   1549 pl_module._current_fx_name = hook_name
   1551 with self.profiler.profile(f"[LightningModule]{pl_module.__class__.__name__}.{hook_name}"):
-> 1552     output = fn(*args, **kwargs)
   1554 # restore current_fx when nested context
   1555 pl_module._current_fx_name = prev_fx_name

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/core/module.py:1666, in LightningModule.optimizer_step(self, epoch, batch_idx, optimizer, optimizer_idx, optimizer_closure, on_tpu, using_native_amp, using_lbfgs)
   1584 def optimizer_step(
   1585     self,
   1586     epoch: int,
   (...)
   1593     using_lbfgs: bool = False,
   1594 ) -> None:
   1595     r"""
   1596     Override this method to adjust the default way the :class:`~pytorch_lightning.trainer.trainer.Trainer` calls
   1597     each optimizer.
   (...)
   1664 
   1665     """
-> 1666     optimizer.step(closure=optimizer_closure)

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/core/optimizer.py:168, in LightningOptimizer.step(self, closure, **kwargs)
    165     raise MisconfigurationException("When `optimizer.step(closure)` is called, the closure should be callable")
    167 assert self._strategy is not None
--> 168 step_output = self._strategy.optimizer_step(self._optimizer, self._optimizer_idx, closure, **kwargs)
    170 self._on_after_step()
    172 return step_output

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/strategies/strategy.py:216, in Strategy.optimizer_step(self, optimizer, opt_idx, closure, model, **kwargs)
    206 """Performs the actual optimizer step.
    207 
    208 Args:
   (...)
    213     **kwargs: Any extra arguments to ``optimizer.step``
    214 """
    215 model = model or self.lightning_module
--> 216 return self.precision_plugin.optimizer_step(model, optimizer, opt_idx, closure, **kwargs)

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/plugins/precision/native_amp.py:80, in NativeMixedPrecisionPlugin.optimizer_step(self, model, optimizer, optimizer_idx, closure, **kwargs)
     70 def optimizer_step(
     71     self,
     72     model: Optional[Union["pl.LightningModule", Module]],
   (...)
     76     **kwargs: Any,
     77 ) -> Any:
     78     if self.scaler is None:
     79         # skip scaler logic, as bfloat16 does not require scaler
---> 80         return super().optimizer_step(model, optimizer, optimizer_idx, closure, **kwargs)
     81     if isinstance(optimizer, LBFGS):
     82         raise MisconfigurationException(
     83             f"Native AMP and the LBFGS optimizer are not compatible (optimizer {optimizer_idx})."
     84         )

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/plugins/precision/precision_plugin.py:153, in PrecisionPlugin.optimizer_step(self, model, optimizer, optimizer_idx, closure, **kwargs)
    151 if isinstance(model, pl.LightningModule):
    152     closure = partial(self._wrap_closure, model, optimizer, optimizer_idx, closure)
--> 153 return optimizer.step(closure=closure, **kwargs)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/optim/optimizer.py:113, in Optimizer._hook_for_profile.<locals>.profile_hook_step.<locals>.wrapper(*args, **kwargs)
    111 profile_name = "Optimizer.step#{}.step".format(obj.__class__.__name__)
    112 with torch.autograd.profiler.record_function(profile_name):
--> 113     return func(*args, **kwargs)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/autograd/grad_mode.py:27, in _DecoratorContextManager.__call__.<locals>.decorate_context(*args, **kwargs)
     24 @functools.wraps(func)
     25 def decorate_context(*args, **kwargs):
     26     with self.clone():
---> 27         return func(*args, **kwargs)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/optim/adam.py:118, in Adam.step(self, closure)
    116 if closure is not None:
    117     with torch.enable_grad():
--> 118         loss = closure()
    120 for group in self.param_groups:
    121     params_with_grad = []

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/plugins/precision/precision_plugin.py:138, in PrecisionPlugin._wrap_closure(self, model, optimizer, optimizer_idx, closure)
    125 def _wrap_closure(
    126     self,
    127     model: "pl.LightningModule",
   (...)
    130     closure: Callable[[], Any],
    131 ) -> Any:
    132     """This double-closure allows makes sure the ``closure`` is executed before the
    133     ``on_before_optimizer_step`` hook is called.
    134 
    135     The closure (generally) runs ``backward`` so this allows inspecting gradients in this hook. This structure is
    136     consistent with the ``PrecisionPlugin`` subclasses that cannot pass ``optimizer.step(closure)`` directly.
    137     """
--> 138     closure_result = closure()
    139     self._after_closure(model, optimizer, optimizer_idx)
    140     return closure_result

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:146, in Closure.__call__(self, *args, **kwargs)
    145 def __call__(self, *args: Any, **kwargs: Any) -> Optional[Tensor]:
--> 146     self._result = self.closure(*args, **kwargs)
    147     return self._result.loss

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:132, in Closure.closure(self, *args, **kwargs)
    131 def closure(self, *args: Any, **kwargs: Any) -> ClosureResult:
--> 132     step_output = self._step_fn()
    134     if step_output.closure_loss is None:
    135         self.warning_cache.warn("`training_step` returned `None`. If this was on purpose, ignore this warning...")

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/optimizer_loop.py:407, in OptimizerLoop._training_step(self, kwargs)
    398 """Performs the actual train step with the tied hooks.
    399 
    400 Args:
   (...)
    404     A ``ClosureResult`` containing the training step output.
    405 """
    406 # manually capture logged metrics
--> 407 training_step_output = self.trainer._call_strategy_hook("training_step", *kwargs.values())
    408 self.trainer.strategy.post_training_step()
    410 model_output = self.trainer._call_lightning_module_hook("training_step_end", training_step_output)

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1706, in Trainer._call_strategy_hook(self, hook_name, *args, **kwargs)
   1703     return
   1705 with self.profiler.profile(f"[Strategy]{self.strategy.__class__.__name__}.{hook_name}"):
-> 1706     output = fn(*args, **kwargs)
   1708 # restore current_fx when nested context
   1709 pl_module._current_fx_name = prev_fx_name

File ~/.env/pytorch/lib/python3.10/site-packages/pytorch_lightning/strategies/strategy.py:358, in Strategy.training_step(self, *args, **kwargs)
    356 with self.precision_plugin.train_step_context():
    357     assert isinstance(self.model, TrainingStep)
--> 358     return self.model.training_step(*args, **kwargs)

File /mnt/scratch/kashif/pytorch-transformer-ts/perceiverar/lightning_module.py:87, in PerceiverARLightningModule.training_step(self, batch, batch_idx)
     83 def training_step(self, batch, batch_idx: int):  # type: ignore
     84     """
     85     Execute training step.
     86     """
---> 87     train_loss = self._compute_loss(batch)
     88     self.log(
     89         "train_loss",
     90         train_loss,
   (...)
     93         prog_bar=True,
     94     )
     95     return train_loss

File /mnt/scratch/kashif/pytorch-transformer-ts/perceiverar/lightning_module.py:64, in PerceiverARLightningModule._compute_loss(self, batch)
     53 future_observed_values = batch["future_observed_values"]
     55 params, scale, _, _ = self.model.lagged_perciever(
     56     feat_static_cat,
     57     feat_static_real,
   (...)
     62     future_target,
     63 )
---> 64 distr = self.model.output_distribution(params, scale)
     66 # context_target = past_target[:, -self.model.context_length + 1 :]
     67 # target = torch.cat(
     68 #     (context_target, future_target),
     69 #     dim=1,
     70 # )
     71 loss_values = self.loss(distr, future_target)

File /mnt/scratch/kashif/pytorch-transformer-ts/perceiverar/module.py:457, in PerceiverARModel.output_distribution(self, params, scale, trailing_n)
    455 if trailing_n is not None:
    456     sliced_params = [p[:, -trailing_n:] for p in params]
--> 457 return self.distr_output.distribution(sliced_params, scale=scale)

File ~/gluon-ts-PR/src/gluonts/torch/distributions/distribution_output.py:138, in DistributionOutput.distribution(self, distr_args, loc, scale)
    117 def distribution(
    118     self,
    119     distr_args,
    120     loc: Optional[torch.Tensor] = None,
    121     scale: Optional[torch.Tensor] = None,
    122 ) -> Distribution:
    123     r"""
    124     Construct the associated distribution, given the collection of
    125     constructor arguments and, optionally, a scale tensor.
   (...)
    136         batch_shape+event_shape of the resulting distribution.
    137     """
--> 138     distr = self._base_distribution(distr_args)
    139     if loc is None and scale is None:
    140         return distr

File ~/gluon-ts-PR/src/gluonts/torch/distributions/distribution_output.py:115, in DistributionOutput._base_distribution(self, distr_args)
    114 def _base_distribution(self, distr_args):
--> 115     return self.distr_cls(*distr_args)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/distributions/studentT.py:50, in StudentT.__init__(self, df, loc, scale, validate_args)
     48 def __init__(self, df, loc=0., scale=1., validate_args=None):
     49     self.df, self.loc, self.scale = broadcast_all(df, loc, scale)
---> 50     self._chi2 = Chi2(self.df)
     51     batch_shape = self.df.size()
     52     super(StudentT, self).__init__(batch_shape, validate_args=validate_args)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/distributions/chi2.py:22, in Chi2.__init__(self, df, validate_args)
     21 def __init__(self, df, validate_args=None):
---> 22     super(Chi2, self).__init__(0.5 * df, 0.5, validate_args=validate_args)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/distributions/gamma.py:52, in Gamma.__init__(self, concentration, rate, validate_args)
     50 else:
     51     batch_shape = self.concentration.size()
---> 52 super(Gamma, self).__init__(batch_shape, validate_args=validate_args)

File ~/.env/pytorch/lib/python3.10/site-packages/torch/distributions/distribution.py:55, in Distribution.__init__(self, batch_shape, event_shape, validate_args)
     53         valid = constraint.check(value)
     54         if not valid.all():
---> 55             raise ValueError(
     56                 f"Expected parameter {param} "
     57                 f"({type(value).__name__} of shape {tuple(value.shape)}) "
     58                 f"of distribution {repr(self)} "
     59                 f"to satisfy the constraint {repr(constraint)}, "
     60                 f"but found invalid values:\n{value}"
     61             )
     62 super(Distribution, self).__init__()

ValueError: Expected parameter df (Tensor of shape (128, 24)) of distribution Chi2() to satisfy the constraint GreaterThan(lower_bound=0.0), but found invalid values:
tensor([[nan, nan, nan,  ..., nan, nan, nan],
        [nan, nan, nan,  ..., nan, nan, nan],
        [nan, nan, nan,  ..., nan, nan, nan],
        ...,
        [nan, nan, nan,  ..., nan, nan, nan],
        [nan, nan, nan,  ..., nan, nan, nan],
        [nan, nan, nan,  ..., nan, nan, nan]], device='cuda:0',
       grad_fn=<MulBackward0>)

In [19]:

forecast_it, ts_it = make_evaluation_predictions(
    dataset=dataset.test,
    predictor=predictor
)

In [20]:

forecasts = list(forecast_it)

In [10]:

tss = list(ts_it)

In [21]:

evaluator = Evaluator()
agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts), num_series=len(dataset.test))

Running evaluation: 100%|██████████| 2247/2247 [00:00<00:00, 4768.58it/s]
/home/kashif/.env/pytorch/lib/python3.10/site-packages/pandas/core/dtypes/cast.py:1181: UserWarning: Warning: converting a masked element to nan.
  return arr.astype(dtype, copy=True)

In [22]:

agg_metrics

Out [22]:

{'MSE': 2632277.5637280988,
 'abs_error': 8510987.796981812,
 'abs_target_sum': 128632956.0,
 'abs_target_mean': 2385.272140631954,
 'seasonal_error': 189.49338196116761,
 'MASE': 0.6778296899315452,
 'MAPE': 0.08927172247730361,
 'sMAPE': 0.09760858887603995,
 'MSIS': 5.672968862545339,
 'QuantileLoss[0.1]': 3457375.6345648617,
 'Coverage[0.1]': 0.08778371161548731,
 'QuantileLoss[0.2]': 5534597.8590742415,
 'Coverage[0.2]': 0.17855288532858626,
 'QuantileLoss[0.3]': 6996813.588530006,
 'Coverage[0.3]': 0.2765353805073431,
 'QuantileLoss[0.4]': 7983532.04939911,
 'Coverage[0.4]': 0.3759827918706424,
 'QuantileLoss[0.5]': 8510987.873387918,
 'Coverage[0.5]': 0.48075211392968403,
 'QuantileLoss[0.6]': 8669924.372969786,
 'Coverage[0.6]': 0.5748405281115562,
 'QuantileLoss[0.7]': 8253363.577501401,
 'Coverage[0.7]': 0.6788310339712208,
 'QuantileLoss[0.8]': 7247401.984374037,
 'Coverage[0.8]': 0.7797804480047471,
 'QuantileLoss[0.9]': 5274768.110512937,
 'Coverage[0.9]': 0.8810265539237501,
 'RMSE': 1622.4295250420275,
 'NRMSE': 0.6801863390783499,
 'ND': 0.06616490875776665,
 'wQuantileLoss[0.1]': 0.02687783708060679,
 'wQuantileLoss[0.2]': 0.04302628215334056,
 'wQuantileLoss[0.3]': 0.05439363135315032,
 'wQuantileLoss[0.4]': 0.06206443743234129,
 'wQuantileLoss[0.5]': 0.06616490935175211,
 'wQuantileLoss[0.6]': 0.06740049084287378,
 'wQuantileLoss[0.7]': 0.06416212325480106,
 'wQuantileLoss[0.8]': 0.056341719958406596,
 'wQuantileLoss[0.9]': 0.04100635074041941,
 'mean_absolute_QuantileLoss': 6880973.894479367,
 'mean_wQuantileLoss': 0.053493086907521324,
 'MAE_Coverage': 0.02065717252633142,
 'OWA': nan}

In [23]:

ts_metrics.plot(x='MSIS', y='MASE', kind='scatter')
plt.grid(which="both")
plt.show()

In [24]:

plt.figure(figsize=(20, 15))
date_formater = mdates.DateFormatter('%b, %d')
plt.rcParams.update({'font.size': 15})

for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 9):
    ax = plt.subplot(3, 3, idx+1)

    plt.plot(ts[-4 * dataset.metadata.prediction_length:].to_timestamp(), label="target", )
    forecast.plot( color='g')
    plt.xticks(rotation=60)
    ax.xaxis.set_major_formatter(date_formater)

plt.gcf().tight_layout()
plt.legend()
plt.show()

In [ ]: