datumaro.components.abstracts.model_interpreter

Classes

IModelInterpreter()

class datumaro.components.abstracts.model_interpreter.IModelInterpreter

Bases: ABC

abstract preprocess(inp: DatasetItem) → Tuple[ndarray | Dict[str, ndarray], PrepInfo]

Preprocessing an dataset item input.

Parameters:

img – DatasetItem input

Returns:

It returns a tuple of preprocessed input and preprocessing information. The preprocessing information will be used in the postprocessing step. One use case for this would be an affine transformation of the output bounding box obtained by object detection models. Input images for those models are usually resized to fit the model input dimensions. As a result, the postprocessing step should refine the model output bounding box to match the original input image size.

abstract postprocess(pred: Dict[str, ndarray] | List[Dict[str, ndarray]], info: PrepInfo) → List[Annotation]

Postprocess a model prediction.

Parameters:

• pred – Model prediction

• info – Preprocessing information coming from the preprocessing step

Returns:

A list of annotations which is created from the model predictions

abstract get_categories()

It should be implemented if the model generate a new categories

class datumaro.components.abstracts.model_interpreter.ABC

Bases: object

Helper class that provides a standard way to create an ABC using inheritance.

class datumaro.components.abstracts.model_interpreter.Annotation(*, id: int = 0, attributes: Dict[str, Any] = _Nothing.NOTHING, group: int = 0, object_id: int = -1)

Bases: object

A base annotation class.

Derived classes must define the ‘_type’ class variable with a value from the AnnotationType enum.

Method generated by attrs for class Annotation.

id: int

attributes: Dict[str, Any]

group: int

object_id: int

property type: AnnotationType

as_dict() → Dict[str, Any]

Returns a dictionary { field_name: value }

wrap(**kwargs)

Returns a modified copy of the object

class datumaro.components.abstracts.model_interpreter.DatasetItem(id: str, *, subset: str | None = None, media: str | MediaElement | None = None, annotations: List[Annotation] | None = None, attributes: Dict[str, Any] | None = None)

Bases: object

id: str

subset: str

media: MediaElement | None

annotations: Annotations

attributes: Dict[str, Any]

wrap(**kwargs)

media_as(t: Type[T]) → T

class datumaro.components.abstracts.model_interpreter.TypeVar(name, *constraints, bound=None, covariant=False, contravariant=False)

Bases: _Final, _Immutable, _TypeVarLike

Type variable.

Usage:

T = TypeVar('T')  # Can be anything
A = TypeVar('A', str, bytes)  # Must be str or bytes

Type variables exist primarily for the benefit of static type checkers. They serve as the parameters for generic types as well as for generic function definitions. See class Generic for more information on generic types. Generic functions work as follows:

def repeat(x: T, n: int) -> List[T]:

‘’’Return a list containing n references to x.’’’ return [x]*n

def longest(x: A, y: A) -> A:

‘’’Return the longest of two strings.’’’ return x if len(x) >= len(y) else y

The latter example’s signature is essentially the overloading of (str, str) -> str and (bytes, bytes) -> bytes. Also note that if the arguments are instances of some subclass of str, the return type is still plain str.

At runtime, isinstance(x, T) and issubclass(C, T) will raise TypeError.

Type variables defined with covariant=True or contravariant=True can be used to declare covariant or contravariant generic types. See PEP 484 for more details. By default generic types are invariant in all type variables.

Type variables can be introspected. e.g.:

T.__name__ == ‘T’ T.__constraints__ == () T.__covariant__ == False T.__contravariant__ = False A.__constraints__ == (str, bytes)

Note that only type variables defined in global scope can be pickled.

datumaro.components.abstracts.model_interpreter.abstractmethod(funcobj)

A decorator indicating abstract methods.

Requires that the metaclass is ABCMeta or derived from it. A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods are overridden. The abstract methods can be called using any of the normal ‘super’ call mechanisms. abstractmethod() may be used to declare abstract methods for properties and descriptors.

Usage:

class C(metaclass=ABCMeta):

@abstractmethod def my_abstract_method(self, …):

…