class_docstr: Sample forecast object used for temporal point process inference. Differs
  from standard forecast objects as it does not implement fixed length
  samples. Each sample has a variable length, that is kept in a separate
  :code:`valid_length` attribute.
  
  Importantly, PointProcessSampleForecast does not implement some
  methods (such as :code:`quantile` or :code:`plot`) that are available
  in discrete time forecasts.
  
  Parameters
  ----------
  samples
      A multidimensional array of samples, of shape
      (number_of_samples, max_pred_length, target_dim). The target_dim is
      equal to 2, where the first dimension contains the inter-arrival times
      and the second - categorical marks.
  valid_length
      An array of integers denoting the valid lengths of each sample
      in :code:`samples`. That is, :code:`valid_length[0] == 2` implies
      that only the first two entries of :code:`samples[0, ...]` are
      valid "points".
  start_date
      Starting Timestamp of the sample
  freq
      The time unit of interarrival times
  prediction_interval_length
      The length of the prediction interval for which samples were drawn.
  item_id
      Item ID, if available.
  info
      Optional dictionary of additional information.
code: def __init__(
      self,
      samples: Union[mx.nd.NDArray, np.ndarray],
      valid_length: Union[mx.nd.NDArray, np.ndarray],
      start_date: pd.Timestamp,
      freq: str,
      prediction_interval_length: float,
      item_id: Optional[str] = None,
      info: Optional[Dict] = None,
  ) -> None:
      assert isinstance(
          samples, (np.ndarray, mx.nd.NDArray)
      ), "samples should be either a numpy or an mxnet array"
      assert samples.ndim == 2 or samples.ndim == 3, (
          "samples should be a 2-dimensional or 3-dimensional array."
          f" Dimensions found: {samples.ndim}"
      )
  
      assert isinstance(
          valid_length, (np.ndarray, mx.nd.NDArray)
      ), "samples should be either a numpy or an mxnet array"
      assert (
          valid_length.ndim == 1
      ), "valid_length should be a 1-dimensional array"
      assert (
          valid_length.shape[0] == samples.shape[0]
      ), "valid_length and samples should have compatible dimensions"
  
      self.samples, self.valid_length = (
          x if isinstance(x, np.ndarray) else x.asnumpy()
          for x in (samples, valid_length)
      )
  
      self._dim = samples.ndim
      self.item_id = item_id
      self.info = info
  
      assert isinstance(
          start_date, pd.Timestamp
      ), "start_date should be a pandas Timestamp object"
      self.start_date = start_date
  
      assert isinstance(freq, str), "freq should be a string"
      self.interarrival_freq = freq
  
      assert (
          prediction_interval_length > 0
      ), "prediction_interval_length must be greater than 0"
      self.prediction_interval_length = prediction_interval_length
  
      self.end_date = (
          start_date
          + to_timedelta(1, freq) * prediction_interval_length
      )
  
file_path: gluonts/src/gluonts/mx/model/tpp/forecast.py
imports: from typing import Dict, Optional, Union, cast
  import mxnet
  import numpy
  import pandas
  from pandas import to_timedelta
  from gluonts.model.forecast import Forecast
label_desc: Use image node_id 1 to create a new PointProcessSampleForecast object from inherited base classes: Forecast with example: obj = PointProcessSampleForecast(samples, valid_length, start_date, freq, prediction_interval_length, item_id, info)