def test_customize_schema(self):
from lale.lib.sklearn import LogisticRegression
pipeline = LogisticRegression.customize_schema(
solver={"enum": ["lbfgs", "liblinear"], "default": "liblinear"},
tol={
"type": "number",
"minimum": 0.00001,
"maximum": 0.1,
"default": 0.0001,
},
)(solver="lbfgs")
expected = """from sklearn.linear_model import LogisticRegression
import lale
lale.wrap_imported_operators()
pipeline = LogisticRegression.customize_schema(
solver={"enum": ["lbfgs", "liblinear"], "default": "liblinear"},
tol={
"type": "number",
"minimum": 1e-05,
"maximum": 0.1,
"default": 0.0001,
},
)(solver="lbfgs")"""
self._roundtrip(expected, pipeline.pretty_print(customize_schema=True))
def test_customize_schema(self):
from lale.json_operator import from_json, to_json
from lale.lib.sklearn import LogisticRegression as LR
operator = LR.customize_schema(
solver={
"enum": ["lbfgs", "liblinear"],
"default": "liblinear"
},
tol={
"type": "number",
"minimum": 0.00001,
"maximum": 0.1,
"default": 0.0001,
},
)
json_expected = {
"class": LR.class_name(),
"state": "planned",
"operator": "LogisticRegression",
"label": "LR",
"documentation_url":
"https://lale.readthedocs.io/en/latest/modules/lale.lib.sklearn.logistic_regression.html",
"customize_schema": {
"properties": {
"hyperparams": {
"allOf": [{
"solver": {
"default": "liblinear",
"enum": ["lbfgs", "liblinear"],
},
"tol": {
"type": "number",
"minimum": 0.00001,
"maximum": 0.1,
"default": 0.0001,
},
}]
}
}
},
}
json = to_json(operator)
self.maxDiff = None
self.assertEqual(json, json_expected)
operator_2 = from_json(json)
json_2 = to_json(operator_2)
self.assertEqual(json, json_2)
def test_disable_schema_validation_pipeline(self):
os.environ["LALE_DISABLE_SCHEMA_VALIDATION"]='True'
from lale.lib.sklearn import PCA, LogisticRegression
import lale.schemas as schemas
lr_input = schemas.Object(required=['X', 'y'], X=schemas.AnyOf([
schemas.Array(
schemas.Array(
schemas.String())),
schemas.Array(
schemas.String())]),
y=schemas.Array(schemas.String()))
foo = LogisticRegression.customize_schema(input_fit=lr_input)
abc = foo()
pipeline = PCA() >> abc
trained_pipeline = pipeline.fit(self.X_train, self.y_train)
trained_pipeline.predict(self.X_test)
os.environ["LALE_DISABLE_SCHEMA_VALIDATION"]='False'
def test_enable_schema_validation_pipeline(self):
with EnableSchemaValidation():
import lale.schemas as schemas
from lale.lib.sklearn import PCA, LogisticRegression
lr_input = schemas.Object(
required=["X", "y"],
X=schemas.AnyOf([
schemas.Array(schemas.Array(schemas.String())),
schemas.Array(schemas.String()),
]),
y=schemas.Array(schemas.String()),
)
foo = LogisticRegression.customize_schema(input_fit=lr_input)
abc = foo()
pipeline = PCA() >> abc
with self.assertRaises(ValueError):
trained_pipeline = pipeline.fit(self.X_train, self.y_train)
trained_pipeline.predict(self.X_test)
def test_disable_schema_validation_pipeline(self):
existing_flag = disable_data_schema_validation
set_disable_data_schema_validation(True)
import lale.schemas as schemas
from lale.lib.sklearn import PCA, LogisticRegression
lr_input = schemas.Object(
required=["X", "y"],
X=schemas.AnyOf([
schemas.Array(schemas.Array(schemas.String())),
schemas.Array(schemas.String()),
]),
y=schemas.Array(schemas.String()),
)
foo = LogisticRegression.customize_schema(input_fit=lr_input)
abc = foo()
pipeline = PCA() >> abc
trained_pipeline = pipeline.fit(self.X_train, self.y_train)
trained_pipeline.predict(self.X_test)
set_disable_data_schema_validation(existing_flag)
if i > max_evals:
assert False
try:
X, y = data_loader()
clf = Hyperopt(estimator=pipeline, max_evals=i, scoring=scoring)
trained_pipeline = clf.fit(X, y)
trained_pipeline.predict(X)
return True
except Exception:
test(3 * i)
test(1)
kls = inspect.getmembers(autogen, lambda m: isinstance(m, Operator))
LR = LogisticRegression.customize_schema(relevantToOptimizer=[])
classifiers = [
"AdaBoostClassifier",
"BernoulliNB",
"CalibratedClassifierCV",
"ComplementNB",
"DecisionTreeClassifier",
"ExtraTreesClassifier",
"GaussianNB",
"GaussianProcessClassifier",
"GradientBoostingClassifier",
"KNeighborsClassifier",
"LGBMClassifier",
"LabelPropagation",
"LabelSpreading",
