def test_trainable_pipe_right(self):
from lale.lib.lale import NoOp
from lale.lib.sklearn import LogisticRegression
from sklearn.decomposition import PCA
iris = sklearn.datasets.load_iris()
pipeline = NoOp() >> PCA() >> LogisticRegression(random_state=42)
pipeline.fit(iris.data, iris.target)
def test_fit(self):
import warnings
warnings.filterwarnings(action="ignore")
from lale.lib.sklearn import MinMaxScaler, MLPClassifier
pipeline = NoOp() >> Batching(
operator=MinMaxScaler() >> MLPClassifier(random_state=42),
batch_size=112)
trained = pipeline.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
lale_accuracy = accuracy_score(self.y_test, predictions)
from sklearn.preprocessing import MinMaxScaler
from sklearn.neural_network import MLPClassifier
prep = MinMaxScaler()
trained_prep = prep.partial_fit(self.X_train, self.y_train)
X_transformed = trained_prep.transform(self.X_train)
clf = MLPClassifier(random_state=42)
import numpy as np
trained_clf = clf.partial_fit(X_transformed,
self.y_train,
classes=np.unique(self.y_train))
predictions = trained_clf.predict(trained_prep.transform(self.X_test))
sklearn_accuracy = accuracy_score(self.y_test, predictions)
self.assertEqual(lale_accuracy, sklearn_accuracy)
def test_export_to_sklearn_pipeline_with_noop_4(self):
from lale.lib.sklearn import KNeighborsClassifier
from lale.lib.lale import NoOp
from sklearn.pipeline import make_pipeline
lale_pipeline = NoOp() >> KNeighborsClassifier()
trained_lale_pipeline = lale_pipeline.fit(self.X_train, self.y_train)
sklearn_pipeline = trained_lale_pipeline.export_to_sklearn_pipeline()
self.assert_equal_predictions(sklearn_pipeline, trained_lale_pipeline)
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_regressor(self):
X_train, y_train = self.X_train, self.y_train
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)
regr = None
if class_name in ["StackingRegressor", "VotingRegressor"]:
regr = class_(estimators=[("base", SGDRegressor())])
else:
regr = class_()
# test_schemas_are_schemas
lale.type_checking.validate_is_schema(regr.input_schema_fit())
lale.type_checking.validate_is_schema(regr.input_schema_predict())
lale.type_checking.validate_is_schema(regr.output_schema_predict())
lale.type_checking.validate_is_schema(regr.hyperparam_schema())
# test_init_fit_predict
trained = regr.fit(self.X_train, self.y_train)
_ = trained.predict(self.X_test)
# test score
_ = trained.score(self.X_test, self.y_test)
# test_predict_on_trainable
trained = regr.fit(X_train, y_train)
regr.predict(X_train)
# test_to_json
regr.to_json()
# test_in_a_pipeline
pipeline = NoOp() >> regr
trained = pipeline.fit(self.X_train, self.y_train)
_ = trained.predict(self.X_test)
# test_with_hyperopt
from lale.lib.sklearn.ridge import Ridge
if isinstance(regr, Ridge): # type: ignore
from lale.lib.lale import Hyperopt
hyperopt = Hyperopt(estimator=pipeline, max_evals=1)
trained = hyperopt.fit(self.X_train, self.y_train)
_ = trained.predict(self.X_test)
def test_regressor(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)
regr = class_()
# test_schemas_are_schemas
lale.type_checking.validate_is_schema(regr.input_schema_fit())
lale.type_checking.validate_is_schema(regr.input_schema_predict())
lale.type_checking.validate_is_schema(regr.output_schema_predict())
lale.type_checking.validate_is_schema(regr.hyperparam_schema())
# test_init_fit_predict
trained = regr.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
# test_predict_on_trainable
trained = regr.fit(X_train, y_train)
regr.predict(X_train)
# test_to_json
regr.to_json()
# test_in_a_pipeline
pipeline = NoOp() >> regr
trained = pipeline.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
# test_with_hyperopt
from lale.lib.sklearn.ridge import RidgeImpl
if regr._impl_class() != RidgeImpl:
from lale.lib.lale import Hyperopt
hyperopt = Hyperopt(estimator=pipeline, max_evals=1)
trained = hyperopt.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
def test_regressor(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)
regr = class_()
#test_schemas_are_schemas
from lale.helpers import validate_is_schema
validate_is_schema(regr.input_schema_fit())
validate_is_schema(regr.input_schema_predict())
validate_is_schema(regr.output_schema())
validate_is_schema(regr.hyperparam_schema())
#test_init_fit_predict
trained = regr.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
#test_predict_on_trainable
trained = regr.fit(X_train, y_train)
regr.predict(X_train)
#test_to_json
regr.to_json()
#test_in_a_pipeline
pipeline = NoOp() >> regr
trained = pipeline.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
#test_with_hyperopt
from lale.lib.sklearn.ridge import RidgeImpl
if not isinstance(regr._impl, RidgeImpl):
from lale.lib.lale import HyperoptRegressor
hyperopt = HyperoptRegressor(model=pipeline, max_evals=1)
trained = hyperopt.fit(self.X_train, self.y_train)
predictions = trained.predict(self.X_test)
def test_export_to_sklearn_pipeline_with_noop_4(self):
lale_pipeline = NoOp() >> KNeighborsClassifier()
trained_lale_pipeline = lale_pipeline.fit(self.X_train, self.y_train)
sklearn_pipeline = trained_lale_pipeline.export_to_sklearn_pipeline()
self.assert_equal_predictions(sklearn_pipeline, trained_lale_pipeline)
