endoreg-db 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

endoreg_db/models/ai_model/model_meta.py

@@ -1,24 +1,250 @@
+"""
+This module defines the ModelMeta and ModelMetaManager classes for managing AI model metadata.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+import shutil
+
 from django.db import models
+from django.core.validators import FileExtensionValidator
+from icecream import ic
+
+if TYPE_CHECKING:
+    from endoreg_db.models import LabelSet, AiModel  # pylint: disable=import-outside-toplevel
+
+PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
+
+STORAGE_LOCATION = PSEUDO_DIR
+WEIGHTS_DIR_NAME = "db_model_weights"
+WEIGHTS_DIR = STORAGE_LOCATION / WEIGHTS_DIR_NAME
+
+if not WEIGHTS_DIR.exists():
+    WEIGHTS_DIR.mkdir(parents=True)
+
 
 class ModelMetaManager(models.Manager):
-    # natural key is name and version
-    def get_by_natural_key(self, name, version):
+    """
+    Custom manager for ModelMeta with additional query methods.
+    """
+
+    def get_by_natural_key(self, name: str, version: str) -> "ModelMeta":
+        """Get the model by its natural key"""
         return self.get(name=name, version=version)
 
+
 class ModelMeta(models.Model):
+    """
+    Attributes:
+        name (str): The name of the model.
+        version (str): The version of the model.
+        type (ModelType): The type of the model.
+        labelset (LabelSet): Associated labels.
+        weights (FileField): Path to the model weights.
+    """
+
     name = models.CharField(max_length=255)
     version = models.CharField(max_length=255)
-    type = models.ForeignKey("ModelType", on_delete=models.CASCADE, related_name="models")
-    labelset = models.ForeignKey("LabelSet", on_delete=models.CASCADE, related_name="models")
-    weights = models.FileField(upload_to='weights/')
-    
+
+    model = models.ForeignKey(
+        "AiModel", on_delete=models.CASCADE, related_name="models"
+    )
+
+    labelset = models.ForeignKey(
+        "LabelSet", on_delete=models.CASCADE, related_name="models"
+    )
+    activation = models.CharField(max_length=255, default="sigmoid")
+
+    weights = models.FileField(
+        upload_to=WEIGHTS_DIR_NAME,
+        validators=[FileExtensionValidator(allowed_extensions=["ckpt"])],
+        # storage=FileSystemStorage(location=STORAGE_LOCATION.resolve().as_posix()),
+        null=True,
+        blank=True,
+    )
+
+    # Means and stds for normalization
+    mean = models.CharField(max_length=255, default="0.45211223,0.27139644,0.19264949")
+    std = models.CharField(max_length=255, default="0.31418097,0.21088019,0.16059452")
+
+    size_x = models.IntegerField(default=716)
+    size_y = models.IntegerField(default=716)
+    axes = models.CharField(max_length=255, default="2,0,1")
+    batchsize = models.IntegerField(default=16)
+    num_workers = models.IntegerField(default=0)
+
     description = models.TextField(blank=True, null=True)
     date_created = models.DateTimeField(auto_now_add=True)
+
     objects = ModelMetaManager()
 
+    if TYPE_CHECKING:
+        labelset: "LabelSet"
+        ai_model: "AiModel"
+
+    @classmethod
+    def create_from_file(
+        cls,
+        meta_name,
+        model_name,
+        model_meta_version,
+        labelset_name,
+        weights_file,
+        bump_version,
+        **kwargs,
+    ):
+        """Create a new model meta from a file"""
+
+        from endoreg_db.models import LabelSet, AiModel  # pylint: disable=import-outside-toplevel
+
+        ic("Start")
+        model_meta_version = kwargs.get("model_meta_version", None)
+
+        ai_model = AiModel.objects.get(name=model_name)
+
+        # check If ModelMeta with same name and model already exists
+        if not model_meta_version:
+            if cls.objects.filter(name=meta_name, model=ai_model).exists():
+                # get highest version number
+                highest_version = (
+                    cls.objects.filter(name=meta_name, model=ai_model)
+                    .latest("version")
+                    .version
+                )
+                version = int(highest_version) + 1
+            else:
+                version = 1
+        else:
+            version = model_meta_version
+
+        meta_exists = cls.objects.filter(
+            name=meta_name, model=ai_model, version=version
+        ).exists()
+        if meta_exists and not bump_version:
+            raise ValueError(
+                f"ModelMeta with name {meta_name} and version {version} already exists"
+            )
+
+        assert labelset_name is not None, "Labelset name must be provided"
+        labelset = LabelSet.objects.get(name=labelset_name)
+        assert labelset is not None, "Labelset not found"
+
+        weights_path = Path(weights_file)
+        # If not under our WEIGHTS_DIR, copy it there
+        if not str(weights_path).startswith(str(WEIGHTS_DIR)):
+            target_path = WEIGHTS_DIR / weights_path.name
+            if not target_path.exists():
+                shutil.copy(weights_path, target_path)
+            weights_file = target_path
+
+        return cls.objects.create(
+            name=meta_name,
+            model=ai_model,
+            version=version,
+            labelset=labelset,
+            weights=str(weights_file),
+            **kwargs,
+        )
+
+    @classmethod
+    def get_latest_version(cls, name) -> int:
+        """
+        get the model meta with the highest version. Assumes Model Name and Meta Name are the same
+        """
+        from endoreg_db.models import AiModel  # pylint: disable=import-outside-toplevel
+
+        ai_model = AiModel.objects.get(name=name)
+        ic(f"Model: {ai_model}")
+        assert ai_model is not None, "Model not found"
+
+        model_meta = cls.objects.filter(name=name, model=ai_model).latest("version")
+        ic(f"Latest ModelMeta: {model_meta}")
+
+        latest_version = model_meta.version
+        ic(f"Latest Version: {latest_version}")
+
+        return int(latest_version)
+
+    @classmethod
+    def get_activation_function(cls, activation: str):
+        """get the activation function"""
+        from torch import nn  # pylint: disable=import-outside-toplevel
+
+        lookup = {
+            "sigmoid": nn.Sigmoid(),
+            "softmax": nn.Softmax(),
+            "none": nn.Identity(),
+        }
+
+        return lookup[activation]
+
+    def get_inference_dataset_config(self):
+        """
+        Creates a dictionary with the configuration for the inference dataset.
+
+        Example:
+            sample_config = {
+                # mean and std for normalization
+                "mean": (0.45211223, 0.27139644, 0.19264949),
+                "std": (0.31418097, 0.21088019, 0.16059452),
+                # Image Size
+                "size_x": 716,
+                "size_y": 716,
+                # how to wrangle axes of the image before putting them in the network
+                "axes": [2,0,1],  # 2,1,0 for opencv
+                "batchsize": 16,
+                "num_workers": 0, # always 1 for Windows systems # FIXME: fix celery crash if multiprocessing
+                # maybe add sigmoid after prediction?
+                "activation": nn.Sigmoid(),
+                "labels": ['appendix',  'blood',  'diverticule',  'grasper',  'ileocaecalvalve',  'ileum',  'low_quality',  'nbi',  'needle',  'outside',  'polyp',  'snare',  'water_jet',  'wound']
+            }
+        """
+        mean = list(map(float, str(self.mean).split(",")))
+        std = list(map(float, str(self.std).split(",")))
+        axes = list(map(int, str(self.axes).split(",")))
+
+        config = {
+            "mean": mean,
+            "std": std,
+            "size_x": self.size_x,
+            "size_y": self.size_y,
+            "axes": axes,
+            "batchsize": self.batchsize,
+            "num_workers": self.num_workers,
+            "activation": self.get_activation_function(self.activation),
+            "labels": self.labelset.get_labels_in_order(),  # pylint: disable=no-member
+        }
+
+        ic(f"ModelMeta - get_inference_dataset_config: {config}")
+
+        return config
+
     def natural_key(self):
+        """Return the natural key for this model"""
         return (self.name, self.version)
 
     def __str__(self):
         return f"{self.name} (v: {self.version})"
 
+    def get_config_dict(self) -> dict:
+        """Return the configuration as a dictionary"""
+        conf_dict = {
+            "mean": list(map(float, str(self.mean).split(","))),
+            "std": list(map(float, str(self.std).split(","))),
+            "size_x": self.size_x,
+            "size_y": self.size_y,
+            "axes": list(map(int, str(self.axes).split(","))),
+            "batchsize": self.batchsize,
+            "num_workers": self.num_workers,
+            "activation": self.activation,
+            "labels": self.labelset.get_labels_in_order(),  # pylint: disable=no-member
+        }
+        return conf_dict
+
+    @classmethod
+    def get_by_name(cls, name: str, version: Optional[int]) -> "ModelMeta":
+        """Get the model by its name and version"""
+        if version is None:
+            version = cls.get_latest_version(name)
+        return cls.objects.get(name=name, version=version)

endoreg_db/models/ai_model/model_type.py

@@ -1,10 +1,17 @@
 from django.db import models
 from django.core import serializers
 
+
 class ModelTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
+    """
+    Custom manager for ModelType with additional query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "ModelType":
+        """Get the model type by its natural key"""
         return self.get(name=name)
-    
+
+
 class ModelType(models.Model):
     """
     A class representing a model type.
@@ -14,13 +21,16 @@ class ModelType(models.Model):
         description (str): A description of the model type.
 
     """
+
     name = models.CharField(max_length=255)
     description = models.TextField(blank=True, null=True)
 
     objects = ModelTypeManager()
 
     def natural_key(self):
+        """Return the natural key for this model type"""
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        """Return the name of the model type"""
+        return str(self.name)

endoreg_db/models/annotation/__init__.py

@@ -1,3 +1,32 @@
+"""Module for annotation models"""
+
 from .image_classification import ImageClassificationAnnotation
-from .binary_classification_annotation_task import LegacyBinaryClassificationAnnotationTask, BinaryClassificationAnnotationTask
-from .anonymized_image_annotation import AnonymousImageAnnotation, DroppedName, AnonymizedImageLabel, AnonymizedFile, UploadedFile
+from .binary_classification_annotation_task import (
+    BinaryClassificationAnnotationTask,
+)
+from .anonymized_image_annotation import (
+    AnonymousImageAnnotation,
+    DroppedName,
+    AnonymizedImageLabel,
+    AnonymizedFile,
+    UploadedFile,
+)
+from .video_segmentation_annotation import (
+    VideoSegmentationLabel,
+    VideoSegmentationAnnotation,
+)
+
+from .video_segmentation_labelset import VideoSegmentationLabelSet
+
+__all__ = [
+    "ImageClassificationAnnotation",
+    "BinaryClassificationAnnotationTask",
+    "AnonymousImageAnnotation",
+    "DroppedName",
+    "AnonymizedImageLabel",
+    "AnonymizedFile",
+    "UploadedFile",
+    "VideoSegmentationLabel",
+    "VideoSegmentationLabelSet",
+    "VideoSegmentationAnnotation",
+]

endoreg_db/models/annotation/anonymized_image_annotation.py

@@ -1,60 +1,115 @@
 from django.db import models
 from django.utils.text import slugify
+from django.utils import timezone
 
 class AnonymizedImageLabel(models.Model):
-    name = models.CharField(max_length=255, unique=True)  # Ensuring label names are unique
-    description = models.TextField(blank=True, null=True)  # Optional description field
+    """
+    Represents a label for anonymized image annotations.
+
+    Attributes:
+        name (str): Unique name of the label.
+        description (str): Optional description for the label.
+    """
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
+
 class AnonymousImageAnnotation(models.Model):
+    """
+    Represents an annotation for anonymized images.
+
+    Attributes:
+        label (ForeignKey): Associated label for the image.
+        image_name (str): Name of the image file.
+        original_image_url (str): URL of the original image.
+        slug (str): Unique identifier for the annotation.
+        polyp_count (int): Number of polyps identified in the image.
+        comments (str): Additional comments about the annotation.
+        gender (str): Gender associated with the annotation (if applicable).
+        name_image_url (str): URL of the name image.
+        date_created (datetime): Date when the annotation was created.
+        processed (bool): Indicates if the annotation has been processed.
+    """
     label = models.ForeignKey(AnonymizedImageLabel, on_delete=models.CASCADE)
     image_name = models.CharField(max_length=255)
-    original_image_url = models.CharField(max_length=255, default='https://example.com/placeholder.jpg') # Field for the original image
+    original_image_url = models.CharField(max_length=255, default='https://example.com/placeholder.jpg')
     slug = models.SlugField(unique=True, blank=True, null=True)
     polyp_count = models.IntegerField()
-    comments = models.TextField(blank=True, null=True)  # Comments can be longer
-    gender = models.CharField(max_length=255)  # Overall gender (if applicable)
+    comments = models.TextField(blank=True, null=True)
+    gender = models.CharField(max_length=255)
     name_image_url = models.CharField(max_length=255)
     date_created = models.DateTimeField(auto_now_add=True)
-    processed = models.BooleanField(default=False)  # Track if this annotation has been processed
+    processed = models.BooleanField(default=False)
 
     def save(self, *args, **kwargs):
+        """
+        Overrides the save method to generate a slug if not already set.
+        """
         if not self.slug:
             self.slug = slugify(f"{self.label}-{self.image_name}")
         super().save(*args, **kwargs)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.image_name} - {self.label}"
 
+
 class DroppedName(models.Model):
+    """
+    Represents a dropped name in the annotation process.
+
+    Attributes:
+        annotation (ForeignKey): Associated annotation.
+        name (str): Dropped name.
+        gender (str): Gender associated with the name.
+        x (float): X-coordinate of the name.
+        y (float): Y-coordinate of the name.
+        name_image_url (str): URL of the name image.
+        box_coordinates (str): Optional coordinates of the bounding box.
+    """
     annotation = models.ForeignKey(AnonymousImageAnnotation, related_name='dropped_names', on_delete=models.CASCADE)
     name = models.CharField(max_length=255)
-    gender = models.CharField(max_length=255)  # Gender of the individual name
+    gender = models.CharField(max_length=255)
     x = models.FloatField()
     y = models.FloatField()
     name_image_url = models.CharField(max_length=255)
-    box_coordinates = models.CharField(max_length=255, blank=True, null=True)  # Store box coordinates if needed
+    box_coordinates = models.CharField(max_length=255, blank=True, null=True)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.name} ({self.gender}) at ({self.x}, {self.y})"
 
-from django.db import models
-from django.utils import timezone
 
 class UploadedFile(models.Model):
+    """
+    Represents a file uploaded to the system.
+
+    Attributes:
+        original_file (FileField): The uploaded original file.
+        upload_date (datetime): Date when the file was uploaded.
+        description (str): Optional description of the file.
+    """
     original_file = models.FileField(upload_to='uploads/original/')
     upload_date = models.DateTimeField(default=timezone.now)
     description = models.TextField(blank=True, null=True)
-    
-    def __str__(self):
+
+    def __str__(self) -> str:
         return self.original_file.name
-    
+
+
 class AnonymizedFile(models.Model):
+    """
+    Represents an anonymized version of an uploaded file.
+
+    Attributes:
+        original_file (OneToOneField): The original uploaded file.
+        anonymized_file (FileField): The anonymized file.
+        anonymization_date (datetime): Date when the file was anonymized.
+    """
     original_file = models.OneToOneField(UploadedFile, on_delete=models.CASCADE, related_name='anonymized_file')
     anonymized_file = models.FileField(upload_to='uploads/anonymized/')
     anonymization_date = models.DateTimeField(default=timezone.now)
-    
-    def __str__(self):
+
+    def __str__(self) -> str:
         return f"Anonymized version of {self.original_file.original_file.name}"

endoreg_db/models/annotation/binary_classification_annotation_task.py

@@ -1,54 +1,76 @@
 from django.db import models
-from rest_framework import serializers
-from ..label import Label
-from ..data_file.video_segment import LegacyLabelVideoSegment
-from .image_classification import ImageClassificationAnnotation
+# from rest_framework import serializers
+# from ..label import Label
+# from .image_classification import ImageClassificationAnnotation
 
 ANNOTATION_PER_S_THRESHOLD = 2
 
-def clear_finished_legacy_tasks():
-    # fetch all BinaryClassificationAnnotationTasks that are finished and delete them
-    tasks = LegacyBinaryClassificationAnnotationTask.objects.filter(finished=True)
+# TODO Migrate
+# def clear_finished_legacy_tasks():
+#     """
+#     Deletes all finished LegacyBinaryClassificationAnnotationTask entries.
+#     """
+#     tasks = LegacyBinaryClassificationAnnotationTask.objects.filter(is_finished=True)
+#     tasks.delete()
+
+# def get_legacy_binary_classification_annotation_tasks_by_label(label:Label, n:int=100, legacy=False):
+#     clear_finished_legacy_tasks()
+#     """
+#     Retrieves legacy binary classification annotation tasks for a specific label.
+
+#     Args:
+#         label (Label): The label to filter tasks by.
+#         n (int): Maximum number of tasks to retrieve. Defaults to 100.
+#         legacy (bool): If True, includes legacy tasks. Defaults to False.
+#     """
+#     if legacy:
+#         # fetch all LegacyLabelVideoSegments with the given label
+#         _segments = LegacyLabelVideoSegment.objects.filter(label=label)
+#         frames_for_tasks = []
+
+#         for segment in _segments:
+#             # check if the segment has already been annotated
+#             annotations = list(ImageClassificationAnnotation.objects.filter(legacy_frame__in=segment.get_frames(), label=label))
+#             segment_len_in_s = segment.get_segment_len_in_s()
+
+#             target_annotation_number = segment_len_in_s * ANNOTATION_PER_S_THRESHOLD
+
+#             if len(annotations) < target_annotation_number:
+#                 get_frame_number = int(target_annotation_number - len(annotations))
+#                 frames = segment.get_frames_without_annotation(get_frame_number)
+#                 frames_for_tasks.extend(frames)
+
+#             if len(frames_for_tasks) >= n:
+#                 break
+
+#         # create tasks
+#         tasks = []
+#         for frame in frames_for_tasks:
+
+#             # get_or_create task
+#             task, created = LegacyBinaryClassificationAnnotationTask.objects.get_or_create(
+#                 label=label,
+#                 image_path=frame.image.path,
+#                 frame_id=frame.pk,
+#             )
 
-    # delete tasks with a bulk operation
-    tasks.delete()
-
-def get_legacy_binary_classification_annotation_tasks_by_label(label:Label, n:int=100, legacy=False):
-    clear_finished_legacy_tasks()
-
-    if legacy:
-        # fetch all LegacyLabelVideoSegments with the given label
-        _segments = LegacyLabelVideoSegment.objects.filter(label=label)
-        frames_for_tasks = []
-
-        for segment in _segments:
-            # check if the segment has already been annotated
-            annotations = list(ImageClassificationAnnotation.objects.filter(legacy_frame__in=segment.get_frames(), label=label))
-            segment_len_in_s = segment.get_segment_len_in_s()
-
-            target_annotation_number = segment_len_in_s * ANNOTATION_PER_S_THRESHOLD
-
-            if len(annotations) < target_annotation_number:
-                get_frame_number = int(target_annotation_number - len(annotations))
-                frames = segment.get_frames_without_annotation(get_frame_number)
-                frames_for_tasks.extend(frames)
-
-            if len(frames_for_tasks) >= n:
-                break
-
-        # create tasks
-        tasks = []
-        for frame in frames_for_tasks:
-
-            # get_or_create task
-            task, created = LegacyBinaryClassificationAnnotationTask.objects.get_or_create(
-                label=label,
-                image_path=frame.image.path,
-                frame_id=frame.pk,
-            )
-        
 
 class AbstractBinaryClassificationAnnotationTask(models.Model):
+    """
+    Abstract base class for binary classification annotation tasks.
+
+    Attributes:
+        label (ForeignKey): The associated label.
+        is_finished (bool): Indicates if the task is completed.
+        date_created (datetime): The creation date of the task.
+        date_finished (datetime): The completion date of the task.
+        image_path (str): Path to the associated image.
+        image_type (str): The type of the image (e.g., "frame" or "legacy").
+        frame_id (int): Identifier of the associated frame.
+        labelstudio_project_id (int): The Label Studio project ID.
+        labelstudio_task_id (int): The Label Studio task ID.
+    """
+
     label = models.ForeignKey("Label", on_delete=models.CASCADE)
     is_finished = models.BooleanField(default=False)
     date_created = models.DateTimeField(auto_now_add=True)
@@ -62,19 +84,34 @@ class AbstractBinaryClassificationAnnotationTask(models.Model):
     class Meta:
         abstract = True
 
-class BinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
-    frame = models.ForeignKey("Frame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
-    image_type = models.CharField(max_length=255, default="frame")
-
-    def get_frame(self):
-        return self.video_segment.get_frame_by_id(self.frame_id)
 
-class LegacyBinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
-    frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
-    image_type = models.CharField(max_length=255, default="legacy")
+class BinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
+    """
+    Represents a binary classification task for a frame.
+
+    Attributes:
+       frame (ForeignKey): The associated frame for this task.
+    """
+
+    frame = models.ForeignKey(
+        "Frame",
+        on_delete=models.CASCADE,
+        related_name="binary_classification_annotation_tasks",
+    )
+    image_type = models.CharField(
+        max_length=255, default="frame"
+    )  # Default image type for non-legacy tasks
 
     def get_frame(self):
-        return self.frame
-
-
-
+        """
+        Retrieves the frame associated with this task.
+        """
+        from endoreg_db.models.data_file.frame import Frame
+
+        frame = self.frame
+        if not frame:
+            return None
+        else:
+            assert isinstance(frame, Frame)
+
+        return frame