text: Title: N-HiTS encounters a RuntimeError  when using 'time_varying_unknown_reals' and 'time_varying_known_reals' covariates  simultaneously
  Body: - PyTorch-Forecasting version: 0.10.2
  - PyTorch version: 1.12.0
  - Python version: 3.8.3
  - Operating System: Linux
  
  ### Expected behavior
  
  I executed the example code of N-HiTS (https://pytorch-forecasting.readthedocs.io/en/latest/tutorials/nhits.html).
  In order to test the forecasting ability of N-HiTS when using covariates, I add two new columns, named ’log_value' and 'exp_value' respectively, into the example data.
  
  Under normal conditions, N-HiTS should take these covariates as a part of input and output forecast result.
  
  ### Actual behavior
  
  However, N-HiTS crashed because of a RuntimeError: mat1 and mat2 shapes cannot be multiplied (1x35 and 24x64).
  
  
  ### Code to reproduce the problem
  ```
  import os
  import warnings
  
  warnings.filterwarnings("ignore")
  
  import matplotlib.pyplot as plt
  import numpy as np
  import pandas as pd
  import pytorch_lightning as pl
  from pytorch_lightning.callbacks import EarlyStopping
  import torch
  
  from pytorch_forecasting import Baseline, NHiTS, TimeSeriesDataSet
  from pytorch_forecasting.data import NaNLabelEncoder
  from pytorch_forecasting.data.examples import generate_ar_data
  from pytorch_forecasting.metrics import SMAPE, QuantileLoss
  
  data = generate_ar_data(seasonality=10.0, timesteps=400, n_series=1, seed=42)
  data["static"] = 2
  data["date"] = pd.Timestamp("2020-01-01") + pd.to_timedelta(data.time_idx, "D")
  data['exp_value'] = np.exp(data['value'])
  data['log_value'] = np.log(abs(data['value']) + 1)
  data.head()
  data['static'] = data['static'].astype(str)
  
  # create dataset and dataloaders
  max_encoder_length = 11
  max_prediction_length = 10
  
  training_cutoff = data["time_idx"].max() - max_prediction_length
  
  context_length = max_encoder_length
  prediction_length = max_prediction_length
  
  training = TimeSeriesDataSet(
      data[lambda x: x.time_idx <= training_cutoff],
      time_idx="time_idx",
      target="value",
      # categorical_encoders={"series": NaNLabelEncoder().fit(data.series)},
      group_ids=["series"],
      # time_varying_known_categoricals=['static'],
      # only unknown variable is "value" - and N-Beats can also not take any additional variables
      time_varying_unknown_reals=["value", 'exp_value'],
      time_varying_known_reals=['log_value'],
      max_encoder_length=context_length,
      max_prediction_length=prediction_length,
  )
  
  validation = TimeSeriesDataSet.from_dataset(training, data, min_prediction_idx=training_cutoff + 1)
  batch_size = 128
  train_dataloader = training.to_dataloader(train=True, batch_size=batch_size, num_workers=0)
  val_dataloader = validation.to_dataloader(train=False, batch_size=batch_size, num_workers=0)
  
  # calculate baseline absolute error
  actuals = torch.cat([y[0] for x, y in iter(val_dataloader)])
  baseline_predictions = Baseline().predict(val_dataloader)
  SMAPE()(baseline_predictions, actuals)
  
  early_stop_callback = EarlyStopping(monitor="val_loss", min_delta=1e-4, patience=10, verbose=False, mode="min")
  trainer = pl.Trainer(
      max_epochs=2,
      gpus=1,
      enable_model_summary=True,
      gradient_clip_val=1.0,
      callbacks=[early_stop_callback],
      limit_train_batches=30,
      enable_checkpointing=True,
  )
  
  
  net = NHiTS.from_dataset(
      training,
      learning_rate=0.09,
      log_interval=10,
      log_val_interval=1,
      weight_decay=1e-2,
      backcast_loss_ratio=0.0,
      hidden_size=64,
      loss=QuantileLoss([0.5,]),
      # time_varying_categoricals_encoder=['static'],
      # time_varying_categoricals_decoder=['static'],
      # time_varying_reals_encoder=['value', 'exp_value', 'log_value'],
      # time_varying_reals_decoder=['log_value'],
  )
  
  
  trainer.fit(
      net,
      train_dataloaders=train_dataloader,
      val_dataloaders=val_dataloader,
  
  )
  ```
  ### Debug info
  ```
  RuntimeError                              Traceback (most recent call last)
  <ipython-input-1-54cddb48a7c1> in <module>
       26 )
       27 
  ---> 28 trainer.fit(
       29     net,
       30     train_dataloaders=train_dataloader,
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in fit(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)
      768         """
      769         self.strategy.model = model
  --> 770         self._call_and_handle_interrupt(
      771             self._fit_impl, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path
      772         )
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _call_and_handle_interrupt(self, trainer_fn, *args, **kwargs)
      721                 return self.strategy.launcher.launch(trainer_fn, *args, trainer=self, **kwargs)
      722             else:
  --> 723                 return trainer_fn(*args, **kwargs)
      724         # TODO: treat KeyboardInterrupt as BaseException (delete the code below) in v1.7
      725         except KeyboardInterrupt as exception:
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _fit_impl(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)
      809             ckpt_path, model_provided=True, model_connected=self.lightning_module is not None
      810         )
  --> 811         results = self._run(model, ckpt_path=self.ckpt_path)
      812 
      813         assert self.state.stopped
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _run(self, model, ckpt_path)
     1234         self._checkpoint_connector.resume_end()
     1235 
  -> 1236         results = self._run_stage()
     1237 
     1238         log.detail(f"{self.__class__.__name__}: trainer tearing down")
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _run_stage(self)
     1321         if self.predicting:
     1322             return self._run_predict()
  -> 1323         return self._run_train()
     1324 
     1325     def _pre_training_routine(self):
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _run_train(self)
     1343 
     1344         with isolate_rng():
  -> 1345             self._run_sanity_check()
     1346 
     1347         # enable train mode
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _run_sanity_check(self)
     1411             # run eval step
     1412             with torch.no_grad():
  -> 1413                 val_loop.run()
     1414 
     1415             self._call_callback_hooks("on_sanity_check_end")
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/loops/base.py in run(self, *args, **kwargs)
      202             try:
      203                 self.on_advance_start(*args, **kwargs)
  --> 204                 self.advance(*args, **kwargs)
      205                 self.on_advance_end()
      206                 self._restarting = False
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/loops/dataloader/evaluation_loop.py in advance(self, *args, **kwargs)
      153         if self.num_dataloaders > 1:
      154             kwargs["dataloader_idx"] = dataloader_idx
  --> 155         dl_outputs = self.epoch_loop.run(self._data_fetcher, dl_max_batches, kwargs)
      156 
      157         # store batch level output per dataloader
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/loops/base.py in run(self, *args, **kwargs)
      202             try:
      203                 self.on_advance_start(*args, **kwargs)
  --> 204                 self.advance(*args, **kwargs)
      205                 self.on_advance_end()
      206                 self._restarting = False
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/loops/epoch/evaluation_epoch_loop.py in advance(self, data_fetcher, dl_max_batches, kwargs)
      126 
      127         # lightning module methods
  --> 128         output = self._evaluation_step(**kwargs)
      129         output = self._evaluation_step_end(output)
      130 
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/loops/epoch/evaluation_epoch_loop.py in _evaluation_step(self, **kwargs)
      224             output = self.trainer._call_strategy_hook("test_step", *kwargs.values())
      225         else:
  --> 226             output = self.trainer._call_strategy_hook("validation_step", *kwargs.values())
      227 
      228         return output
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/trainer/trainer.py in _call_strategy_hook(self, hook_name, *args, **kwargs)
     1763 
     1764         with self.profiler.profile(f"[Strategy]{self.strategy.__class__.__name__}.{hook_name}"):
  -> 1765             output = fn(*args, **kwargs)
     1766 
     1767         # restore current_fx when nested context
  
  /usr/local/lib/python3.8/site-packages/pytorch_lightning/strategies/strategy.py in validation_step(self, *args, **kwargs)
      342         """
      343         with self.precision_plugin.val_step_context():
  --> 344             return self.model.validation_step(*args, **kwargs)
      345 
      346     def test_step(self, *args, **kwargs) -> Optional[STEP_OUTPUT]:
  
  /usr/local/lib/python3.8/site-packages/pytorch_forecasting/models/base_model.py in validation_step(self, batch, batch_idx)
      417     def validation_step(self, batch, batch_idx):
      418         x, y = batch
  --> 419         log, out = self.step(x, y, batch_idx)
      420         log.update(self.create_log(x, y, out, batch_idx))
      421         return log
  
  /usr/local/lib/python3.8/site-packages/pytorch_forecasting/models/nhits/__init__.py in step(self, x, y, batch_idx)
      352         Take training / validation step.
      353         """
  --> 354         log, out = super().step(x, y, batch_idx=batch_idx)
      355 
      356         if self.hparams.backcast_loss_ratio > 0:  # add loss from backcast
  
  /usr/local/lib/python3.8/site-packages/pytorch_forecasting/models/base_model.py in step(self, x, y, batch_idx, **kwargs)
      557             loss = loss * (1 + monotinicity_loss)
      558         else:
  --> 559             out = self(x, **kwargs)
      560 
      561             # calculate loss
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
     1128         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
     1129                 or _global_forward_hooks or _global_forward_pre_hooks):
  -> 1130             return forward_call(*input, **kwargs)
     1131         # Do not call functions when jit is used
     1132         full_backward_hooks, non_full_backward_hooks = [], []
  
  /usr/local/lib/python3.8/site-packages/pytorch_forecasting/models/nhits/__init__.py in forward(self, x)
      263 
      264         # run model
  --> 265         forecast, backcast, block_forecasts, block_backcasts = self.model(
      266             encoder_y, encoder_mask, encoder_x_t, decoder_x_t, x_s
      267         )
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
     1128         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
     1129                 or _global_forward_hooks or _global_forward_pre_hooks):
  -> 1130             return forward_call(*input, **kwargs)
     1131         # Do not call functions when jit is used
     1132         full_backward_hooks, non_full_backward_hooks = [], []
  
  /usr/local/lib/python3.8/site-packages/pytorch_forecasting/models/nhits/sub_modules.py in forward(self, encoder_y, encoder_mask, encoder_x_t, decoder_x_t, x_s)
      356         # forecast by block
      357         for block in self.blocks:
  --> 358             block_backcast, block_forecast = block(
      359                 encoder_y=residuals, encoder_x_t=encoder_x_t, decoder_x_t=decoder_x_t, x_s=x_s
      360             )
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
     1128         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
     1129                 or _global_forward_hooks or _global_forward_pre_hooks):
  -> 1130             return forward_call(*input, **kwargs)
     1131         # Do not call functions when jit is used
     1132         full_backward_hooks, non_full_backward_hooks = [], []
  
  /usr/local/lib/python3.8/site-packages/pytorch_forecasting/models/nhits/sub_modules.py in forward(self, encoder_y, encoder_x_t, decoder_x_t, x_s)
      191 
      192         # Compute local projection weights and projection
  --> 193         theta = self.layers(encoder_y)
      194         backcast_theta = theta[:, : self.context_length * len(self.output_size)].reshape(-1, self.context_length)
      195         forecast_theta = theta[:, self.context_length * len(self.output_size) :].reshape(-1, self.n_theta)
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
     1128         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
     1129                 or _global_forward_hooks or _global_forward_pre_hooks):
  -> 1130             return forward_call(*input, **kwargs)
     1131         # Do not call functions when jit is used
     1132         full_backward_hooks, non_full_backward_hooks = [], []
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/container.py in forward(self, input)
      137     def forward(self, input):
      138         for module in self:
  --> 139             input = module(input)
      140         return input
      141 
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
     1128         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
     1129                 or _global_forward_hooks or _global_forward_pre_hooks):
  -> 1130             return forward_call(*input, **kwargs)
     1131         # Do not call functions when jit is used
     1132         full_backward_hooks, non_full_backward_hooks = [], []
  
  /usr/local/lib/python3.8/site-packages/torch/nn/modules/linear.py in forward(self, input)
      112 
      113     def forward(self, input: Tensor) -> Tensor:
  --> 114         return F.linear(input, self.weight, self.bias)
      115 
      116     def extra_repr(self) -> str:
  
  RuntimeError: mat1 and mat2 shapes cannot be multiplied (1x35 and 24x64)
  ```
  Paste the command(s) you ran and the output. Including a link to a colab notebook will speed up issue resolution.
  If there was a crash, please include the traceback here.
  The code used to initialize the TimeSeriesDataSet and model should be also included.
  