endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/management/commands/load_tag_data.py

@@ -0,0 +1,54 @@
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models import (
+    Tag,
+)
+
+from ...data import TAG_DATA_DIR
+from ...utils import load_model_data_from_yaml
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    Tag.__name__,
+]
+
+IMPORT_METADATA = {
+    Tag.__name__: {
+        "dir": TAG_DATA_DIR,  # e.g. "interventions"
+        "model": Tag,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+}
+
+
+class Command(BaseCommand):
+    help = """Load all requirement-related YAML files from their respective directories
+    into the database, including RequirementType, RequirementOperator, Requirement, 
+    RequirementSetType, and RequirementSet models"""
+
+    def add_arguments(self, parser):
+        """
+        Add command-line arguments to enable verbose output.
+
+        Adds an optional '--verbose' flag to the command parser. When specified,
+        this flag causes the command to display detailed output during execution.
+        """
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        """
+        Executes data import for requirement models from YAML files.
+
+        Retrieves the verbosity setting from the command options and iterates over each model
+        listed in IMPORT_MODELS. For each model, it obtains the corresponding metadata from
+        IMPORT_METADATA and calls a helper to load the YAML data into the database. Verbose mode
+        enables detailed output during the process.
+        """
+        verbose = options["verbose"]
+        for model_name in IMPORT_MODELS:
+            _metadata = IMPORT_METADATA[model_name]
+            load_model_data_from_yaml(self, model_name, _metadata, verbose)

endoreg_db/management/commands/load_unit_data.py

@@ -0,0 +1,40 @@
+from django.core.management.base import BaseCommand
+
+from ...data import UNIT_DATA_DIR
+from ...models import Unit
+from ...utils import load_model_data_from_yaml
+
+SOURCE_DIR = UNIT_DATA_DIR  # e.g. settings.DATA_DIR_INTERVENTION
+
+MODEL_0 = Unit
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    MODEL_0.__name__,
+]
+
+IMPORT_METADATA = {
+    MODEL_0.__name__: {
+        "dir": SOURCE_DIR,  # e.g. "interventions"
+        "model": MODEL_0,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    }
+}
+
+
+class Command(BaseCommand):
+    help = """Load all .yaml files in the data/intervention directory
+    into the Intervention and InterventionType model"""
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        verbose = options["verbose"]
+        for model_name in IMPORT_MODELS:
+            _metadata = IMPORT_METADATA[model_name]
+            load_model_data_from_yaml(self, model_name, _metadata, verbose)

endoreg_db/management/commands/load_user_groups.py

@@ -0,0 +1,26 @@
+from django.core.management.base import BaseCommand
+from django.contrib.auth.models import Group
+
+
+class Command(BaseCommand):
+    help = "Create additional user groups and permissions for all models in 'endoreg_db' app."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        verbose = options["verbose"]
+
+        # Create groups
+        groups = ["demo", "verified", "agl", "endo_reg_user", "g_play_user", "ukw_user"]
+        for group_name in groups:
+            _group, created = Group.objects.get_or_create(name=group_name)
+            if verbose and created:
+                self.stdout.write(self.style.SUCCESS(f"Created group {group_name}"))
+
+        if verbose:
+            self.stdout.write(self.style.SUCCESS("All groups processed successfully."))

endoreg_db/management/commands/model_input.py

@@ -0,0 +1,169 @@
+# endoreg_db/management/commands/model_input.py
+
+from __future__ import annotations
+
+from django.core.management.base import BaseCommand, CommandError
+
+from endoreg_db.models import AIDataSet
+from endoreg_db.utils.ai.data_loader_for_model_input import (
+    build_dataset_for_training,
+)
+from endoreg_db.utils.ai.model_training.config import (
+    TrainingConfig,
+)
+from endoreg_db.utils.ai.model_training.trainer_gastronet_multilabel import (
+    train_gastronet_multilabel,
+)
+
+
+class Command(BaseCommand):
+    help = (
+        "Build the dynamic multi-label dataset from AIDataSet and train a "
+        "GastroNet-ResNet50 multi-label model on it.\n"
+        "\n"
+        "This command:\n"
+        "- Uses AIDataSet.id to select annotations.\n"
+        "- Infers the LabelSet from used labels.\n"
+        "- Builds image_paths, label_vectors, and label_masks from DB.\n"
+        "- Prints a short debug dump.\n"
+        "- Trains a model using RN50 GastroNet checkpoint (if provided).\n"
+    )
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--dataset-id",
+            type=int,
+            required=True,
+            help="Primary key of the AIDataSet to use for training.",
+        )
+        parser.add_argument(
+            "--backbone-checkpoint",
+            type=str,
+            default=None,
+            help=(
+                "Path to RN50_GastroNet-1M_DINOv1.pth (or similar). "
+                "If omitted, ResNet50 is randomly initialized."
+            ),
+        )
+        parser.add_argument(
+            "--backbone-name",
+            type=str,
+            default="gastro_rn50",
+            help=(
+                "Backbone name, e.g. 'gastro_rn50' (default), "
+                "'resnet50_imagenet', 'resnet50_random', 'efficientnet_b0_imagenet', etc."
+            ),
+        )
+        parser.add_argument(
+            "--epochs",
+            type=int,
+            default=10,
+            help="Number of training epochs.",
+        )
+
+    def handle(self, *args, **options):
+        dataset_id = options["dataset_id"]
+        backbone_ckpt = options["backbone_checkpoint"]
+        backbone_name = options["backbone_name"]
+        num_epochs = options["epochs"]
+
+        try:
+            dataset = AIDataSet.objects.get(id=dataset_id)
+        except AIDataSet.DoesNotExist:
+            raise CommandError(f"AIDataSet with id={dataset_id} does not exist.")
+
+        # Basic info
+        self.stdout.write(
+            self.style.NOTICE(
+                f"Using AIDataSet id={dataset.id}, "
+                f"name={dataset.name!r}, "
+                f"dataset_type={dataset.dataset_type!r}, "
+                f"ai_model_type={dataset.ai_model_type!r}"
+            )
+        )
+
+        data = build_dataset_for_training(dataset)
+
+        image_paths = data["image_paths"]
+        label_vectors = data["label_vectors"]
+        label_masks = data["label_masks"]
+        labels = data["labels"]
+        labelset = data["labelset"]
+
+        self.stdout.write(self.style.NOTICE("Inferred LabelSet for this AIDataSet:"))
+        self.stdout.write(
+            f"  LabelSet id={labelset.id}, "
+            f"name={labelset.name!r}, "
+            f"version={labelset.version}"
+        )
+        self.stdout.write("  Labels (index, id, name):")
+        for idx, lbl in enumerate(labels):
+            self.stdout.write(f"    [{idx}] id={lbl.id}, name={lbl.name!r}")
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"\nBuilt training dataset from AIDataSet id={dataset.id}:\n"
+                f"- #samples: {len(image_paths)}\n"
+                f"- #labels:  {len(labels)}"
+            )
+        )
+
+        MAX_PRINT = 10
+        self.stdout.write(self.style.NOTICE("\nPer-sample debug output (first 10):"))
+        for i, (path, vec, mask) in enumerate(
+            zip(image_paths, label_vectors, label_masks)
+        ):
+            if i >= MAX_PRINT:
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"... ({len(image_paths) - MAX_PRINT} more samples not shown)"
+                    )
+                )
+                break
+
+            self.stdout.write(
+                f"  Sample {i}:"
+                f"\n    path = {path!r}"
+                f"\n    vector (1/0/None) = {vec}"
+                f"\n    mask (1=use, 0=ignore) = {mask}"
+            )
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"\n Input for model training built successfully from AIDataSet id={dataset.id}."
+            )
+        )
+
+        # ------------------------------------------------------------------
+        # Ask user if we should really start training
+        # ------------------------------------------------------------------
+        self.stdout.write("")
+        confirm = (
+            input(
+                "Proceed with model training? "
+                "Type 'yes' and press Enter to continue, anything else to abort: "
+            )
+            .strip()
+            .lower()
+        )
+
+        if confirm != "yes":
+            self.stdout.write(
+                self.style.WARNING("Training aborted by user. No model was trained.")
+            )
+            return
+
+        # ---- Training ----
+        cfg = TrainingConfig(
+            dataset_id=dataset.id,
+            backbone_checkpoint=backbone_ckpt,
+            backbone_name=backbone_name,
+            num_epochs=num_epochs,
+        )
+        result = train_gastronet_multilabel(cfg)
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"\nTraining finished. Model saved to: {result['model_path']}"
+            )
+        )

endoreg_db/management/commands/register_ai_model.py

@@ -0,0 +1,70 @@
+# django command to register a new AI model
+# expects path to model_meta.json file
+# example model_meta: {
+# "name": "multilabel_classification",
+# "version": 0,
+# "model_type": "multilabel_classification", # name of modeltype, is unique
+# "labelset": "multilabel_classification", #labelset name, combination of name and version is unique
+# "labelset_version": 0,
+# "weights_path": "weights/multilabel_classification_0.pth", # path to weights file
+# }
+
+from django.core.management.base import BaseCommand
+from django.core.files import File
+from endoreg_db.models import ModelMeta, ModelType, LabelSet
+import json
+from pathlib import Path
+
+
+class Command(BaseCommand):
+    """
+    Registers a new AI model in the database.
+    """
+
+    help = "Registers a new AI model in the database."
+
+    def add_arguments(self, parser):
+        parser.add_argument("model_meta_path", type=str)
+
+    def handle(self, *args, **options):
+        model_meta_path = Path(options["model_meta_path"])
+
+        with open(model_meta_path, "r") as f:
+            model_meta = json.load(f)
+
+        # get or create model type
+        model_type = ModelType.objects.get(name=model_meta["model_type"])
+
+        # get or create labelset
+        labelset = LabelSet.objects.get(
+            name=model_meta["labelset"], version=model_meta["labelset_version"]
+        )
+
+        # Handle weights file
+        weights_path = model_meta["weights_path"]
+        # weights path is realative to model_meta_path
+        weights_path = model_meta_path.parent / weights_path
+
+        assert weights_path.exists(), f"weights file at {weights_path} does not exist"
+
+        # Make sure the path is correct and the file exists
+        try:
+            with open(weights_path, "rb") as file:
+                model_name_string = f"{model_meta['name']}_{model_meta['version']}"
+                weights = File(file, name=model_name_string)
+                # Create ModelMeta instance
+                model_meta_instance = ModelMeta.objects.create(
+                    name=model_meta["name"],
+                    version=model_meta["version"],
+                    type=model_type,
+                    labelset=labelset,
+                    weights=weights,
+                    description=model_meta.get(
+                        "description", ""
+                    ),  # Assuming description is optional
+                )
+                print(f"Successfully registered model {model_meta_instance}")
+        except IOError:
+            print(
+                f"Failed to open weights file at {weights_path}. Make sure the file exists."
+            )