class_docstr: Selects training instances by slicing "intervals" from a continuous-time
  process instantiation. Concretely, the input data is expected to describe
  an instantiation from a point (or jump) process, with the "target"
  identifying inter-arrival times and other features (marks), as described in
  detail below.
  
  The splitter will then take random points in continuous time from each
  given observation, and return a (variable-length) array of points in
  the past (context) and the future (prediction) intervals.
  
  The transformation is analogous to its discrete counterpart
  `InstanceSplitter` except that
  
  - It does not allow "incomplete" records. That is, the past and future
    intervals sampled are always complete
  - Outputs a (T, C) layout.
  - Does not accept `time_series_fields` (i.e., only accepts target fields)
    as these would typically not be available in TPP data.
  
  The target arrays are expected to have (2, T) layout where the first axis
  corresponds to the (i) inter-arrival times between consecutive points, in
  order and (ii) integer identifiers of marks (from
  {0, 1, ..., :code:`num_marks`}). The returned arrays will have (T, 2)
  layout.
  
  For example, the array below corresponds to a target array where points
  with timestamps 0.5, 1.1, and 1.5 were observed belonging to categories
  (marks) 3, 1 and 0 respectively: :code:`[[0.5, 0.6, 0.4], [3, 1, 0]]`.
  
  Parameters
  ----------
  past_interval_length
      length of the interval seen before making prediction
  future_interval_length
      length of the interval that must be predicted
  train_sampler
      instance sampler that provides sampling indices given a time series
  target_field
      field containing the target
  start_field
      field containing the start date of the of the point process observation
  end_field
      field containing the end date of the point process observation
  forecast_start_field
      output field that will contain the time point where the forecast starts
code: def __init__(
      self,
      past_interval_length: float,
      future_interval_length: float,
      freq: BaseOffset,
      instance_sampler: ContinuousTimePointSampler,
      target_field: str = FieldName.TARGET,
      start_field: str = FieldName.START,
      end_field: str = "end",
      forecast_start_field: str = FieldName.FORECAST_START,
  ) -> None:
      super().__init__()
  
      assert (
          future_interval_length > 0
      ), "Prediction interval must have length greater than 0."
  
      self.instance_sampler = instance_sampler
      self.past_interval_length = past_interval_length
      self.future_interval_length = future_interval_length
      self.target_field = target_field
      self.start_field = start_field
      self.end_field = end_field
      self.forecast_start_field = forecast_start_field
      self.freq = freq
  
imports: from typing import Iterator, List, Optional, Tuple
  import numpy
  from pandas.tseries.offsets import BaseOffset
  from gluonts.core.component import validated
  from gluonts.dataset.common import DataEntry
  from gluonts.dataset.field_names import FieldName
  from gluonts.zebras._util import pad_axis
  from ._base import FlatMapTransformation
  from .sampler import ContinuousTimePointSampler, InstanceSampler
label_desc: Use image node_id 1 to create a new ContinuousTimeInstanceSplitter object from inherited base classes: FlatMapTransformation with example: obj = ContinuousTimeInstanceSplitter(past_interval_length, future_interval_length, freq, instance_sampler, target_field, start_field, end_field, forecast_start_field)