class_docstr: Abstract base class to implement feed-forward networks for probabilistic
  time series prediction.
  
  This class does not implement hybrid_forward: this is delegated
  to the two subclasses SimpleFeedForwardTrainingNetwork and
  SimpleFeedForwardPredictionNetwork, that define respectively how to
  compute the loss and how to generate predictions.
  
  Parameters
  ----------
  num_hidden_dimensions
      Number of hidden nodes in each layer.
  prediction_length
      Number of time units to predict.
  context_length
      Number of time units that condition the predictions.
  batch_normalization
      Whether to use batch normalization.
  mean_scaling
      Scale the network input by the data mean and the network output by
      its inverse.
  distr_output
      Distribution to fit.
  kwargs
code: def __init__(
      self,
      num_hidden_dimensions: List[int],
      prediction_length: int,
      context_length: int,
      batch_normalization: bool,
      mean_scaling: bool,
      distr_output: DistributionOutput,
      **kwargs,
  ) -> None:
      super().__init__(**kwargs)
  
      self.num_hidden_dimensions = num_hidden_dimensions
      self.prediction_length = prediction_length
      self.context_length = context_length
      self.batch_normalization = batch_normalization
      self.mean_scaling = mean_scaling
      self.distr_output = distr_output
  
      with self.name_scope():
          self.distr_args_proj = self.distr_output.get_args_proj()
          self.mlp = mx.gluon.nn.HybridSequential()
          dims = self.num_hidden_dimensions
          for layer_no, units in enumerate(dims[:-1]):
              self.mlp.add(
                  mx.gluon.nn.Dense(units=units, activation="relu")
              )
              if self.batch_normalization:
                  self.mlp.add(mx.gluon.nn.BatchNorm())
          self.mlp.add(
              mx.gluon.nn.Dense(units=prediction_length * dims[-1])
          )
          self.mlp.add(
              mx.gluon.nn.HybridLambda(
                  lambda F, o: F.reshape(
                      o, (-1, prediction_length, dims[-1])
                  )
              )
          )
          self.scaler = MeanScaler() if mean_scaling else NOPScaler()
  
imports: from typing import List, Tuple
  import mxnet
  from gluonts.core.component import validated
  from gluonts.mx import Tensor
  from gluonts.mx.block.scaler import MeanScaler, NOPScaler
  from gluonts.mx.distribution import DistributionOutput
  from gluonts.mx.util import weighted_average
label_desc: Use image node_id 1 to create a new SimpleFeedForwardNetworkBase object from inherited base classes: mx.gluon with example: obj = SimpleFeedForwardNetworkBase(num_hidden_dimensions, prediction_length, context_length, batch_normalization, mean_scaling, distr_output)