gavindiaz/drift
1
0
Fork 0
mirror of https://github.com/webclinic017/drift.git synced 2026-08-19 05:48:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(Naming): use new convention, added Ensemble model parameter back, support multiple Meta-Labeling models (#132)

Browse Source 
* refactor(Naming): use `primary_models` & `meta_labeling_models`

* refactor(Naming): using primary * meta_labeling across config and in pipeline

* feat(Pipeline): added back Ensemble models

* fix(Pipeline): compiler error

* fix(Config): typo

* chore(Pipeline): removed unused averaging step

* revert the changes in discretizing

* chore(Pipeline): remove sharpe improvement logging

* fix(Pipeline): ensemble predictions should be a pd.Series instead of a DataFrame

* fix(Pipeline): discard unnecessary ensemble_probabilities

* fix(Pipeline): fixes regarding various meta-labeling ensemble bugs

* fix(Reporting): use the new naming convention

* fix(Reporting): use the right variable

* feat(Sweep): new sweep for ensemble models

* fix(Sweep): config reference

* fix(Config): simplified dev config

* fix(Models): use the faster LR model

* fix(Models): use LGBM in the meta-labeling model for speed

* fix(Selection): always use the first model for feature selection, commented out caching from select_features() as it's close to redundant in terms of speed
This commit is contained in:
Mark Aron Szulyovszky
2022-01-09 17:21:06 +01:00
committed by GitHub
parent 22b3167cb9
commit b1c04afb13
20 changed files with 202 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config/config.py
+24 -67
View File
@@ -1,15 +1,14 @@
def get_default_level_1_daily_config() -> tuple[dict, dict, dict]:
def get_dev_config() -> tuple[dict, dict, dict]:
training_config = dict(
meta_labeling_lvl_1 = False,
primary_models_meta_labeling = False,
dimensionality_reduction = True,
n_features_to_select = 30,
dynamic_feature_selection = True,
expanding_window_level1 = False,
expanding_window_level2 = False,
sliding_window_size_level1 = 380,
sliding_window_size_level2 = 1,
expanding_window_primary = False,
expanding_window_meta_labeling = False,
sliding_window_size_primary = 380,
sliding_window_size_meta_labeling = 1,
retrain_every = 20,
scaler = 'minmax', # 'normalize' 'minmax' 'standardize' 'none'
)
@@ -26,76 +25,33 @@ def get_default_level_1_daily_config() -> tuple[dict, dict, dict]:
exogenous_features = ['standard_scaling'],
index_column= 'int',
method= 'classification',
no_of_classes= 'three-balanced',
no_of_classes= 'two',
narrow_format = False,
)
regression_models = ["Lasso"]
classification_models = ["KNN"]
classification_models = ["LR_two_class"]
model_config = dict(
level_1_models = regression_models if data_config['method'] == 'regression' else classification_models,
level_2_model = None
primary_models = regression_models if data_config['method'] == 'regression' else classification_models,
meta_labeling_models = [],
ensemble_model = None
)
return model_config, training_config, data_config
def get_default_level_2_hourly_config() -> tuple[dict, dict, dict]:
def get_default_ensemble_config() -> tuple[dict, dict, dict]:
training_config = dict(
meta_labeling_lvl_1 = True,
primary_models_meta_labeling = True,
dimensionality_reduction = True,
n_features_to_select = 30,
dynamic_feature_selection = True,
expanding_window_level1 = True,
expanding_window_level2 = False,
sliding_window_size_level1 = 2480,
sliding_window_size_level2 = 1,
retrain_every = 100,
scaler = 'minmax', # 'normalize' 'minmax' 'standardize' 'none'
)
data_config = dict(
assets = ['hourly_crypto'],
other_assets = [],
exogenous_data = [],
load_non_target_asset= True,
log_returns= True,
forecasting_horizon = 1,
own_features = ['level_2', 'date_days', 'lags_up_to_5'],
other_features = ['level_2'],
exogenous_features = ['standard_scaling'],
index_column= 'int',
method= 'classification',
no_of_classes= 'three-balanced',
narrow_format = False,
)
regression_models = ["Lasso", "KNN", "RF"]
regression_ensemble_model = 'KNN'
classification_models = ["LDA", "KNN", "CART", "RF", "StaticMom"]
classification_ensemble_model = 'Ensemble_Average'
model_config = dict(
level_1_models = regression_models if data_config['method'] == 'regression' else classification_models,
level_2_model = regression_ensemble_model if data_config['method'] == 'regression' else classification_ensemble_model
)
return model_config, training_config, data_config
def get_default_level_2_daily_config() -> tuple[dict, dict, dict]:
training_config = dict(
meta_labeling_lvl_1 = True,
dimensionality_reduction = True,
n_features_to_select = 30,
dynamic_feature_selection = True,
expanding_window_level1 = False,
expanding_window_level2 = True,
sliding_window_size_level1 = 380,
sliding_window_size_level2 = 240,
expanding_window_primary = False,
expanding_window_meta_labeling = True,
sliding_window_size_primary = 380,
sliding_window_size_meta_labeling = 240,
retrain_every = 20,
scaler = 'minmax', # 'normalize' 'minmax' 'standardize' 'none'
)
@@ -117,13 +73,14 @@ def get_default_level_2_daily_config() -> tuple[dict, dict, dict]:
)
regression_models = ["Lasso", "KNN", "RF"]
regression_ensemble_model = 'KNN'
classification_models = ['SVC', 'LDA', 'KNN', 'CART', 'NB', 'AB', 'RF', 'XGB_two_class', 'LGBM', 'StaticMom']
classification_ensemble_model = 'LDA'
classification_models = ['LR_two_class', 'SVC', 'KNN', 'CART', 'NB', 'AB', 'RF', 'XGB_two_class', 'LGBM', 'StaticMom']
meta_labeling_models = ['LR_two_class', 'LGBM']
ensemble_model = 'Average'
model_config = dict(
level_1_models = regression_models if data_config['method'] == 'regression' else classification_models,
level_2_model = regression_ensemble_model if data_config['method'] == 'regression' else classification_ensemble_model
primary_models = regression_models if data_config['method'] == 'regression' else classification_models,
meta_labeling_models = meta_labeling_models,
ensemble_model = ensemble_model
)
return model_config, training_config, data_config
config/preprocess.py
+11 -9
View File
@@ -21,9 +21,11 @@ def __preprocess_feature_extractors_config(data_dict: dict) -> dict:
return data_dict
def __preprocess_model_config(model_config:dict, method:str) -> dict:
model_config['level_1_models'] = [(model_name, model_map[method + '_models'][model_name]) for model_name in model_config['level_1_models']]
if model_config['level_2_model'] is not None:
model_config['level_2_model'] = (model_config['level_2_model'], model_map[method + '_models'][model_config['level_2_model']])
model_config['primary_models'] = [(model_name, model_map[method + '_models'][model_name]) for model_name in model_config['primary_models']]
if len(model_config['meta_labeling_models']) > 0:
model_config['meta_labeling_models'] = [(model_name, model_map[method + '_models'][model_name]) for model_name in model_config['meta_labeling_models']]
if model_config['ensemble_model'] is not None:
model_config['ensemble_model'] = (model_config['ensemble_model'], model_map['ensemble_models'][model_config['ensemble_model']])
return model_config
@@ -39,15 +41,15 @@ def __preprocess_data_collections_config(data_dict: dict) -> dict:
def validate_config(model_config:dict, training_config:dict, data_config:dict):
# We need to make sure there's only one output from the pipeline
# If level-2 model is there, we need more than one level-1 models to train
if model_config["level_2_model"] is not None: assert len(model_config["level_1_models"]) > 0
if len(model_config["meta_labeling_models"]) > 1: assert len(model_config["primary_models"]) > 0
# If there's no level-2 model, we need to have only one level-1 model
if model_config["level_2_model"] is None: assert len(model_config["level_1_models"]) == 1
if len(model_config["meta_labeling_models"]) == 0: assert len(model_config["primary_models"]) == 1
def get_model_name(model_config:dict) -> str:
if model_config["level_2_model"] is not None:
return model_config["level_2_model"][0]
elif len(model_config["level_1_models"]) == 1:
return model_config["level_1_models"][0][0]
if len(model_config["meta_labeling_models"]) > 0:
return model_config["meta_labeling_models"][0][0]
elif len(model_config["primary_models"]) == 1:
return model_config["primary_models"][0][0]
else:
raise Exception("No model name found")