keras-hub-nightly 0.16.1.dev202410020340__py3-none-any.whl → 0.19.0.dev202501260345__py3-none-any.whl

keras_hub/src/models/resnet/resnet_image_classifier.py

@@ -1,5 +1,3 @@
-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
@@ -10,140 +8,5 @@ from keras_hub.src.models.resnet.resnet_image_classifier_preprocessor import (
 
 @keras_hub_export("keras_hub.models.ResNetImageClassifier")
 class ResNetImageClassifier(ImageClassifier):
-    """ResNet image classifier task model.
-
-    Args:
-        backbone: A `keras_hub.models.ResNetBackbone` instance.
-        num_classes: int. The number of classes to predict.
-        activation: `None`, str or callable. The activation function to use on
-            the `Dense` layer. Set `activation=None` to return the output
-            logits. Defaults to `"softmax"`.
-        head_dtype: `None` or str or `keras.mixed_precision.DTypePolicy`. The
-            dtype to use for the classification head's computations and weights.
-
-    To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
-    where `x` is a tensor and `y` is a integer from `[0, num_classes)`.
-    All `ImageClassifier` tasks include a `from_preset()` constructor which can
-    be used to load a pre-trained config and weights.
-
-    Examples:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
-        "resnet_50_imagenet"
-    )
-    classifier.predict(images)
-    ```
-
-    Call `fit()` on a single batch.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    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(
-        "resnet_50_imagenet"
-    )
-    classifier.compile(
-        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
-        optimizer=keras.optimizers.Adam(5e-5),
-    )
-    classifier.backbone.trainable = False
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Custom backbone.
-    ```python
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    backbone = keras_hub.models.ResNetBackbone(
-        stackwise_num_filters=[64, 64, 64],
-        stackwise_num_blocks=[2, 2, 2],
-        stackwise_num_strides=[1, 2, 2],
-        block_type="basic_block",
-        use_pre_activation=True,
-        pooling="avg",
-    )
-    classifier = keras_hub.models.ResNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = ResNetBackbone
     preprocessor_cls = ResNetImageClassifierPreprocessor
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        preprocessor=None,
-        pooling="avg",
-        activation=None,
-        head_dtype=None,
-        **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,
-            dtype=head_dtype,
-            name="predictions",
-        )
-
-        # === Functional Model ===
-        inputs = self.backbone.input
-        x = self.backbone(inputs)
-        x = self.pooler(x)
-        outputs = self.output_dense(x)
-        super().__init__(
-            inputs=inputs,
-            outputs=outputs,
-            **kwargs,
-        )
-
-        # === Config ===
-        self.num_classes = num_classes
-        self.activation = activation
-        self.pooling = pooling
-
-    def get_config(self):
-        # Backbone serialized in `super`
-        config = super().get_config()
-        config.update(
-            {
-                "num_classes": self.num_classes,
-                "pooling": self.pooling,
-                "activation": self.activation,
-            }
-        )
-        return config

keras_hub/src/models/resnet/resnet_image_converter.py

@@ -1,10 +1,8 @@
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.layers.preprocessing.resizing_image_converter import (
-    ResizingImageConverter,
-)
+from keras_hub.src.layers.preprocessing.image_converter import ImageConverter
 from keras_hub.src.models.resnet.resnet_backbone import ResNetBackbone
 
 
 @keras_hub_export("keras_hub.layers.ResNetImageConverter")
-class ResNetImageConverter(ResizingImageConverter):
+class ResNetImageConverter(ImageConverter):
     backbone_cls = ResNetBackbone

keras_hub/src/models/resnet/resnet_presets.py

@@ -8,11 +8,9 @@ backbone_presets = {
                 "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/3",
+        "kaggle_handle": "kaggle://keras/resnetv1/keras/resnet_18_imagenet/3",
     },
     "resnet_50_imagenet": {
         "metadata": {
@@ -21,11 +19,9 @@ backbone_presets = {
                 "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/3",
+        "kaggle_handle": "kaggle://keras/resnetv1/keras/resnet_50_imagenet/3",
     },
     "resnet_101_imagenet": {
         "metadata": {
@@ -34,11 +30,9 @@ backbone_presets = {
                 "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/3",
+        "kaggle_handle": "kaggle://keras/resnetv1/keras/resnet_101_imagenet/3",
     },
     "resnet_152_imagenet": {
         "metadata": {
@@ -47,11 +41,9 @@ backbone_presets = {
                 "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/3",
+        "kaggle_handle": "kaggle://keras/resnetv1/keras/resnet_152_imagenet/3",
     },
     "resnet_v2_50_imagenet": {
         "metadata": {
@@ -60,11 +52,9 @@ backbone_presets = {
                 "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/3",
+        "kaggle_handle": "kaggle://keras/resnetv2/keras/resnet_v2_50_imagenet/3",
     },
     "resnet_v2_101_imagenet": {
         "metadata": {
@@ -73,10 +63,129 @@ backbone_presets = {
                 "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/3",
+        "kaggle_handle": "kaggle://keras/resnetv2/keras/resnet_v2_101_imagenet/3",
+    },
+    "resnet_vd_18_imagenet": {
+        "metadata": {
+            "description": (
+                "18-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution."
+            ),
+            "params": 11722824,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_18_imagenet/2",
+    },
+    "resnet_vd_34_imagenet": {
+        "metadata": {
+            "description": (
+                "34-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution."
+            ),
+            "params": 21838408,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_34_imagenet/2",
+    },
+    "resnet_vd_50_imagenet": {
+        "metadata": {
+            "description": (
+                "50-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution."
+            ),
+            "params": 25629512,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_50_imagenet/2",
+    },
+    "resnet_vd_50_ssld_imagenet": {
+        "metadata": {
+            "description": (
+                "50-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution with knowledge distillation."
+            ),
+            "params": 25629512,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_50_ssld_imagenet/2",
+    },
+    "resnet_vd_50_ssld_v2_imagenet": {
+        "metadata": {
+            "description": (
+                "50-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution with knowledge distillation and AutoAugment."
+            ),
+            "params": 25629512,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_50_ssld_v2_imagenet/2",
+    },
+    "resnet_vd_50_ssld_v2_fix_imagenet": {
+        "metadata": {
+            "description": (
+                "50-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution with knowledge distillation, AutoAugment and "
+                "additional fine-tuning of the classification head."
+            ),
+            "params": 25629512,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_50_ssld_v2_fix_imagenet/2",
+    },
+    "resnet_vd_101_imagenet": {
+        "metadata": {
+            "description": (
+                "101-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution."
+            ),
+            "params": 44673864,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_101_imagenet/2",
+    },
+    "resnet_vd_101_ssld_imagenet": {
+        "metadata": {
+            "description": (
+                "101-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution with knowledge distillation."
+            ),
+            "params": 44673864,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_101_ssld_imagenet/2",
+    },
+    "resnet_vd_152_imagenet": {
+        "metadata": {
+            "description": (
+                "152-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution."
+            ),
+            "params": 60363592,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_152_imagenet/2",
+    },
+    "resnet_vd_200_imagenet": {
+        "metadata": {
+            "description": (
+                "200-layer ResNetVD (ResNet with bag of tricks) model "
+                "pre-trained on the ImageNet 1k dataset at a 224x224 "
+                "resolution."
+            ),
+            "params": 74933064,
+            "path": "resnet",
+        },
+        "kaggle_handle": "kaggle://keras/resnet_vd/keras/resnet_vd_200_imagenet/2",
     },
 }

keras_hub/src/models/retinanet/__init__.py

@@ -0,0 +1,5 @@
+from keras_hub.src.models.retinanet.retinanet_backbone import RetinaNetBackbone
+from keras_hub.src.models.retinanet.retinanet_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, RetinaNetBackbone)

keras_hub/src/models/retinanet/anchor_generator.py

@@ -3,9 +3,13 @@ import math
 import keras
 from keras import ops
 
+from keras_hub.src.api_export import keras_hub_export
+
+# TODO: https://github.com/keras-team/keras-hub/issues/1965
 from keras_hub.src.bounding_box.converters import convert_format
 
 
+@keras_hub_export("keras_hub.layers.AnchorGenerator")
 class AnchorGenerator(keras.layers.Layer):
     """Generates anchor boxes for object detection tasks.
 
@@ -81,6 +85,7 @@ class AnchorGenerator(keras.layers.Layer):
         self.num_scales = num_scales
         self.aspect_ratios = aspect_ratios
         self.anchor_size = anchor_size
+        self.num_base_anchors = num_scales * len(aspect_ratios)
         self.built = True
 
     def call(self, inputs):
@@ -92,60 +97,61 @@ class AnchorGenerator(keras.layers.Layer):
 
         image_shape = tuple(image_shape)
 
-        multilevel_boxes = {}
+        multilevel_anchors = {}
         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")
+            stride_y = image_shape[0] // feat_size_y
+            stride_x = image_shape[1] // feat_size_x
 
             # 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)
+            cx = ops.arange(0, feat_size_x, dtype="float32") * stride_x
+            cy = ops.arange(0, feat_size_y, dtype="float32") * 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",
+            cy_grid, cx_grid = ops.meshgrid(cy, cx, indexing="ij")
+            cy_grid = ops.reshape(cy_grid, (-1,))
+            cx_grid = ops.reshape(cx_grid, (-1,))
+
+            shifts = ops.stack((cx_grid, cy_grid, cx_grid, cy_grid), axis=1)
+            sizes = [
+                int(
+                    2**level * self.anchor_size * 2 ** (scale / self.num_scales)
+                )
+                for scale in range(self.num_scales)
+            ]
+
+            base_anchors = self.generate_base_anchors(
+                sizes=sizes, aspect_ratios=self.aspect_ratios
+            )
+            shifts = ops.reshape(shifts, (-1, 1, 4))
+            base_anchors = ops.reshape(base_anchors, (1, -1, 4))
+
+            anchors = shifts + base_anchors
+            anchors = ops.reshape(anchors, (-1, 4))
+            multilevel_anchors[f"P{level}"] = convert_format(
+                anchors,
+                source="xyxy",
                 target=self.bounding_box_format,
             )
-        return multilevel_boxes
+        return multilevel_anchors
+
+    def generate_base_anchors(self, sizes, aspect_ratios):
+        sizes = ops.convert_to_tensor(sizes, dtype="float32")
+        aspect_ratios = ops.convert_to_tensor(aspect_ratios)
+        h_ratios = ops.sqrt(aspect_ratios)
+        w_ratios = 1 / h_ratios
+
+        ws = ops.reshape(w_ratios[:, None] * sizes[None, :], (-1,))
+        hs = ops.reshape(h_ratios[:, None] * sizes[None, :], (-1,))
+
+        base_anchors = ops.stack([-1 * ws, -1 * hs, ws, hs], axis=1) / 2
+        base_anchors = ops.round(base_anchors)
+        return base_anchors
 
     def compute_output_shape(self, input_shape):
         multilevel_boxes_shape = {}
@@ -156,18 +162,11 @@ class AnchorGenerator(keras.layers.Layer):
 
         for i in range(self.min_level, self.max_level + 1):
             multilevel_boxes_shape[f"P{i}"] = (
-                (image_height // 2 ** (i))
-                * (image_width // 2 ** (i))
-                * self.anchors_per_location,
+                int(
+                    math.ceil(image_height / 2 ** (i))
+                    * math.ceil(image_width // 2 ** (i))
+                    * self.num_base_anchors
+                ),
                 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)