def test_sklearn_lasso_cv():
# Regression
sklearn_regressor_cls = get_sklearn_learner('sklearn.linear_model.LassoCV')
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, sklearn_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=1)
assert results['Testing R-Squared'] == '0.547'
print(results['Selected Variables'])
assert results['Selected Variables'] == ['Shell weight', 'Shucked weight', 'Whole weight', \
'Shell weight.ABS(* - Q25(*))', 'Viscera weight.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - MEAN(*))', \
'Height', 'Length', 'Diameter', 'Sex_I', 'Shucked weight.ABS(* - MEDIAN(*))', 'Diameter.ABS(* - MEDIAN(*))', \
'Viscera weight.ABS(* - Q75(*))', 'Viscera weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q25(*))', 'Sex_M', \
'Sex_F', 'Shucked weight.ABS(* - Q75(*))', 'Shucked weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q75(*))', \
'Length.ABS(* - Q75(*))']
def test_lean_boosted_pytorch_regressor():
import torch
torch.manual_seed(0)
# Regression
layers = [(10, 'relu'), (5, 'relu'), (1, None)]
pt_regressor_cls = get_pytorch_dense_learner('skorch.NeuralNetRegressor',
layers,
max_epochs=10,
batch_size=100)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column],
fill_na=True)
# Model building
results = features_df.kxy.fit(target_column, pt_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=3)
assert results['Testing R-Squared'] == '0.424'
print(results['Selected Variables'])
assert results['Selected Variables'] == ['Shell weight', 'Shucked weight', 'Whole weight', \
'Shell weight.ABS(* - Q25(*))', 'Viscera weight.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - MEAN(*))', \
'Height', 'Length', 'Diameter', 'Sex_I', 'Shucked weight.ABS(* - MEDIAN(*))', 'Diameter.ABS(* - MEDIAN(*))', \
'Viscera weight.ABS(* - Q75(*))', 'Viscera weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q25(*))', 'Sex_M', \
'Sex_F', 'Shucked weight.ABS(* - Q75(*))', 'Shucked weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q75(*))']
def test_linear_regression():
regressor_cls = get_sklearn_learner(
'sklearn.linear_model.LinearRegression')
from warnings import simplefilter
from sklearn.exceptions import ConvergenceWarning
simplefilter("ignore", category=ConvergenceWarning)
fs = RFE(regressor_cls)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Feature selection
x_columns = [_ for _ in features_df.columns if _ != target_column]
x_df = features_df[x_columns]
y_df = features_df[[target_column]]
n_vars = max(x_df.shape[1] - 5, 1)
m = fs.fit(x_df, y_df, n_vars)
# Assertions
assert len(fs.selected_variables) == n_vars
assert fs.selected_variables == ['Height.ABS(* - MEDIAN(*))', 'Height.ABS(* - MEAN(*))', 'Viscera weight.ABS(* - MEDIAN(*))', \
'Shell weight', 'Diameter.ABS(* - MEAN(*))', 'Shell weight.ABS(* - MEDIAN(*))', 'Shucked weight', 'Viscera weight.ABS(* - MEAN(*))', \
'Shell weight.ABS(* - MEAN(*))', 'Diameter.ABS(* - MEDIAN(*))', 'Diameter', 'Height', 'Length.ABS(* - Q25(*))', \
'Shucked weight.ABS(* - Q75(*))', 'Height.ABS(* - Q75(*))', 'Viscera weight', 'Shell weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q75(*))', \
'Shucked weight.ABS(* - MEDIAN(*))', 'Whole weight.ABS(* - Q25(*))', 'Length', 'Shucked weight.ABS(* - MEAN(*))', 'Viscera weight.ABS(* - Q75(*))', \
'Shucked weight.ABS(* - Q25(*))', 'Whole weight', 'Whole weight.ABS(* - MEAN(*))', 'Viscera weight.ABS(* - Q25(*))', 'Whole weight.ABS(* - Q75(*))', \
'Whole weight.ABS(* - MEDIAN(*))', 'Length.ABS(* - MEDIAN(*))', 'Length.ABS(* - Q75(*))', 'Length.ABS(* - MEAN(*))', 'Shell weight.ABS(* - Q75(*))']
def test_lean_boosted_sklearn_regressor():
for clz in [
'sklearn.neighbors.KNeighborsRegressor',
'sklearn.linear_model.LassoCV',
'sklearn.linear_model.LinearRegression'
]:
# Regression
sklearn_regressor_cls = get_sklearn_learner(clz)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, sklearn_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=1)
model = results['predictor'].models[0]
feature_columns = results['Selected Variables']
x = features_df[feature_columns].values
predictions = model.predict(x)
path = '../kxy/misc/cache/%s-%s.sav' % (dataset.name, clz)
model.save(path)
loaded_model = sklearn_regressor_cls(path=path)
loaded_predictions = loaded_model.predict(x)
assert np.allclose(predictions, loaded_predictions)
def test_rfe_predictor_xgboost():
for clz in ['xgboost.XGBRegressor']:
# Regression
xgboost_regressor_cls = get_xgboost_learner(clz)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, xgboost_regressor_cls, \
problem_type='regression', feature_selection_method='rfe', rfe_n_features=5)
predictor = results['predictor']
predictions = predictor.predict(features_df)
path = '../kxy/misc/cache/%s-%s.sav' % (dataset.name, clz)
predictor.save(path)
loaded_predictor = RFEPredictor.load(path, xgboost_regressor_cls)
loaded_predictions = loaded_predictor.predict(features_df)
assert np.allclose(predictions, loaded_predictions)
def test_non_additive_lean_boosted_regressor():
# Regression
params = {
'objective': 'rmse',
'boosting_type': 'gbdt',
'num_leaves': 100,
'n_jobs': -1,
'learning_rate': 0.1,
'feature_fraction': 0.8,
'bagging_fraction': 0.8,
'verbose': -1,
}
lightgbm_regressor_cls = get_lightgbm_learner_learning_api(params, num_boost_round=10000, \
split_random_seed=42)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, lightgbm_regressor_cls, \
problem_type='regression', additive_learning=False, return_scores=True, \
n_down_perf_before_stop=1)
assert results['Testing R-Squared'] == '0.554'
assert results['Selected Variables'] == ['Shell weight', 'Shucked weight', 'Whole weight', 'Shell weight.ABS(* - Q25(*))',\
'Viscera weight.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - MEAN(*))', 'Height', 'Length', 'Diameter', 'Sex_I',\
'Shucked weight.ABS(* - MEDIAN(*))', 'Diameter.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - Q75(*))',\
'Viscera weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q25(*))', 'Sex_M', 'Sex_F']
def test_save_pfs():
# Regression
xgboost_regressor_cls = get_xgboost_learner('xgboost.XGBRegressor')
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
path = 'Abalone'
results = features_df.kxy.fit(target_column, xgboost_regressor_cls, \
problem_type='regression', feature_selection_method='pfs', \
path=path)
loaded_predictor = PFSPredictor().load(path, xgboost_regressor_cls)
feature_directions = loaded_predictor.feature_directions
assert feature_directions.shape[1] == features_df.shape[1] - 1
predictions = loaded_predictor.predict(features_df)
assert len(predictions.columns) == 1
assert target_column in predictions.columns
assert set(features_df.index).difference(set(predictions.index)) == set()
assert set(predictions.index).difference(set(features_df.index)) == set()
def test_lean_boosted_tensorflow_regressor():
import tensorflow as tf
tf.random.set_seed(0)
# Regression
layers = [(10, 'relu'), (5, 'relu'), (1, 'linear')]
loss = 'mean_absolute_error'
optimizer = 'adam'
tf_regressor_cls = get_tensorflow_dense_learner('KerasRegressor', layers, loss, optimizer=optimizer, \
epochs=10, batch_size=100)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column],
fill_na=True)
# Model building
results = features_df.kxy.fit(target_column, tf_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=3)
assert results['Testing R-Squared'] == '0.097'
assert results['Selected Variables'] == ['Shell weight', 'Shucked weight', 'Whole weight', 'Shell weight.ABS(* - Q25(*))', \
'Viscera weight.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - MEAN(*))', 'Height', 'Length', 'Diameter', 'Sex_I', \
'Shucked weight.ABS(* - MEDIAN(*))', 'Diameter.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - Q75(*))', \
'Viscera weight.ABS(* - Q25(*))', 'Diameter.ABS(* - Q25(*))', 'Sex_M', 'Sex_F']
def test_include_mi():
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
results = df.kxy.data_valuation(target_column, problem_type='regression', \
include_mutual_information=True)
assert 'Mutual Information' in results
def test_linear_regression():
regressor_cls = get_sklearn_learner(
'sklearn.linear_model.LinearRegression', random_state=0)
from warnings import simplefilter
from sklearn.exceptions import ConvergenceWarning
simplefilter("ignore", category=ConvergenceWarning)
fs = Boruta(regressor_cls)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Feature selection
x_columns = [_ for _ in features_df.columns if _ != target_column]
x_df = features_df[x_columns]
y_df = features_df[[target_column]]
m = fs.fit(x_df, y_df)
# Assertions
assert len(fs.selected_variables) == 3
assert fs.selected_variables == ['Sex_M', 'Sex_I', 'Sex_F']
def test_xgboost_regression():
regressor_cls = get_xgboost_learner('xgboost.XGBRegressor', random_state=0)
fs = RFE(regressor_cls)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Feature selection
x_columns = [_ for _ in features_df.columns if _ != target_column]
x_df = features_df[x_columns]
y_df = features_df[[target_column]]
n_vars = max(x_df.shape[1] - 5, 1)
m = fs.fit(x_df, y_df, n_vars)
# Assertions
assert len(fs.selected_variables) == n_vars
assert fs.selected_variables == ['Shell weight', 'Sex_I', 'Shucked weight.ABS(* - Q25(*))', 'Shucked weight', 'Shucked weight.ABS(* - MEDIAN(*))', \
'Shucked weight.ABS(* - MEAN(*))', 'Diameter.ABS(* - Q75(*))', 'Height.ABS(* - Q75(*))', 'Diameter.ABS(* - MEAN(*))', 'Diameter.ABS(* - Q25(*))', \
'Whole weight.ABS(* - MEDIAN(*))', 'Viscera weight.ABS(* - Q75(*))', 'Sex_M', 'Height.ABS(* - MEAN(*))', 'Shucked weight.ABS(* - Q75(*))', \
'Viscera weight.ABS(* - MEAN(*))', 'Height.ABS(* - Q25(*))', 'Whole weight.ABS(* - MEAN(*))', 'Shell weight.ABS(* - Q25(*))', 'Whole weight.ABS(* - Q25(*))', \
'Length.ABS(* - MEAN(*))', 'Length.ABS(* - Q75(*))', 'Whole weight.ABS(* - Q75(*))', 'Diameter.ABS(* - MEDIAN(*))', 'Shell weight.ABS(* - Q75(*))', \
'Shell weight.ABS(* - MEAN(*))', 'Shell weight.ABS(* - MEDIAN(*))', 'Length.ABS(* - MEDIAN(*))', 'Sex_F', 'Viscera weight', 'Whole weight', \
'Length.ABS(* - Q25(*))', 'Viscera weight.ABS(* - MEDIAN(*))']
def test_xgboost_regression():
regressor_cls = get_xgboost_learner('xgboost.XGBRegressor', random_state=0)
fs = Boruta(regressor_cls)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Feature selection
x_columns = [_ for _ in features_df.columns if _ != target_column]
x_df = features_df[x_columns]
y_df = features_df[[target_column]]
m = fs.fit(x_df, y_df)
# Assertions
assert len(fs.selected_variables) == 5
assert fs.selected_variables == [
'Shucked weight', 'Shell weight', 'Sex_I',
'Shucked weight.ABS(* - Q25(*))', 'Whole weight'
]
def test_random_forest_regression():
regressor_cls = get_sklearn_learner(
'sklearn.ensemble.RandomForestRegressor', random_state=0)
from warnings import simplefilter
from sklearn.exceptions import ConvergenceWarning
simplefilter("ignore", category=ConvergenceWarning)
fs = Boruta(regressor_cls)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Feature selection
x_columns = [_ for _ in features_df.columns if _ != target_column]
x_df = features_df[x_columns]
y_df = features_df[[target_column]]
m = fs.fit(x_df, y_df)
# Assertions
assert len(fs.selected_variables) == 11
assert fs.selected_variables == ['Shucked weight.ABS(* - Q75(*))', 'Shucked weight.ABS(* - Q25(*))', 'Shucked weight.ABS(* - MEDIAN(*))', \
'Shucked weight.ABS(* - MEAN(*))', 'Shucked weight', 'Shell weight.ABS(* - Q75(*))', 'Shell weight.ABS(* - Q25(*))', \
'Shell weight.ABS(* - MEDIAN(*))', 'Shell weight.ABS(* - MEAN(*))', 'Shell weight', 'Sex_I']
def test_lightgbm_regression():
lgbm_params = {
'objective': 'rmse',
'boosting_type': 'gbdt',
'n_jobs': -1,
'learning_rate': 0.1,
'verbose': -1,
}
regressor_cls = get_lightgbm_learner_learning_api(lgbm_params, num_boost_round=2000, \
early_stopping_rounds=5, split_random_seed=0)
fs = Boruta(regressor_cls)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Feature selection
x_columns = [_ for _ in features_df.columns if _ != target_column]
x_df = features_df[x_columns]
y_df = features_df[[target_column]]
m = fs.fit(x_df, y_df)
assert len(fs.selected_variables) == 13
assert fs.selected_variables == ['Shucked weight.ABS(* - Q75(*))', 'Shucked weight.ABS(* - MEDIAN(*))', \
'Shucked weight.ABS(* - MEAN(*))', 'Shucked weight', 'Shell weight.ABS(* - MEAN(*))', 'Shell weight', \
'Shucked weight.ABS(* - Q25(*))', 'Sex_I', 'Diameter', 'Whole weight', 'Shell weight.ABS(* - Q75(*))', \
'Whole weight.ABS(* - MEAN(*))', 'Height']
def test_norm():
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
y = features_df[target_column].values
x_columns = [_ for _ in features_df.columns if _ != target_column]
x = features_df[x_columns].values
# Principal features construction
feature_directions = PFS().fit(x, y)
n_directions = feature_directions.shape[0]
for i in range(n_directions):
assert np.allclose(
np.dot(feature_directions[i, :], feature_directions[i, :]), 1.)
predictor = PFSPredictor()
learner_func = get_sklearn_learner(
'sklearn.ensemble.RandomForestRegressor', random_state=0)
results = predictor.fit(features_df, target_column, learner_func)
feature_directions = results['Feature Directions']
n_directions = feature_directions.shape[0]
for i in range(n_directions):
assert np.allclose(
np.dot(feature_directions[i, :], feature_directions[i, :]), 1.)
def test_boruta():
# Regression
sklearn_regressor_cls = get_xgboost_learner('xgboost.XGBRegressor')
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None, max_lag=None, entity_name='*', exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, sklearn_regressor_cls, \
problem_type='regression', feature_selection_method='boruta', boruta_n_evaluations=100)
assert results['Selected Variables'] == ['Shucked weight', 'Shell weight', 'Sex_I', \
'Shucked weight.ABS(* - Q25(*))', 'Whole weight']
def test_single_learner():
# Regression
xgboost_regressor_cls = get_xgboost_learner('xgboost.XGBRegressor')
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, xgboost_regressor_cls, \
problem_type='regression', start_n_features=2, min_n_features=2, max_n_features=2, \
additive_learning=True, return_scores=True, n_down_perf_before_stop=1)
assert results['Testing R-Squared'] == '0.493'
assert results['Selected Variables'] == ['Shell weight', 'Shucked weight']
assert len(features_df.kxy.predictor.models) == 1
def test_lean_boosted_lightgbm_learning_regressor():
# Regression
params = params = {
'objective': 'rmse',
'boosting_type': 'gbdt',
'num_leaves': 100,
'n_jobs': -1,
'learning_rate': 0.1,
'feature_fraction': 0.8,
'bagging_fraction': 0.8,
'verbose': -1,
}
lightgbm_regressor_cls = get_lightgbm_learner_learning_api(params, num_boost_round=10000, \
early_stopping_rounds=50, verbose_eval=50, split_random_seed=42)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, lightgbm_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=1)
model = results['predictor'].models[0]
feature_columns = results['Selected Variables']
x = features_df[feature_columns].values
predictions = model.predict(x)
path = '../kxy/misc/cache/%s-%s.sav' % (dataset.name,
'lightbm-learning-api-regressor')
model.save(path)
loaded_model = lightgbm_regressor_cls(path=path)
loaded_predictions = loaded_model.predict(x)
assert np.allclose(predictions, loaded_predictions)
def test_leanml_predictor_lightgbm():
# Regression
params = params = {
'objective': 'rmse',
'boosting_type': 'gbdt',
'num_leaves': 100,
'n_jobs': -1,
'learning_rate': 0.1,
'feature_fraction': 0.8,
'bagging_fraction': 0.8,
'verbose': -1,
}
lightgbm_regressor_cls = get_lightgbm_learner_learning_api(params, num_boost_round=10000, \
early_stopping_rounds=50, verbose_eval=50, split_random_seed=42)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, lightgbm_regressor_cls, \
problem_type='regression')
feature_columns = results['Selected Variables']
predictor = results['predictor']
predictions = predictor.predict(features_df[feature_columns])
path = '../kxy/misc/cache/%s-%s.sav' % (dataset.name,
'lightbm-learning-api-regressor')
predictor.save(path)
loaded_predictor = LeanMLPredictor.load(path, lightgbm_regressor_cls)
loaded_predictions = loaded_predictor.predict(features_df[feature_columns])
assert np.allclose(predictions, loaded_predictions)
def test_pfs_feature_selection():
# Regression
xgboost_regressor_cls = get_xgboost_learner('xgboost.XGBRegressor')
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, xgboost_regressor_cls, \
problem_type='regression', feature_selection_method='pfs')
assert results['Feature Directions'].shape[1] == features_df.shape[1] - 1
predictor = results['predictor']
predictions = predictor.predict(features_df)
assert len(predictions.columns) == 1
assert target_column in predictions.columns
assert set(features_df.index).difference(set(predictions.index)) == set()
assert set(predictions.index).difference(set(features_df.index)) == set()
def test_shape():
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
y = features_df[target_column].values
x_columns = [_ for _ in features_df.columns if _ != target_column]
x = features_df[x_columns].values
# Principal features construction
feature_directions = PCA().fit(x, y)
assert feature_directions.shape[1] == x.shape[1]
predictor = PCAPredictor()
learner_func = get_sklearn_learner(
'sklearn.ensemble.RandomForestRegressor', random_state=0)
results = predictor.fit(features_df, target_column, learner_func)
feature_directions = results['Feature Directions']
assert feature_directions.shape[1] == x.shape[1]
def test_lean_boosted_pytorch_regressor():
import torch
torch.manual_seed(0)
# Regression
layers = [(10, 'relu'), (5, 'relu'), (1, None)]
clz = 'skorch.NeuralNetRegressor'
pt_regressor_cls = get_pytorch_dense_learner(clz,
layers,
max_epochs=10,
batch_size=100)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, pt_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=1)
model = results['predictor'].models[0]
feature_columns = results['Selected Variables']
x = features_df[feature_columns].values
predictions = model.predict(x)
path = '../kxy/misc/cache/%s-%s.sav' % (dataset.name, clz)
model.save(path)
n_vars = x.shape[1]
loaded_model = pt_regressor_cls(n_vars=n_vars, path=path)
loaded_predictions = loaded_model.predict(x)
assert np.allclose(predictions, loaded_predictions)
def test_lean_boosted_tensorflow_regressor():
import tensorflow as tf
tf.random.set_seed(0)
# Regression
layers = [(10, 'relu'), (5, 'relu'), (1, 'linear')]
loss = 'mean_absolute_error'
optimizer = 'adam'
clz = 'KerasRegressor'
tf_regressor_cls = get_tensorflow_dense_learner(clz, layers, loss, optimizer=optimizer, \
epochs=10, batch_size=100)
dataset = Abalone()
target_column = dataset.y_column
df = dataset.df
# Features generation
features_df = df.kxy.generate_features(entity=None,
max_lag=None,
entity_name='*',
exclude=[target_column])
# Model building
results = features_df.kxy.fit(target_column, tf_regressor_cls, \
problem_type='regression', additive_learning=True, return_scores=True, \
n_down_perf_before_stop=1)
model = results['predictor'].models[0]
feature_columns = results['Selected Variables']
x = features_df[feature_columns].values
predictions = model.predict(x)
path = '../kxy/misc/cache/%s-%s.h5' % (dataset.name, clz)
model.save(path)
n_vars = x.shape[1]
loaded_model = tf_regressor_cls(n_vars=n_vars, path=path)
loaded_predictions = loaded_model.predict(x)
assert np.allclose(predictions, loaded_predictions)
