def test_add_constraint(self):
init = self.sk_pca.hyperparam_schema()
expected = {
'allOf': [{
'type': 'object',
'properties': {}
}, {
'anyOf': [{
'type': 'object',
'properties': {
'n_components': {
'not': {
'enum': ['mle']
},
}
},
}, {
'type': 'object',
'properties': {
'svd_solver': {
'enum': ['full', 'auto']
},
}
}]
}]
}
foo = self.sk_pca.customize_schema(constraint=schemas.AnyOf([
schemas.Object(
{'n_components': schemas.Not(schemas.Enum(['mle']))}),
schemas.Object({'svd_solver': schemas.Enum(['full', 'auto'])})
]))
self.assertEqual(foo.hyperparam_schema(), expected)
helpers.validate_is_schema(foo._schemas)
self.assertEqual(self.sk_pca.hyperparam_schema(), init)
def test_add_constraint(self):
init = self.sk_pca.hyperparam_schema()
init_expected = {
"allOf": [
{
"type": "object",
"relevantToOptimizer": [],
"additionalProperties": False,
"properties": {
"n_components": {"default": None},
"copy": {"default": True},
"whiten": {"default": False},
"svd_solver": {"default": "auto"},
"tol": {"default": 0.0},
"iterated_power": {"default": "auto"},
"random_state": {"default": None},
},
}
]
}
self.assertEqual(init, init_expected)
expected = {
"allOf": [
init_expected["allOf"][0],
{
"anyOf": [
{
"type": "object",
"properties": {
"n_components": {
"not": {"enum": ["mle"]},
}
},
},
{
"type": "object",
"properties": {
"svd_solver": {"enum": ["full", "auto"]},
},
},
]
},
]
}
foo = self.sk_pca.customize_schema(
constraint=schemas.AnyOf(
[
schemas.Object(n_components=schemas.Not(schemas.Enum(["mle"]))),
schemas.Object(svd_solver=schemas.Enum(["full", "auto"])),
]
)
)
self.assertEqual(foo.hyperparam_schema(), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.sk_pca.hyperparam_schema(), init)
def test_override_enum_param(self):
init = self.ll_pca.hyperparam_schema('svd_solver')
expected = {'default': 'full', 'enum': ['auto', 'full']}
foo = self.ll_pca.customize_schema(
svd_solver=schemas.Enum(default='full', values=['auto', 'full']))
self.assertEqual(foo.hyperparam_schema('svd_solver'), expected)
helpers.validate_is_schema(foo._schemas)
self.assertEqual(self.ll_pca.hyperparam_schema('svd_solver'), init)
def test_override_enum_param(self):
init = self.ll_pca.hyperparam_schema("svd_solver")
expected = {"default": "full", "enum": ["auto", "full"]}
foo = self.ll_pca.customize_schema(
svd_solver=schemas.Enum(default="full", values=["auto", "full"]))
self.assertEqual(foo.hyperparam_schema("svd_solver"), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.ll_pca.hyperparam_schema("svd_solver"), init)
def test_classifier(self):
X_train, y_train = self.X_train, self.y_train
X_test, y_test = self.X_test, self.y_test
import importlib
module_name = ".".join(clf_name.split('.')[0:-1])
class_name = clf_name.split('.')[-1]
module = importlib.import_module(module_name)
class_ = getattr(module, class_name)
clf = class_()
#test_schemas_are_schemas
lale.type_checking.validate_is_schema(clf.input_schema_fit())
lale.type_checking.validate_is_schema(clf.input_schema_predict())
lale.type_checking.validate_is_schema(clf.output_schema_predict())
lale.type_checking.validate_is_schema(clf.hyperparam_schema())
#test_init_fit_predict
trained = clf.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
#test_with_hyperopt
from lale.lib.lale import Hyperopt
hyperopt = Hyperopt(estimator=clf, max_evals=1)
trained = hyperopt.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
#test_cross_validation
from lale.helpers import cross_val_score
cv_results = cross_val_score(clf, X_train, y_train, cv = 2)
self.assertEqual(len(cv_results), 2)
#test_with_gridsearchcv_auto_wrapped
from sklearn.metrics import accuracy_score, make_scorer
with warnings.catch_warnings():
warnings.simplefilter("ignore")
from lale.lib.sklearn.gradient_boosting_classifier import GradientBoostingClassifierImpl
if clf._impl_class() == GradientBoostingClassifierImpl:
#because exponential loss does not work with iris dataset as it is not binary classification
import lale.schemas as schemas
clf = clf.customize_schema(loss=schemas.Enum(default='deviance', values=['deviance']))
grid_search = lale.lib.lale.GridSearchCV(
estimator=clf, lale_num_samples=1, lale_num_grids=1,
cv=2, scoring=make_scorer(accuracy_score))
grid_search.fit(X_train, y_train)
#test_predict_on_trainable
trained = clf.fit(X_train, y_train)
clf.predict(X_train)
#test_to_json
clf.to_json()
#test_in_a_pipeline
pipeline = NoOp() >> clf
trained = pipeline.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
def test_override_any_param(self):
init = self.ll_pca.hyperparam_schema('iterated_power')
expected = {'anyOf': [
{'type': 'integer'},
{'enum': ['auto', 'full']}],
'default': 'auto'}
foo = self.ll_pca.customize_schema(
iterated_power=schemas.AnyOf([schemas.Int(),
schemas.Enum(['auto', 'full'])], default='auto'))
self.assertEqual(foo.hyperparam_schema('iterated_power'), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.ll_pca.hyperparam_schema('iterated_power'), init)
def test_add_constraint(self):
init = self.sk_pca.hyperparam_schema()
init_expected = {'allOf': [
{ 'type': 'object',
'relevantToOptimizer': [],
'additionalProperties': False,
'properties': {
'n_components': {'default': None},
'copy': {'default': True},
'whiten': {'default': False},
'svd_solver': {'default': 'auto'},
'tol': {'default': 0.0},
'iterated_power': {'default': 'auto'},
'random_state': {'default': None}}}]}
self.assertEqual(init, init_expected)
expected = {'allOf': [
init_expected['allOf'][0],
{'anyOf': [
{'type': 'object',
'properties': {
'n_components': {
'not': {
'enum': ['mle']},
}},
},
{'type': 'object',
'properties': {
'svd_solver': {
'enum': ['full', 'auto']},
}}]}]}
foo = self.sk_pca.customize_schema(
constraint=schemas.AnyOf([
schemas.Object(n_components=schemas.Not(schemas.Enum(['mle']))),
schemas.Object(svd_solver=schemas.Enum(['full', 'auto']))
]))
self.assertEqual(foo.hyperparam_schema(), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.sk_pca.hyperparam_schema(), init)
def test_override_any_param(self):
init = self.ll_pca.hyperparam_schema("iterated_power")
expected = {
"anyOf": [{"type": "integer"}, {"enum": ["auto", "full"]}],
"default": "auto",
}
foo = self.ll_pca.customize_schema(
iterated_power=schemas.AnyOf(
[schemas.Int(), schemas.Enum(["auto", "full"])], default="auto"
)
)
self.assertEqual(foo.hyperparam_schema("iterated_power"), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.ll_pca.hyperparam_schema("iterated_power"), init)
