test onnx models

onnx_models/YOLOv8l/args.yaml

@@ -0,0 +1,95 @@
+task: detect
+mode: train
+model: /scratch/project_2007454/ship_detection/yolo_models/yolov8l.pt
+data: /run/nvme/job_15987187/data/processed//yolo_fold3.yaml
+epochs: 200
+patience: 30
+batch: -1
+imgsz: 640
+save: true
+save_period: -1
+cache: disk
+device: 0
+workers: 5
+project: /scratch/project_2007454/ship_detection/runs/yolov8l_Adam
+name: fold_3
+exist_ok: true
+pretrained: false
+optimizer: Adam
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+image_weights: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+show: false
+save_txt: false
+save_conf: false
+save_crop: false
+hide_labels: false
+hide_conf: false
+vid_stride: 1
+line_thickness: 3
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+boxes: true
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: false
+opset: null
+workspace: 4
+nms: false
+lr0: 0.001
+lrf: 0.01
+momentum: 0.9
+weight_decay: 0.0
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+fl_gamma: 0.0
+label_smoothing: 0.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.25
+shear: 0.0
+perspective: 0.0
+flipud: 0.5
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+cfg: null
+v5loader: false
+tracker: botsort.yaml
+save_dir: /scratch/project_2007454/ship_detection/runs/yolov8l_Adam/fold_3

onnx_models/YOLOv8l/best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4db77122653c39a3e229de324005ea023428a63c896f8624a07c14f9c345d96b
+size 174624801

onnx_models/YOLOv8m/args.yaml

@@ -0,0 +1,95 @@
+task: detect
+mode: train
+model: /scratch/project_2007454/ship_detection/yolo_models/yolov8m.pt
+data: /run/nvme/job_15987186/data/processed//yolo_fold3.yaml
+epochs: 200
+patience: 30
+batch: -1
+imgsz: 640
+save: true
+save_period: -1
+cache: disk
+device: 0
+workers: 5
+project: /scratch/project_2007454/ship_detection/runs/yolov8m_Adam
+name: fold_3
+exist_ok: true
+pretrained: false
+optimizer: Adam
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+image_weights: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+show: false
+save_txt: false
+save_conf: false
+save_crop: false
+hide_labels: false
+hide_conf: false
+vid_stride: 1
+line_thickness: 3
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+boxes: true
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: false
+opset: null
+workspace: 4
+nms: false
+lr0: 0.001
+lrf: 0.01
+momentum: 0.9
+weight_decay: 0.0
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+fl_gamma: 0.0
+label_smoothing: 0.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.25
+shear: 0.0
+perspective: 0.0
+flipud: 0.5
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+cfg: null
+v5loader: false
+tracker: botsort.yaml
+save_dir: /scratch/project_2007454/ship_detection/runs/yolov8m_Adam/fold_3

onnx_models/YOLOv8m/best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f55e1dca428d4c5ec3c61b29ecbb67e68af9505580e18d1e3215e37a526d955c
+size 103539108

onnx_models/YOLOv8n/args.yaml

@@ -0,0 +1,95 @@
+task: detect
+mode: train
+model: /scratch/project_2007454/ship_detection/yolo_models/yolov8n.pt
+data: /run/nvme/job_15987184/data/processed//yolo_fold3.yaml
+epochs: 200
+patience: 30
+batch: -1
+imgsz: 640
+save: true
+save_period: -1
+cache: disk
+device: 0
+workers: 5
+project: /scratch/project_2007454/ship_detection/runs/yolov8n_Adam
+name: fold_3
+exist_ok: true
+pretrained: false
+optimizer: Adam
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+image_weights: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+show: false
+save_txt: false
+save_conf: false
+save_crop: false
+hide_labels: false
+hide_conf: false
+vid_stride: 1
+line_thickness: 3
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+boxes: true
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: false
+opset: null
+workspace: 4
+nms: false
+lr0: 0.001
+lrf: 0.01
+momentum: 0.9
+weight_decay: 0.0
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+fl_gamma: 0.0
+label_smoothing: 0.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.25
+shear: 0.0
+perspective: 0.0
+flipud: 0.5
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+cfg: null
+v5loader: false
+tracker: botsort.yaml
+save_dir: /scratch/project_2007454/ship_detection/runs/yolov8n_Adam/fold_3

onnx_models/YOLOv8n/best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86c5fde83a420ecdc098c633588e02a0b69ce2d1b669e1d79cf45ce210a1b4d4
+size 12183580

onnx_models/YOLOv8s/args.yaml

@@ -0,0 +1,95 @@
+task: detect
+mode: train
+model: /scratch/project_2007454/ship_detection/yolo_models/yolov8s.pt
+data: /run/nvme/job_15987185/data/processed//yolo_fold3.yaml
+epochs: 200
+patience: 30
+batch: -1
+imgsz: 640
+save: true
+save_period: -1
+cache: disk
+device: 0
+workers: 5
+project: /scratch/project_2007454/ship_detection/runs/yolov8s_Adam
+name: fold_3
+exist_ok: true
+pretrained: false
+optimizer: Adam
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+image_weights: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+show: false
+save_txt: false
+save_conf: false
+save_crop: false
+hide_labels: false
+hide_conf: false
+vid_stride: 1
+line_thickness: 3
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+boxes: true
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: false
+opset: null
+workspace: 4
+nms: false
+lr0: 0.001
+lrf: 0.01
+momentum: 0.9
+weight_decay: 0.0
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+fl_gamma: 0.0
+label_smoothing: 0.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.25
+shear: 0.0
+perspective: 0.0
+flipud: 0.5
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+cfg: null
+v5loader: false
+tracker: botsort.yaml
+save_dir: /scratch/project_2007454/ship_detection/runs/yolov8s_Adam/fold_3

onnx_models/YOLOv8s/best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4dbc91dd16140c661fb49474b81aedaeacb8063ee32eeb249b768b8e0a5f0b5
+size 44664251

onnx_models/YOLOv8x/args.yaml

@@ -0,0 +1,95 @@
+task: detect
+mode: train
+model: /scratch/project_2007454/ship_detection/yolo_models/yolov8x.pt
+data: /run/nvme/job_15987188/data/processed//yolo_fold3.yaml
+epochs: 200
+patience: 30
+batch: -1
+imgsz: 640
+save: true
+save_period: -1
+cache: disk
+device: 0
+workers: 5
+project: /scratch/project_2007454/ship_detection/runs/yolov8x_Adam
+name: fold_3
+exist_ok: true
+pretrained: false
+optimizer: Adam
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+image_weights: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+show: false
+save_txt: false
+save_conf: false
+save_crop: false
+hide_labels: false
+hide_conf: false
+vid_stride: 1
+line_thickness: 3
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+boxes: true
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: false
+opset: null
+workspace: 4
+nms: false
+lr0: 0.001
+lrf: 0.01
+momentum: 0.9
+weight_decay: 0.0
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+fl_gamma: 0.0
+label_smoothing: 0.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.25
+shear: 0.0
+perspective: 0.0
+flipud: 0.5
+fliplr: 0.5
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+cfg: null
+v5loader: false
+tracker: botsort.yaml
+save_dir: /scratch/project_2007454/ship_detection/runs/yolov8x_Adam/fold_3

onnx_models/YOLOv8x/best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2367dee31d0eebd95661e86c70b6b7abbf43c5a913a51fda0056bd1fd3e4e33d
+size 272693412

src/sahi_onnx.py

@@ -0,0 +1,142 @@
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+from sahi.models.base import DetectionModel
+from sahi.prediction import ObjectPrediction
+from sahi.utils.compatibility import fix_full_shape_list, fix_shift_amount_list
+from sahi.utils.import_utils import check_requirements
+from .yolov8_onnx import *
+
+class Yolov8onnxDetectionModel(DetectionModel):
+    def check_dependencies(self) -> None:
+        check_requirements(["ultralytics"])
+
+    def load_model(self):
+        """
+        Detection model is initialized and set to self.model.
+        """
+        import yaml
+        from pathlib import Path
+        config = yaml.safe_load(Path(self.config_path).read_text())
+
+        try:
+            self.model = Yolov8onnx(
+                onnx_model=self.model_path,
+                input_width = config['imgsz'],
+                input_height = config['imgsz'],
+                confidence_thres=self.confidence_threshold,
+                iou_thres=0.5,
+                device=self.device
+                )
+        except Exception as e:
+            raise TypeError("model_path is not a valid yolov8 model path: ", e)
+
+        self.category_name_list = list(self.category_mapping.values())
+        self.category_name_list_len = len(self.category_name_list)
+
+
+    def perform_inference(self, image: np.ndarray):
+        """
+        Prediction is performed using self.model and the prediction result is set to self._original_predictions.
+        Args:
+            image: np.ndarray
+                A numpy array that contains the image to be predicted. 3 channel image should be in RGB order.
+        """
+
+        # Confirm model is loaded
+        if self.model is None:
+            raise ValueError("Model is not loaded, load it by calling .load_model()")
+        prediction_result = self.model.inference(image[:, :, ::-1])  # YOLOv8 expects numpy arrays to have BGR
+        #prediction_result = [
+        #    result.boxes.data[result.boxes.data[:, 4] >= self.confidence_threshold] for result in prediction_result
+        #]
+        self._original_predictions = [prediction_result]
+
+    @property
+    def num_categories(self):
+        return self.category_name_list_len
+
+    @property
+    def has_mask(self):
+        return False
+
+    @property
+    def category_names(self):
+        return self.category_name_list
+
+    def _create_object_prediction_list_from_original_predictions(
+        self,
+        shift_amount_list: Optional[List[List[int]]] = [[0, 0]],
+        full_shape_list: Optional[List[List[int]]] = None,
+    ):
+        """
+        self._original_predictions is converted to a list of prediction.ObjectPrediction and set to
+        self._object_prediction_list_per_image.
+        Args:
+            shift_amount_list: list of list
+                To shift the box and mask predictions from sliced image to full sized image, should
+                be in the form of List[[shift_x, shift_y],[shift_x, shift_y],...]
+            full_shape_list: list of list
+                Size of the full image after shifting, should be in the form of
+                List[[height, width],[height, width],...]
+        """
+        original_predictions = self._original_predictions
+
+        # compatilibty for sahi v0.8.15
+        shift_amount_list = fix_shift_amount_list(shift_amount_list)
+        full_shape_list = fix_full_shape_list(full_shape_list)
+
+        # handle all predictions
+        object_prediction_list_per_image = []
+        for image_ind, original_prediction in enumerate(original_predictions):
+            bboxes = original_prediction[0]
+            scores = original_prediction[1]
+            class_ids = original_prediction[2]
+            shift_amount = shift_amount_list[image_ind]
+            full_shape = None if full_shape_list is None else full_shape_list[image_ind]
+            object_prediction_list = []
+            # process predictions
+            for original_bbox, score, category_id in zip(bboxes, scores, class_ids):
+                x1 = original_bbox[0]
+                y1 = original_bbox[1]
+                x2 = original_bbox[2]
+                y2 = original_bbox[3]
+                bbox = [x1, y1, x2, y2]
+                category_name = self.category_mapping[str(category_id)]
+
+                # fix negative box coords
+                bbox[0] = max(0, bbox[0])
+                bbox[1] = max(0, bbox[1])
+                bbox[2] = max(0, bbox[2])
+                bbox[3] = max(0, bbox[3])
+
+                # fix out of image box coords
+                if full_shape is not None:
+                    bbox[0] = min(full_shape[1], bbox[0])
+                    bbox[1] = min(full_shape[0], bbox[1])
+                    bbox[2] = min(full_shape[1], bbox[2])
+                    bbox[3] = min(full_shape[0], bbox[3])
+
+                # ignore invalid predictions
+                if not (bbox[0] < bbox[2]) or not (bbox[1] < bbox[3]):
+                    logger.warning(f"ignoring invalid prediction with bbox: {bbox}")
+                    continue
+
+                object_prediction = ObjectPrediction(
+                    bbox=bbox,
+                    category_id=category_id,
+                    score=score,
+                    bool_mask=None,
+                    category_name=category_name,
+                    shift_amount=shift_amount,
+                    full_shape=full_shape,
+                )
+                object_prediction_list.append(object_prediction)
+            object_prediction_list_per_image.append(object_prediction_list)
+
+        self._object_prediction_list_per_image = object_prediction_list_per_image

src/yolov8_onnx.py

@@ -0,0 +1,148 @@
+import cv2
+import numpy as np
+import onnxruntime as ort
+import torch
+import copy
+
+from ultralytics.utils import ROOT, yaml_load
+from ultralytics.utils.checks import check_requirements, check_yaml
+
+
+class Yolov8onnx:
+
+    def __init__(self, 
+                 onnx_model,
+                 input_width,
+                 input_height, 
+                 confidence_thres, 
+                 iou_thres, 
+                 device='cpu'):
+        """
+        Initializes an instance of the Yolov8 class.
+
+        Args:
+            onnx_model: Path to the ONNX model.
+            confidence_thres: Confidence threshold for filtering detections.
+            iou_thres: IoU (Intersection over Union) threshold for non-maximum suppression.
+        """
+        self.onnx_model = onnx_model
+        self.confidence_thres = confidence_thres
+        self.iou_thres = iou_thres
+        self.input_width = input_width
+        self.input_height = input_height
+        if device == 'cpu':
+            providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+        else:
+            providers = ['CPUExecutionProvider']
+
+        self.onnx_session = ort.InferenceSession(
+            onnx_model,
+            providers=providers
+        )
+
+        self.input_name = self.onnx_session.get_inputs()[0].name
+        self.output_name = self.onnx_session.get_outputs()[0].name
+
+
+    def preprocess(self, input_image):
+        """
+        Preprocesses the input image before performing inference.
+
+        Returns:
+            image_data: Preprocessed image data ready for inference.
+        """
+        # Read the input image using OpenCV
+        self.img = input_image
+
+        # Get the height and width of the input image
+        self.img_height, self.img_width = self.img.shape[:2]
+
+        # Convert the image color space from BGR to RGB
+        img = cv2.cvtColor(self.img, cv2.COLOR_BGR2RGB)
+
+        # Resize the image to match the input shape
+        img = cv2.resize(img, (self.input_width, self.input_height))
+
+        # Normalize the image data by dividing it by 255.0
+        image_data = np.array(img) / 255.0
+
+        # Transpose the image to have the channel dimension as the first dimension
+        image_data = np.transpose(image_data, (2, 0, 1))  # Channel first
+
+        # Expand the dimensions of the image data to match the expected input shape
+        image_data = np.expand_dims(image_data, axis=0).astype(np.float32)
+
+        # Return the preprocessed image data
+        return image_data
+
+    def postprocess(self, output):
+        """
+        Performs post-processing on the model's output to extract bounding boxes, scores, and class IDs.
+        """
+
+        # Transpose and squeeze the output to match the expected shape
+        outputs = np.transpose(np.squeeze(output[0]))
+
+        # Get the number of rows in the outputs array
+        rows = outputs.shape[0]
+        # Lists to store the bounding boxes, scores, and class IDs of the detections
+        boxes = []
+        scores = []
+        class_ids = []
+
+        # Calculate the scaling factors for the bounding box coordinates
+        x_factor = self.img_width / self.input_width
+        y_factor = self.img_height / self.input_height
+        # Iterate over each row in the outputs array
+        for i in range(rows):
+            # Extract the class scores from the current row
+            classes_scores = outputs[i][4:]
+
+            # Find the maximum score among the class scores
+            max_score = np.amax(classes_scores)
+            # If the maximum score is above the confidence threshold
+            if max_score >= self.confidence_thres:
+                # Get the class ID with the highest score
+                class_id = np.argmax(classes_scores)
+
+                # Extract the bounding box coordinates from the current row
+                x, y, w, h = outputs[i][0], outputs[i][1], outputs[i][2], outputs[i][3]
+
+                # Calculate the scaled coordinates of the bounding box
+                left = int((x - w / 2) * x_factor)
+                top = int((y - h / 2) * y_factor)
+                width = int(w * x_factor)
+                height = int(h * y_factor)
+
+                # Add the class ID, score, and box coordinates to the respective lists
+                class_ids.append(int(class_id))
+                scores.append(max_score)
+                boxes.append([left, top, left+width, top+height])
+        # Apply non-maximum suppression to filter out overlapping bounding boxes
+        indices = cv2.dnn.NMSBoxes(boxes, scores, self.confidence_thres, self.iou_thres)
+        output_boxes = [boxes[i] for i in indices]
+        output_scores = [scores[i] for i in indices]
+        output_classes = [class_ids[i] for i in indices]
+
+        # Return the outputs
+        return output_boxes, output_scores, output_classes
+
+    def inference(self, image):
+        """
+        Performs inference using an ONNX model and returns the output image with drawn detections.
+
+        Returns:
+            output_img: The output image with drawn detections.
+        """
+        # Create an inference session using the ONNX model and specify execution providers
+        temp_image = copy.deepcopy(image)
+        image_height, image_width = image.shape[0], image.shape[1]
+
+        # Preprocess the image data
+        img_data = self.preprocess(temp_image)
+        # Run inference using the preprocessed image data
+        outputs = self.onnx_session.run(None, {self.input_name: img_data})
+        # Perform post-processing on the outputs to obtain output image.
+        bboxes, scores, class_ids = self.postprocess(outputs)
+        # Return the resulting output image
+        return bboxes, scores, class_ids