def test_make_choice_with_instance(self): from lale.operators import make_union, make_choice, make_pipeline from sklearn.datasets import load_iris iris = load_iris() X, y = iris.data, iris.target tfm = PCA() | Nystroem() | NoOp() with self.assertRaises(AttributeError): trained = tfm.fit(X, y) planned_pipeline1 = (OneHotEncoder | NoOp) >> tfm >> (LogisticRegression | KNeighborsClassifier) planned_pipeline2 = (OneHotEncoder | NoOp) >> (PCA | Nystroem) >> (LogisticRegression | KNeighborsClassifier) planned_pipeline3 = make_choice(OneHotEncoder, NoOp) >> make_choice(PCA, Nystroem) >> make_choice(LogisticRegression, KNeighborsClassifier)
def test_pipeline_2(self): from lale.lib.lale import NoOp from lale.lib.sklearn import Nystroem from lale.lib.sklearn import PCA from lale.lib.sklearn import LogisticRegression from lale.lib.sklearn import KNeighborsClassifier from lale.operators import make_choice, make_pipeline from lale.json_operator import to_json, from_json kernel_tfm_or_not = make_choice(NoOp, Nystroem) tfm = PCA clf = make_choice(LogisticRegression, KNeighborsClassifier) operator = make_pipeline(kernel_tfm_or_not, tfm, clf) json = to_json(operator) operator_2 = from_json(json) json_2 = to_json(operator_2) self.assertEqual(json, json_2)
def _unfold(self, op: Operator, n: int) -> Optional[Operator]: """ Unroll all possible operators from the grammar `g` starting from non-terminal `op` after `n` derivations. Parameters ---------- op : Operator starting rule (e.g., `g.start`) n : int number of derivations Returns ------- Optional[Operator] """ if isinstance(op, BasePipeline): steps = op.steps() new_steps = [self._unfold(sop, n) for sop in op.steps()] step_map = {steps[i]: new_steps[i] for i in range(len(steps))} new_edges = [(step_map[s], step_map[d]) for s, d in op.edges()] if not None in new_steps: return get_pipeline_of_applicable_type(new_steps, new_edges, True) return None if isinstance(op, OperatorChoice): steps = [ s for s in (self._unfold(sop, n) for sop in op.steps()) if s ] return make_choice(*steps) if steps else None if isinstance(op, NonTerminal): return self._unfold(self._variables[op.name()], n - 1) if n > 0 else None if isinstance(op, IndividualOp): return op assert False, f"Unknown operator {op}"
def test_make_choice_with_instance(self): from sklearn.datasets import load_iris from lale.operators import make_choice iris = load_iris() X, y = iris.data, iris.target tfm = PCA() | Nystroem() | NoOp() with self.assertRaises(AttributeError): # we are trying to trigger a runtime error here, so we ignore the static warning _ = tfm.fit(X, y) # type: ignore _ = (OneHotEncoder | NoOp) >> tfm >> (LogisticRegression | KNeighborsClassifier) _ = ((OneHotEncoder | NoOp) >> (PCA | Nystroem) >> (LogisticRegression | KNeighborsClassifier)) _ = (make_choice(OneHotEncoder, NoOp) >> make_choice(PCA, Nystroem) >> make_choice(LogisticRegression, KNeighborsClassifier))
def test_with_operator_choice(self): from lale.operators import make_choice from lale.lib.lale import NoOp from lale.lib.sklearn import KNeighborsClassifier from lale.lib.sklearn import LogisticRegression from lale.lib.sklearn import Nystroem from lale.lib.sklearn import PCA kernel_tfm_or_not = NoOp | Nystroem tfm = PCA clf = make_choice(LogisticRegression, KNeighborsClassifier) clf.visualize(ipython_display=False) optimizable = kernel_tfm_or_not >> tfm >> clf optimizable.visualize(ipython_display=False)
def test_2_steps_regressor(): T = make_choice(*[Op for (n, Op) in kls if n in transformers]) R = make_choice(*[Op for (n, Op) in kls if n in regressors]) base_test("transformer_regressor", T >> R, load_regression, scoring="r2")
def test_2_steps_classifier(): T = make_choice(*[Op for (n, Op) in kls if n in transformers]) C = make_choice(*[Op for (n, Op) in kls if n in classifiers]) base_test("transformer_classifier", T >> C, load_iris)