keras-hub-nightly 0.15.0.dev20240911134614__py3-none-any.whl → 0.16.0.dev2024092017__py3-none-any.whl

keras_hub/src/models/resnet/resnet_presets.py

@@ -14,7 +14,7 @@
 """ResNet preset configurations."""
 
 backbone_presets = {
-    "resnet_18": {
+    "resnet_18_imagenet": {
         "metadata": {
             "description": (
                 "18-layer ResNet model pre-trained on the ImageNet 1k dataset "
@@ -25,9 +25,9 @@ backbone_presets = {
             "path": "resnet",
             "model_card": "https://arxiv.org/abs/2110.00476",
         },
-        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_18/1",
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_18_imagenet/2",
     },
-    "resnet_50": {
+    "resnet_50_imagenet": {
         "metadata": {
             "description": (
                 "50-layer ResNet model pre-trained on the ImageNet 1k dataset "
@@ -38,9 +38,9 @@ backbone_presets = {
             "path": "resnet",
             "model_card": "https://arxiv.org/abs/2110.00476",
         },
-        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_50/1",
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_50_imagenet/2",
     },
-    "resnet_101": {
+    "resnet_101_imagenet": {
         "metadata": {
             "description": (
                 "101-layer ResNet model pre-trained on the ImageNet 1k dataset "
@@ -51,9 +51,9 @@ backbone_presets = {
             "path": "resnet",
             "model_card": "https://arxiv.org/abs/2110.00476",
         },
-        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_101/1",
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_101_imagenet/2",
     },
-    "resnet_152": {
+    "resnet_152_imagenet": {
         "metadata": {
             "description": (
                 "152-layer ResNet model pre-trained on the ImageNet 1k dataset "
@@ -64,9 +64,9 @@ backbone_presets = {
             "path": "resnet",
             "model_card": "https://arxiv.org/abs/2110.00476",
         },
-        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_152/1",
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_152_imagenet/2",
     },
-    "resnet_v2_50": {
+    "resnet_v2_50_imagenet": {
         "metadata": {
             "description": (
                 "50-layer ResNetV2 model pre-trained on the ImageNet 1k "
@@ -77,9 +77,9 @@ backbone_presets = {
             "path": "resnet",
             "model_card": "https://arxiv.org/abs/2110.00476",
         },
-        "kaggle_handle": "kaggle://kerashub/resnetv2/keras/resnet_v2_50/1",
+        "kaggle_handle": "kaggle://kerashub/resnetv2/keras/resnet_v2_50_imagenet/2",
     },
-    "resnet_v2_101": {
+    "resnet_v2_101_imagenet": {
         "metadata": {
             "description": (
                 "101-layer ResNetV2 model pre-trained on the ImageNet 1k "
@@ -90,6 +90,6 @@ backbone_presets = {
             "path": "resnet",
             "model_card": "https://arxiv.org/abs/2110.00476",
         },
-        "kaggle_handle": "kaggle://kerashub/resnetv2/keras/resnet_v2_101/1",
+        "kaggle_handle": "kaggle://kerashub/resnetv2/keras/resnet_v2_101_imagenet/2",
     },
 }

keras_hub/src/models/retinanet/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

keras_hub/src/models/retinanet/anchor_generator.py

@@ -0,0 +1,175 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+
+import keras
+from keras import ops
+
+from keras_hub.src.bounding_box.converters import convert_format
+
+
+class AnchorGenerator(keras.layers.Layer):
+    """Generates anchor boxes for object detection tasks.
+
+    This layer creates a set of anchor boxes (also known as default boxes or
+    priors) for use in object detection models, particularly those utilizing
+    Feature Pyramid Networks (FPN). It generates anchors across multiple
+    pyramid levels, with various scales and aspect ratios.
+
+    Feature Pyramid Levels:
+    - Levels typically range from 2 to 6 (P2 to P7), corresponding to different
+        resolutions of the input image.
+    - Each level l has a stride of 2^l pixels relative to the input image.
+    - Lower levels (e.g., P2) have higher resolution and are used for
+        detecting smaller objects.
+    - Higher levels (e.g., P7) have lower resolution and are used
+        for larger objects.
+
+    Args:
+        bounding_box_format (str): The format of the bounding boxes
+            to be generated. Expected to be a string like 'xyxy', 'xywh', etc.
+        min_level (int): Minimum level of the output feature pyramid.
+        max_level (int): Maximum level of the output feature pyramid.
+        num_scales (int): Number of intermediate scales added on each level.
+            For example, num_scales=2 adds one additional intermediate anchor
+            scale [2^0, 2^0.5] on each level.
+        aspect_ratios (list of float): Aspect ratios of anchors added on
+            each level. Each number indicates the ratio of width to height.
+        anchor_size (float): Scale of size of the base anchor relative to the
+            feature stride 2^level.
+
+    Call arguments:
+        images (Optional[Tensor]): An image tensor with shape `[B, H, W, C]` or
+            `[H, W, C]`. If provided, its shape will be used to determine anchor
+            sizes.
+
+    Returns:
+        Dict: A dictionary mapping feature levels
+        (e.g., 'P3', 'P4', etc.) to anchor boxes. Each entry contains a tensor
+        of shape `(H/stride * W/stride * num_anchors_per_location, 4)`,
+        where H and W are the height and width of the image, stride is 2^level,
+        and num_anchors_per_location is `num_scales * len(aspect_ratios)`.
+
+    Example:
+    ```python
+    anchor_generator = AnchorGenerator(
+        bounding_box_format='xyxy',
+        min_level=3,
+        max_level=7,
+        num_scales=3,
+        aspect_ratios=[0.5, 1.0, 2.0],
+        anchor_size=4.0,
+    )
+    anchors = anchor_generator(images=keas.ops.ones(shape=(2, 640, 480, 3)))
+    ```
+    """
+
+    def __init__(
+        self,
+        bounding_box_format,
+        min_level,
+        max_level,
+        num_scales,
+        aspect_ratios,
+        anchor_size,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.bounding_box_format = bounding_box_format
+        self.min_level = min_level
+        self.max_level = max_level
+        self.num_scales = num_scales
+        self.aspect_ratios = aspect_ratios
+        self.anchor_size = anchor_size
+        self.built = True
+
+    def call(self, images):
+        images_shape = ops.shape(images)
+        if len(images_shape) == 4:
+            image_shape = images_shape[1:-1]
+        else:
+            image_shape = images_shape[:-1]
+
+        image_shape = tuple(image_shape)
+
+        multilevel_boxes = {}
+        for level in range(self.min_level, self.max_level + 1):
+            boxes_l = []
+            # Calculate the feature map size for this level
+            feat_size_y = math.ceil(image_shape[0] / 2**level)
+            feat_size_x = math.ceil(image_shape[1] / 2**level)
+
+            # Calculate the stride (step size) for this level
+            stride_y = ops.cast(image_shape[0] / feat_size_y, "float32")
+            stride_x = ops.cast(image_shape[1] / feat_size_x, "float32")
+
+            # Generate anchor center points
+            # Start from stride/2 to center anchors on pixels
+            cx = ops.arange(stride_x / 2, image_shape[1], stride_x)
+            cy = ops.arange(stride_y / 2, image_shape[0], stride_y)
+
+            # Create a grid of anchor centers
+            cx_grid, cy_grid = ops.meshgrid(cx, cy)
+
+            for scale in range(self.num_scales):
+                for aspect_ratio in self.aspect_ratios:
+                    # Calculate the intermediate scale factor
+                    intermidate_scale = 2 ** (scale / self.num_scales)
+                    # Calculate the base anchor size for this level and scale
+                    base_anchor_size = (
+                        self.anchor_size * 2**level * intermidate_scale
+                    )
+                    # Adjust anchor dimensions based on aspect ratio
+                    aspect_x = aspect_ratio**0.5
+                    aspect_y = aspect_ratio**-0.5
+                    half_anchor_size_x = base_anchor_size * aspect_x / 2.0
+                    half_anchor_size_y = base_anchor_size * aspect_y / 2.0
+
+                    # Generate anchor boxes (y1, x1, y2, x2 format)
+                    boxes = ops.stack(
+                        [
+                            cy_grid - half_anchor_size_y,
+                            cx_grid - half_anchor_size_x,
+                            cy_grid + half_anchor_size_y,
+                            cx_grid + half_anchor_size_x,
+                        ],
+                        axis=-1,
+                    )
+                    boxes_l.append(boxes)
+            # Concat anchors on the same level to tensor shape HxWx(Ax4)
+            boxes_l = ops.concatenate(boxes_l, axis=-1)
+            boxes_l = ops.reshape(boxes_l, (-1, 4))
+            # Convert to user defined
+            multilevel_boxes[f"P{level}"] = convert_format(
+                boxes_l,
+                source="yxyx",
+                target=self.bounding_box_format,
+            )
+        return multilevel_boxes
+
+    def compute_output_shape(self, input_shape):
+        multilevel_boxes_shape = {}
+        for level in range(self.min_level, self.max_level + 1):
+            multilevel_boxes_shape[f"P{level}"] = (None, None, 4)
+        return multilevel_boxes_shape
+
+    @property
+    def anchors_per_location(self):
+        """
+        The `anchors_per_location` property returns the number of anchors
+        generated per pixel location, which is equal to
+        `num_scales * len(aspect_ratios)`.
+        """
+        return self.num_scales * len(self.aspect_ratios)

keras_hub/src/models/retinanet/box_matcher.py

@@ -0,0 +1,259 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import keras
+from keras import ops
+
+
+class BoxMatcher(keras.layers.Layer):
+    """Box matching logic based on argmax of highest value (e.g., IOU).
+
+    This class computes matches from a similarity matrix. Each row will be
+    matched to at least one column, the matched result can either be positive
+    or negative, or simply ignored depending on the setting.
+
+    The settings include `thresholds` and `match_values`, for example if:
+    1) `thresholds=[negative_threshold, positive_threshold]`, and
+       `match_values=[negative_value=0, ignore_value=-1, positive_value=1]`: the
+       rows will be assigned to positive_value if its argmax result >=
+       positive_threshold; the rows will be assigned to negative_value if its
+       argmax result < negative_threshold, and the rows will be assigned to
+       ignore_value if its argmax result is between [negative_threshold,
+       positive_threshold).
+    2) `thresholds=[negative_threshold, positive_threshold]`, and
+       `match_values=[ignore_value=-1, negative_value=0, positive_value=1]`: the
+       rows will be assigned to positive_value if its argmax result >=
+       positive_threshold; the rows will be assigned to ignore_value if its
+       argmax result < negative_threshold, and the rows will be assigned to
+       negative_value if its argmax result is between [negative_threshold,
+       positive_threshold). This is different from case 1) by swapping first two
+       values.
+    3) `thresholds=[positive_threshold]`, and
+       `match_values=[negative_values, positive_value]`: the rows will be
+        assigned to positive value if its argmax result >= positive_threshold;
+        the rows will be assigned to negative_value if its argmax result <
+        negative_threshold.
+
+    Args:
+        thresholds: A sorted list of floats to classify the matches into
+            different results (e.g. positive or negative or ignored match). The
+            list will be prepended with -Inf and and appended with +Inf.
+        match_values: A list of integers representing matched results (e.g.
+            positive or negative or ignored match). len(`match_values`) must
+            equal to len(`thresholds`) + 1.
+        force_match_for_each_col: each row will be argmax matched to at
+            least one column. This means some columns will be matched to
+            multiple rows while some columns will not be matched to any rows.
+            Filtering by `thresholds` will make less columns match to positive
+            result. Setting this to True guarantees that each column will be
+            matched to positive result to at least one row.
+
+    Raises:
+        ValueError: if `thresholds` not sorted or
+        len(`match_values`) != len(`thresholds`) + 1
+
+    Example:
+    ```python
+    box_matcher = keras_cv.layers.BoxMatcher([0.3, 0.7], [-1, 0, 1])
+    iou_metric = keras_cv.bounding_box.compute_iou(anchors, boxes)
+    matched_columns, matched_match_values = box_matcher(iou_metric)
+    cls_mask = ops.less_equal(matched_match_values, 0)
+    ```
+
+    """
+
+    def __init__(
+        self,
+        thresholds,
+        match_values,
+        force_match_for_each_col=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        if sorted(thresholds) != thresholds:
+            raise ValueError(f"`threshold` must be sorted, got {thresholds}")
+        self.match_values = match_values
+        if len(match_values) != len(thresholds) + 1:
+            raise ValueError(
+                f"len(`match_values`) must be len(`thresholds`) + 1, got "
+                f"match_values {match_values}, thresholds {thresholds}"
+            )
+        thresholds.insert(0, -float("inf"))
+        thresholds.append(float("inf"))
+        self.thresholds = thresholds
+        self.force_match_for_each_col = force_match_for_each_col
+        self.built = True
+
+    def call(self, similarity_matrix):
+        """Matches each row to a column based on argmax
+
+        Args:
+            similarity_matrix: A float Tensor of shape `[num_rows, num_cols]` or
+                `[batch_size, num_rows, num_cols]` representing any similarity
+                metric.
+
+        Returns:
+            matched_columns: An integer tensor of shape `[num_rows]` or
+                `[batch_size, num_rows]` storing the index of the matched
+                column for each row.
+            matched_values: An integer tensor of shape [num_rows] or
+                `[batch_size, num_rows]` storing the match result
+                `(positive match, negative match, ignored match)`.
+        """
+        squeeze_result = False
+        if len(similarity_matrix.shape) == 2:
+            squeeze_result = True
+            similarity_matrix = ops.expand_dims(similarity_matrix, axis=0)
+        static_shape = list(similarity_matrix.shape)
+        num_rows = static_shape[1] or ops.shape(similarity_matrix)[1]
+        batch_size = static_shape[0] or ops.shape(similarity_matrix)[0]
+
+        def _match_when_cols_are_empty():
+            """Performs matching when the rows of similarity matrix are empty.
+            When the rows are empty, all detections are false positives. So we
+            return a tensor of -1's to indicate that the rows do not match to
+            any columns.
+
+            Returns:
+                matched_columns: An integer tensor of shape [batch_size,
+                    num_rows] storing the index of the matched column for each
+                    row.
+                matched_values: An integer tensor of shape [batch_size,
+                    num_rows] storing the match type indicator (e.g. positive or
+                    negative or ignored match).
+            """
+            matched_columns = ops.zeros([batch_size, num_rows], dtype="int32")
+            matched_values = -ops.ones([batch_size, num_rows], dtype="int32")
+            return matched_columns, matched_values
+
+        def _match_when_cols_are_non_empty():
+            """Performs matching when the rows of similarity matrix are
+            non-empty.
+            Returns:
+                matched_columns: An integer tensor of shape [batch_size,
+                    num_rows] storing the index of the matched column for each
+                    row.
+                matched_values: An integer tensor of shape [batch_size,
+                    num_rows] storing the match type indicator (e.g. positive or
+                    negative or ignored match).
+            """
+            # Jax traces this function even when running eagerly and the
+            # columns are non-empty. Therefore, we need to handle the case
+            # where the similarity matrix is empty. We do this by padding
+            # some -1s to the end. -1s are guaranteed to not affect argmax
+            # matching because all values in a similarity matrix are [0,1]
+            # and the indexing won't change because these are added at the
+            # end.
+            padded_similarity_matrix = ops.concatenate(
+                [similarity_matrix, -ops.ones((batch_size, num_rows, 1))],
+                axis=-1,
+            )
+
+            matched_columns = ops.argmax(
+                padded_similarity_matrix,
+                axis=-1,
+            )
+
+            # Get logical indices of ignored and unmatched columns as int32
+            matched_vals = ops.max(padded_similarity_matrix, axis=-1)
+            matched_values = ops.zeros([batch_size, num_rows], "int32")
+
+            match_dtype = matched_vals.dtype
+            for ind, low, high in zip(
+                self.match_values, self.thresholds[:-1], self.thresholds[1:]
+            ):
+                low_threshold = ops.cast(low, match_dtype)
+                high_threshold = ops.cast(high, match_dtype)
+                mask = ops.logical_and(
+                    ops.greater_equal(matched_vals, low_threshold),
+                    ops.less(matched_vals, high_threshold),
+                )
+                matched_values = self._set_values_using_indicator(
+                    matched_values, mask, ind
+                )
+
+            if self.force_match_for_each_col:
+                # [batch_size, num_cols], for each column (groundtruth_box),
+                # find the best matching row (anchor).
+                matching_rows = ops.argmax(
+                    padded_similarity_matrix,
+                    axis=1,
+                )
+                # [batch_size, num_cols, num_rows], a transposed 0-1 mapping
+                # matrix M, where M[j, i] = 1 means column j is matched to
+                # row i.
+                column_to_row_match_mapping = ops.one_hot(
+                    matching_rows, num_rows
+                )
+                # [batch_size, num_rows], for each row (anchor), find the
+                # matched column (groundtruth_box).
+                force_matched_columns = ops.argmax(
+                    column_to_row_match_mapping,
+                    axis=1,
+                )
+                # [batch_size, num_rows]
+                force_matched_column_mask = ops.cast(
+                    ops.max(column_to_row_match_mapping, axis=1),
+                    "bool",
+                )
+                # [batch_size, num_rows]
+                matched_columns = ops.where(
+                    force_matched_column_mask,
+                    force_matched_columns,
+                    matched_columns,
+                )
+                matched_values = ops.where(
+                    force_matched_column_mask,
+                    self.match_values[-1]
+                    * ops.ones([batch_size, num_rows], dtype="int32"),
+                    matched_values,
+                )
+
+            return ops.cast(matched_columns, "int32"), matched_values
+
+        num_boxes = (
+            similarity_matrix.shape[-1] or ops.shape(similarity_matrix)[-1]
+        )
+        matched_columns, matched_values = ops.cond(
+            pred=ops.greater(num_boxes, 0),
+            true_fn=_match_when_cols_are_non_empty,
+            false_fn=_match_when_cols_are_empty,
+        )
+
+        if squeeze_result:
+            matched_columns = ops.squeeze(matched_columns, axis=0)
+            matched_values = ops.squeeze(matched_values, axis=0)
+
+        return matched_columns, matched_values
+
+    def _set_values_using_indicator(self, x, indicator, val):
+        """Set the indicated fields of x to val.
+
+        Args:
+            x: tensor.
+            indicator: boolean with same shape as x.
+            val: scalar with value to set.
+        Returns:
+            modified tensor.
+        """
+        indicator = ops.cast(indicator, x.dtype)
+        return ops.where(indicator == 0, x, val)
+
+    def get_config(self):
+        config = {
+            "thresholds": self.thresholds[1:-1],
+            "match_values": self.match_values,
+            "force_match_for_each_col": self.force_match_for_each_col,
+        }
+        return config