gluonts.transform.split module

class gluonts.transform.split.CanonicalInstanceSplitter(target_field: str, is_pad_field: str, start_field: str, forecast_start_field: str, instance_sampler: gluonts.transform.sampler.InstanceSampler, instance_length: int, output_NTC: bool = True, time_series_fields: List[str] = [], allow_target_padding: bool = False, pad_value: float = 0.0, use_prediction_features: bool = False, prediction_length: Optional[int] = None)[source]

Bases: gluonts.transform._base.FlatMapTransformation

Selects instances, by slicing the target and other time series like arrays at random points in training mode or at the last time point in prediction mode. Assumption is that all time like arrays start at the same time point.

In training mode, the returned instances contain past_`target_field` as well as past_`time_series_fields`.

In prediction mode, one can set use_prediction_features to get future_`time_series_fields`.

If the target array is one-dimensional, the target_field in the resulting instance has shape (instance_length). In the multi-dimensional case, the instance has shape (dim, instance_length), where dim can also take a value of 1.

In the case of insufficient number of time series values, the transformation also adds a field ‘past_is_pad’ that indicates whether values where padded or not, and the value is padded with default_pad_value with a default value 0. This is done only if allow_target_padding is True, and the length of target is smaller than instance_length.

Parameters
  • target_field – fields that contains time-series

  • is_pad_field – output field indicating whether padding happened

  • start_field – field containing the start date of the time series

  • forecast_start_field – field containing the forecast start date

  • instance_sampler – instance sampler that provides sampling indices given a time-series

  • instance_length – length of the target seen before making prediction

  • output_NTC – whether to have time series output in (time, dimension) or in (dimension, time) layout

  • time_series_fields – fields that contains time-series, they are split in the same interval as the target

  • allow_target_padding – flag to allow padding

  • pad_value – value to be used for padding

  • use_prediction_features – flag to indicate if prediction range features should be returned

  • prediction_length – length of the prediction range, must be set if use_prediction_features is True

flatmap_transform(data: Dict[str, Any], is_train: bool) → Iterator[Dict[str, Any]][source]
class gluonts.transform.split.ContinuousTimeInstanceSplitter(past_interval_length: float, future_interval_length: float, train_sampler: gluonts.transform.sampler.ContinuousTimePointSampler, target_field: str = 'target', start_field: str = 'start', end_field: str = 'end', forecast_start_field: str = 'forecast_start')[source]

Bases: gluonts.transform._base.FlatMapTransformation

Selects training instances by slicing “intervals” from a continous-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) interarrival times between consecutive points, in order and (ii) integer identifiers of marks (from {0, 1, …, 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: [[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

flatmap_transform(data: Dict[str, Any], is_train: bool) → Iterator[Dict[str, Any]][source]
class gluonts.transform.split.InstanceSplitter(target_field: str, is_pad_field: str, start_field: str, forecast_start_field: str, train_sampler: gluonts.transform.sampler.InstanceSampler, past_length: int, future_length: int, lead_time: int = 0, output_NTC: bool = True, time_series_fields: Optional[List[str]] = None, pick_incomplete: bool = True, dummy_value: float = 0.0)[source]

Bases: gluonts.transform._base.FlatMapTransformation

Selects training instances, by slicing the target and other time series like arrays at random points in training mode or at the last time point in prediction mode. Assumption is that all time like arrays start at the same time point.

The target and each time_series_field is removed and instead two corresponding fields with prefix past_ and future_ are included. E.g.

If the target array is one-dimensional, the resulting instance has shape (len_target). In the multi-dimensional case, the instance has shape (dim, len_target).

target -> past_target and future_target

The transformation also adds a field ‘past_is_pad’ that indicates whether values where padded or not.

Convention: time axis is always the last axis.

Parameters
  • target_field – field containing the target

  • is_pad_field – output field indicating whether padding happened

  • start_field – field containing the start date of the time series

  • forecast_start_field – output field that will contain the time point where the forecast starts

  • train_sampler – instance sampler that provides sampling indices given a time-series

  • past_length – length of the target seen before making prediction

  • future_length – length of the target that must be predicted

  • lead_time – gap between the past and future windows (default: 0)

  • output_NTC – whether to have time series output in (time, dimension) or in (dimension, time) layout (default: True)

  • time_series_fields – fields that contains time-series, they are split in the same interval as the target (default: None)

  • pick_incomplete – whether training examples can be sampled with only a part of past_length time-units present for the time series. This is useful to train models for cold-start. In such case, is_pad_out contains an indicator whether data is padded or not. (default: True)

  • dummy_value – Value to use for padding. (default: 0.0)

flatmap_transform(data: Dict[str, Any], is_train: bool) → Iterator[Dict[str, Any]][source]
gluonts.transform.split.shift_timestamp(ts: pandas._libs.tslibs.timestamps.Timestamp, offset: int) → pandas._libs.tslibs.timestamps.Timestamp[source]

Computes a shifted timestamp.

Basic wrapping around pandas ts + offset with caching and exception handling.