docstr: Computes sample paths by unrolling the LSTM starting with a initial
  input and state.
  
  Parameters
  ----------
  static_feat : Tensor
      static features. Shape: (batch_size, num_static_features).
  past_target : Tensor
      target history. Shape: (batch_size, history_length).
  time_feat : Tensor
      time features. Shape: (batch_size, prediction_length,
      num_time_features).
  scale : Tensor
      tensor containing the scale of each element in the batch.
      Shape: (batch_size, 1, 1).
  begin_states : List
      list of initial states for the LSTM layers. The shape of each
      tensor of the list should be (batch_size, num_cells)
  Returns
  --------
  Tensor
      A tensor containing sampled paths.
      Shape: (batch_size, num_sample_paths, prediction_length).
docstr_tok: ["Computes","sample","paths","by","unrolling","the","LSTM","starting","with","a","initial","input","and","state",".","Parameters","--","--","--","--","--","static_feat",":","Tensor","static","features",".","Shape",":","(","batch_size",",","num_static_features",")",".","past_target",":","Tensor","target","history",".","Shape",":","(","batch_size",",","history_length",")",".","time_feat",":","Tensor","time","features",".","Shape",":","(","batch_size",",","prediction_length",",","num_time_features",")",".","scale",":","Tensor","tensor","containing","the","scale","of","each","element","in","the","batch",".","Shape",":","(","batch_size",",","1",",","1",")",".","begin_states",":","List","list","of","initial","states","for","the","LSTM","layers",".","The","shape","of","each","tensor","of","the","list","should","be","(","batch_size",",","num_cells",")","Returns","--","--","--","--","Tensor","A","tensor","containing","sampled","paths",".","Shape",":","(","batch_size",",","num_sample_paths",",","prediction_length",")","."]
code: def sampling_decoder(
      self,
      F,
      static_feat: Tensor,
      past_target: Tensor,
      time_feat: Tensor,
      scale: Tensor,
      begin_states: List,
  ) -> Tensor:
      """
      Computes sample paths by unrolling the LSTM starting with a initial
      input and state.
  
      Parameters
      ----------
      static_feat : Tensor
          static features. Shape: (batch_size, num_static_features).
      past_target : Tensor
          target history. Shape: (batch_size, history_length).
      time_feat : Tensor
          time features. Shape: (batch_size, prediction_length,
          num_time_features).
      scale : Tensor
          tensor containing the scale of each element in the batch.
          Shape: (batch_size, 1, 1).
      begin_states : List
          list of initial states for the LSTM layers. The shape of each
          tensor of the list should be (batch_size, num_cells)
      Returns
      --------
      Tensor
          A tensor containing sampled paths.
          Shape: (batch_size, num_sample_paths, prediction_length).
      """
  
      # blows-up the dimension of each tensor to batch_size *
      # self.num_parallel_samples for increasing parallelism
      repeated_past_target = past_target.repeat(
          repeats=self.num_parallel_samples, axis=0
      )
      repeated_time_feat = time_feat.repeat(
          repeats=self.num_parallel_samples, axis=0
      )
      repeated_static_feat = static_feat.repeat(
          repeats=self.num_parallel_samples, axis=0
      ).expand_dims(axis=1)
      repeated_scale = scale.repeat(
          repeats=self.num_parallel_samples, axis=0
      )
      repeated_states = [
          s.repeat(repeats=self.num_parallel_samples, axis=0)
          for s in begin_states
      ]
  
      future_samples = []
  
      # for each future time-units we draw new samples for this time-unit and
      # update the state
      for k in range(self.prediction_length):
          # (batch_size * num_samples, 1, *target_shape, num_lags)
          lags = self.get_lagged_subsequences(
              F=F,
              sequence=repeated_past_target,
              sequence_length=self.history_length + k,
              indices=self.shifted_lags,
              subsequences_length=1,
          )
  
          # (batch_size * num_samples, 1, *target_shape, num_lags)
          lags_scaled = F.broadcast_div(
              lags, repeated_scale.expand_dims(axis=-1)
          )
  
          # from (batch_size * num_samples, 1, *target_shape, num_lags)
          # to (batch_size * num_samples, 1, prod(target_shape) * num_lags)
          input_lags = F.reshape(
              data=lags_scaled,
              shape=(
                  -1,
                  1,
                  prod(self.target_shape) * len(self.lags_seq),
              ),
          )
  
          # (batch_size * num_samples, 1, prod(target_shape) * num_lags +
          # num_time_features + num_static_features)
          decoder_input = F.concat(
              input_lags,
              repeated_time_feat.slice_axis(axis=1, begin=k, end=k + 1),
              # observed_values.expand_dims(axis=1),
              repeated_static_feat,
              dim=-1,
          )
  
          # output shape: (batch_size * num_samples, 1, num_cells)
          # state shape: (batch_size * num_samples, num_cells)
          rnn_outputs, repeated_states = self.rnn.unroll(
              inputs=decoder_input,
              length=1,
              begin_state=repeated_states,
              layout="NTC",
              merge_outputs=True,
          )
  
          distr_args = self.proj_distr_args(rnn_outputs)
  
          # compute likelihood of target given the predicted parameters
          distr = self.distr_output.distribution(
              distr_args, scale=repeated_scale
          )
  
          # (batch_size * num_samples, 1, *target_shape)
          new_samples = distr.sample(dtype=self.dtype)
          new_samples = self.post_process_samples(F, new_samples)
  
          # (batch_size * num_samples, seq_len, *target_shape)
          repeated_past_target = F.concat(
              repeated_past_target, new_samples, dim=1
          )
  
          future_samples.append(new_samples)
  
      # (batch_size * num_samples, prediction_length, *target_shape)
      samples = F.concat(*future_samples, dim=1)
  
      # (batch_size, num_samples, prediction_length, *target_shape)
      return samples.reshape(
          shape=(
              (-1, self.num_parallel_samples)
              + (self.prediction_length,)
              + self.target_shape
          )
      )
  
imports: from typing import List, Optional, Tuple, Union, Type
  import mxnet
  import numpy
  from mxnet.gluon.contrib.rnn import VariationalDropoutCell
  from mxnet.gluon.rnn import ZoneoutCell
  from gluonts.core.component import validated
  from gluonts.itertools import prod
  from gluonts.mx import Tensor
  from gluonts.mx.block.dropout import RNNZoneoutCell, VariationalZoneoutCell
  from gluonts.mx.block.feature import FeatureEmbedder
  from gluonts.mx.block.regularization import ActivationRegularizationLoss, TemporalActivationRegularizationLoss
  from gluonts.mx.block.scaler import MeanScaler, NOPScaler
  from gluonts.mx.distribution import Distribution, DistributionOutput
  from gluonts.mx.distribution.distribution import getF
  from gluonts.mx.util import weighted_average, mx_switch
  from mxnet import autograd
label_desc: Use image node_id 2 for calling the DeepARPredictionNetwork obj's underlying member method code with example usage: obj.sampling_decoder(F, static_feat, past_target, time_feat, scale, begin_states) and returns: samples