Overview

GitHub Tutorials

Search…

Overview

Installation

walkthrough

Hyperparameter Optimization

CLI

Configuring KTS

Overview

Modular Feature Engineering
Define features as independent blocks to organize your projects.
Source Code Tracking
Track source code of every feature and experiment to make each of them reproducible.
Parallel Computing and Caching
Compute independent features in parallel. Cache them to avoid repeated computations. 
Experiment Tracking
Track your progress with local leaderboards. 
Feature Selection
Compute feature importances and select features from any experiment with experiment.feature_importances() and experiment.select().
Easy Stacking
Design stacked ensembles of any complexity with stl.stack().
Safe Validation
Compute stateful features, such as target encoding, after CV split to avoid target leakage.
End-to-end Experiment Inference
Automatically compute all your features and run models just with experiment.predict(test_frame).
Interactivity and Rich Reports
Monitor the progress of everything going on in KTS with our interactive reports. From model fitting to computing feature importances. 
Clean API
Features are defined as decorated functions. Then they are collected into features sets. Features may save state between training and inference stages. They can also be nested, i.e. use other features inside. In case of possible target leakage, stateful feature can be computed after CV split.
1
@feature
2
def simple_feature(df):
3
    res = stl.empty_like(df)
4
    res['c'] = df['a'] - df['b']
5
    res['d'] = df['a'] * df['b']
6
    return res
7
   
8
from somelib import Encoder
9
​
10
@feature
11
def stateful_feature(df):
12
    res = simple_feature(df)
13
    if df.train:
14
        enc = Encoder()
15
        res = enc.fit_transform(...)
16
        df.state['enc'] = enc
17
    else:
18
        enc = df.state['enc']
19
        res = enc.transform(...)
20
    ...
21
    return res 
22
    
23
fs = FeatureSet(before_split=[simple_feature], 
24
                after_split=[stateful_feature],
25
                train_frame=train,
26
                targets='Survived')
Copied!
Feature Engineering
KTS provides wrappers for most frequently used models for regression and binary and multiclass classification tasks. Other models can also be easily wrapped.
1
from kts.models import binary
2
​
3
model = binary.CatBoostClassifier(rsm=0.2)
Copied!
Modelling
Validation strategies are defined by splitter and metric. In more advanced cases you can subclass Validator and define your own validation strategy using auxiliary data (e.g. time series or groups for either splitting or evaluation).
1
from sklearn.metrics import roc_auc_score
2
from sklearn.model_selection import StratifiedKFold
3
​
4
skf = StratifiedKFold(5, True, 42)
5
val = Validator(skf, roc_auc_score)
6
​
7
summary = val.score(model, fs)
8
exp_id = summary['id']
Copied!
Validation
Stacking is easy with stl.stack that behaves as an ordinary feature and can be simply added to any feature set. To avoid target leakage, use noise or special splitters.
1
val_splitter = ...
2
val_stack = Validator(val_splitter, roc_auc_score)
3
​
4
model_stack = binary.LogisticRegression(C=10)
5
fs_stack = FeatureSet([..., stl.stack(exp_id)], ...)
6
​
7
summary_stack = val_stack.score(model_stack, fs_stack)
8
stack_id = summary_stack['id']
Copied!
Stacking
Any experiment, even stacked, automatically computes all its features and runs all models. All you need is experiment.predict(test_frame).
1
model = leaderboard[exp_id]
2
model_stack = leaderboard[stack_id]
3
​
4
model.predict(test_frame)
5
model_stack.predict(test_frame)
Copied!
Get started
Start exploring KTS with our tutorials:
Tutorials

Installation

Last modified 1yr ago

Copy link

Contents

Modular Feature Engineering

Source Code Tracking

Parallel Computing and Caching

End-to-end Experiment Inference

Interactivity and Rich Reports

Clean API

Get started