class_docstr: DeepTPP is a multivariate point process model based on an RNN.
  
  After each event :math:`(\tau_i, m_i)`, we feed the inter-arrival time
  :math:`\tau_i` and the mark :math:`m_i` into the RNN. The state :math:`h_i`
  of the RNN represents the history embedding. We use :math:`h_i` to
  parametrize the distribution over the next inter-arrival time
  :math:`p(\tau_{i+1} | h_i)` and the distribution over the next mark
  :math:`p(m_{i+1} | h_i)`. The distribution over the marks is always
  categorical, but different choices are possible for the distribution over
  inter-arrival times - see :code:`gluonts.model.tpp.distribution`.
  
  The model is a generalization of the approaches described in [DDT+16]_,
  [TWJ19]_ and [SBG20]_.
  
  References
  ----------
  
  
  Parameters
  ----------
  prediction_interval_length
      The length of the interval (in continuous time) that the estimator will
      predict at prediction time.
  context_interval_length
      The length of intervals (in continuous time) that the estimator will be
      trained with.
  num_marks
      The number of marks (distinct processes), i.e., the cardinality of the
      mark set.
  time_distr_output
      TPPDistributionOutput for the distribution over the inter-arrival
      times. See :code:`gluonts.model.tpp.distribution` for possible choices.
  embedding_dim
      The dimension of vector embeddings for marks (used as input to the
      GRU).
  trainer
      :code:`gluonts.mx.trainer.Trainer` object which will be used to train
      the estimator. Note that :code:`Trainer(hybridize=False)` must be set
      as :code:`DeepTPPEstimator` currently does not support hybridization.
  num_hidden_dimensions
      Number of hidden units in the GRU network.
  num_parallel_samples
      The number of samples returned by the :code:`Predictor` learned.
  num_training_instances
      The number of training instances to be sampled from each entry in the
      data set provided during training.
  freq
      Similar to the :code:`freq` of discrete-time models, specifies the time
      unit by which inter-arrival times are given.
  batch_size
      The size of the batches to be used training and prediction.
code: def create_training_network(self) -> HybridBlock:
      return DeepTPPTrainingNetwork(
          num_marks=self.num_marks,
          time_distr_output=self.time_distr_output,
          interval_length=self.prediction_interval_length,
          embedding_dim=self.embedding_dim,
          num_hidden_dimensions=self.num_hidden_dimensions,
      )
  
imports: from functools import partial
  from mxnet.gluon import HybridBlock
  from gluonts.core.component import validated
  from gluonts.dataset.common import Dataset
  from gluonts.dataset.loader import DataLoader, TrainDataLoader, ValidationDataLoader
  from gluonts.model.predictor import Predictor
  from gluonts.mx.model.tpp import PointProcessGluonPredictor
  from gluonts.mx.model.tpp.distribution import TPPDistributionOutput, WeibullOutput
  from gluonts.mx.batchify import batchify
  from gluonts.mx.model.estimator import GluonEstimator
  from gluonts.mx.trainer import Trainer
  from gluonts.mx.util import get_hybrid_forward_input_names
  from gluonts.transform import Chain, ContinuousTimeInstanceSplitter, ContinuousTimePointSampler, ContinuousTimePredictionSampler, ContinuousTimeUniformSampler, RenameFields, SelectFields, Transformation
  from ._network import DeepTPPPredictionNetwork, DeepTPPTrainingNetwork
label_desc: Use image node_id 6 for calling the DeepTPPEstimator obj's underlying member method code with example usage: obj.create_training_network() and returns: DeepTPPTrainingNetwork