gavindiaz/drift
1
0
Fork 0
mirror of https://github.com/webclinic017/drift.git synced 2026-08-07 16:17:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refractor(Main Pipeline): Refractored the two main steps and the data processing. (#156)

Browse Source 
* refr: Took out main primary and secondary loops and data processing.

* feat: Tidied the code up.

* feat: Saving models and results now works in a type safe way.

* fix: There was error in the saving function.

* chore: Took out some remaining comments.

* fix: Fixed the previous data checking process.

* feat: Fixed model selection method. I will continue the inference after we merged.

Co-authored-by: Daniel Szemerey <szemereydaniel@gmail.com>
This commit is contained in:
Daniel Szemerey
2022-01-12 23:10:18 +01:00
committed by GitHub
parent c611481eb6
commit 3084f5e271
9 changed files with 277 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files
training/inference.py
+22 -17
View File
@@ -4,46 +4,51 @@ from data_loader.load_data import load_data
from typing import Optional, Union
import warnings
from utils.encapsulation import Asset, Single_Model, Training_Step
def run_inference_pipeline(data_config:dict, training_config:dict, all_models_all_assets:dict):
def run_inference_pipeline(data_config:dict, training_config:dict, all_models_all_assets:list[Asset]):
data_params = data_config.copy()
data_params['target_asset'] = data_params['assets'][0]
X, y, _ = load_data(**data_params)
input_features = __select_data(X, training_config)
primary_models, secondary_models = __select_models(data_params, all_models_all_assets)
primary_step, secondary_step = __select_models(data_params, all_models_all_assets)
result = __inference(input_features, primary_models, secondary_models)
result = __inference(input_features, primary_step, secondary_step)
return result
def __inference(data:pd.DataFrame, primary_models:Union[dict,None], secondary_models:Union[dict,None]) -> pd.DataFrame:
assert primary_models is not None, "No primary models found. Cancelling Inference."
def __inference(data:pd.DataFrame, primary_step:Union[Training_Step,None], secondary_step:Union[Training_Step,None]) -> pd.DataFrame:
assert primary_step is not None, "No primary models found. Cancelling Inference."
data = __primary_models(data, primary_models)
data = __primary_models(data, primary_step)
if secondary_models is not None:
if secondary_step is not None:
warnings.warn("Secondary models are not specified.")
data = __secondary_models(data, secondary_models)
data = __secondary_models(data, secondary_step)
return data
def __select_models( data_params:dict, all_models_all_assets:dict)-> tuple[Optional[dict],Optional[dict]]:
def __select_models( data_params:dict, all_models_all_assets:list[Asset])-> tuple[Union[Training_Step,None], Union[Training_Step, None]]:
target_asset_name = data_params['target_asset'][1]
primary_models, secondary_models = None, None
primary_step, secondary_step, = None, None
target_asset_models = next((x for x in all_models_all_assets if x.name == target_asset_name), None)
if 'primary_models' in all_models_all_assets[target_asset_name]:
primary_models = all_models_all_assets[target_asset_name]['primary_models']
if target_asset_models is not None:
if len(target_asset_models.primary.base)>0:
primary_step = target_asset_models.primary
else: warnings.warn("No primary models found for {}.".format(target_asset_name))
if len(target_asset_models.secondary.base)>0:
secondary_step = target_asset_models.secondary
else: warnings.warn("No secondary models found for {}.".format(target_asset_name))
else:
assert("No primary models found for asset: " + target_asset_name)
assert("No models found for asset: " + target_asset_name)
if 'secondary_model' in all_models_all_assets[target_asset_name]:
secondary_models = all_models_all_assets[target_asset_name]['secondary_model']
return primary_models, secondary_models
return primary_step, secondary_step
def __select_data(X:pd.DataFrame, training_config:dict)-> pd.DataFrame:
training/meta_labeling.py
+4 -1
View File
@@ -5,6 +5,7 @@ from feature_selection.feature_selection import select_features
import pandas as pd
from models.model_map import default_feature_selector_regression, default_feature_selector_classification
from models.base import Model
from utils.encapsulation import Single_Model
def train_meta_labeling_model(
@@ -18,8 +19,9 @@ def train_meta_labeling_model(
model_config: dict,
training_config: dict,
model_suffix: str
) -> tuple[pd.Series, pd.Series, pd.DataFrame, dict]:
) -> tuple[pd.Series, pd.Series, pd.DataFrame, list[Single_Model]]:
discretize = discretize_threeway_threshold(0.33)
discretized_predictions = input_predictions.apply(discretize)
meta_y: pd.Series = pd.concat([discretized_predictions, y], axis=1).apply(equal_except_nan, axis = 1)
@@ -67,5 +69,6 @@ def train_meta_labeling_model(
discretize=False
)
meta_result.rename("model_" + target_asset + "_" + model_suffix, inplace=True)
return meta_result, avg_predictions_with_sizing, meta_probabilities, all_models_single_asset
training/primary_model.py
+12 -8
View File
@@ -5,6 +5,7 @@ from utils.evaluate import evaluate_predictions
from models.base import Model
from utils.scaler import get_scaler
from utils.types import ScalerTypes
from utils.encapsulation import Training_Step, Single_Model, Asset
def train_primary_model(
ticker_to_predict: str,
@@ -20,15 +21,17 @@ def train_primary_model(
scaler: ScalerTypes,
no_of_classes: Literal['two', 'three-balanced', 'three-imbalanced'],
level: str,
print_results: bool
) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, dict]:
print_results: bool,
) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, list[Single_Model]]:
scaler = get_scaler(scaler)
results = pd.DataFrame()
all_models_single_asset = dict()
predictions = pd.DataFrame(index=y.index)
probabilities = pd.DataFrame(index=y.index)
all_models_single_asset:list[Single_Model] = []
for model_name, model in models:
model_over_time, scaler_over_time = walk_forward_train(
@@ -65,15 +68,16 @@ def train_primary_model(
levelname=("_" + level) if level=='metalabeling' else ""
column_name = "model_" + model_name + "_" + ticker_to_predict + levelname
results[column_name] = result
all_models_single_asset[column_name]=dict()
all_models_single_asset[column_name][level] = model_over_time.tolist()
# all_models_single_asset[model_name]=dict()
# all_models_single_asset[model_name][level] = model_over_time.tolist()
all_models_single_asset.append(Single_Model(model_name=column_name, model_over_time=model_over_time.tolist()))
# column names for model outputs should be different, so we can differentiate between original data and model predictions later, where necessary
predictions[column_name] = preds
probs_column_name = "probs_" + ticker_to_predict + "_" + model_name + "_" + level
probs.columns = [probs_column_name + "_" + c for c in probs.columns]
probabilities = pd.concat([probabilities, probs], axis=1)
return results, predictions, probabilities, all_models_single_asset
training/training_steps.py
+117
View File
@@ -0,0 +1,117 @@
import pandas as pd
from operator import itemgetter
from training.primary_model import train_primary_model
from training.meta_labeling import train_meta_labeling_model
from utils.encapsulation import Reporting, Asset, Single_Model, Training_Step
def primary_step(X: pd.DataFrame, y:pd.Series, original_X:pd.DataFrame, X_pca:pd.DataFrame, asset:list, target_returns:pd.Series, configs: dict, reporting: Reporting) -> tuple[Training_Step, pd.DataFrame]:
training_step = Training_Step(level='primary')
model_config, training_config, data_config = itemgetter('model_config', 'training_config', 'data_config')(configs)
# 3. Train Primary models
current_result, current_predictions, current_probabilities, all_models_for_single_asset = train_primary_model(
ticker_to_predict = asset[1],
original_X = original_X,
X = X,
y = y,
target_returns = target_returns,
models = model_config['primary_models'],
method = data_config['method'],
expanding_window = training_config['expanding_window_primary'],
sliding_window_size = training_config['sliding_window_size_primary'],
retrain_every = training_config['retrain_every'],
scaler = training_config['scaler'],
no_of_classes = data_config['no_of_classes'],
level = 'primary',
print_results= True
)
training_step.base = all_models_for_single_asset
# 4. Train a Meta-Labeling model for each Primary model and replace their predictions with the meta-labeling predictions
if training_config['primary_models_meta_labeling'] == True:
for model_name in current_result.columns:
primary_model_predictions = current_predictions[model_name]
primary_meta_result, primary_meta_preds, primary_meta_probabilities, meta_labeling_models = train_meta_labeling_model(
target_asset=asset[1],
X_pca = X_pca,
input_predictions= primary_model_predictions,
y = y,
target_returns = target_returns,
models = model_config['meta_labeling_models'],
data_config= data_config,
model_config= model_config,
training_config= training_config,
model_suffix = 'meta'
)
current_result[model_name] = primary_meta_result
current_predictions[model_name] = primary_meta_preds
training_step.metalabeling.append(meta_labeling_models)
reporting.results = pd.concat([reporting.results, current_result], axis=1)
# With static models, because of the lag in the indicator, the first prediction is NA, so we fill it with zero.
reporting.all_predictions = pd.concat([reporting.all_predictions, current_predictions], axis=1).fillna(0.)
reporting.all_probabilities = pd.concat([reporting.all_probabilities, current_probabilities], axis=1).fillna(0.)
return training_step, current_predictions
def secondary_step(X:pd.DataFrame, y:pd.Series, original_X:pd.DataFrame, X_pca:pd.DataFrame, current_predictions:pd.DataFrame, asset:list, target_returns:pd.Series, configs: dict, reporting: Reporting) -> Training_Step:
training_step = Training_Step(level='secondary')
model_config, training_config, data_config = itemgetter('model_config', 'training_config', 'data_config')(configs)
# 5. Ensemble primary model predictions (If Ensemble model is present)
if model_config['ensemble_model'] is not None:
ensemble_result, ensemble_predictions, _, ensemble_models_one_asset = train_primary_model(
ticker_to_predict = asset[1],
original_X = current_predictions,
X = current_predictions,
y = y,
target_returns = target_returns,
models = [model_config['ensemble_model']],
method = data_config['method'],
expanding_window = False,
sliding_window_size = 1,
retrain_every = training_config['retrain_every'],
scaler = training_config['scaler'],
no_of_classes = data_config['no_of_classes'],
level = 'ensemble',
print_results= True,
)
ensemble_result, ensemble_predictions = ensemble_result.iloc[:,0], ensemble_predictions.iloc[:,0]
training_step.base = ensemble_models_one_asset
reporting.results = pd.concat([reporting.results, ensemble_result], axis=1)
reporting.all_predictions = pd.concat([reporting.all_predictions, ensemble_predictions], axis=1)
if len(model_config['meta_labeling_models']) > 0:
# 3. Train a Meta-labeling model on the averaged level-1 model predictions
ensemble_meta_result, ensemble_meta_predictions, ensemble_meta_probabilities, ensemble_meta_labeling_models = train_meta_labeling_model(
target_asset=asset[1],
X_pca = X_pca,
input_predictions= ensemble_predictions,
y = y,
target_returns = target_returns,
models = model_config['meta_labeling_models'],
data_config= data_config,
model_config= model_config,
training_config= training_config,
model_suffix = 'ensemble'
)
training_step.metalabeling.append(ensemble_meta_labeling_models)
reporting.results = pd.concat([reporting.results, ensemble_meta_result], axis=1)
reporting.all_predictions = pd.concat([reporting.all_predictions, ensemble_meta_predictions], axis=1)
reporting.all_probabilities = pd.concat([reporting.all_probabilities, ensemble_meta_probabilities], axis=1).fillna(0.)
return training_step