LambdaOp

class hybrid_learning.fuzzy_logic.predicates.custom_ops.LambdaOp(*in_keys, trafo, symb='CustomOp', arity=- 1, **kwargs)[source]

Bases: Merge

Provide a custom transformation on the sequence of values extracted from the annotations dict.

Public Data Attributes:

`settings`	Settings to reproduce the instance.
`setting_defaults`	Defaults used for `settings`.

Inherited from : py: class:Merge

`SYMB`	The string symbol of this class (override for sub-classes).
`ARITY`	The arity of the operation.
`IS_COMMUTATIVE`	Whether instances are equivalent to ones with permuted `in_keys`.
`is_variadic`	Whether the instance is variadic.
`settings`	Settings to reproduce the instance.
`setting_defaults`	Defaults used for `settings`.
`pretty_op_symb`	Name of the operation symbol suitable for filenames etc.
`children`	The input keys which are child operations.
`all_children`	All children operations in the flattened computational tree, sorted depth first.
`consts`	The constant string keys in the input keys.
`operation_keys`	The list of keys used for this parent operation in original order (constants and children output keys).
`all_in_keys`	All string input keys both of self and of all child operations.
`all_out_keys`	Output keys of self and all child operations.

Inherited from : py: class:DictTransform

settings

Settings to reproduce the instance.

Inherited from : py: class:Transform

`IDENTITY_CLASS`	The identity class or classes for composition / addition.
`settings`	Settings to reproduce the instance.

Public Methods:

operation(annotation_vals)

Apply trafo to annotation values.

Inherited from : py: class:Merge

`to_infix_notation`([sort_key, ...])	Return an infix str encoding equal for differently sorted operations.
`to_str`(**infix_notation_kwargs)	Alias for `to_infix_notation()`.
`to_pretty_str`(**infix_notation_kwargs)	Same as `to_str()` but using pretty operation names suitable for filenames etc.
`to_repr`([settings, defaults, sort_key, ...])	Return str representation which can be used to reproduce and compare the instance.
`treerecurse_replace_keys`(**replace_map)	Return a new formula with all occurences of variables in `replace_map` replaced and else identical settings.
`treerecurse`(fun)	Apply the given function recursively to this and all children instances.
`apply_to`(annotations[, keep_keys])	Apply this operation to the `annotations` dict.
`variadic_apply_to`(annotations)	Return the result of operation on the values/items of a mapping or sequence of arbitrary length.
`operation`(annotation_vals)	Apply `trafo` to annotation values.

Inherited from : py: class:DictTransform

apply_to(annotations[, keep_keys])

Apply this operation to the annotations dict.

Inherited from : py: class:Transform

apply_to(annotations[, keep_keys])

Apply this operation to the annotations dict.

Special Methods:

__init__(*in_keys, trafo[, symb, arity])

Init.

Inherited from : py: class:Merge

`__init__`(*in_keys, trafo[, symb, arity])	Init.
`__str__`()	Return str(self).
`__repr__`()	Call `to_repr()` without sorting.
`__eq__`(other)	Two merge operations are considered equal, if their normalized representations coincide.
`__copy__`()	Return a deep copy of self using settings.
`__call__`(annotations[, keep_keys])	Call method modifying a given dictionary.

Inherited from : py: class:DictTransform

__call__(annotations[, keep_keys])

Call method modifying a given dictionary.

Inherited from : py: class:Transform

`__repr__`()	Call `to_repr()` without sorting.
`__eq__`(other)	Two merge operations are considered equal, if their normalized representations coincide.
`__copy__`()	Return a deep copy of self using settings.
`__add__`(other)	Return a flat composition of `self` with `other`.
`__radd__`(other)	Return a flat composition of `other` and `self`.
`__call__`(annotations[, keep_keys])	Call method modifying a given dictionary.

Parameters

in_keys (Sequence[Union[str, Merge]]) –
trafo (Callable[[Sequence[Any]], Any]) –
symb (str) –
arity (int) –

__init__(*in_keys, trafo, symb='CustomOp', arity=- 1, **kwargs)[source]

Init.

Hand over input keys either as str or as a Merge operation of str.

Parameters

in_keys (Union[str, Merge]) – sequence of either Merge operation instances or strings with placeholders for the input keys
out_key – key for the output of this operation; used to init out_key
overwrite – on call, whether to overwrite the value at out_key in the given dict if the key already exists; raise if key exists and overwrite is true; saved in overwrite.
replace_none – if not None, the value to replace any None values with; see replace_none
symb (str) – override the SYMB for this instance
keep_keys – intermediate output keys to add to call output; see keep_keys
cache_duplicates – whether outputs of children with identical keys should be cached and reused; see cache_duplicates
_variadic – the preferred way to specify this argument is variadic_(); see there for details
trafo (Callable[[Sequence[Any]], Any]) –
arity (int) –

operation(annotation_vals)[source]

Apply trafo to annotation values.

Parameters: annotation_vals (Sequence) –
Return type: Any

cache_duplicates: bool: Whether to cache duplicate child operation outputs with duplicate out_key. If set to false, all children and children children are evaluated and the values of duplicate out_keys are evaluated several times and overwritten, possibly leading to more computational time while using less memory. Note that the order of children execution is determined by their order in in_keys, depth first for nested operations.

in_keys: Sequence[Union[str, 'Merge']]: The keys of segmentation masks to unite in given order. Keys are either constant strings or a merge operation.

keep_keys: Optional[Collection[str]]: The keys of intermediate outputs in all_out_keys which should be added to the return of a call. Default (None or empty collection): duplicate children outputs are cached but not returned to save memory.

out_key: str: The key to use to store the merge output in the annotations dict. Take care to not accidentally overwrite existing keys (cf. overwrite).

overwrite: Union[bool, Literal['noop']]: Whether to overwrite a value in the input dictionary when applying this operation. The operation is defined in operation(). The key that may be overwritten is stored in out_key. An exception is raised if this is False and the key exists. If set to 'noop' and out_key is in the given annotations dict, it is returned unchanged.

replace_none: Optional[Any]: If not None, any received None value is replaced by the given value. This is done only for computation, the None value in the received dict is left unchanged. Key-value pairs with None value may come from the input or from child operations.

property setting_defaults: Dict[str, Any]: Defaults used for settings.

property settings: Dict[str, Any]: Settings to reproduce the instance. (Mind that in_keys must be expanded! For direct reproduction use copy.)

skip_none: bool: If set to True, when a None input value is encountered simply None is returned. If False, an error is raised.

trafo: Callable[[Sequence[Any]], Any]: The operation to apply to the annotation values selected by in_keys. The output is added under out_key.