discopat.core package

Subpackages

• discopat.core.entities package
  • Submodules
  • discopat.core.entities.annotation module
    • Annotation
      • Annotation.printable_fields()
      • Annotation.rescale()
      • Annotation.to_dict()
      • Annotation.type
    • Box
      • Box.from_dict()
      • Box.printable_fields()
      • Box.rescale()
      • Box.xmax
      • Box.xmin
      • Box.ymax
      • Box.ymin
    • Keypoint
      • Keypoint.from_dict()
      • Keypoint.printable_fields()
      • Keypoint.rescale()
    • Track
    • annotation_factory()
  • discopat.core.entities.array module
    • Array
  • discopat.core.entities.data module
    • DataLoader
      • DataLoader.batch_size
      • DataLoader.dataset
    • Dataset
  • discopat.core.entities.detection module
    • CDModel
    • Model
      • Model.from_dict()
      • Model.post_process()
      • Model.pre_process()
      • Model.predict()
      • Model.to_dict()
    • NNModel
      • NNModel.predict()
      • NNModel.set_device()
    • NeuralNet
  • discopat.core.entities.frame module
    • Frame
      • Frame.from_dict()
      • Frame.printable_fields()
      • Frame.resize()
      • Frame.to_dict()
  • discopat.core.entities.metadata module
    • Metadata
      • Metadata.from_dict()
      • Metadata.printable_fields()
      • Metadata.to_dict()
  • discopat.core.entities.movie module
    • Movie
      • Movie.from_dict()
      • Movie.printable_fields()
      • Movie.to_coco()
      • Movie.to_dict()
  • discopat.core.entities.tracking module
    • SORTTracker
    • Tracker
      • Tracker.make_tracks()
  • Module contents

Submodules

discopat.core.value_objects module

class discopat.core.value_objects.ComputingDevice(*values)

Bases: Enum

cpu = 'cpu'

gpu = 'gpu'

class discopat.core.value_objects.DataSource(*values)

Bases: Enum

local = 'local'

osf = 'osf'

class discopat.core.value_objects.Framework(*values)

Bases: Enum

torch = 'torch'

Module contents

class discopat.core.Annotation(label, score)

Bases: Metadata

Abstract class to represent annotations and model predictions.

Parameters:

• label (str)

• score (float)

classmethod printable_fields()

List of the relevant fields to serialise the object.

Return type:

list[str]

abstractmethod rescale(w_ratio, h_ratio)

Rescale object.

Parameters:

• w_ratio (float) – Width ratio.

• h_ratio (float) – Height ratio.

Return type:

None

to_dict()

Serialise object to a dictionary.

Return type:

dict

property type: str

Handle for annotation types (box, keypoint, track, …).

class discopat.core.Array

Bases: ABC

class discopat.core.Box(label, x, y, width, height, score)

Bases: Annotation

Class to represent bounding boxes.

Parameters:

• label (str)

• x (float)

• y (float)

• width (float)

• height (float)

• score (float)

classmethod from_dict(data_as_dict)

Make object from a dictionary.

Parameters:

data_as_dict (dict)

Return type:

Self

classmethod printable_fields()

List of the relevant fields to serialise the object.

Return type:

list[str]

rescale(w_ratio, h_ratio)

Rescale object.

Parameters:

• w_ratio (float) – Width ratio.

• h_ratio (float) – Height ratio.

Return type:

None

property xmax: float

Xmax for XYXY format.

property xmin: float

Xmin for XYXY format.

property ymax: float

Ymax for XYXY format.

property ymin: float

Ymin for XYXY format.

class discopat.core.CDModel

Bases: Model

Abstract class representing convolutional-dictionary-based models.

class discopat.core.ComputingDevice(*values)

Bases: Enum

cpu = 'cpu'

gpu = 'gpu'

class discopat.core.DataLoader(*args, **kwargs)

Bases: Protocol[X_co, Y_co]

Generic interface for objects yielding (X, y) pairs.

property batch_size: int | None

Return the number of samples per batch, if known.

property dataset: Dataset[X_co, Y_co]

Return the underlying dataset from which batches are drawn.

class discopat.core.DataSource(*values)

Bases: Enum

local = 'local'

osf = 'osf'

class discopat.core.Dataset(*args, **kwargs)

Bases: Protocol[X_co, Y_co]

A dataset providing indexed access to samples.

class discopat.core.Frame(name, width, height, annotations, image_array=None)

Bases: Metadata

Class to model movie frames or images.

Parameters:

• name (str)

• width (int)

• height (int)

• annotations (list[Annotation])

• image_array (Array)

classmethod from_dict(data_as_dict)

Make object from a dictionary.

Parameters:

data_as_dict (dict)

Return type:

Self

classmethod printable_fields()

List of the relevant fields to serialise the object.

Return type:

list[str]

resize(target_width, target_height)

Resize the image to (target_width, target_height).

Parameters:

• target_width (int)

• target_height (int)

Return type:

None

to_dict()

Serialise object to a dictionary.

Return type:

dict

class discopat.core.Framework(*values)

Bases: Enum

torch = 'torch'

class discopat.core.Keypoint(label, point_list, score)

Bases: Annotation

Class to represent keypoint annotations (e.g., for pose estimation).

Parameters:

• label (str)

• point_list (list[tuple[float, float]])

• score (float)

classmethod from_dict(data_as_dict)

Make object from a dictionary.

Parameters:

data_as_dict (dict)

Return type:

Self

classmethod printable_fields()

List of the relevant fields to serialise the object.

Return type:

list[str]

rescale(w_ratio, h_ratio)

Rescale object.

Parameters:

• w_ratio (float) – Width ratio.

• h_ratio (float) – Height ratio.

Return type:

None

class discopat.core.Model

Bases: ABC

Abstract class to represent a pattern detection model.

abstractmethod classmethod from_dict(model_as_dict)

Parameters:

model_as_dict (dict)

Return type:

Self

abstractmethod post_process(raw_predictions)

Adapt the internal detector’s predictions to discopat’s format.

Parameters:

raw_predictions (Any)

Return type:

list[Annotation]

abstractmethod pre_process(frame)

Prepare the frame’s array to pass through the internal detector.

Can be a neural net, a convolutional sparse encoder…

Parameters:

frame (Frame)

Return type:

Array

abstractmethod predict(frame)

Run the predictions of the model on a frame.

Parameters:

frame (Frame) – Object representing the image or movie frame on which the model will be applied.

Returns:

The input frame where the model predictions have been

appended to the list of already present annotations.

Return type:

Frame

abstractmethod to_dict()

Return type:

dict

class discopat.core.Movie(name, frames, tracks)

Bases: Metadata

Parameters:

• name (str)

• frames (list[Frame])

• tracks (list[Track])

classmethod from_dict(data_as_dict)

Make object from a dictionary.

Parameters:

data_as_dict (dict)

Return type:

Self

classmethod printable_fields()

List of the relevant fields to serialise the object.

Return type:

list[str]

to_coco(image_file_extension='png')

Convert movie to COCO annotation format.

Parameters:

image_file_extension (str)

Return type:

dict

to_dict()

Serialise object to a dictionary.

Return type:

dict

class discopat.core.NNModel(net, label_map, model_parameters)

Bases: Model

Abstract class representing neural-network-based models.

Parameters:

• net (NeuralNet)

• label_map (dict[str, int])

• model_parameters (dict)

predict(frame)

Run the predictions of the model on a frame.

The method follows the following scheme:

• input_frame ——[pre-processing ]–> input_array,

• input_array ——[ net ]–> raw_predictions,

• raw_predictions –[post_processing]–> output_frame.

Parameters:

frame (Frame) – Object representing the image or movie frame on which the model will be applied.

Returns:

The input frame where the model predictions have been

appended to the list of already present annotations.

Return type:

Frame

abstractmethod set_device(device)

Parameters:

device (ComputingDevice)

Return type:

None

class discopat.core.NeuralNet

Bases: object

Abstract class to model a neural network.

class discopat.core.Track(track_id, box_list)

Bases: Annotation

Class to represent object tracks accross frames in a movie.

Parameters:

• track_id (int)

• box_list (list[tuple[int, Box]])