edgefirst-validator 4.2.1__py3-none-any.whl

edgefirst/validator/runners/deepviewrt.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import os
+from time import monotonic_ns as clock_now
+from typing import TYPE_CHECKING, List, Any
+
+import numpy as np
+
+from edgefirst.validator.publishers.utils.logger import logger
+from edgefirst.validator.runners.processing.outputs import Outputs
+from edgefirst.validator.runners.core import Runner
+
+if TYPE_CHECKING:
+    from edgefirst.validator.evaluators import ModelParameters, TimerContext
+
+
+class DeepViewRTRunner(Runner):
+    """
+    Loads and runs DeepViewRT models using the VAAL API.
+
+    Parameters
+    ----------
+    model: List[str]
+        This is typically the path to the model backbone and decoder.
+    parameters: ModelParameters
+        These are the model parameters set from the command line.
+    metadata: dict
+        The model metadata which contains information for decoding
+        the model outputs.
+    timer: TimerContext
+        A timer object for handling validation timings for the model.
+
+    Raises
+    ------
+    ImportError
+        Raised if the deepview.vaal library is not found.
+    EnvironmentError
+        Raised if VAAL Context is not found.
+    FileNotFoundError
+        Raised if the path to the model does not exist.
+    NotImplementedError
+        Some methods have not been implemented yet.
+    """
+
+    def __init__(
+        self,
+        model: List[str],
+        parameters: ModelParameters,
+        metadata: dict,
+        timer: TimerContext
+    ):
+        super(DeepViewRTRunner, self).__init__(model, parameters, timer=timer)
+
+        try:
+            import deepview.vaal as vaal  # type: ignore
+        except ImportError:
+            raise ImportError(
+                "VAAL library is needed to run DeepViewRT models.")
+
+        try:
+            self.ctx = vaal.Context(self.parameters.engine)
+        except AttributeError:
+            raise EnvironmentError(
+                'Did not find Vaal Context. Try setting the environment \
+                    variable VAAL_LIBRARY to the VAAL library.')
+
+        # Change because VAAL automatically uses CPU if NPU is unavailable.
+        self.parameters.engine = self.ctx.device
+
+        if self.parameters.max_detections is not None:
+            self.ctx['max_detection'] = self.parameters.max_detections
+        self.ctx['score_threshold'] = self.parameters.score_threshold
+        self.ctx['iou_threshold'] = self.parameters.iou_threshold
+
+        if (self.parameters.nms in ['standard', 'fast', 'matrix']):
+            self.ctx['nms_type'] = self.parameters.nms
+
+        if self.parameters.common.norm == 'raw':
+            self.ctx['proc'] = vaal.ImageProc.RAW
+        elif self.parameters.common.norm == 'signed':
+            self.ctx['proc'] = vaal.ImageProc.SIGNED_NORM
+        elif self.parameters.common.norm == 'unsigned':
+            self.ctx['proc'] = vaal.ImageProc.UNSIGNED_NORM
+        elif self.parameters.common.norm == 'whitening':
+            self.ctx['proc'] = vaal.ImageProc.WHITENING
+        elif self.parameters.common.norm == 'imagenet':
+            self.ctx['proc'] = vaal.ImageProc.IMAGENET
+        else:
+            logger(f"Unsupported normalization method: {self.parameters.common.norm}",
+                   code="ERROR")
+
+        if not os.path.exists(model):
+            raise FileNotFoundError(
+                "The model '{}' does not exist.".format(model))
+
+        self.ctx.load_model(model)
+
+        if len(self.ctx.labels) > 0:
+            self.parameters.labels = self.ctx.labels
+
+        outputs = [{"quantization": [out.scales, out.zeros],
+                    "shape": out.shape} for out in self.ctx.outputs]
+        # Parse the model output details in the metadata.
+        self.outputs = Outputs(
+            metadata=metadata,
+            parameters=parameters,
+            outputs=outputs
+        )
+
+        if self.parameters.warmup > 0:
+            self.warmup()
+
+    def warmup(self):
+        """
+        Run model warmup.
+        """
+        logger("Running model warmup...", code="INFO")
+
+        times = []
+        for _ in range(self.parameters.warmup):
+            start = clock_now()
+            self.ctx.run_model()
+            stop = clock_now() - start
+            times.append(stop * 1e-6)
+
+        outputs = []
+        for x in self.ctx.outputs:
+            outputs.append(x.array())
+
+        # Warmup output postprocessing.
+        if len(outputs):
+            self.postprocessing(outputs)
+
+        message = "model warmup took %f ms (%f ms avg)" % (np.sum(times),
+                                                           np.average(times))
+        logger(message, code="INFO")
+        self.timer.reset()
+
+    def run_single_instance(self, image: str) -> Any:
+        """
+        Run two stage DeepViewRT inference
+        on a single image and record the timings.
+
+        Parameters
+        ----------
+        image: str
+            The path to the image. This is used to match the
+            annotation to be read.
+
+        Returns
+        -------
+        Any
+            This could either return detection outputs after NMS.
+                np.ndarray
+                    The prediction bounding boxes.. [[box1], [box2], ...].
+                np.ndarray
+                    The prediction labels.. [cl1, cl2, ...].
+                np.ndarray
+                    The prediction confidence scores.. [score, score, ...]
+                    normalized between 0 and 1.
+            This could also return segmentation masks.
+                np.ndarray
+        """
+        # Preprocessing
+        with self.timer.time("input"):
+            self.ctx.load_image(image)
+
+        # Inference
+        with self.timer.time("inference"):
+            self.ctx.run_model()
+
+        outputs = []
+        for x in self.ctx.outputs:
+            outputs.append(x.array())
+
+        # Postprocessing
+        return self.postprocessing(outputs)

edgefirst/validator/runners/hailo.py

@@ -0,0 +1,263 @@
+"""
+This implementation is currently deprecated!
+"""
+
+from __future__ import annotations
+
+from timeit import timeit
+from time import monotonic_ns as clock_now
+from typing import TYPE_CHECKING, Tuple, Union
+
+import numpy as np
+
+from edgefirst.validator.publishers.utils.logger import logger
+from edgefirst.validator.datasets.utils.transformations import (resize, pad)
+from edgefirst.validator.runners.core import Runner
+
+if TYPE_CHECKING:
+    from edgefirst.validator.evaluators import Parameters
+
+
+class HailoRunner(Runner):
+    """
+    Runs Hailo models.
+
+    Parameters
+    ----------
+        model: str
+            The path to the model or the loaded Hailo model.
+
+        parameters: Parameters
+            These are the model parameters set from the command line.
+
+        labels: list
+            Unique string labels.
+
+    Raises
+    ------
+    ImportError
+        Raised if hailo_platform library is not intalled.
+    """
+
+    def __init__(
+        self,
+        model,
+        parameters: Parameters,
+        labels: list = None
+    ):
+        super(HailoRunner, self).__init__(model, parameters, labels)
+
+        try:
+            from hailo_platform import (  # type: ignore
+                HEF, Device, VDevice, HailoStreamInterface, ConfigureParams,
+                InputVStreamParams, OutputVStreamParams, FormatType,
+                InferVStreams)
+        except ImportError:
+            raise ImportError(
+                "hailo_platform library is needed to run Hailo models.")
+
+        if isinstance(model, str):
+            model = self.validate_model_path(model)
+            devices = Device.scan()
+            self.hef = HEF(model)
+            self.target = VDevice(device_ids=devices)
+            configure_params = ConfigureParams.create_from_hef(
+                self.hef, interface=HailoStreamInterface.PCIe)
+            self.network_group = self.target.configure(
+                self.hef, configure_params)[0]
+            self.network_group_params = self.network_group.create_params()
+
+            self.input_vstreams_params = InputVStreamParams.make_from_network_group(
+                self.network_group, quantized=False, format_type=FormatType.FLOAT32)
+            self.output_vstreams_params = OutputVStreamParams.make_from_network_group(
+                self.network_group, quantized=False, format_type=FormatType.FLOAT32)
+        else:
+            raise ValueError("Only string filepaths are supported")
+
+        self.parameters.engine = "hailo"
+
+        if self.parameters.warmup > 0:
+            input_vstream_info = self.hef.get_input_vstream_infos()[0]
+            with InferVStreams(self.network_group, self.input_vstreams_params, self.output_vstreams_params) as infer_pipeline:
+                # Produce a sample image of zeros.
+                input_type = "float32" if "float" in self.get_input_type() else "uint32"
+                height, width = self.get_input_shape()[1:3]
+                image = np.expand_dims(np.zeros((height, width, 3)), 0).astype(
+                    np.dtype(input_type))
+                input_data = {input_vstream_info.name: np.expand_dims(
+                    image, axis=0).astype(np.float32)}
+
+                with self.network_group.activate(self.network_group_params):
+                    logger("Loading model and warmup...", code="INFO")
+                    t = timeit(lambda: infer_pipeline.infer(input_data),
+                               number=self.parameters.warmup)
+                    logger("model warmup took %f seconds (%f ms avg)" %
+                           (t, t * 1000 / self.parameters.warmup), code="INFO")
+
+    def run_single_instance(
+        self,
+        image: Union[str, np.ndarray]
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Produce Hailo inference on one image and records the timings.
+
+        Parameters
+        ----------
+            image: str or np.ndarray
+                The path to the image or NumPy array image.
+
+        Returns
+        -------
+            nmsed_boxes: np.ndarray
+                The prediction bounding boxes.. [[box1], [box2], ...].
+
+            nmsed_classes: np.ndarray
+                The prediction labels.. [cl1, cl2, ...].
+
+            nmsed_scores: np.ndarray
+                The prediction confidence scores.. [score, score, ...]
+                normalized between 0 and 1.
+        """
+        try:
+            from hailo_platform import InferVStreams  # type: ignore
+        except ImportError:
+            raise ImportError(
+                "hailo_platform library is needed to run Hailo models.")
+        input_vstream_info = self.hef.get_input_vstream_infos()[0]
+        output_name = self.hef.get_output_vstream_infos()[0].name
+
+        with InferVStreams(
+            self.network_group,
+            self.input_vstreams_params,
+            self.output_vstreams_params
+        ) as infer_pipeline:
+            infer_pipeline.set_nms_iou_threshold(self.parameters.iou_threshold)
+            infer_pipeline.set_nms_score_threshold(
+                self.parameters.score_threshold)
+
+            """Inference"""
+            start = clock_now()
+            input_data = {
+                input_vstream_info.name: image
+            }
+            with self.network_group.activate(self.network_group_params):
+                raw_detections = infer_pipeline.infer(input_data)
+            infer_ns = clock_now() - start
+            self.backbone_timings.append(infer_ns * 1e-6)
+
+            """Postprocessing"""
+            # An output with 7 columns refers to batch_id, xmin, ymin, xmax, ymax, cls, score.
+            # Otherwise it is batch_size, number of boxes, number of classes
+            # which needs external NMS.
+            # Decoder and box timings are measured in this function.
+            nmsed_boxes, nmsed_classes, nmsed_scores = self.postprocessing(
+                raw_detections[output_name][0])
+
+        return nmsed_boxes, nmsed_classes, nmsed_scores
+
+    def postprocessing(
+            self, output: list) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Retrieves the boxes, scores and labels.
+
+        Parameters
+        ----------
+            outputs:
+                This contains bounding boxes, scores, labels in the format.
+                [[xmin, ymin, xmax, ymax, confidence, label], [...], ...].
+
+        Returns
+        -------
+            nmsed_boxes: np.ndarray
+                The prediction bounding boxes.. [[box1], [box2], ...].
+
+            nmsed_classes: np.ndarray
+                The prediction labels.. [cl1, cl2, ...].
+
+            nmsed_scores: np.ndarray
+                The prediction confidence scores.. [score, score, ...]
+                normalized between 0 and 1.
+        """
+        boxes, classes, scores = list(), list(), list()
+        num_detections = 0
+
+        for i, detection in enumerate(output):
+            if len(detection) == 0:
+                continue
+            for j in range(len(detection)):
+                bbox = np.array(detection)[j][:4]
+                score = np.array(detection)[j][4]
+                xyxy_bbox = np.asarray([bbox[1], bbox[0], bbox[3], bbox[2]])
+                boxes.append(xyxy_bbox)
+                scores.append(score)
+                classes.append(i)
+                num_detections = num_detections + 1
+
+        nmsed_classes = np.asarray(classes)
+        if self.parameters.label_offset != 0:
+            nmsed_classes += self.parameters.label_offset
+        return np.asarray(boxes), nmsed_classes, np.asarray(scores)
+
+    def get_input_type(self) -> str:
+        """
+        This returns the input type of the model.
+
+        Returns
+        -------
+            type: str
+                The input type of the model.
+        """
+        inputs = self.hef.get_input_vstream_infos()
+        base_format = str(inputs[0].format.type)
+        return base_format[base_format.find('.') + 1:].lower()
+
+    def get_input_shape(self) -> np.ndarray:
+        """
+        Grabs the model input shape.
+
+        Returns
+        -------
+            shape: np.ndarray
+                The model input shape.
+                (batch size, channels, height, width).
+        """
+        inputs = self.hef.get_input_vstream_infos()
+        return tuple([1] + list(inputs[0].shape))
+
+    def get_output_type(self) -> str:
+        """
+        This returns the output type of the model.
+
+        Returns
+        -------
+            type: str
+                The output type of the model.
+        """
+        outputs = self.hef.get_output_vstream_infos()
+        base_format = str(outputs[0].format.type)
+        return base_format[base_format.find('.') + 1:].lower()
+
+    def get_output_shape(self) -> np.ndarray:
+        """
+        Grabs the model output shape.
+
+        Returns
+        --------
+            shape: np.ndarray
+                The model output shape.
+                (batch size, boxes, classes).
+        """
+        outputs = self.hef.get_output_vstream_infos()
+        return outputs[0].shape
+
+    def get_image_shape(self) -> tuple:
+        """
+        Returns the input image shape passed to the model.
+
+        Returns
+        -------
+            shape: tuple
+                The shape as (height, width).
+        """
+        _, _, height, width = self.get_input_shape()
+        return (height, width)

edgefirst/validator/runners/keras.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from edgefirst.validator.runners.core import Runner
+
+if TYPE_CHECKING:
+    from edgefirst.validator.evaluators import ModelParameters, TimerContext
+
+
+class KerasRunner(Runner):
+    """
+    Loads and runs the Keras (.h5, .keras) models using the TensorFlow library.
+
+    Parameters
+    ----------
+    model: str or tf.keras.Model
+        The path to the model or the loaded keras model.
+    parameters: ModelParameters
+        These are the model parameters set from the command line.
+    metadata: dict
+        The model metadata which contains information for decoding
+        the model outputs.
+    timer: TimerContext
+        A timer object for handling validation timings for the model.
+
+    Raises
+    ------
+    ImportError
+        Raised if the TensorFlow library is not installed.
+    FileNotFoundError
+        Raised if the path to the model does not exist.
+    """
+
+    def __init__(
+        self,
+        model: Any,
+        parameters: ModelParameters,
+        metadata: dict,
+        timer: TimerContext
+    ):
+        super(KerasRunner, self).__init__(model, parameters, timer=timer)
+
+        # Load Argmax dependency needed for keras
+        try:
+            from deepview.modelpack.utils.argmax import Argmax
+        except ImportError:
+            pass
+
+        try:
+            os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+            import tensorflow as tf  # type: ignore
+        except ImportError:
+            raise ImportError(
+                "TensorFlow is needed to run keras models.")
+
+        if isinstance(model, str):
+            if not os.path.exists(model):
+                raise FileNotFoundError(
+                    "The model '{}' does not exist.".format(model))
+
+            if os.path.exists(os.path.join(model, "saved_model.pb")):
+                self.model = tf.saved_model.load(model)
+                self.input = self.model.signatures["serving_default"].inputs
+                outputs = self.model.signatures["serving_default"].outputs
+            else:
+                self.model = tf.keras.models.load_model(model, compile=False)
+                outputs = self.model.output
+                self.input = self.model.input
+        self.init_decoder(metadata=metadata, outputs=outputs)
+
+        if self.parameters.warmup > 0:
+            self.warmup()
+
+    def run_single_instance(self, image: np.ndarray) -> Any:
+        """
+        Run Keras inference on a single image and record the timings.
+
+        Parameters
+        ----------
+        image: np.ndarray
+            The input image after being preprocessed.
+            Typically this is an RGB image array.
+
+        Returns
+        -------
+        Any
+            This could either return detection outputs after NMS.
+                np.ndarray
+                    The prediction bounding boxes.. [[box1], [box2], ...].
+                np.ndarray
+                    The prediction labels.. [cl1, cl2, ...].
+                np.ndarray
+                    The prediction confidence scores.. [score, score, ...]
+                    normalized between 0 and 1.
+            This could also return segmentation masks.
+                np.ndarray
+        """
+        # Inference
+        with self.timer.time("inference"):
+            outputs = self.model(image)
+
+        # Postprocessing
+        return self.postprocessing(outputs)
+
+    def get_input_type(self) -> np.dtype:
+        """
+        This returns the input type of the model with shape
+        (batch size, channels, height, width) or
+        (batch size, height, width, channels).
+
+        Returns
+        -------
+        np.dtype
+            The input type of the model.
+        """
+        try:
+            try:
+                return self.model.input.dtype.as_numpy_dtype
+            except AttributeError:
+                return np.dtype(self.model.input.dtype)
+        except AttributeError:
+            for input in self.input:
+                shape = input.shape
+                if len(shape) == 4:
+                    if shape[1] == 3 or shape[-1] == [3]:
+                        return input.dtype
+            return self.input[0].dtype
+
+    def get_input_shape(self) -> np.ndarray:
+        """
+        Grabs the model input shape.
+
+        Returns
+        -------
+        np.ndarray
+            The model input shape (batch size, channels, height, width) or
+            (batch size, height, width, channels).
+        """
+        try:
+            return self.model.input.shape
+        except AttributeError:
+            for input in self.input:
+                shape = input.shape
+                if len(shape) == 4:
+                    if shape[1] == 3 or shape[-1] == [3]:
+                        return shape
+            return self.input[0].shape