class_docstr: Estimator class to train a DeepAR model, as described in [SFG17]_.
  
  This class is uses the model defined in ``DeepARModel``, and wraps it
  into a ``DeepARLightningModule`` for training purposes: training is
  performed using PyTorch Lightning's ``pl.Trainer`` class.
  
  *Note:* the code of this model is unrelated to the implementation behind
  `SageMaker's DeepAR Forecasting Algorithm
  <https://docs.aws.amazon.com/sagemaker/latest/dg/deepar.html>`_.
  
  Parameters
  ----------
  freq
      Frequency of the data to train on and predict.
  prediction_length
      Length of the prediction horizon.
  context_length
      Number of steps to unroll the RNN for before computing predictions
      (default: None, in which case context_length = prediction_length).
  num_layers
      Number of RNN layers (default: 2).
  hidden_size
      Number of RNN cells for each layer (default: 40).
  lr
      Learning rate (default: ``1e-3``).
  weight_decay
      Weight decay regularization parameter (default: ``1e-8``).
  dropout_rate
      Dropout regularization parameter (default: 0.1).
  patience
      Patience parameter for learning rate scheduler.
  num_feat_dynamic_real
      Number of dynamic real features in the data (default: 0).
  num_feat_static_real
      Number of static real features in the data (default: 0).
  num_feat_static_cat
      Number of static categorical features in the data (default: 0).
  cardinality
      Number of values of each categorical feature.
      This must be set if ``num_feat_static_cat > 0`` (default: None).
  embedding_dimension
      Dimension of the embeddings for categorical features
      (default: ``[min(50, (cat+1)//2) for cat in cardinality]``).
  distr_output
      Distribution to use to evaluate observations and sample predictions
      (default: StudentTOutput()).
  scaling
      Whether to automatically scale the target values (default: true).
  default_scale
      Default scale that is applied if the context length window is
      completely unobserved. If not set, the scale in this case will be
      the mean scale in the batch.
  lags_seq
      Indices of the lagged target values to use as inputs of the RNN
      (default: None, in which case these are automatically determined
      based on freq).
  time_features
      List of time features, from :py:mod:`gluonts.time_feature`, to use as
      inputs of the RNN in addition to the provided data (default: None,
      in which case these are automatically determined based on freq).
  num_parallel_samples
      Number of samples per time series to that the resulting predictor
      should produce (default: 100).
  batch_size
      The size of the batches to be used for training (default: 32).
  num_batches_per_epoch
      Number of batches to be processed in each training epoch
      (default: 50).
  trainer_kwargs
      Additional arguments to provide to ``pl.Trainer`` for construction.
  train_sampler
      Controls the sampling of windows during training.
  validation_sampler
      Controls the sampling of windows during validation.
  nonnegative_pred_samples
      Should final prediction samples be non-negative? If yes, an activation
      function is applied to ensure non-negative. Observe that this is applied
      only to the final samples and this is not applied during training.
code: def create_transformation(self) -> Transformation:
      remove_field_names = []
      if self.num_feat_static_real == 0:
          remove_field_names.append(FieldName.FEAT_STATIC_REAL)
      if self.num_feat_dynamic_real == 0:
          remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)
  
      return Chain(
          [RemoveFields(field_names=remove_field_names)]
          + (
              [
                  SetField(
                      output_field=FieldName.FEAT_STATIC_CAT, value=[0]
                  )
              ]
              if not self.num_feat_static_cat > 0
              else []
          )
          + (
              [
                  SetField(
                      output_field=FieldName.FEAT_STATIC_REAL,
                      value=[0.0],
                  )
              ]
              if not self.num_feat_static_real > 0
              else []
          )
          + [
              AsNumpyArray(
                  field=FieldName.FEAT_STATIC_CAT,
                  expected_ndim=1,
                  dtype=int,
              ),
              AsNumpyArray(
                  field=FieldName.FEAT_STATIC_REAL,
                  expected_ndim=1,
              ),
              AsNumpyArray(
                  field=FieldName.TARGET,
                  # in the following line, we add 1 for the time dimension
                  expected_ndim=1 + len(self.distr_output.event_shape),
              ),
              AddObservedValuesIndicator(
                  target_field=FieldName.TARGET,
                  output_field=FieldName.OBSERVED_VALUES,
                  imputation_method=self.imputation_method,
              ),
              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 []
                  ),
              ),
              AsNumpyArray(FieldName.FEAT_TIME, expected_ndim=2),
          ]
      )
  
imports: from typing import List, Optional, Iterable, Dict, Any
  import torch
  from gluonts.core.component import validated
  from gluonts.dataset.common import Dataset
  from gluonts.dataset.field_names import FieldName
  from gluonts.dataset.loader import as_stacked_batches
  from gluonts.itertools import Cyclic
  from gluonts.dataset.stat import calculate_dataset_statistics
  from gluonts.time_feature import TimeFeature, time_features_from_frequency_str
  from gluonts.transform import Transformation, Chain, RemoveFields, SetField, AsNumpyArray, AddObservedValuesIndicator, AddTimeFeatures, AddAgeFeature, VstackFeatures, InstanceSplitter, ValidationSplitSampler, TestSplitSampler, ExpectedNumInstanceSampler, MissingValueImputation, DummyValueImputation
  from gluonts.torch.model.estimator import PyTorchLightningEstimator
  from gluonts.torch.model.predictor import PyTorchPredictor
  from gluonts.torch.distributions import DistributionOutput, StudentTOutput
  from gluonts.transform.sampler import InstanceSampler
  from .lightning_module import DeepARLightningModule
label_desc: Use image node_id 3 for calling the DeepAREstimator obj's underlying member method code with example usage: obj.create_transformation() and returns: Chain