def test_auto_ensemble_trainer():
for anova_estimator in ['LinearRegression', 'RandomForestRegressor']:
assert check(automl_run,
boston_dataset,
boston_label,
task='prediction',
base_layer_models=[
'LinearRegression', 'Ridge', 'Lasso',
'DecisionTreeRegressor', 'RandomForestRegressor',
'ExtraTreesRegressor', 'AdaBoostRegressor',
'GradientBoostingRegressor'
],
meta_layer_models=[anova_estimator],
max_evals=10)
for anova_estimator in ['LogisticRegression', 'RandomForestClassifier']:
assert check(automl_run,
diabetes_dataset,
diabetes_label,
task='classification',
base_layer_models=[
'LogisticRegression', 'DecisionTreeClassifier',
'RandomForestClassifier',
'GradientBoostingClassifier', 'ExtraTreesClassifier',
'AdaBoostClassifier'
],
meta_layer_models=[anova_estimator],
max_evals=10)
def test_load_dataset():
for name in [
'boston', 'carprice', 'diabetes', 'heart_disease', 'salary',
'titanic'
]:
assert check(load_dataset, name)
assert check(load_dataset, 'literally_any_other_name') == False
# test_load_dataset()
def test_get_model_metrics_ensemble():
boston_train_X, boston_test_X, boston_train_y, boston_test_y = dataset_split(
boston_dataset, boston_label)
model = LinearRegression()
model.fit(boston_train_X, boston_train_y)
assert check(get_model_metrics_ensemble, [], 'prediction', boston_test_y,
model.predict(boston_test_X))
diabetes_train_X, diabetes_test_X, diabetes_train_y, diabetes_test_y = dataset_split(
diabetes_dataset, diabetes_label)
model = LogisticRegression()
model.fit(diabetes_train_X, diabetes_train_y)
assert check(get_model_metrics_ensemble, [0, 1], 'classification',
diabetes_test_y, model.predict(diabetes_test_X))
def test_auto_trainer():
for model in ['LinearRegression']:
# auto_trainer(boston_dataset, boston_label, models=[model] ,task='prediction', anova_estimator=model)
assert check(auto_trainer,
boston_dataset,
boston_label,
models=[model],
task='prediction',
anova_estimator=model)
for model in ['LogisticRegression']:
assert check(auto_trainer,
diabetes_dataset,
diabetes_label,
models=[model],
task='classification',
anova_estimator=model)
def test_dataset_split():
assert check(dataset_split, boston_dataset, boston_label, test_size=0.3)
split_datasets = dataset_split(boston_dataset, boston_label, test_size=0.3)
other_split_datasets = dataset_split(boston_dataset,
boston_label,
test_size=0.3)
# the datasets should be same since the random_state is same
assert [(split_datasets[i] == other_split_datasets[i]).all().all()
for i in range(4)] == [True] * 4
def test_bayesian_tpe():
for model in [LinearRegression, Lasso, Ridge]:
assert check(bayesian_tpe,
model,
boston_X_train,
boston_X_test,
boston_y_train,
boston_y_test,
'prediction',
max_evals=10)
for model in [LogisticRegression, RandomForestClassifier]:
assert check(bayesian_tpe,
model,
diabetes_X_train,
diabetes_X_test,
diabetes_y_train,
diabetes_y_test,
'classification',
max_evals=10)
def test_hpo():
for model in [LinearRegression, Lasso, Ridge]:
for method_name in ['grid_search', 'random_search', 'bayesian_tpe']:
# get_trained_model(boston_dataset, boston_label, model.__name__, 'prediction', method_name)
assert check(get_trained_model,
boston_dataset,
boston_label,
model.__name__,
'prediction',
method_name,
max_evals=10)
for model in [LogisticRegression, RandomForestClassifier]:
for method_name in ['grid_search', 'random_search', 'bayesian_tpe']:
assert check(get_trained_model,
diabetes_dataset,
diabetes_label,
model.__name__,
'classification',
method_name,
max_evals=10)
def test_SuperLearnerClassifier():
def test_func(meta_model, new_models):
meta_model = meta_model or 'RandomForestClassifier'
super_learner_obj = SuperLearnerClassifier(meta_model=meta_model)
if new_models:
super_learner_obj.add_models(new_models)
diabetes_train_X, diabetes_test_X, diabetes_train_y, diabetes_test_y = dataset_split(
diabetes_dataset, diabetes_label)
super_learner_obj.fit(diabetes_train_X, diabetes_train_y)
super_learner_obj.predict(diabetes_test_X)
new_models = [
'DecisionTreeClassifier', 'RandomForestClassifier',
'ExtraTreesClassifier', 'AdaBoostClassifier',
'GradientBoostingClassifier'
]
assert check(test_func, 'AdaBoostClassifier', None)
assert check(test_func, 'AdaBoostClassifier', new_models)
assert check(test_func, None, new_models)
assert check(test_func, 'LogisticRegression', None)
assert check(test_func, 'LogisticRegression', new_models)
def test_SuperLearnerRegressor():
def test_func(meta_model, new_models):
meta_model = meta_model or 'RandomForestRegressor'
super_learner_obj = SuperLearnerRegressor(meta_model=meta_model)
if new_models:
super_learner_obj.add_models(new_models)
boston_train_X, boston_test_X, boston_train_y, boston_test_y = dataset_split(
boston_dataset, boston_label)
super_learner_obj.fit(boston_train_X, boston_train_y)
super_learner_obj.predict(boston_test_X)
new_models = [
'DecisionTreeRegressor', 'RandomForestRegressor',
'ExtraTreesRegressor', 'AdaBoostRegressor', 'GradientBoostingRegressor'
]
# assert check(test_func, None, None)
# assert check(test_func, 'AdaBoostRegressor', None)
assert check(test_func, 'AdaBoostRegressor', new_models)
assert check(test_func, None, new_models)
assert check(test_func, 'LinearRegression', None)
assert check(test_func, 'LinearRegression', new_models)
def test_correlation_matrix():
assert check(correlation_matrix, boston_dataset, boston_label)
assert check(correlation_matrix, titanic_dataset, titanic_label)
def test_random_search():
for model in [LinearRegression, Lasso, Ridge]:
assert check(random_search, model, boston_X_train, boston_y_train)
for model in [LogisticRegression, RandomForestClassifier]:
assert check(random_search, model, diabetes_X_train, diabetes_y_train)
def test_grid_search():
for model in [LinearRegression, Lasso, Ridge]:
# grid_search(boston_dataset, boston_label, model)
assert check(grid_search, model, boston_X_train, boston_y_train)
for model in [LogisticRegression, RandomForestClassifier]:
assert check(grid_search, model, diabetes_X_train, diabetes_y_train)
def test_pca():
assert check(pca, boston_dataset, boston_label)
assert check(pca, diabetes_dataset, diabetes_label)
def test_anova_regressor():
assert check(anova_regressor, boston_dataset, boston_label)
assert check(anova_regressor, boston_dataset, boston_label, 'LinearRegression')
def test_anova_classifier():
assert check(anova_classifier, diabetes_dataset, diabetes_label)
assert check(anova_classifier, diabetes_dataset, diabetes_label, 'LogisticRegression')
def test_preprocess_data():
assert check(preprocess_data, boston_dataset, boston_label, 'regression')
assert check(preprocess_data, boston_dataset, boston_label,
'classification') == False
def test_select_from_model():
assert check(select_from_model, boston_dataset, boston_label,
LinearRegression)
assert check(select_from_model, diabetes_dataset, diabetes_label,
LogisticRegression)
def test_oversampling():
assert check(oversampling, boston_dataset, boston_label) == False
assert check(oversampling, titanic_dataset, titanic_label)
def test_label_encode():
assert check(label_encode, titanic_dataset, titanic_label)
def test_remove_null():
assert check(remove_null, boston_dataset, boston_label)
assert check(remove_null, titanic_dataset, titanic_label)