def test_stacking_regressor_with_cv_gridsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='mlxtendstackingcvregressor',
pipeline_transform='standardscaler',
stacking_options=dict(layers=stack))
search_params = dict(reg__kneighborsregressor__n_neighbors=[2, 4, 5],
reg__bayesianridge__alpha_1=[1e-7, 1e-6],
reg__meta_regressor__alpha=[1.0],
tr__with_std=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 2.8)
self.assertIn(
reg.best_params_['reg__kneighborsregressor__n_neighbors'],
[2, 4, 5])
self.assertIn(reg.best_params_['reg__bayesianridge__alpha_1'],
[1e-7, 1e-6])
self.assertIn(reg.best_params_['reg__meta_regressor__alpha'], [1.0])
def test_return_incumbent(self):
X_train, X_test, y_train, y_test = load_benchmark(return_split=True)
linear_basis_fn = 'ridge'
n_regressors = 1
boosting_loss = 'ls'
line_search_options = dict(init_guess=1,
opt_method='minimize',
method='Nelder-Mead',
tol=1e-7,
options={"maxiter": 10000},
niter=None,
T=None,
loss='lad',
regularization=0.1)
base_boosting_options = dict(n_regressors=n_regressors,
boosting_loss=boosting_loss,
line_search_options=line_search_options)
index = 3
reg = Regressor(regressor_choice=linear_basis_fn,
params=dict(alpha=0.1),
target_index=index,
base_boosting_options=base_boosting_options)
reg.baseboostcv(X_train.iloc[:10, :], y_train.iloc[:10, :])
self.assertHasAttr(reg, 'return_incumbent_')
def test_baseboostcv_score(self):
X_train, X_test, y_train, y_test = load_benchmark(return_split=True)
stack = dict(regressors=['ridge', 'lgbmregressor'],
final_regressor='ridge')
line_search_options = dict(init_guess=1,
opt_method='minimize',
method='Nelder-Mead',
tol=1e-7,
options={"maxiter": 10000},
niter=None,
T=None,
loss='lad',
regularization=0.1)
base_boosting_options = dict(n_regressors=3,
boosting_loss='ls',
line_search_options=line_search_options)
reg = Regressor(regressor_choice='stackingregressor',
target_index=0,
stacking_options=dict(layers=stack),
base_boosting_options=base_boosting_options)
y_pred = reg.baseboostcv(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred)
self.assertNotHasAttr(reg, 'return_incumbent_')
self.assertGreaterEqual(score['mae'].values, 0.0)
self.assertGreaterEqual(score['mse'].values, 0.0)
self.assertLess(score['mae'].values, 2.0)
self.assertLess(score['mse'].values, 6.2)
def test_multioutput_regressorchain_randomizedsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='ridge',
pipeline_transform='standardscaler',
randomizedcv_n_iter=6,
chain_order=[2, 0, 1])
search_params = dict(reg__alpha=uniform(loc=0.01, scale=1.5),
reg__fit_intercept=[True, False],
tr__with_std=[True, False])
reg.search(X_train,
y_train,
search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 12.0)
self.assertLessEqual(reg.best_params_['reg__base_estimator__alpha'],
1.51)
self.assertGreaterEqual(reg.best_params_['reg__base_estimator__alpha'],
0.01)
self.assertIn(reg.best_params_['reg__base_estimator__fit_intercept'],
[True, False])
def test_multioutput_regressorchain_with_cv_randomizedsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='mlxtendstackingcvregressor', stacking_layer=stack,
pipeline_transform='standardscaler', chain_order=[2, 0, 1])
search_params = {'kneighborsregressor__n_neighbors': randint(low=2, high=5),
'bayesianridge__alpha_1': [1e-7, 1e-6],
'meta_regressor__alpha': [1.0]}
reg.search(X_train, y_train, search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 10.0)
self.assertLessEqual(reg.best_params_['reg__base_estimator__kneighborsregressor__n_neighbors'],
5)
self.assertGreaterEqual(reg.best_params_['reg__base_estimator__kneighborsregressor__n_neighbors'],
2)
self.assertIn(reg.best_params_['reg__base_estimator__bayesianridge__alpha_1'],
[1e-7, 1e-6])
self.assertIn(reg.best_params_['reg__base_estimator__meta_regressor__alpha'],
[1.0])
def test_multioutput_regressor_without_cv_gridsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='mlxtendstackingregressor',
pipeline_transform='standardscaler',
stacking_options=dict(layers=stack))
search_params = dict(reg__kneighborsregressor__n_neighbors=[2, 4, 5],
reg__bayesianridge__alpha_1=[1e-7, 1e-6],
reg__meta_regressor__alpha=[1.0],
tr__with_std=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 10.0)
self.assertIn(
reg.
best_params_['reg__estimator__kneighborsregressor__n_neighbors'],
[2, 4, 5])
self.assertIn(
reg.best_params_['reg__estimator__bayesianridge__alpha_1'],
[1e-7, 1e-6])
self.assertIn(
reg.best_params_['reg__estimator__meta_regressor__alpha'], [1.0])
def test_stacking_regressor_randomizedsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='stackingregressor',
stacking_layer=stack,
pipeline_transform='standardscaler')
search_params = {
'0__n_neighbors': randint(low=2, high=5),
'1__alpha_1': [1e-7, 1e-6],
'final_estimator__alpha': [1.0]
}
reg.search(X_train,
y_train,
search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 2.8)
self.assertLessEqual(reg.best_params_['reg__0__n_neighbors'], 5)
self.assertGreaterEqual(reg.best_params_['reg__0__n_neighbors'], 2)
self.assertIn(reg.best_params_['reg__1__alpha_1'], [1e-7, 1e-6])
self.assertIn(reg.best_params_['reg__final_estimator__alpha'], [1.0])
def test_multioutput_regressorchain_randomizedsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(n_estimators=10,
objective='reg:squarederror',
booster='gbtree')
reg = Regressor(regressor_choice='xgbregressor',
pipeline_transform='standardscaler',
params=params,
randomizedcv_n_iter=6,
chain_order=[2, 0, 1])
search_params = dict(reg__n_estimators=randint(low=3, high=10),
tr__with_std=[True, False])
reg.search(X_train,
y_train,
search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 42.0)
self.assertLessEqual(
reg.best_params_['reg__base_estimator__n_estimators'], 10)
self.assertGreaterEqual(
reg.best_params_['reg__base_estimator__n_estimators'], 3)
def test_stacking_regressor_without_cv_randomizedsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='mlxtendstackingregressor',
pipeline_transform='standardscaler',
stacking_options=dict(layers=stack),
randomizedcv_n_iter=6)
search_params = dict(reg__kneighborsregressor__n_neighbors=randint(
low=2, high=5),
reg__bayesianridge__alpha_1=[1e-7, 1e-6],
reg__meta_regressor__alpha=[1.0],
tr__with_std=[True, False])
reg.search(X_train,
y_train,
search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 3.0)
self.assertLessEqual(
reg.best_params_['reg__kneighborsregressor__n_neighbors'], 5)
self.assertGreaterEqual(
reg.best_params_['reg__kneighborsregressor__n_neighbors'], 2)
self.assertIn(reg.best_params_['reg__bayesianridge__alpha_1'],
[1e-7, 1e-6])
self.assertIn(reg.best_params_['reg__meta_regressor__alpha'], [1.0])
def test_benchmark(self):
_, X_test, _, y_test = load_benchmark(return_split=True)
reg = Regressor()
score = reg.score(y_test, X_test)
self.assertEqual(score['mae'].mean().round(decimals=2), 1.34)
self.assertEqual(score['mse'].mean().round(decimals=2), 4.19)
self.assertEqual(score['rmse'].mean().round(decimals=2), 1.88)
self.assertEqual(score['r2'].mean().round(decimals=2), 0.99)
self.assertEqual(score['ev'].mean().round(decimals=2), 0.99)
def test_regressor_gridsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
search_params = dict(n_estimators=[3, 5, 10])
reg = Regressor(regressor_choice='xgbregressor', pipeline_transform='standardscaler')
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 3.8)
self.assertIn(reg.best_params_['reg__n_estimators'], [3, 5, 10])
def test_multioutput_regressor_gridsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
search_params = dict(n_estimators=[3, 5, 10])
reg = Regressor(regressor_choice='xgbregressor', pipeline_transform='standardscaler')
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 10.5)
self.assertIn(reg.best_params_['reg__estimator__n_estimators'], [3, 5, 10])
def test_regressor_randomizedsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
search_params = dict(n_estimators=randint(low=3, high=10))
reg = Regressor(regressor_choice='xgbregressor', pipeline_transform='standardscaler')
reg.search(X_train, y_train, search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 4.0)
self.assertLessEqual(reg.best_params_['reg__n_estimators'], 10)
self.assertGreaterEqual(reg.best_params_['reg__n_estimators'], 3)
def test_multioutput_regressor_randomizedsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
search_params = dict(n_estimators=randint(low=3, high=10))
reg = Regressor(regressor_choice='xgbregressor', pipeline_transform='standardscaler')
reg.search(X_train, y_train, search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 12.0)
self.assertLessEqual(reg.best_params_['reg__estimator__n_estimators'], 10)
self.assertGreaterEqual(reg.best_params_['reg__estimator__n_estimators'], 3)
def test_regressor_gridsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='ridge',
pipeline_transform='standardscaler')
search_params = dict(alpha=[0.1, 0.2, 0.5],
fit_intercept=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 3.6)
self.assertIn(reg.best_params_['reg__alpha'], [0.1, 0.2, 0.5])
self.assertIn(reg.best_params_['reg__fit_intercept'], [True, False])
def test_regressor_gridsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(iterations=10, loss_function='RMSE')
reg = Regressor(regressor_choice='catboostregressor',
pipeline_transform='standardscaler',
params=params)
search_params = dict(reg__iterations=[3, 5, 10],
tr__with_std=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 3.6)
self.assertIn(reg.best_params_['reg__iterations'], [3, 5, 10])
def test_multioutput_regressorchain_fit_score(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
params = dict(n_estimators=10, objective='reg:squarederror', booster='gbtree')
reg = Regressor(regressor_choice='xgbregressor', pipeline_transform='standardscaler',
params=params, chain_order=[0, 2, 1])
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred).mean()
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'], 0.0)
self.assertGreaterEqual(score['mse'], 0.0)
self.assertLess(score['mae'], 14.0)
self.assertLess(score['mse'], 430.0)
def test_multioutput_regressor_fit_score(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='ridge',
pipeline_transform='standardscaler')
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred).mean()
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'], 0.0)
self.assertGreaterEqual(score['mse'], 0.0)
self.assertLess(score['mae'], 11.0)
self.assertLess(score['mse'], 232.0)
def test_multioutput_regressor_gridsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(iterations=10, loss_function='RMSE')
reg = Regressor(regressor_choice='catboostregressor',
pipeline_transform='standardscaler',
params=params)
search_params = dict(reg__iterations=[3, 5, 10],
tr__with_std=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 10.0)
self.assertIn(reg.best_params_['reg__estimator__iterations'],
[3, 5, 10])
def test_multioutput_regressorchain_with_cv_fit_score(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=42)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='mlxtendstackingcvregressor', stacking_layer=stack,
pipeline_transform='standardscaler', chain_order=[2, 0, 1])
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred).mean()
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'], 0.0)
self.assertGreaterEqual(score['mse'], 0.0)
self.assertLess(score['mae'], 7.0)
self.assertLess(score['mse'], 110.0)
def test_multioutput_regressor_gridsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='ridge',
pipeline_transform='standardscaler')
search_params = dict(alpha=[0.1, 0.2, 0.5],
fit_intercept=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 10.0)
self.assertIn(reg.best_params_['reg__estimator__alpha'],
[0.1, 0.2, 0.5])
self.assertIn(reg.best_params_['reg__estimator__fit_intercept'],
[True, False])
def test_with_cv_pipeline_clone_fit_score(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
transformer_list = [('pca', PCA(n_components=1)),
('svd', TruncatedSVD(n_components=2))]
union = FeatureUnion(transformer_list=transformer_list, n_jobs=-1)
stack = dict(regressors=['kneighborsregressor', 'bayesianridge'],
final_regressor='lasso')
reg = Regressor(regressor_choice='mlxtendstackingcvregressor',
pipeline_transform=('tr', union),
stacking_options=dict(layers=stack))
reg.get_pipeline(y=y_train)
_class_before_clone = reg.pipe.__class__
reg.pipe = clone(reg.pipe)
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred)
self.assertEqual(_class_before_clone, reg.pipe.__class__)
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'].values, 0.0)
self.assertGreaterEqual(score['mse'].values, 0.0)
self.assertLess(score['mae'].values, 11.0)
self.assertLess(score['mse'].values, 232.0)
def test_pipeline_clone_fit_score(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
transformer_list = [('pca', PCA(n_components=1)),
('svd', TruncatedSVD(n_components=2))]
union = FeatureUnion(transformer_list=transformer_list, n_jobs=-1)
params = dict(n_estimators=10,
objective='reg:squarederror',
booster='gbtree')
reg = Regressor(regressor_choice='xgbregressor',
pipeline_transform=('tr', union),
params=params)
reg.get_pipeline(y=y_train)
_class_before_clone = reg.pipe.__class__
reg.pipe = clone(reg.pipe)
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred)
self.assertEqual(_class_before_clone, reg.pipe.__class__)
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'].values, 0.0)
self.assertGreaterEqual(score['mse'].values, 0.0)
self.assertLess(score['mae'].values, 11.0)
self.assertLess(score['mse'].values, 232.0)
def test_multioutput_regressorchain_gridsearchcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(n_estimators=3, objective='mean_squared_error')
reg = Regressor(regressor_choice='lgbmregressor',
pipeline_transform='standardscaler',
params=params,
chain_order=[2, 0, 1])
search_params = dict(reg__n_estimators=[3, 5, 10],
tr__with_std=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 10.0)
self.assertIn(reg.best_params_['reg__base_estimator__n_estimators'],
[3, 5, 10])
def test_multioutput_regressor_fit_score(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(n_estimators=3, objective='mean_squared_error')
reg = Regressor(regressor_choice='lgbmregressor',
pipeline_transform='standardscaler',
params=params)
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred).mean()
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'], 0.0)
self.assertGreaterEqual(score['mse'], 0.0)
self.assertLess(score['mae'], 8.1)
self.assertLess(score['mse'], 122.5)
def test_regressor_gridsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(n_estimators=10,
objective='reg:squarederror',
booster='gbtree')
reg = Regressor(regressor_choice='xgbregressor',
pipeline_transform='standardscaler',
params=params)
search_params = dict(reg__n_estimators=[3, 5, 10],
tr__with_std=[True, False])
reg.search(X_train, y_train, search_params=search_params)
self.assertLess(reg.best_score_.values, 9.0)
self.assertIn(reg.best_params_['reg__n_estimators'], [3, 5, 10])
def test_regressor_randomizedsearchcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='ridge',
pipeline_transform='standardscaler')
search_params = dict(alpha=uniform(loc=0.01, scale=1.5),
fit_intercept=[True, False])
reg.search(X_train,
y_train,
search_params=search_params,
search_method='randomizedsearchcv')
self.assertLess(reg.best_score_.values, 3.6)
self.assertLessEqual(reg.best_params_['reg__alpha'], 1.51)
self.assertGreaterEqual(reg.best_params_['reg__alpha'], 0.01)
self.assertIn(reg.best_params_['reg__fit_intercept'], [True, False])
def test_multioutput_regressorchain_fit_score(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
params = dict(iterations=10, loss_function='RMSE')
reg = Regressor(regressor_choice='catboostregressor',
pipeline_transform='standardscaler',
params=params,
chain_order=[0, 2, 1])
y_pred = reg.fit(X_train, y_train).predict(X_test)
score = reg.score(y_test, y_pred).mean()
self.assertCountEqual(y_pred.index, y_test.index)
self.assertGreaterEqual(score['mae'], 0.0)
self.assertGreaterEqual(score['mse'], 0.0)
self.assertLess(score['mae'], 11.0)
self.assertLess(score['mse'], 240.0)
def test_regressor_bayesoptcv(self):
X, y = load_boston(return_X_y=True)
X, y = pd.DataFrame(X), pd.Series(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='svr',
pipeline_transform='standardscaler')
search_pbounds = dict(gamma=(0.1, 2.0), epsilon=(0.1, 0.4))
reg.search(X_train,
y_train,
search_params=search_pbounds,
search_method='bayesoptcv')
self.assertLess(reg.best_score_.values, 3.7)
self.assertLessEqual(reg.best_params_['reg__gamma'], 2.0)
self.assertGreaterEqual(reg.best_params_['reg__gamma'], 0.1)
self.assertLessEqual(reg.best_params_['reg__epsilon'], 0.4)
self.assertGreaterEqual(reg.best_params_['reg__epsilon'], 0.1)
def test_multioutput_regressor_bayesoptcv(self):
bunch = load_linnerud(as_frame=True) # returns a Bunch instance
X, y = bunch['data'], bunch['target']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=42)
reg = Regressor(regressor_choice='svr',
pipeline_transform='standardscaler')
search_pbounds = dict(gamma=(0.1, 2.0), epsilon=(0.1, 0.4))
reg.search(X_train,
y_train,
search_params=search_pbounds,
search_method='bayesoptcv')
self.assertLess(reg.best_score_.values, 10.0)
self.assertLessEqual(reg.best_params_['reg__estimator__gamma'], 2.0)
self.assertGreaterEqual(reg.best_params_['reg__estimator__gamma'], 0.1)
self.assertLessEqual(reg.best_params_['reg__estimator__epsilon'], 0.4)
self.assertGreaterEqual(reg.best_params_['reg__estimator__epsilon'],
0.1)
