FastPropModel

class getml.feature_learning.FastPropModel(aggregation: List[str] = <factory>, loss_function: str = 'SquareLoss', min_df: int = 30, n_most_frequent: int = 0, num_features: int = 200, num_threads: int = 0, sampling_factor: float = 1.0, silent: bool = True, vocab_size: int = 500)

Generates simple features based on propositionalization.

FastPropModel generates simple and easily interpretable features for relational data and time series. It is based on a propositionalization approach and has been optimized for speed and memory efficiency. FastPropModel generates a large number of features and selects the most relevant ones based on the pair-wise correlation with the target(s).

It is recommended to combine FastPropModel with the Mapping and Seasonal preprocessors, which can drastically improve predictive accuracy.

Args:

aggregation (List[aggregations], optional):

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

Must be from aggregations.

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.

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\)]

num_features (int, optional):

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

n_most_frequent (int, optional):

FastPropModel can find the N most frequent categories in a categorical column and derive features from them. The parameter determines how many categories should be used. Range: [0, \(\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\)]

sampling_factor (float, optional):

FastProp 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 2,000 samples are drawn from the population table. If the population table contains less than 2,000 samples, it will use standard bagging. When set to 0.0, there will be no sampling at all. Range: [0, \(\infty\)]

silent (bool, optional):

Controls the logging during training.

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:

population_placeholder = getml.data.Placeholder("population")
order_placeholder = getml.data.Placeholder("order")
trans_placeholder = getml.data.Placeholder("trans")

population_placeholder.join(order_placeholder,
                            join_key="account_id")

population_placeholder.join(trans_placeholder,
                            join_key="account_id",
                            time_stamp="date")

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

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

agg = getml.feature_learning.aggregations

feature_learner = getml.feature_learning.FastPropModel(
    aggregation=[
        agg.Avg,
        agg.Count,
        agg.Max,
        agg.Median,
        agg.Min,
        agg.Sum,
        agg.Var
    ],
    num_features=200,
    loss_function=getml.feature_learning.loss_functions.CrossEntropyLoss
)

pipe = getml.pipeline.Pipeline(
    tags=["dfs"],
    population=population_placeholder,
    peripheral=[order_placeholder, trans_placeholder],
    feature_learners=feature_learner,
    feature_selectors=feature_selector,
    predictors=predictor,
    share_selected_features=0.5
)

pipe.check(
    population_table=population_train,
    peripheral_tables={"order": order, "trans": trans}
)

pipe = pipe.fit(
    population_table=population_train,
    peripheral_tables={"order": order, "trans": trans}
)

in_sample = pipe.score(
    population_table=population_train,
    peripheral_tables={"order": order, "trans": trans}
)

out_of_sample = pipe.score(
    population_table=population_test,
    peripheral_tables={"order": order, "trans": trans}
)

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
aggregation
loss_function
min_df
n_most_frequent
num_features
num_threads
sampling_factor
silent
type
vocab_size