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

keras_hub/src/models/resnet/resnet_image_classifier.py

@@ -16,6 +16,9 @@ import keras
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.resnet.resnet_backbone import ResNetBackbone
+from keras_hub.src.models.resnet.resnet_image_classifier_preprocessor import (
+    ResNetImageClassifierPreprocessor,
+)
 
 
 @keras_hub_export("keras_hub.models.ResNetImageClassifier")
@@ -42,7 +45,9 @@ class ResNetImageClassifier(ImageClassifier):
     ```python
     # Load preset and train
     images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset("resnet50")
+    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
+        "resnet_50_imagenet"
+    )
     classifier.predict(images)
     ```
 
@@ -51,13 +56,17 @@ class ResNetImageClassifier(ImageClassifier):
     # Load preset and train
     images = np.ones((2, 224, 224, 3), dtype="float32")
     labels = [0, 3]
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset("resnet50")
+    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
+        "resnet_50_imagenet"
+    )
     classifier.fit(x=images, y=labels, batch_size=2)
     ```
 
     Call `fit()` with custom loss, optimizer and backbone.
     ```python
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset("resnet50")
+    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
+        "resnet_50_imagenet"
+    )
     classifier.compile(
         loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
         optimizer=keras.optimizers.Adam(5e-5),
@@ -88,21 +97,36 @@ class ResNetImageClassifier(ImageClassifier):
     """
 
     backbone_cls = ResNetBackbone
+    preprocessor_cls = ResNetImageClassifierPreprocessor
 
     def __init__(
         self,
         backbone,
         num_classes,
-        activation="softmax",
+        preprocessor=None,
+        pooling="avg",
+        activation=None,
         head_dtype=None,
-        preprocessor=None,  # adding this dummy arg for saved model test
-        # TODO: once preprocessor flow is figured out, this needs to be updated
         **kwargs,
     ):
         head_dtype = head_dtype or backbone.dtype_policy
 
         # === Layers ===
         self.backbone = backbone
+        self.preprocessor = preprocessor
+        if pooling == "avg":
+            self.pooler = keras.layers.GlobalAveragePooling2D(
+                data_format=backbone.data_format, dtype=head_dtype
+            )
+        elif pooling == "max":
+            self.pooler = keras.layers.GlobalAveragePooling2D(
+                data_format=backbone.data_format, dtype=head_dtype
+            )
+        else:
+            raise ValueError(
+                "Unknown `pooling` type. Polling should be either `'avg'` or "
+                f"`'max'`. Received: pooling={pooling}."
+            )
         self.output_dense = keras.layers.Dense(
             num_classes,
             activation=activation,
@@ -113,6 +137,7 @@ class ResNetImageClassifier(ImageClassifier):
         # === Functional Model ===
         inputs = self.backbone.input
         x = self.backbone(inputs)
+        x = self.pooler(x)
         outputs = self.output_dense(x)
         super().__init__(
             inputs=inputs,
@@ -123,6 +148,7 @@ class ResNetImageClassifier(ImageClassifier):
         # === Config ===
         self.num_classes = num_classes
         self.activation = activation
+        self.pooling = pooling
 
     def get_config(self):
         # Backbone serialized in `super`
@@ -130,6 +156,7 @@ class ResNetImageClassifier(ImageClassifier):
         config.update(
             {
                 "num_classes": self.num_classes,
+                "pooling": self.pooling,
                 "activation": self.activation,
             }
         )

keras_hub/src/models/resnet/resnet_image_classifier_preprocessor.py

@@ -0,0 +1,28 @@
+# 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.
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.image_classifier_preprocessor import (
+    ImageClassifierPreprocessor,
+)
+from keras_hub.src.models.resnet.resnet_backbone import ResNetBackbone
+from keras_hub.src.models.resnet.resnet_image_converter import (
+    ResNetImageConverter,
+)
+
+
+@keras_hub_export("keras_hub.models.ResNetImageClassifierPreprocessor")
+class ResNetImageClassifierPreprocessor(ImageClassifierPreprocessor):
+    backbone_cls = ResNetBackbone
+    image_converter_cls = ResNetImageConverter

keras_hub/src/models/{llama3/llama3_preprocessor.py → resnet/resnet_image_converter.py}

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.models.llama3.llama3_tokenizer import Llama3Tokenizer
-from keras_hub.src.models.llama.llama_preprocessor import LlamaPreprocessor
+from keras_hub.src.layers.preprocessing.resizing_image_converter import (
+    ResizingImageConverter,
+)
+from keras_hub.src.models.resnet.resnet_backbone import ResNetBackbone
 
 
-@keras_hub_export("keras_hub.models.Llama3Preprocessor")
-class Llama3Preprocessor(LlamaPreprocessor):
-    tokenizer_cls = Llama3Tokenizer
+@keras_hub_export("keras_hub.layers.ResNetImageConverter")
+class ResNetImageConverter(ResizingImageConverter):
+    backbone_cls = ResNetBackbone

keras_hub/src/models/resnet/resnet_presets.py

@@ -0,0 +1,95 @@
+# 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.
+"""ResNet preset configurations."""
+
+backbone_presets = {
+    "resnet_18_imagenet": {
+        "metadata": {
+            "description": (
+                "18-layer ResNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 11186112,
+            "official_name": "ResNet",
+            "path": "resnet",
+            "model_card": "https://arxiv.org/abs/2110.00476",
+        },
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_18_imagenet/2",
+    },
+    "resnet_50_imagenet": {
+        "metadata": {
+            "description": (
+                "50-layer ResNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 23561152,
+            "official_name": "ResNet",
+            "path": "resnet",
+            "model_card": "https://arxiv.org/abs/2110.00476",
+        },
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_50_imagenet/2",
+    },
+    "resnet_101_imagenet": {
+        "metadata": {
+            "description": (
+                "101-layer ResNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 42605504,
+            "official_name": "ResNet",
+            "path": "resnet",
+            "model_card": "https://arxiv.org/abs/2110.00476",
+        },
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_101_imagenet/2",
+    },
+    "resnet_152_imagenet": {
+        "metadata": {
+            "description": (
+                "152-layer ResNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 58295232,
+            "official_name": "ResNet",
+            "path": "resnet",
+            "model_card": "https://arxiv.org/abs/2110.00476",
+        },
+        "kaggle_handle": "kaggle://kerashub/resnetv1/keras/resnet_152_imagenet/2",
+    },
+    "resnet_v2_50_imagenet": {
+        "metadata": {
+            "description": (
+                "50-layer ResNetV2 model pre-trained on the ImageNet 1k "
+                "dataset at a 224x224 resolution."
+            ),
+            "params": 23561152,
+            "official_name": "ResNet",
+            "path": "resnet",
+            "model_card": "https://arxiv.org/abs/2110.00476",
+        },
+        "kaggle_handle": "kaggle://kerashub/resnetv2/keras/resnet_v2_50_imagenet/2",
+    },
+    "resnet_v2_101_imagenet": {
+        "metadata": {
+            "description": (
+                "101-layer ResNetV2 model pre-trained on the ImageNet 1k "
+                "dataset at a 224x224 resolution."
+            ),
+            "params": 42605504,
+            "official_name": "ResNet",
+            "path": "resnet",
+            "model_card": "https://arxiv.org/abs/2110.00476",
+        },
+        "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)