MultirelTimeSeries¶

class getml.feature_learning.MultirelTimeSeries(aggregation: List[str] = <factory>, allow_sets: bool = True, delta_t: float = 0.0, grid_factor: float = 1.0, loss_function: str = 'SquareLoss', max_length: int = 4, min_df: int = 30, min_num_samples: int = 1, num_features: int = 100, num_subfeatures: int = 5, num_threads: int = 0, propositionalization: getml.feature_learning.fastprop_model.FastPropModel = FastPropModel(aggregation=['AVG', 'COUNT', 'COUNT DISTINCT', 'COUNT MINUS COUNT DISTINCT', 'FIRST', 'LAST', 'MAX', 'MEDIAN', 'MIN', 'MODE', 'STDDEV', 'SUM'], loss_function='SquareLoss', min_df=30, n_most_frequent=0, num_features=200, num_threads=0, sampling_factor=1.0, silent=True, vocab_size=500), regularization: float = 0.01, round_robin: bool = False, sampling_factor: float = 1.0, seed: int = 5543, share_aggregations: float = 0.0, share_conditions: float = 1.0, shrinkage: float = 0.0, silent: bool = True, use_timestamps: bool = True, vocab_size: int = 500, horizon: float = 0.0, memory: float = 0.0, self_join_keys: List[str] = <factory>, ts_name: str = '', allow_lagged_targets: bool = False)[source]¶

Feature learning for time series based on multi-relational decision tree learning.

MultirelTimeSeries automates feature learning for time series. It adds a convenience layer over MultirelModel which abstracts away the self-join over the population table.

For more information on the underlying feature learning algorithm, check out the User guide.

Args:

horizon (float, optional):

The period of time you want to look ahead to generate the predictions.

memory (float, optional):

The period of time you want to the to look back until the algorithm “forgets” the data. If you set memory to 0.0, then there will be no limit.

self_join_keys (List[str], optional):

A list of the join keys to use for the self join. If none are passed, then the self join will take place on the entire population table.

ts_name (str, optional):

The name of the time stamp column to be used. If none is passed, then the row ID will be used.

allow_lagged_targets (bool, optional):

In some time series problems, it is allowed to aggregate over target variables from the past. In others, this is not allowed. If allow_lagged_targets is set to True, you must pass a horizon that is greater than zero, otherwise you would have a data leak (an exception will be thrown to prevent this).

aggregation (List[aggregations], optional):

Mathematical operations used by the automated feature learning algorithm to create new features.

Must be from aggregations.

allow_sets (bool, optional):

Multirel can summarize different categories into sets for producing conditions. When expressed as SQL statements these sets might look like this:
t2.category IN ( 'value_1', 'value_2', ... )
This can be very powerful, but it can also produce features that are hard to read and might be prone to overfitting when the sampling_factor is too low.

delta_t (float, optional):

Frequency with which lag variables will be explored in a time series setting. When set to 0.0, there will be no lag variables.

For more information please refer to Time series. Range: [0, \(\infty\)]

grid_factor (float, optional):

Multirel will try a grid of critical values for your numerical features. A higher grid_factor will lead to a larger number of critical values being considered. This can increase the training time, but also lead to more accurate features. Range: (0, \(\infty\)]

loss_function (loss_functions, optional):

Objective function used by the feature learning algorithm to optimize your features. For regression problems use SquareLoss and for classification problems use CrossEntropyLoss.

max_length (int, optional):

The maximum length a subcondition might have. Multirel will create conditions in the form
(condition 1.1 AND condition 1.2 AND condition 1.3 )
OR ( condition 2.1 AND condition 2.2 AND condition 2.3 )
...
Using this parameter you can set the maximum number of conditions allowed in the brackets. Range: [0, \(\infty\)]

min_df (int, optional):

Only relevant for columns with role text. The minimum number of fields (i.e. rows) in text column a given word is required to appear in to be included in the bag of words. Range: [1, \(\infty\)]

min_num_samples (int, optional):

Determines the minimum number of samples a subcondition should apply to in order for it to be considered. Higher values lead to less complex statements and less danger of overfitting. Range: [1, \(\infty\)]

num_features (int, optional):

Number of features generated by the feature learning algorithm. Range: [1, \(\infty\)]

num_subfeatures (int, optional):

The number of subfeatures you would like to extract in a subensemble (for snowflake data model only). See The snowflake schema for more information. Range: [1, \(\infty\)]

num_threads (int, optional):

Number of threads used by the feature learning algorithm. If set to zero or a negative value, the number of threads will be determined automatically by the getML engine. Range: [\(0\), \(\infty\)]

propositionalization (FastPropModel, optional):

The feature learner used for joins, which are flagged to be propositionalized (through setting a join’s relationship parameter to getml.data.relationship.propositionalization)

regularization (float, optional):

Most important regularization parameter for the quality of the features produced by Multirel. Higher values will lead to less complex features and less danger of overfitting. A regularization of 1.0 is very strong and allows no conditions. Range: [0, 1]

round_robin (bool, optional):

If True, the Multirel picks a different aggregation every time a new feature is generated.

sampling_factor (float, optional):

Multirel uses a bootstrapping procedure (sampling with replacement) to train each of the features. The sampling factor is proportional to the share of the samples randomly drawn from the population table every time Multirel generates a new feature. A lower sampling factor (but still greater than 0.0), will lead to less danger of overfitting, less complex statements and faster training. When set to 1.0, roughly 20,000 samples are drawn from the population table. If the population table contains less than 20,000 samples, it will use standard bagging. When set to 0.0, there will be no sampling at all. Range: [0, \(\infty\)]

seed (Union[int,None], optional):

Seed used for the random number generator that underlies the sampling procedure to make the calculation reproducible. Internally, a seed of None will be mapped to 5543. Range: [0, \(\infty\)]

share_aggregations (float, optional):

Every time a new feature is generated, the aggregation will be taken from a random subsample of possible aggregations and values to be aggregated. This parameter determines the size of that subsample. Only relevant when round_robin is False. Range: [0, 1]

share_conditions (float, optional):

Every time a new column is tested for applying conditions, it might be skipped at random. This parameter determines the probability that a column will not be skipped. Range: [0, 1]

shrinkage (float, optional):

Since Multirel works using a gradient-boosting-like algorithm, shrinkage (or learning rate) scales down the weights and thus the impact of each new tree. This gives more room for future ones to improve the overall performance of the model in this greedy algorithm. Higher values will lead to more danger of overfitting. Range: [0, 1]

silent (bool, optional):

Controls the logging during training.

use_timestamps (bool, optional):

Whether you want to ignore all elements in the peripheral tables where the time stamp is greater than the one in the corresponding elements of the population table. In other words, this determines whether you want add the condition
t2.time_stamp <= t1.time_stamp
at the very end of each feature. It is strongly recommend to enable this behavior.

vocab_size (int, optional):

Determines the maximum number of words that are extracted in total from getml.data.roles.text columns. This can be interpreted as the maximum size of the bag of words. Range: [0, \(\infty\)]

Example:

# Our forecast horizon is 0.
# We do not predict the future, instead we infer
# the present state from current and past sensor data.
horizon = 0.0

# We do not allow the time series features
# to use target values from the past.
# (Otherwise, we would need the horizon to
# be greater than 0.0).
allow_lagged_targets = False

# We want our time series features to only use
# data from the last 15 minutes
memory = getml.data.time.minutes(15)

feature_learner = getml.feature_learning.MultirelTimeSeries(
        ts_name="date",
        horizon=horizon,
        memory=memory,
        allow_lagged_targets=allow_lagged_targets,
        num_features=30,
        loss_function=getml.feature_learning.loss_functions.CrossEntropyLoss
)

predictor = getml.predictors.XGBoostClassifier(reg_lambda=500)

pipe = getml.pipeline.Pipeline(
    tags=["memory=15", "no ts_name", "multirel"],
    feature_learners=[feature_learner],
    predictors=[predictor]
)

pipe.check(data_train)

pipe = pipe.fit(data_train)

predictions = pipe.predict(data_test)

scores = pipe.score(data_test)

Methods

validate([params])

Checks both the types and the values of all instance variables and raises an exception if something is off.

Attributes

`agg_sets`
`allow_lagged_targets`
`allow_sets`
`delta_t`
`grid_factor`
`horizon`
`loss_function`
`max_length`
`memory`
`min_df`
`min_num_samples`
`num_features`
`num_subfeatures`
`num_threads`
`propositionalization`
`regularization`
`round_robin`
`sampling_factor`
`seed`
`share_aggregations`
`share_conditions`
`shrinkage`
`silent`
`ts_name`
`type`
`use_timestamps`
`vocab_size`