coralnet-toolbox 0.0.75__py2.py3-none-any.whl → 0.0.77__py2.py3-none-any.whl

coralnet_toolbox/Transformers/Models/GroundingDINO.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+import torch
+
+from ultralytics.engine.results import Results
+
+from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
+
+from autodistill.detection import CaptionOntology
+
+from coralnet_toolbox.Transformers.Models.QtBase import QtBaseModel
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class GroundingDINOModel(QtBaseModel):
+    def __init__(self, ontology: CaptionOntology, model="SwinB", device: str = "cpu"):
+        super().__init__(ontology, device)
+        
+        if model == "SwinB":
+            model_name = "IDEA-Research/grounding-dino-base"
+        else:
+            model_name = "IDEA-Research/grounding-dino-tiny"
+            
+        self.processor = AutoProcessor.from_pretrained(model_name, use_fast=True)
+        self.model = AutoModelForZeroShotObjectDetection.from_pretrained(model_name).to(self.device)
+
+    def _process_predictions(self, image, texts, confidence):
+        """Process model predictions for a single image."""
+        inputs = self.processor(text=texts, images=image, return_tensors="pt").to(self.device)
+        outputs = self.model(**inputs)
+
+        results_processed = self.processor.post_process_grounded_object_detection(
+            outputs,
+            inputs.input_ids,
+            threshold=confidence,
+            target_sizes=[image.shape[:2]],
+        )[0]
+
+        boxes = results_processed["boxes"]
+        scores = results_processed["scores"]
+        
+        # If no objects are detected, return an empty list to match the original behavior.
+        if scores.nelement() == 0:
+            return []
+
+        # Per original logic, assign all detections to class_id 0.
+        # TODO: We are only supporting a single class right now
+        class_ids = torch.zeros(scores.shape[0], 1, device=self.device)
+
+        # Combine boxes, scores, and class_ids into the (N, 6) tensor format
+        # required by the Results object: [x1, y1, x2, y2, confidence, class_id]
+        combined_data = torch.cat([
+            boxes,
+            scores.unsqueeze(1),
+            class_ids
+        ], dim=1)
+
+        # Create the dictionary mapping class indices to class names.
+        names = {idx: text for idx, text in enumerate(self.ontology.classes())}
+        
+        # Create the Results object with a DETACHED tensor
+        result = Results(orig_img=image, 
+                         path=None, 
+                         names=names, 
+                         boxes=combined_data.detach().cpu())
+        
+        return result

coralnet_toolbox/Transformers/Models/OWLViT.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+import torch
+
+from ultralytics.engine.results import Results
+
+from transformers import OwlViTForObjectDetection, OwlViTProcessor
+
+from autodistill.detection import CaptionOntology
+
+from coralnet_toolbox.Transformers.Models.QtBase import QtBaseModel
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class OWLViTModel(QtBaseModel):
+    def __init__(self, ontology: CaptionOntology, device: str = "cpu"):
+        super().__init__(ontology, device)
+        
+        model_name = "google/owlvit-base-patch32"
+        self.processor = OwlViTProcessor.from_pretrained(model_name, use_fast=True)
+        self.model = OwlViTForObjectDetection.from_pretrained(model_name).to(self.device)
+
+    def _process_predictions(self, image, texts, confidence):
+        """
+        Process model predictions for a single image, converting directly
+        to an Ultralytics Results object without an intermediate Supervision object.
+        """
+        inputs = self.processor(text=texts, images=image, return_tensors="pt").to(self.device)
+        outputs = self.model(**inputs)
+
+        # Post-process the outputs to get detections.
+        # The confidence threshold is applied during this step.
+        results_processed = self.processor.post_process_object_detection(
+            outputs,
+            threshold=confidence,
+            target_sizes=[image.shape[:2]]
+        )[0]
+
+        boxes = results_processed["boxes"]
+        scores = results_processed["scores"]
+        
+        # If no objects are detected, return an empty list to match the original behavior.
+        if scores.nelement() == 0:
+            return []
+
+        # Per original logic, assign all detections to class_id 0.
+        # TODO: We are only supporting a single class right now
+        class_ids = torch.zeros(scores.shape[0], 1, device=self.device)
+
+        # Combine boxes, scores, and class_ids into the (N, 6) tensor format
+        # required by the Results object: [x1, y1, x2, y2, confidence, class_id]
+        combined_data = torch.cat([
+            boxes,
+            scores.unsqueeze(1),
+            class_ids
+        ], dim=1)
+
+        # Create the dictionary mapping class indices to class names.
+        names = {idx: text for idx, text in enumerate(self.ontology.classes())}
+        
+        # Create the Results object with a DETACHED tensor
+        result = Results(orig_img=image, 
+                         path=None, 
+                         names=names, 
+                         boxes=combined_data.detach().cpu())
+        
+        return result

coralnet_toolbox/Transformers/Models/OmDetTurbo.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+
+import torch
+
+from ultralytics.engine.results import Results
+
+from transformers import AutoProcessor, OmDetTurboForObjectDetection
+
+from autodistill.detection import CaptionOntology
+
+from coralnet_toolbox.Transformers.Models.QtBase import QtBaseModel
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class OmDetTurboModel(QtBaseModel):
+    def __init__(self, ontology: CaptionOntology, device: str = "cpu"):
+        super().__init__(ontology, device)
+        
+        model_name = "omlab/omdet-turbo-swin-tiny-hf"
+        self.processor = AutoProcessor.from_pretrained(model_name, use_fast=True)
+        self.model = OmDetTurboForObjectDetection.from_pretrained(model_name).to(self.device)
+
+    def _process_predictions(self, image, texts, confidence):
+        """Process model predictions for a single image."""
+        inputs = self.processor(text=texts, images=image, return_tensors="pt").to(self.device)
+        outputs = self.model(**inputs)
+
+        results_processed = self.processor.post_process_grounded_object_detection(
+            outputs,
+            threshold=confidence,
+            target_sizes=[image.shape[:2]],
+            text_labels=texts,
+        )[0]
+
+        boxes = results_processed["boxes"]
+        scores = results_processed["scores"]
+        
+        # If no objects are detected, return an empty list to match the original behavior.
+        if scores.nelement() == 0:
+            return []
+
+        # Per original logic, assign all detections to class_id 0.
+        # TODO: We are only supporting a single class right now
+        class_ids = torch.zeros(scores.shape[0], 1, device=self.device)
+
+        # Combine boxes, scores, and class_ids into the (N, 6) tensor format
+        # required by the Results object: [x1, y1, x2, y2, confidence, class_id]
+        combined_data = torch.cat([
+            boxes,
+            scores.unsqueeze(1),
+            class_ids
+        ], dim=1)
+
+        # Create the dictionary mapping class indices to class names.
+        names = {idx: text for idx, text in enumerate(self.ontology.classes())}
+        
+        # Create the Results object with a DETACHED tensor
+        result = Results(orig_img=image, 
+                         path=None, 
+                         names=names, 
+                         boxes=combined_data.detach().cpu())
+        
+        return result

coralnet_toolbox/Transformers/Models/QtBase.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+
+import cv2
+import numpy as np
+
+from ultralytics.engine.results import Results
+
+from autodistill.detection import CaptionOntology, DetectionBaseModel
+from autodistill.helpers import load_image
+
+from coralnet_toolbox.Results import CombineResults
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class QtBaseModel(DetectionBaseModel, ABC):
+    """
+    Base class for Transformer foundation models that provides common functionality for 
+    handling inputs, processing image data, and formatting detection results.
+    """
+    ontology: CaptionOntology
+
+    def __init__(self, ontology: CaptionOntology, device: str = "cpu"):
+        """
+        Initialize the base model with ontology and device.
+        
+        Args:
+            ontology: The CaptionOntology containing class labels
+            device: The compute device (cpu, cuda, etc.)
+        """
+        self.ontology = ontology
+        self.device = device
+        self.processor = None
+        self.model = None
+        
+    def _normalize_input(self, input) -> list[np.ndarray]:
+        """
+        Normalizes various input types into a list of images in CV2 (BGR) format.
+
+        Args:
+            input: Can be an image path, a list of paths, a numpy array, or a list of numpy arrays.
+
+        Returns:
+            A list of images, each as a numpy array in CV2 (BGR) format.
+        """
+        images = []
+        if isinstance(input, str):
+            # Single image path
+            images = [load_image(input, return_format="cv2")]
+        elif isinstance(input, np.ndarray):
+            # Single image numpy array (RGB) or a batch of images (NHWC, RGB)
+            if input.ndim == 3:
+                images = [cv2.cvtColor(input, cv2.COLOR_RGB2BGR)]
+            elif input.ndim == 4:
+                images = [cv2.cvtColor(img, cv2.COLOR_RGB2BGR) for img in input]
+            else:
+                raise ValueError(f"Unsupported numpy array dimensions: {input.ndim}")
+        elif isinstance(input, list):
+            if all(isinstance(i, str) for i in input):
+                # List of image paths
+                images = [load_image(path, return_format="cv2") for path in input]
+            elif all(isinstance(i, np.ndarray) for i in input):
+                # List of image arrays (RGB)
+                images = [cv2.cvtColor(img, cv2.COLOR_RGB2BGR) for img in input]
+            else:
+                raise ValueError("A list input must contain either all image paths or all numpy arrays.")
+        else:
+            raise TypeError(f"Unsupported input type: {type(input)}")
+        
+        return images
+        
+    @abstractmethod
+    def _process_predictions(self, image: np.ndarray, texts: list[str], confidence: float) -> Results:
+        """
+        Process model predictions for a single image.
+        
+        Args:
+            image: The input image in CV2 (BGR) format.
+            texts: The text prompts from the ontology.
+            confidence: Confidence threshold.
+            
+        Returns:
+            A single Ultralytics Results object, which may be empty if no detections are found.
+        """
+        pass
+
+    def predict(self, inputs, confidence=0.01) -> list[Results]:
+        """
+        Run inference on input images.
+        
+        Args:
+            inputs: Can be an image path, a list of image paths, a numpy array, or a list of numpy arrays.
+            confidence: Detection confidence threshold.
+            
+        Returns:
+            A list containing a single combined Ultralytics Results object with detections from all input images.
+            Returns an empty list if no detections are found in any image.
+        """
+        # Step 1: Normalize the input into a consistent list of images
+        normalized_inputs = self._normalize_input(inputs)
+
+        # Step 2: Prepare for inference
+        results = []
+        texts = self.ontology.prompts()
+        
+        # Step 3: Loop through images and process predictions
+        for normalized_input in normalized_inputs:
+            result = self._process_predictions(normalized_input, texts, confidence)
+            if result:
+                results.append(result)
+        
+        if len(results):
+            # Combine the results into one, then wrap in a list
+            results = CombineResults().combine_results(results)
+
+        return [results] if results else []

coralnet_toolbox/{AutoDistill → Transformers}/Models/__init__.py

@@ -1,4 +1,4 @@
-# coralnet_toolbox/AutoDistill/Models/__init__.py
+# coralnet_toolbox/Transformers/Models/__init__.py
 
 from .GroundingDINO import GroundingDINOModel
 from .OWLViT import OWLViTModel

coralnet_toolbox/{AutoDistill → Transformers}/QtBatchInference.py

@@ -13,14 +13,14 @@ from PyQt5.QtWidgets import (QApplication, QMessageBox, QCheckBox, QVBoxLayout,
 
 
 class BatchInferenceDialog(QDialog):
-    """Dialog for performing batch inference on images using AutoDistill."""
+    """Dialog for performing batch inference on images using Transformers."""
 
     def __init__(self, main_window, parent=None):
         super().__init__(parent)
         self.main_window = main_window
         self.image_window = main_window.image_window
         self.annotation_window = main_window.annotation_window
-        self.deploy_model_dialog = main_window.auto_distill_deploy_model_dialog
+        self.deploy_model_dialog = main_window.transformers_deploy_model_dialog
         self.loaded_models = self.deploy_model_dialog.loaded_model
 
         self.setWindowTitle("Batch Inference")
@@ -64,25 +64,25 @@ class BatchInferenceDialog(QDialog):
         self.image_options_group = QButtonGroup(self)
 
         # Create image selection options
-        self.apply_filtered = QCheckBox("▼ Apply to filtered images")
-        self.apply_prev = QCheckBox("↑ Apply to previous images")
-        self.apply_next = QCheckBox("↓ Apply to next images")
-        self.apply_all = QCheckBox("↕ Apply to all images")
+        self.apply_filtered_checkbox = QCheckBox("▼ Apply to filtered images")
+        self.apply_prev_checkbox = QCheckBox("↑ Apply to previous images")
+        self.apply_next_checkbox = QCheckBox("↓ Apply to next images")
+        self.apply_all_checkbox = QCheckBox("↕ Apply to all images")
         # Add options to button group
-        self.image_options_group.addButton(self.apply_filtered)
-        self.image_options_group.addButton(self.apply_prev)
-        self.image_options_group.addButton(self.apply_next)
-        self.image_options_group.addButton(self.apply_all)
+        self.image_options_group.addButton(self.apply_filtered_checkbox)
+        self.image_options_group.addButton(self.apply_prev_checkbox)
+        self.image_options_group.addButton(self.apply_next_checkbox)
+        self.image_options_group.addButton(self.apply_all_checkbox)
         # Make selections exclusive
         self.image_options_group.setExclusive(True)
         # Default selection
-        self.apply_all.setChecked(True)
+        self.apply_all_checkbox.setChecked(True)
 
         # Add widgets to layout
-        layout.addWidget(self.apply_filtered)
-        layout.addWidget(self.apply_prev)
-        layout.addWidget(self.apply_next)
-        layout.addWidget(self.apply_all)
+        layout.addWidget(self.apply_filtered_checkbox)
+        layout.addWidget(self.apply_prev_checkbox)
+        layout.addWidget(self.apply_next_checkbox)
+        layout.addWidget(self.apply_all_checkbox)
 
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)

coralnet_toolbox/{AutoDistill → Transformers}/QtDeployModel.py

@@ -18,6 +18,7 @@ from PyQt5.QtWidgets import (QApplication, QComboBox, QDialog,
 from coralnet_toolbox.QtProgressBar import ProgressBar
 
 from coralnet_toolbox.Results import ResultsProcessor
+from coralnet_toolbox.Results import ConvertResults
 from coralnet_toolbox.Results import MapResults
 
 from coralnet_toolbox.utilities import rasterio_open
@@ -33,13 +34,13 @@ from coralnet_toolbox.Icons import get_icon
 
 class DeployModelDialog(QDialog):
     """
-    Dialog for deploying and managing AutoDistill models.
+    Dialog for deploying and managing Transformers models.
     Allows users to load, configure, and deactivate models, as well as make predictions on images.
     """
 
     def __init__(self, main_window, parent=None):
         """
-        Initialize the AutoDistillDeployModelDialog.
+        Initialize the TransformersDeployModelDialog.
 
         Args:
             main_window: The main application window.
@@ -52,7 +53,7 @@ class DeployModelDialog(QDialog):
         self.annotation_window = main_window.annotation_window
 
         self.setWindowIcon(get_icon("coral.png"))
-        self.setWindowTitle("AutoDistill Deploy Model (Ctrl + 6)")
+        self.setWindowTitle("Transformers Deploy Model (Ctrl + 6)")
         self.resize(400, 325)
 
         # Initialize variables
@@ -66,6 +67,8 @@ class DeployModelDialog(QDialog):
         self.ontology = None
         self.class_mapping = {}
         self.ontology_pairs = []
+        
+        self.task = 'detect'
 
         # Create the layout
         self.layout = QVBoxLayout(self)
@@ -422,8 +425,6 @@ class DeployModelDialog(QDialog):
         progress_bar.close()
         # Restore cursor
         QApplication.restoreOverrideCursor()
-        # Exit the dialog box
-        self.accept()
 
     def load_new_model(self, model_name):
         """
@@ -433,8 +434,17 @@ class DeployModelDialog(QDialog):
             model_name: Name of the model to load.
             uncertainty_thresh: Threshold for uncertainty.
         """
+        
+        # Clear the model
+        self.loaded_model = None
+        self.model_name = None
+        
+        # Clear cache
+        gc.collect()
+        torch.cuda.empty_cache()
+        
         if "GroundingDINO" in model_name:
-            from coralnet_toolbox.AutoDistill.Models.GroundingDINO import GroundingDINOModel
+            from coralnet_toolbox.Transformers.Models.GroundingDINO import GroundingDINOModel
 
             model = model_name.split("-")[1].strip()
             self.model_name = model_name
@@ -443,14 +453,14 @@ class DeployModelDialog(QDialog):
                                                    device=self.main_window.device)
 
         elif "OmDetTurbo" in model_name:
-            from coralnet_toolbox.AutoDistill.Models.OmDetTurbo import OmDetTurboModel
+            from coralnet_toolbox.Transformers.Models.OmDetTurbo import OmDetTurboModel
 
             self.model_name = model_name
             self.loaded_model = OmDetTurboModel(ontology=self.ontology,
                                                 device=self.main_window.device)
 
         elif "OWLViT" in model_name:
-            from coralnet_toolbox.AutoDistill.Models.OWLViT import OWLViTModel
+            from coralnet_toolbox.Transformers.Models.OWLViT import OWLViTModel
 
             self.model_name = model_name
             self.loaded_model = OWLViTModel(ontology=self.ontology,
@@ -495,7 +505,6 @@ class DeployModelDialog(QDialog):
                     continue
 
                 results = self._apply_model(inputs)
-                results = self._update_results(results_processor, results, inputs, image_path)
                 results = self._apply_sam(results, image_path)
                 self._process_results(results_processor, results, image_path)
 
@@ -553,13 +562,6 @@ class DeployModelDialog(QDialog):
 
         return results_list
 
-    def _update_results(self, results_processor, results, inputs, image_path):
-        """Update the results to match Ultralytics format."""
-        return [results_processor.from_supervision(results,
-                                                   inputs,
-                                                   image_path,
-                                                   self.class_mapping)]
-
     def _apply_sam(self, results_list, image_path):
         """Apply SAM to the results if needed."""
         # Check if SAM model is deployed and loaded

coralnet_toolbox/{AutoDistill → Transformers}/__init__.py

@@ -1,4 +1,4 @@
-# coralnet_toolbox/AutoDistill/__init__.py
+# coralnet_toolbox/Transformers/__init__.py
 
 from .QtDeployModel import DeployModelDialog
 from .QtBatchInference import BatchInferenceDialog

coralnet_toolbox/__init__.py

@@ -1,6 +1,6 @@
 """Top-level package for CoralNet-Toolbox."""
 
-__version__ = "0.0.75"
+__version__ = "0.0.77"
 __author__ = "Jordan Pierce"
 __email__ = "jordan.pierce@noaa.gov"
 __credits__ = "National Center for Coastal and Ocean Sciences (NCCOS)"

coralnet_toolbox/utilities.py

@@ -30,21 +30,6 @@ from coralnet_toolbox.QtProgressBar import ProgressBar
 # ----------------------------------------------------------------------------------------------------------------------
 
 
-def get_available_device():
-    """
-    Get available devices
-
-    :return:
-    """
-    devices = ['cpu',]
-    if torch.cuda.is_available():
-        for i in range(torch.cuda.device_count()):
-            devices.append(f'cuda:{i}')
-    if torch.backends.mps.is_available():
-        devices.append('mps')
-    return devices
-
-
 @lru_cache(maxsize=32)
 def rasterio_open(image_path):
     """

{coralnet_toolbox-0.0.75.dist-info → coralnet_toolbox-0.0.77.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coralnet-toolbox
-Version: 0.0.75
+Version: 0.0.77
 Summary: Tools for annotating and developing ML models for benthic imagery
 Author-email: Jordan Pierce <jordan.pierce@noaa.gov>
 License: MIT License
@@ -16,7 +16,7 @@ License-File: LICENSE.txt
 Requires-Dist: PyQt5>=5.15.11
 Requires-Dist: pyqtdarktheme
 Requires-Dist: pyqtgraph
-Requires-Dist: ultralytics>=8.3.152
+Requires-Dist: ultralytics>=8.3.191
 Requires-Dist: lap>=0.5.12
 Requires-Dist: open-clip-torch>=2.20.0
 Requires-Dist: supervision>=0.24.0
@@ -27,7 +27,7 @@ Requires-Dist: pycocotools
 Requires-Dist: ujson
 Requires-Dist: timm==0.9.2
 Requires-Dist: autodistill
-Requires-Dist: transformers>=4.55.4
+Requires-Dist: transformers>=4.56.0
 Requires-Dist: hf_xet
 Requires-Dist: x-segment-anything>=0.0.8
 Requires-Dist: yolo-tiling>=0.0.19
@@ -39,6 +39,8 @@ Requires-Dist: beautifulsoup4>=4.12.2
 Requires-Dist: webdriver_manager
 Requires-Dist: dill
 Requires-Dist: seaborn
+Requires-Dist: GPUtil
+Requires-Dist: psutil
 Provides-Extra: all
 Requires-Dist: coralnet-toolbox[extra]; extra == "all"
 Dynamic: license-file
@@ -114,6 +116,7 @@ For a complete installation guide (including CUDA setup), see the [Installation
 | **Overview** | Get the big picture | [📋 Read More](https://jordan-pierce.github.io/CoralNet-Toolbox/overview) |
 | **Installation** | Detailed setup instructions | [⚙️ Setup Guide](https://jordan-pierce.github.io/CoralNet-Toolbox/installation) |
 | **Usage** | Learn the tools | [🛠️ User Manual](https://jordan-pierce.github.io/CoralNet-Toolbox/usage) |
+| **Hot Keys** | Keyboard shortcuts | [⌨️ Shortcuts](https://jordan-pierce.github.io/CoralNet-Toolbox/hot-keys) |
 | **Classification** | Community tutorial | [🧠 AI Tutorial](https://jordan-pierce.github.io/CoralNet-Toolbox/classify) |
 
 </div>
@@ -179,7 +182,7 @@ The toolbox integrates state-of-the-art models for efficient annotation workflow
 | **Framework** | **Models** | **Capability** |
 |:---:|:---:|:---:|
 | **YOLOE** | See Anything | Visual prompt detection |
-| **AutoDistill** | Grounding DINO • OWLViT • OmDetTurbo | Zero-shot detection |
+| **Transformers** | Grounding DINO • OWLViT • OmDetTurbo | Zero-shot detection |
 
 </div>
 
@@ -277,12 +280,9 @@ uv pip install coralnet-toolbox
 ### 🚀 **Step 3: GPU Acceleration (Optional)**
 For CUDA-enabled systems:
 ```bash
-# Example for CUDA 11.8
-conda install nvidia/label/cuda-11.8.0::cuda-nvcc -y
-conda install nvidia/label/cuda-11.8.0::cuda-toolkit -y
-
+# Example for CUDA 12.9
 # Install PyTorch with CUDA support
-uv pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 --upgrade
+uv pip install torch torchvision --index-url https://download.pytorch.org/whl/cu129 --upgrade
 ```
 
 ### 🏃‍♂️ **Step 4: Launch**