def __init__(self,
base_estimator=None,
n_estimators=10,
max_samples=1.0,
max_features=1.0,
bootstrap=True,
bootstrap_features=False,
oob_score=False,
warm_start=False,
n_jobs=None,
random_state=None,
verbose=0):
self._hyperparams = {
'base_estimator': make_sklearn_compat(base_estimator),
'n_estimators': n_estimators,
'max_samples': max_samples,
'max_features': max_features,
'bootstrap': bootstrap,
'bootstrap_features': bootstrap_features,
'oob_score': oob_score,
'warm_start': warm_start,
'n_jobs': n_jobs,
'random_state': random_state,
'verbose': verbose
}
self._wrapped_model = SKLModel(**self._hyperparams)
def test_clone_operator_choice(self):
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score, make_scorer
from sklearn.base import clone
from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target
lr = LogisticRegression()
trainable = PCA() >> lr
trainable_wrapper = make_sklearn_compat(trainable)
trainable2 = clone(trainable_wrapper)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
result = cross_val_score(trainable_wrapper,
X,
y,
scoring=make_scorer(accuracy_score),
cv=2)
result2 = cross_val_score(trainable2,
X,
y,
scoring=make_scorer(accuracy_score),
cv=2)
for i in range(len(result)):
self.assertEqual(result[i], result2[i])
def __init__(
self,
base_estimator=None,
n_estimators=10,
max_samples=1.0,
max_features=1.0,
bootstrap=True,
bootstrap_features=False,
oob_score=False,
warm_start=False,
n_jobs=None,
random_state=None,
verbose=0,
):
self._hyperparams = {
"base_estimator": make_sklearn_compat(base_estimator),
"n_estimators": n_estimators,
"max_samples": max_samples,
"max_features": max_features,
"bootstrap": bootstrap,
"bootstrap_features": bootstrap_features,
"oob_score": oob_score,
"warm_start": warm_start,
"n_jobs": n_jobs,
"random_state": random_state,
"verbose": verbose,
}
self._wrapped_model = SKLModel(**self._hyperparams)
def test_clone_operator_choice(self):
from sklearn.base import clone
lr = LogisticRegression()
trainable = (PCA() | NoOp) >> lr
trainable_wrapper = make_sklearn_compat(trainable)
_ = clone(trainable_wrapper)
_ = clone(trainable)
def lale_trainable_op_from_config(op: 'Ops.PlannedOperator',
cfg) -> 'Ops.TrainableOperator':
from sklearn.base import clone
op_compat = make_sklearn_compat(op)
wrapped_op = clone(op_compat)
cfg2 = smac_fixup_params(cfg)
trainable = wrapped_op.set_params(**cfg2)
return trainable
def test_wrap_from_instance(self):
from lale.operators import make_operator, TrainableIndividualOp
from lale.sklearn_compat import make_sklearn_compat
from sklearn.base import clone
self.assertFalse(isinstance(UnknownOp, TrainableIndividualOp))
instance = UnknownOp(n_neighbors=3)
self.assertFalse(isinstance(instance, TrainableIndividualOp))
wrapped = make_operator(instance)
self.assertTrue(isinstance(wrapped, TrainableIndividualOp))
self.assertEqual(wrapped.hyperparams(), {'n_neighbors': 3})
cloned = clone(make_sklearn_compat(wrapped)).to_lale()
self.assertTrue(isinstance(cloned, TrainableIndividualOp))
self.assertEqual(cloned.hyperparams(), {'n_neighbors': 3})
def lale_op_smac_tae(op: 'Ops.PlannedOperator', f_min):
# TODO: we can probably do this in a different way, but get_smac_configuration_space
# we already have these sklearn compatibility wrappers it is easier for now to use them
op_compat = make_sklearn_compat(op)
def f(cfg):
from sklearn.base import clone
wrapped_op = clone(op_compat)
cfg2 = smac_fixup_params(cfg)
trainable = wrapped_op.set_params(**cfg2)
return f_min(trainable)
return f
def test_sklearn_get_param_ranges_and_dist(self):
for op in [
ConcatFeatures,
KNeighborsClassifier,
LogisticRegression,
MLPClassifier,
Nystroem,
OneHotEncoder,
PCA,
RandomForestClassifier,
]:
skop = make_sklearn_compat(op)
self.validate_get_param_ranges(skop)
self.validate_get_param_dist(skop)
def test_wrap_from_instance(self):
from sklearn.base import clone
from lale.operators import TrainableIndividualOp, make_operator
from lale.sklearn_compat import make_sklearn_compat
self.assertFalse(isinstance(UnknownOp, TrainableIndividualOp))
instance = UnknownOp(n_neighbors=3)
self.assertFalse(isinstance(instance, TrainableIndividualOp))
wrapped = make_operator(instance)
self.assertTrue(isinstance(wrapped, TrainableIndividualOp))
assert isinstance(
wrapped, TrainableIndividualOp
) # help type checkers that don't know about assertTrue
self.assertEqual(wrapped.hyperparams(), {"n_neighbors": 3})
cloned = clone(make_sklearn_compat(wrapped)).to_lale()
self.assertTrue(isinstance(cloned, TrainableIndividualOp))
self.assertEqual(cloned.hyperparams(), {"n_neighbors": 3})
def LaleGridSearchCV(
op:'PlannedOperator',
lale_num_samples:Optional[int]=None,
lale_num_grids:Optional[float]=None,
lale_pgo:Optional[PGO]=None,
**kwargs):
"""
Parameters
----------
op : The lale PlannedOperator
lale_num_samples : integer, optional
If set, will limit the number of samples for each distribution
lale_num_grids: integer or float, optional
if set to an integer => 1, it will determine how many parameter grids will be returned (at most)
if set to an float between 0 and 1, it will determine what fraction should be returned
note that setting it to 1 is treated as in integer. To return all results, use None
"""
params = get_parameter_grids(op, num_samples=lale_num_samples, num_grids=lale_num_grids, pgo=lale_pgo)
if not params and isinstance(op, Ops.IndividualOp):
params = [get_defaults_as_param_grid(op)]
return get_lale_gridsearchcv_op(make_sklearn_compat(op), params, **kwargs)
def get_lale_gridsearchcv_op(op, params, **kwargs):
g = GridSearchCV(make_sklearn_compat(op), params, **kwargs)
return g
def fit_clone_fit(op): op1 = make_sklearn_compat(op) op1.fit(X=[1,2], y=[1,2]) op2 = clone(op1) fit2 = op2.fit(X=[3,4], y=[3,4]) print(fit2)
def get_lale_gridsearchcv_op(op, params, **kwargs):
g = sklearn.model_selection.GridSearchCV(
make_sklearn_compat(op), params, **kwargs)
return g
def __init__(self, estimator, **hyperparams):
self._hyperparams = {"estimator": make_sklearn_compat(estimator), **hyperparams}
self._wrapped_model = SKLModel(**self._hyperparams)
def __init__(self, operator=None, resampler=None):
self.operator = make_sklearn_compat(operator)
self.resampler = resampler
