def test_override_output2(self):
init_output_schema = self.sk_pca.get_schema("output_transform")
pca_output = schemas.AnyOf([
schemas.Array(schemas.Array(schemas.Float())),
schemas.Array(schemas.Float()),
])
expected = {
"anyOf": [
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
},
},
{
"type": "array",
"items": {
"type": "number"
}
},
]
}
foo = self.sk_pca.customize_schema(output_transform=pca_output)
self.assertEqual(foo.get_schema("output_transform"), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.sk_pca.get_schema("output_transform"),
init_output_schema)
def test_override_output2(self):
init_output_schema = self.sk_pca.get_schema('output')
pca_output = schemas.AnyOf([
schemas.Array(schemas.Array(schemas.Float())),
schemas.Array(schemas.Float())
])
expected = {
'anyOf': [{
'type': 'array',
'items': {
'type': 'array',
'items': {
'type': 'number'
}
}
}, {
'type': 'array',
'items': {
'type': 'number'
}
}]
}
foo = self.sk_pca.customize_schema(output=pca_output)
self.assertEqual(foo.get_schema('output'), expected)
helpers.validate_is_schema(foo._schemas)
self.assertEqual(self.sk_pca.get_schema('output'), init_output_schema)
def test_no_max_schema(self):
pca = PCA().customize_schema(n_components=schemas.Float(min=0.0))
plan = ((pca & (MinMaxScaler | Normalizer)) >> ConcatFeatures() >>
(MinMaxScaler | Normalizer) >>
(LogisticRegression | KNeighborsClassifier))
from lale.search.search_space import SearchSpaceError
with self.assertRaises(SearchSpaceError) as ctxt:
run_hyperopt_on_planned_pipeline(plan)
def test_override_object_param(self):
init = self.sk_pca.get_schema('input_fit')
expected = {'type': 'object',
'required': ['X'],
'additionalProperties': False,
'properties': {
'X': {'type': 'array',
'items': {
'type': 'number'}}}}
foo = self.sk_pca.customize_schema(
input_fit=schemas.Object(required=['X'],
additionalProperties=False,
X=schemas.Array(schemas.Float())))
self.assertEqual(foo.get_schema('input_fit'), expected)
lale.type_checking.validate_is_schema(foo.get_schema('input_fit'))
self.assertEqual(self.sk_pca.get_schema('input_fit'), init)
def test_override_float_param(self):
init = self.ll_pca.hyperparam_schema('tol')
expected = {'default': 0.1,
'type': 'number',
'minimum': -10,
'maximum': 10,
'exclusiveMaximum': True,
'exclusiveMinimum': False}
foo = self.ll_pca.customize_schema(
tol=schemas.Float(default=0.1,
min=-10,
max=10,
exclusiveMax=True,
exclusiveMin=False))
self.assertEqual(foo.hyperparam_schema('tol'), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.ll_pca.hyperparam_schema('tol'), init)
def test_override_object_param(self):
init = self.sk_pca.get_schema("input_fit")
expected = {
"type": "object",
"required": ["X"],
"additionalProperties": False,
"properties": {"X": {"type": "array", "items": {"type": "number"}}},
}
foo = self.sk_pca.customize_schema(
input_fit=schemas.Object(
required=["X"],
additionalProperties=False,
X=schemas.Array(schemas.Float()),
)
)
self.assertEqual(foo.get_schema("input_fit"), expected)
lale.type_checking.validate_is_schema(foo.get_schema("input_fit"))
self.assertEqual(self.sk_pca.get_schema("input_fit"), init)
def test_override_float_param(self):
init = self.ll_pca.hyperparam_schema("tol")
expected = {
"default": 0.1,
"type": "number",
"minimum": -10,
"maximum": 10,
"exclusiveMaximum": True,
"exclusiveMinimum": False,
}
foo = self.ll_pca.customize_schema(
tol=schemas.Float(
default=0.1, min=-10, max=10, exclusiveMax=True, exclusiveMin=False
)
)
self.assertEqual(foo.hyperparam_schema("tol"), expected)
lale.type_checking.validate_is_schema(foo._schemas)
self.assertEqual(self.ll_pca.hyperparam_schema("tol"), init)
def test_override_object_param(self):
init = self.sk_pca.get_schema('input_fit')
expected = {
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'required': ['X'],
'additionalProperties': False,
'properties': {
'X': {
'type': 'array',
'items': {
'type': 'number'
}
}
}
}
foo = self.sk_pca.customize_schema(input_fit=schemas.Object(
required=['X'],
additionalProperties=False,
properties={'X': schemas.Array(schemas.Float())}))
self.assertEqual(foo.get_schema('input_fit'), expected)
helpers.validate_is_schema(foo.get_schema('input_fit'))
self.assertEqual(self.sk_pca.get_schema('input_fit'), init)
def test_override_int_param2(self):
from lale.lib.sklearn import PCA
from lale.search.schema2search_space import op_to_search_space
from lale.search.search_space import SearchSpaceNumber, SearchSpaceObject
pca = PCA.customize_schema(
relevantToOptimizer=["iterated_power"],
iterated_power=schemas.Float(
minimum=0,
minimumForOptimizer=1,
maximum=6,
maximumForOptimizer=5,
exclusiveMaximumForOptimizer=False,
exclusiveMinimumForOptimizer=True,
),
)
search = op_to_search_space(pca)
assert isinstance(search, SearchSpaceObject)
num_space = list(search.choices)[0][0]
assert isinstance(num_space, SearchSpaceNumber)
self.assertEqual(num_space.minimum, 1)
self.assertEqual(num_space.maximum, 5)
self.assertFalse(num_space.exclusiveMaximum)
self.assertTrue(num_space.exclusiveMinimum)
def test_override_float_param1(self):
from lale.lib.sklearn import PCA
from lale.search.schema2search_space import op_to_search_space
from lale.search.search_space import SearchSpaceNumber, SearchSpaceObject
pca = PCA.customize_schema(
relevantToOptimizer=["tol"],
tol=schemas.Float(
minimum=0.25,
minimumForOptimizer=0,
maximum=0.5,
maximumForOptimizer=1.0,
exclusiveMaximum=True,
exclusiveMinimum=False,
),
)
search = op_to_search_space(pca)
assert isinstance(search, SearchSpaceObject)
num_space = list(search.choices)[0][0]
assert isinstance(num_space, SearchSpaceNumber)
self.assertEqual(num_space.minimum, 0.25)
self.assertEqual(num_space.maximum, 0.5)
self.assertTrue(num_space.exclusiveMaximum)
self.assertFalse(num_space.exclusiveMinimum)
