BestIoUWith

class hybrid_learning.fuzzy_logic.predicates.custom_ops.BestIoUWith(*in_keys, batch_dims=None, **kwargs)[source]

Bases: AbstractFuzzyIntersect

Given two stacked sets of masks masks_a and masks_b, calculate for each mask in masks_a the best IoU with any mask in masks_b. Precisely, all entries in masks_a and masks_b are compared via IoU by varying over all dimensions except for mask_dims and batch_dims. The returned result is the stacked best IoUs, one for each mask in masks_a. The input masks are assumed to have the same dimensionality in the mask_dims. The output mask will have the same size as masks_a only with mask_dims squeezed.

Consider mask_a.size()==[batch, stack_a, h, w] and mask_b.size()==[batch, stack_b, h, w]. The settings mask_dim = (-2, -1) (h and w) and batch_dim = (0,) then mean:

The output will have size [batch, stack_a].
The entry at index [batch_idx, s_a] is the maximum of IoUs between the mask masks_a[batch_idx, s_a] and mask masks_b[batch_idx, s_b] for any value s_b in \range(stack_b).

Public Data Attributes:

SYMB

The string symbol of this class (override for sub-classes).

Inherited from : py: class:AbstractFuzzyIntersect

`ARITY`	The arity of the operation.
`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:

torch_operation(masks_a, masks_b)

Calculate for each mask in masks_a with those in masks_b at same non-stack dims.

Inherited from : py: class:AbstractFuzzyIntersect

`torch_intersect`(*masks)
`torch_union`(*masks)
`torch_intersect_proportion`(*masks[, iou, ...])	Calculate to what degree `mask_a` is covered by `mask_b`.

Inherited from : py: class:TorchOperation

operation(annotation_vals)

Calculate the predicate output.

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)	Calculate the predicate output.

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[, batch_dims])

Init.

Inherited from : py: class:AbstractFuzzyIntersect

__init__(*in_keys[, batch_dims])

Init.

Inherited from : py: class:Merge

`__init__`(*in_keys[, batch_dims])	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: batch_dims (Optional[Sequence[int]]) –

__init__(*in_keys, batch_dims=None, **kwargs)[source]

Init.

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

Parameters

in_keys – 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 – 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
batch_dims (Optional[Sequence[int]]) –

torch_operation(masks_a, masks_b)[source]

Calculate for each mask in masks_a with those in masks_b at same non-stack dims.

Parameters

masks_a (Tensor) –
masks_b (Tensor) –

Return type

Tensor

SYMB: str = 'BestIoUWith': The string symbol of this class (override for sub-classes).

batch_dims: Sequence[int]: The dimensions to match of masks_a and masks_b before IoU comparison. Defaults to (0,) in case the masks have more than len(self.mask_dims)+1 dimensions, else defaults to (,).