lale.operators module

class lale.operators.IndividualOp(name: str, impl, schemas)

Bases: lale.operators.MetaModelOperator

This is a concrete class that can instantiate a new individual operator and provide access to its metadata.

accept(visitor, *args, **kwargs)

arrange(*args, **kwargs)

Given composable operators, create a plan. TBD.

auto_arrange(planner)

Auto arrange the operators to make a new plan.

Parameters

TBD –

class_name() → str

customize_schema(**kwargs: lale.schemas.Schema) → lale.operators.IndividualOp

Return a new operator with a customized schema

Parameters

• schema (Schema) – A dictionary of json schemas for the operator. Override the entire schema and ignore other arguments

• input (Schema) – (or input_*) override the input schema for method *. input_* must be an existing method (already defined in the schema for lale operators, exising method for external operators)

• output (Schema) – (or output_*) override the output schema for method *. output_* must be an existing method (already defined in the schema for lale operators, exising method for external operators)

• constraint (Schema) – Add a constraint in JSON schema format.

• relevantToOptimizer (String list) – update the set parameters that will be optimized.

• param (Schema) – Override the schema of the hyperparameter. param must be an existing parameter (already defined in the schema for lale operators, __init__ parameter for external operators)

• tags (Dict) – Override the tags of the operator.

Returns

Copy of the operator with a customized schema

Return type

IndividualOp

documentation_url()

get_param_ranges() → Tuple[Dict[str, Any], Dict[str, Any]]

Returns two dictionaries, ranges and cat_idx, for hyperparameters.

The ranges dictionary has two kinds of entries. Entries for numeric and Boolean hyperparameters are tuples of the form (min, max, default). Entries for categorical hyperparameters are lists of their values.

The cat_idx dictionary has (min, max, default) entries of indices into the corresponding list of values.

get_schema(schema_kind: str) → Dict[str, Any]

Return a schema of the operator.

Parameters

schema_kind (string, 'input_fit' or 'input_predict' or 'output' or 'hyperparams') – Type of the schema to be returned.

Returns

The python object containing the json schema of the operator. For all the schemas currently present, this would be a dictionary.

Return type

dict

get_schema_maybe(schema_kind: str, default: Any = None) → Dict[str, Any]

Return a schema of the operator or a given default if the schema is unspecified

Parameters

schema_kind (string, 'input_fit' or 'input_predict' or 'output' or 'hyperparams') – Type of the schema to be returned.

Returns

The python object containing the json schema of the operator. For all the schemas currently present, this would be a dictionary.

Return type

dict

get_tags() → Dict[str, List[str]]

Return the tags of an operator.

Returns

A list of tags describing the operator.

Return type

list

has_same_impl(other: lale.operators.Operator) → bool

Checks if the type of the operator implementations are compatible

has_tag(tag: str) → bool

Check the presence of a tag for an operator.

Parameters

tag (string) –

Returns

Flag indicating the presence or absence of the given tag in this operator’s schemas.

Return type

boolean

hyperparam_defaults()

Returns the default values of hyperparameters for the operator.

Returns

A dictionary with names of the hyperparamers as keys and their default values as values.

Return type

dict

hyperparam_schema(name: Optional[str] = None)

Returns the hyperparameter schema for the operator.

Parameters

name (string, optional) – Name of the hyperparameter.

Returns

Full hyperparameter schema for this operator or part of the schema corresponding to the hyperparameter given by parameter name.

Return type

dict

input_schema_fit()

Returns the schema for fit method’s input.

Returns

Logical schema describing input required by this operator’s fit method.

Return type

dict

input_schema_predict()

Returns the schema for predict method’s input.

Returns

Logical schema describing input required by this operator’s predict method.

Return type

dict

input_schema_predict_proba()

Returns the schema for predict proba method’s input.

Returns

Logical schema describing input required by this operator’s predict proba method.

Return type

dict

input_schema_transform()

Returns the schema for transform method’s input.

Returns

Logical schema describing input required by this operator’s transform method.

Return type

dict

name() → str

[summary]

Returns

[description]

Return type

[type]

output_schema()

Returns the schema for predict/transform method’s output.

Returns

Logical schema describing output of this operator’s predict/transform method.

Return type

dict

output_schema_predict_proba()

Returns the schema for predict proba method’s output.

Returns

Logical schema describing output of this operator’s predict proba method.

Return type

dict

transform_schema(s_X)

validate_schema(X, y=None)

class lale.operators.MetaModel

Bases: abc.ABC

Abstract base class for LALE operators states: MetaModel, Planned, Trainable, and Trained.

abstract arrange(*args, **kwargs)

Given composable operators, create a plan. TBD.

abstract auto_arrange(planner)

Auto arrange the operators to make a new plan.

Parameters

TBD –

class lale.operators.MetaModelOperator

Bases: lale.operators.Operator, lale.operators.MetaModel

accept(visitor, *args, **kwargs)

class lale.operators.Operator

Bases: object

Abstract base class for a LALE operator.

Pipelines and individual operators extend this.

accept(visitor, *args, **kwargs)

abstract has_same_impl(other: lale.operators.Operator) → bool

Checks if the type of the operator imnplementations are compatible

abstract name() → str

Returns the name of the operator.

to_json()

Returns the json representation of the operator.

class lale.operators.OperatorChoice(steps, name: str)

Bases: lale.operators.Operator

accept(visitor, *args, **kwargs)

arrange(*args, **kwargs)

auto_arrange()

auto_configure(X, y=None, optimizer=None)

class_name() → str

configure(*args, **kwargs)

has_same_impl(other: lale.operators.Operator) → bool

Checks if the type of the operator imnplementations are compatible

name() → str

Returns the name of the operator.

steps() → List[OperatorChoiceType]

class lale.operators.Pipeline(steps: List[OpType], edges: Optional[Iterable[Tuple[OpType, OpType]]], ordered: bool = False)

Bases: lale.operators.MetaModelOperator

This is a concrete class that can instantiate a new pipeline operator and provide access to its meta data.

accept(visitor, *args, **kwargs)

arrange(*args, **kwargs)

Given composable operators, create a plan. TBD.

auto_arrange(planner)

Auto arrange the operators to make a new plan.

Parameters

TBD –

class_name() → str

constructor_for_cloning(steps: List[OpType])

edges() → List[Tuple[OpType, OpType]]

find_sink_nodes()

get_leaves() → List[OpType]

get_roots() → List[OpType]

has_same_impl(other: lale.operators.Operator) → bool

Checks if the type of the operator imnplementations are compatible

is_in_topological_order() → bool

name() → str

Returns the name of the operator.

sort_topologically() → None

steps() → List[OpType]

subst_steps(m: Dict[OpType, OpType]) → None

validate_schema(X, y=None)

class lale.operators.Planned

Bases: lale.operators.MetaModel

Base class to tag an operator’s state as Planned.

Warning: This class is not to be used directly by users/developers.

abstract auto_configure(X, y=None, optimizer=None) → lale.operators.Trainable

Abstract method to use an hyper-param optimizer.

Automatically select hyper-parameter values using an optimizer. This will return an operator in a Trainable state.

Parameters

TBD –

abstract configure(*args, **kwargs) → lale.operators.Trainable

Abstract method to configure an operator to make it Trainable.

Parameters

kwargs (args,) – The parameters are used to configure an operator in a Planned state to bind hyper-parameter values such that it becomes Trainable.

class lale.operators.PlannedIndividualOp(_name: str, _impl, _schemas)

Bases: lale.operators.IndividualOp, lale.operators.PlannedOperator

This is a concrete class that returns a trainable individual operator through its __call__ method. A configure method can use an optimizer and return the best hyperparameter combination.

accept(visitor, *args, **kwargs)

auto_configure(X, y=None, optimizer=None)

Abstract method to use an hyper-param optimizer.

Automatically select hyper-parameter values using an optimizer. This will return an operator in a Trainable state.

Parameters

TBD –

configure(*args, **kwargs) → lale.operators.TrainableOperator

Abstract method to configure an operator to make it Trainable.

Parameters

kwargs (args,) – The parameters are used to configure an operator in a Planned state to bind hyper-parameter values such that it becomes Trainable.

hyperparam_schema_with_hyperparams()

set_params(**impl_params)

class lale.operators.PlannedOperator

Bases: lale.operators.MetaModelOperator, lale.operators.Planned

accept(visitor, *args, **kwargs)

class lale.operators.PlannedPipeline(steps: List[PlannedOpType], edges: Optional[Iterable[Tuple[PlannedOpType, PlannedOpType]]], ordered: bool = False)

Bases: lale.operators.Pipeline, lale.operators.PlannedOperator

accept(visitor, *args, **kwargs)

auto_configure(X, y=None, optimizer=None)

Abstract method to use an hyper-param optimizer.

Automatically select hyper-parameter values using an optimizer. This will return an operator in a Trainable state.

Parameters

TBD –

configure(*args, **kwargs) → lale.operators.TrainableOperator

Make sure the args i.e. operators form a trainable pipeline and return it. It takes only one argument which is a list of steps like make_pipeline so, need to check that it is consistent with the steps and edges already present

class lale.operators.Trainable

Bases: lale.operators.Planned

Base class to tag an operator’s state as Trainable.

Warning: This class is not to be used directly by users/developers.

abstract fit(X, y=None, **fit_params) → lale.operators.Trained

Abstract fit method to be overriden by all trainable operators.

Parameters

• X – The type of X is as per input_fit schema of the operator.

• y (optional) – The type of y is as per input_fit schema of the operator. Default is None.

• fit_params (Dictionary, optional) – A dictionary of keyword parameters to be used during training.

abstract freeze_trainable()

abstract is_frozen_trainable()

class lale.operators.TrainableIndividualOp(_name, _impl, _schemas)

Bases: lale.operators.PlannedIndividualOp, lale.operators.TrainableOperator

accept(visitor, *args, **kwargs)

fit(X, y=None, **fit_params) → lale.operators.TrainedOperator

Abstract fit method to be overriden by all trainable operators.

Parameters

• X – The type of X is as per input_fit schema of the operator.

• y (optional) – The type of y is as per input_fit schema of the operator. Default is None.

• fit_params (Dictionary, optional) – A dictionary of keyword parameters to be used during training.

free_hyperparams()

freeze_trainable()

get_params(deep: bool = True) → Dict[str, Any]

Get parameters for this operator.

This method follows scikit-learn’s convention that all operators have a constructor which takes a list of keyword arguments. This is not required for operator impls which do not desire scikit-compatibility.

Parameters

deep (boolean, optional) – If True, will return the parameters for this operator state wrapper and its impl object

Returns

params – Parameter names mapped to their values.

Return type

mapping of string to any

get_params_all()

get_params_set_by_user()

hyperparams()

is_frozen_trainable()

is_supervised() → bool

Checks if the this operator needs labeled data for learning (the `y’ parameter for fit)

partial_fit(X, y=None, **fit_params) → lale.operators.TrainedOperator

predict(X)

Deprecated since version 0.0.0: The predict method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict on the trained operator returned by fit instead.

predict_proba(X)

Deprecated since version 0.0.0: The predict_proba method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict_proba on the trained operator returned by fit instead.

set_params(**impl_params)

transform(X, y=None)

Deprecated since version 0.0.0: The transform method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call transform on the trained operator returned by fit instead.

transform_schema(s_X)

class lale.operators.TrainableOperator

Bases: lale.operators.PlannedOperator, lale.operators.Trainable

accept(visitor, *args, **kwargs)

abstract fit(X, y=None, **fit_params) → lale.operators.TrainedOperator

Abstract fit method to be overriden by all trainable operators.

Parameters

• X – The type of X is as per input_fit schema of the operator.

• y (optional) – The type of y is as per input_fit schema of the operator. Default is None.

• fit_params (Dictionary, optional) – A dictionary of keyword parameters to be used during training.

abstract is_supervised() → bool

Checks if the this operator needs labeled data for learning (the `y’ parameter for fit)

class lale.operators.TrainablePipeline(steps: List[TrainableOpType], edges: Optional[Iterable[Tuple[TrainableOpType, TrainableOpType]]], ordered: bool = False)

Bases: lale.operators.PlannedPipeline, lale.operators.TrainableOperator

accept(visitor, *args, **kwargs)

fit(X, y=None, **fit_params) → lale.operators.TrainedOperator

Abstract fit method to be overriden by all trainable operators.

Parameters

• X – The type of X is as per input_fit schema of the operator.

• y (optional) – The type of y is as per input_fit schema of the operator. Default is None.

• fit_params (Dictionary, optional) – A dictionary of keyword parameters to be used during training.

fit_with_batches(X, y=None, serialize=True)

[summary]

Parameters

• X – [description]

• y ([type], optional) – For a supervised pipeline, this is an array with the unique class labels in the entire dataset, by default None

Returns

[description]

Return type

[type]

freeze_trainable()

get_params(deep: bool = True) → Dict[str, Any]

classmethod import_from_sklearn_pipeline(sklearn_pipeline)

is_frozen_trainable()

is_supervised() → bool

Checks if the this operator needs labeled data for learning (the `y’ parameter for fit)

predict(X)

Deprecated since version 0.0.0: The predict method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict on the trained operator returned by fit instead.

predict_proba(X)

Deprecated since version 0.0.0: The predict_proba method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict_proba on the trained operator returned by fit instead.

transform(X, y=None)

Deprecated since version 0.0.0: The transform method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call transform on the trained operator returned by fit instead.

class lale.operators.Trained

Bases: lale.operators.Trainable

Base class to tag an operator’s state as Trained.

Warning: This class is not to be used directly by users/developers.

abstract freeze_trained()

abstract is_frozen_trained()

abstract predict(X)

Abstract predict method to be overriden by trained operators as applicable.

Parameters

X – The type of X is as per input_predict schema of the operator.

abstract predict_proba(X)

Abstract predict method to be overriden by trained operators as applicable.

Parameters

X – The type of X is as per input_predict schema of the operator.

abstract transform(X, y=None)

Abstract transform method to be overriden by trained operators as applicable.

Parameters

X – The type of X is as per input_predict schema of the operator.

class lale.operators.TrainedIndividualOp(_name, _impl, _schemas)

Bases: lale.operators.TrainableIndividualOp, lale.operators.TrainedOperator

accept(visitor, *args, **kwargs)

fit(X, y=None, **fit_params) → lale.operators.TrainedOperator

Abstract fit method to be overriden by all trainable operators.

Parameters

• X – The type of X is as per input_fit schema of the operator.

• y (optional) – The type of y is as per input_fit schema of the operator. Default is None.

• fit_params (Dictionary, optional) – A dictionary of keyword parameters to be used during training.

freeze_trained()

is_frozen_trained()

is_transformer() → bool

Checks if the operator is a transformer

predict(X)

Deprecated since version 0.0.0.

The predict method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict on the trained operator returned by fit instead.

predict_proba(X)

Deprecated since version 0.0.0.

The predict_proba method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict_proba on the trained operator returned by fit instead.

transform(X, y=None)

Deprecated since version 0.0.0.

The transform method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call transform on the trained operator returned by fit instead.

class lale.operators.TrainedOperator

Bases: lale.operators.TrainableOperator, lale.operators.Trained

accept(visitor, *args, **kwargs)

abstract is_transformer() → bool

Checks if the operator is a transformer

class lale.operators.TrainedPipeline(steps: List[TrainedOpType], edges: List[Tuple[TrainedOpType, TrainedOpType]], ordered: bool = False)

Bases: lale.operators.TrainablePipeline, lale.operators.TrainedOperator

accept(visitor, *args, **kwargs)

export_to_sklearn_pipeline()

freeze_trained()

is_frozen_trained()

is_transformer() → bool

Checks if the operator is a transformer

predict(X, y=None)

Deprecated since version 0.0.0.

The predict method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict on the trained operator returned by fit instead.

predict_proba(X)

Deprecated since version 0.0.0.

The predict_proba method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call predict_proba on the trained operator returned by fit instead.

transform(X, y=None)

Deprecated since version 0.0.0.

The transform method is deprecated on a trainable operator, because the learned coefficients could be accidentally overwritten by retraining. Call transform on the trained operator returned by fit instead.

transform_with_batches(X, y=None, serialize=True)

[summary]

Parameters

• X ([type]) – [description]

• y ([type], optional) – by default None

Returns

[description]

Return type

[type]

lale.operators.fixup_hyperparams_dict(d)

lale.operators.get_available_estimators(tags: AbstractSet[str] = None) → List[lale.operators.PlannedOperator]

lale.operators.get_available_operators(tag: str, more_tags: AbstractSet[str] = None) → List[lale.operators.PlannedOperator]

lale.operators.get_available_transformers(tags: AbstractSet[str] = None) → List[lale.operators.PlannedOperator]

lale.operators.get_pipeline_of_applicable_type(steps, edges, ordered=False) → lale.operators.PlannedPipeline

Based on the state of the steps, it is important to decide an appropriate type for a new Pipeline. This method will decide the type, create a new Pipeline of that type and return it. #TODO: If multiple independently trained components are composed together in a pipeline, should it be of type TrainedPipeline? Currently, it will be TrainablePipeline, i.e. it will be forced to train it again.

lale.operators.make_choice(*orig_steps: Union[lale.operators.Operator, Any], name: Optional[str] = None) → lale.operators.OperatorChoice

lale.operators.make_operator(impl, schemas=None, name=None) → lale.operators.PlannedOperator

lale.operators.make_pipeline(*orig_steps: Union[lale.operators.Operator, Any]) → lale.operators.PlannedPipeline

lale.operators.make_union(*orig_steps: Union[lale.operators.Operator, Any]) → lale.operators.Operator

lale.operators.make_union_no_concat(*orig_steps: Union[lale.operators.Operator, Any]) → lale.operators.Operator