keras-hub-nightly 0.19.0.dev202502060348__py3-none-any.whl → 0.19.0.dev202502080344__py3-none-any.whl

keras_hub/api/__init__.py

@@ -4,7 +4,6 @@ This file was autogenerated. Do not edit it by hand,
 since your modifications would be overwritten.
 """
 
-from keras_hub.api import bounding_box
 from keras_hub.api import layers
 from keras_hub.api import metrics
 from keras_hub.api import models

keras_hub/api/layers/__init__.py

@@ -5,11 +5,14 @@ since your modifications would be overwritten.
 """
 
 from keras_hub.src.layers.modeling.alibi_bias import AlibiBias
+from keras_hub.src.layers.modeling.anchor_generator import AnchorGenerator
+from keras_hub.src.layers.modeling.box_matcher import BoxMatcher
 from keras_hub.src.layers.modeling.cached_multi_head_attention import (
     CachedMultiHeadAttention,
 )
 from keras_hub.src.layers.modeling.f_net_encoder import FNetEncoder
 from keras_hub.src.layers.modeling.masked_lm_head import MaskedLMHead
+from keras_hub.src.layers.modeling.non_max_supression import NonMaxSuppression
 from keras_hub.src.layers.modeling.position_embedding import PositionEmbedding
 from keras_hub.src.layers.modeling.reversible_embedding import (
     ReversibleEmbedding,
@@ -55,7 +58,6 @@ from keras_hub.src.models.pali_gemma.pali_gemma_image_converter import (
 from keras_hub.src.models.resnet.resnet_image_converter import (
     ResNetImageConverter,
 )
-from keras_hub.src.models.retinanet.anchor_generator import AnchorGenerator
 from keras_hub.src.models.retinanet.retinanet_image_converter import (
     RetinaNetImageConverter,
 )

keras_hub/api/models/__init__.py

@@ -193,10 +193,6 @@ from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.image_classifier_preprocessor import (
     ImageClassifierPreprocessor,
 )
-from keras_hub.src.models.image_object_detector import ImageObjectDetector
-from keras_hub.src.models.image_object_detector_preprocessor import (
-    ImageObjectDetectorPreprocessor,
-)
 from keras_hub.src.models.image_segmenter import ImageSegmenter
 from keras_hub.src.models.image_segmenter_preprocessor import (
     ImageSegmenterPreprocessor,
@@ -232,6 +228,16 @@ from keras_hub.src.models.mobilenet.mobilenet_backbone import MobileNetBackbone
 from keras_hub.src.models.mobilenet.mobilenet_image_classifier import (
     MobileNetImageClassifier,
 )
+from keras_hub.src.models.object_detector import ObjectDetector
+from keras_hub.src.models.object_detector import (
+    ObjectDetector as ImageObjectDetector,
+)
+from keras_hub.src.models.object_detector_preprocessor import (
+    ObjectDetectorPreprocessor,
+)
+from keras_hub.src.models.object_detector_preprocessor import (
+    ObjectDetectorPreprocessor as ImageObjectDetectorPreprocessor,
+)
 from keras_hub.src.models.opt.opt_backbone import OPTBackbone
 from keras_hub.src.models.opt.opt_causal_lm import OPTCausalLM
 from keras_hub.src.models.opt.opt_causal_lm_preprocessor import (

keras_hub/src/{models/retinanet → layers/modeling}/anchor_generator.py

@@ -4,9 +4,7 @@ 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
+from keras_hub.src.utils.tensor_utils import assert_bounding_box_support
 
 
 @keras_hub_export("keras_hub.layers.AnchorGenerator")
@@ -56,7 +54,7 @@ class AnchorGenerator(keras.layers.Layer):
 
     Example:
     ```python
-    anchor_generator = AnchorGenerator(
+    anchor_generator = keras_hub.layers.AnchorGenerator(
         bounding_box_format='xyxy',
         min_level=3,
         max_level=7,
@@ -78,6 +76,9 @@ class AnchorGenerator(keras.layers.Layer):
         anchor_size,
         **kwargs,
     ):
+        # Check whether current version of keras support bounding box utils
+        assert_bounding_box_support(self.__class__.__name__)
+
         super().__init__(**kwargs)
         self.bounding_box_format = bounding_box_format
         self.min_level = min_level
@@ -94,29 +95,23 @@ class AnchorGenerator(keras.layers.Layer):
             image_shape = images_shape[1:-1]
         else:
             image_shape = images_shape[:-1]
-
         image_shape = tuple(image_shape)
-
         multilevel_anchors = {}
         for level in range(self.min_level, self.max_level + 1):
             # 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 = 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(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
             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(
@@ -124,7 +119,6 @@ class AnchorGenerator(keras.layers.Layer):
                 )
                 for scale in range(self.num_scales)
             ]
-
             base_anchors = self.generate_base_anchors(
                 sizes=sizes, aspect_ratios=self.aspect_ratios
             )
@@ -133,10 +127,12 @@ class AnchorGenerator(keras.layers.Layer):
 
             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,
+            multilevel_anchors[f"P{level}"] = (
+                keras.utils.bounding_boxes.convert_format(
+                    anchors,
+                    source="xyxy",
+                    target=self.bounding_box_format,
+                )
             )
         return multilevel_anchors
 
@@ -145,10 +141,8 @@ class AnchorGenerator(keras.layers.Layer):
         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
@@ -159,7 +153,6 @@ class AnchorGenerator(keras.layers.Layer):
             image_height, image_width = input_shape[1:-1]
         else:
             image_height, image_width = input_shape[:-1]
-
         for i in range(self.min_level, self.max_level + 1):
             multilevel_boxes_shape[f"P{i}"] = (
                 int(

keras_hub/src/{models/retinanet → layers/modeling}/box_matcher.py

@@ -1,7 +1,11 @@
 import keras
 from keras import ops
 
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.utils.tensor_utils import assert_bounding_box_support
 
+
+@keras_hub_export("keras_hub.layers.BoxMatcher")
 class BoxMatcher(keras.layers.Layer):
     """Box matching logic based on argmax of highest value (e.g., IOU).
 
@@ -51,10 +55,16 @@ class BoxMatcher(keras.layers.Layer):
 
     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)
+    positive_threshold = 0.5
+    negative_threshold = 0.4
+
+    matcher = keras_hub.layers.BoxMatcher(
+        thresholds=[negative_threshold, positive_threshold],
+        match_values=[-1, -2, 1],
+    )
+    match_indices, matched_values = matcher(sim_matrix)
+    positive_mask = ops.equal(matched_vals, 1)
+    ignore_mask = ops.equal(matched_vals, -2)
     ```
 
     """
@@ -66,6 +76,9 @@ class BoxMatcher(keras.layers.Layer):
         force_match_for_each_col=False,
         **kwargs,
     ):
+        # Check whether current version of keras support bounding box utils
+        assert_bounding_box_support(self.__class__.__name__)
+
         super().__init__(**kwargs)
         if sorted(thresholds) != thresholds:
             raise ValueError(f"`threshold` must be sorted, got {thresholds}")

keras_hub/src/{models/retinanet → layers/modeling}/non_max_supression.py

@@ -3,32 +3,52 @@ import math
 import keras
 from keras import ops
 
-# TODO: https://github.com/keras-team/keras-hub/issues/1965
-from keras_hub.src.bounding_box import converters
-from keras_hub.src.bounding_box import utils
-from keras_hub.src.bounding_box import validate_format
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.utils.tensor_utils import assert_bounding_box_support
 
 EPSILON = 1e-8
 
 
+@keras_hub_export("keras_hub.layers.NonMaxSuppression")
 class NonMaxSuppression(keras.layers.Layer):
     """A Keras layer that decodes predictions of an object detection model.
 
     Args:
-        bounding_box_format: The format of bounding boxes of input dataset.
-            Refer
-            TODO: link keras core bounding box docs
-            for more details on supported bounding box formats.
+        bounding_box_format: str. The format of bounding boxes of input dataset.
+            Refer `keras.utils.bounding_boxes.convert_format` args for more
+            details on supported bounding box formats.
         from_logits: boolean, True means input score is logits, False means
             confidence.
-        iou_threshold: a float value in the range [0, 1] representing the
+        iou_threshold: float. Value in the range [0, 1] representing the
             minimum IoU threshold for two boxes to be considered
             same for suppression. Defaults to 0.5.
-        confidence_threshold: a float value in the range [0, 1]. All boxes with
+        confidence_threshold: float. Value in the range [0, 1]. All boxes with
             confidence below this value will be discarded, defaults to 0.5.
-        max_detections: the maximum detections to consider after nms is applied.
-            A large number may trigger significant memory overhead,
+        max_detections: int. the maximum detections to consider after nms is
+            applied. A large number may trigger significant memory overhead,
             defaults to 100.
+
+    Example:
+    ```python
+    boxes = np.random.uniform(low=0, high=1, size=(2, 5, 4))
+    classes = np.expand_dims(
+        np.array(
+            [[0.1, 0.1, 0.4, 0.5, 0.9], [0.7, 0.5, 0.3, 0.0, 0.0]],
+            "float32",
+        ),
+        axis=-1,
+    )
+
+    nms = keras_hub.layers.NonMaxSuppression(
+        bounding_box_format="yxyx",
+        from_logits=False,
+        iou_threshold=1.0,
+        confidence_threshold=0.1,
+        max_detections=1,
+    )
+
+    nms_outputs = nms(boxes, classes)
+    ```
     """
 
     def __init__(
@@ -40,6 +60,8 @@ class NonMaxSuppression(keras.layers.Layer):
         max_detections=100,
         **kwargs,
     ):
+        # Check whether current version of keras support bounding box utils
+        assert_bounding_box_support(self.__class__.__name__)
         super().__init__(**kwargs)
         self.bounding_box_format = bounding_box_format
         self.from_logits = from_logits
@@ -49,7 +71,10 @@ class NonMaxSuppression(keras.layers.Layer):
         self.built = True
 
     def call(
-        self, box_prediction, class_prediction, images=None, image_shape=None
+        self,
+        box_prediction,
+        class_prediction,
+        images=None,
     ):
         """Accepts images and raw scores, returning bounding box predictions.
 
@@ -59,15 +84,24 @@ class NonMaxSuppression(keras.layers.Layer):
             class_prediction: Dense Tensor of shape [batch, boxes, num_classes].
         """
         target_format = "yxyx"
-        if utils.is_relative(self.bounding_box_format):
-            target_format = utils.as_relative(target_format)
+        height, width = None, None
+
+        if "rel" in self.bounding_box_format and images is None:
+            raise ValueError(
+                "`images` cannot be None when using relative "
+                "bounding box format."
+            )
 
-        box_prediction = converters.convert_format(
+        if "rel" in self.bounding_box_format:
+            target_format = "rel_" + target_format
+            height, width, _ = ops.shape(images)
+
+        box_prediction = keras.utils.bounding_boxes.convert_format(
             box_prediction,
             source=self.bounding_box_format,
             target=target_format,
-            images=images,
-            image_shape=image_shape,
+            height=height,
+            width=width,
         )
         if self.from_logits:
             class_prediction = ops.sigmoid(class_prediction)
@@ -95,17 +129,17 @@ class NonMaxSuppression(keras.layers.Layer):
             class_prediction, ops.expand_dims(idx, axis=-1), axis=1
         )
 
-        box_prediction = converters.convert_format(
+        box_prediction = keras.utils.bounding_boxes.convert_format(
             box_prediction,
             source=target_format,
             target=self.bounding_box_format,
-            images=images,
-            image_shape=image_shape,
+            height=height,
+            width=width,
         )
         bounding_boxes = {
             "boxes": box_prediction,
             "confidence": confidence_prediction,
-            "classes": ops.argmax(class_prediction, axis=-1),
+            "labels": ops.argmax(class_prediction, axis=-1),
             "num_detections": valid_det,
         }
 
@@ -519,22 +553,40 @@ def mask_invalid_detections(bounding_boxes):
         returned value will also return `tf.RaggedTensor` representations.
     """
     # ensure we are complying with Keras bounding box format.
-    info = validate_format.validate_format(bounding_boxes)
-    if info["ragged"]:
+    if (
+        not isinstance(bounding_boxes, dict)
+        or "labels" not in bounding_boxes
+        or "boxes" not in bounding_boxes
+    ):
         raise ValueError(
-            "`bounding_box.mask_invalid_detections()` requires inputs to be "
-            "Dense tensors. Please call "
-            "`bounding_box.to_dense(bounding_boxes)` before passing your boxes "
-            "to `bounding_box.mask_invalid_detections()`."
+            "Expected `bounding_boxes` agurment to be a "
+            "dict with keys 'boxes' and 'labels'. Received: "
+            f"bounding_boxes={bounding_boxes}"
         )
+
     if "num_detections" not in bounding_boxes:
         raise ValueError(
             "`bounding_boxes` must have key 'num_detections' "
-            "to be used with `bounding_box.mask_invalid_detections()`."
+            "to be used with `mask_invalid_detections()`."
         )
 
     boxes = bounding_boxes.get("boxes")
-    classes = bounding_boxes.get("classes")
+    labels = bounding_boxes.get("labels")
+    if isinstance(boxes, list):
+        if not isinstance(labels, list):
+            raise ValueError(
+                "If `bounding_boxes['boxes']` is a list, then "
+                "`bounding_boxes['labels']` must also be a list."
+                f"Received: bounding_boxes['labels']={labels}"
+            )
+        if len(boxes) != len(labels):
+            raise ValueError(
+                "If `bounding_boxes['boxes']` and "
+                "`bounding_boxes['labels']` are both lists, "
+                "they must have the same length. Received: "
+                f"len(bounding_boxes['boxes'])={len(boxes)} and "
+                f"len(bounding_boxes['labels'])={len(labels)} and "
+            )
     confidence = bounding_boxes.get("confidence", None)
     num_detections = bounding_boxes.get("num_detections")
 
@@ -545,7 +597,7 @@ def mask_invalid_detections(bounding_boxes):
     )
     mask = mask < num_detections[:, None]
 
-    classes = ops.where(mask, classes, -ops.ones_like(classes))
+    labels = ops.where(mask, labels, -ops.ones_like(labels))
 
     if confidence is not None:
         confidence = ops.where(mask, confidence, -ops.ones_like(confidence))
@@ -558,7 +610,7 @@ def mask_invalid_detections(bounding_boxes):
     result = bounding_boxes.copy()
 
     result["boxes"] = boxes
-    result["classes"] = classes
+    result["labels"] = labels
     if confidence is not None:
         result["confidence"] = confidence
 

keras_hub/src/layers/preprocessing/image_converter.py

@@ -14,6 +14,7 @@ from keras_hub.src.utils.preset_utils import find_subclass
 from keras_hub.src.utils.preset_utils import get_preset_loader
 from keras_hub.src.utils.preset_utils import get_preset_saver
 from keras_hub.src.utils.python_utils import classproperty
+from keras_hub.src.utils.tensor_utils import check_bounding_box_support
 from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
@@ -64,6 +65,12 @@ class ImageConverter(PreprocessingLayer):
         interpolation: String, the interpolation method.
             Supports `"bilinear"`, `"nearest"`, `"bicubic"`,
             `"lanczos3"`, `"lanczos5"`. Defaults to `"bilinear"`.
+        bounding_box_format: A string specifying the format of the bounding
+            boxes, one of `"xyxy"`, `"rel_xyxy"`, `"xywh"`, `"center_xywh"`,
+            `"yxyx"`, `"rel_yxyx"`. Specifies the format of the bounding boxes
+            which will be resized to `image_size` along with the image. To pass
+            bounding boxed to this layer, pass a dict with keys `"images"` and
+            `"bounding_boxes"` when calling the layer.
         data_format: String, either `"channels_last"` or `"channels_first"`.
             The ordering of the dimensions in the inputs. `"channels_last"`
             corresponds to inputs with shape `(batch, height, width, channels)`
@@ -100,6 +107,7 @@ class ImageConverter(PreprocessingLayer):
         crop_to_aspect_ratio=True,
         pad_to_aspect_ratio=False,
         interpolation="bilinear",
+        bounding_box_format="yxyx",
         data_format=None,
         **kwargs,
     ):
@@ -121,6 +129,9 @@ class ImageConverter(PreprocessingLayer):
 
         # Create the `Resizing` layer here even if it's not being used. That
         # allows us to make `image_size` a settable property.
+        resizing_kwargs = {}
+        if check_bounding_box_support():
+            resizing_kwargs["bounding_box_format"] = bounding_box_format
         self.resizing = keras.layers.Resizing(
             height=image_size[0] if image_size else None,
             width=image_size[1] if image_size else None,
@@ -130,12 +141,14 @@ class ImageConverter(PreprocessingLayer):
             data_format=data_format,
             dtype=self.dtype_policy,
             name="resizing",
+            **resizing_kwargs,
         )
         self.scale = scale
         self.offset = offset
         self.crop_to_aspect_ratio = crop_to_aspect_ratio
         self.pad_to_aspect_ratio = pad_to_aspect_ratio
         self.interpolation = interpolation
+        self.bounding_box_format = bounding_box_format
         self.data_format = standardize_data_format(data_format)
 
     @property
@@ -154,14 +167,22 @@ class ImageConverter(PreprocessingLayer):
 
     @preprocessing_function
     def call(self, inputs):
-        x = inputs
         if self.image_size is not None:
-            x = self.resizing(x)
+            inputs = self.resizing(inputs)
+        # Allow dictionary input for handling bounding boxes.
+        if isinstance(inputs, dict):
+            x = inputs["images"]
+        else:
+            x = inputs
         if self.scale is not None:
             x = x * self._expand_non_channel_dims(self.scale, x)
         if self.offset is not None:
             x = x + self._expand_non_channel_dims(self.offset, x)
-        return x
+        if isinstance(inputs, dict):
+            inputs["images"] = x
+        else:
+            inputs = x
+        return inputs
 
     def _expand_non_channel_dims(self, value, inputs):
         unbatched = len(ops.shape(inputs)) == 3
@@ -192,6 +213,7 @@ class ImageConverter(PreprocessingLayer):
                 "interpolation": self.interpolation,
                 "crop_to_aspect_ratio": self.crop_to_aspect_ratio,
                 "pad_to_aspect_ratio": self.pad_to_aspect_ratio,
+                "bounding_box_format": self.bounding_box_format,
             }
         )
         return config

keras_hub/src/models/{image_object_detector.py → object_detector.py}

@@ -4,20 +4,25 @@ from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.task import Task
 
 
-@keras_hub_export("keras_hub.models.ImageObjectDetector")
-class ImageObjectDetector(Task):
+@keras_hub_export(
+    [
+        "keras_hub.models.ObjectDetector",
+        "keras_hub.models.ImageObjectDetector",
+    ]
+)
+class ObjectDetector(Task):
     """Base class for all image object detection tasks.
 
-    The `ImageObjectDetector` tasks wrap a `keras_hub.models.Backbone` and
+    The `ObjectDetector` tasks wrap a `keras_hub.models.Backbone` and
     a `keras_hub.models.Preprocessor` to create a model that can be used for
-    object detection. `ImageObjectDetector` tasks take an additional
+    object detection. `ObjectDetector` tasks take an additional
     `num_classes` argument, controlling the number of predicted output classes.
 
     To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
     labels where `x` is a string and `y` is dictionary with `boxes` and
     `classes`.
 
-    All `ImageObjectDetector` tasks include a `from_preset()` constructor which
+    All `ObjectDetector` tasks include a `from_preset()` constructor which
     can be used to load a pre-trained config and weights.
     """
 
@@ -29,9 +34,9 @@ class ImageObjectDetector(Task):
         metrics=None,
         **kwargs,
     ):
-        """Configures the `ImageObjectDetector` task for training.
+        """Configures the `ObjectDetector` task for training.
 
-        The `ImageObjectDetector` task extends the default compilation signature
+        The `ObjectDetector` task extends the default compilation signature
         of `keras.Model.compile` with defaults for `optimizer`, `loss`, and
         `metrics`. To override these defaults, pass any value
         to these arguments during compilation.

keras_hub/src/models/{image_object_detector_preprocessor.py → object_detector_preprocessor.py}

@@ -5,20 +5,25 @@ from keras_hub.src.models.preprocessor import Preprocessor
 from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
-@keras_hub_export("keras_hub.models.ImageObjectDetectorPreprocessor")
-class ImageObjectDetectorPreprocessor(Preprocessor):
+@keras_hub_export(
+    [
+        "keras_hub.models.ObjectDetectorPreprocessor",
+        "keras_hub.models.ImageObjectDetectorPreprocessor",
+    ]
+)
+class ObjectDetectorPreprocessor(Preprocessor):
     """Base class for object detector preprocessing layers.
 
-    `ImageObjectDetectorPreprocessor` tasks wraps a
+    `ObjectDetectorPreprocessor` tasks wraps a
     `keras_hub.layers.Preprocessor` to create a preprocessing layer for
     object detection tasks. It is intended to be paired with a
     `keras_hub.models.ImageObjectDetector` task.
 
-    All `ImageObjectDetectorPreprocessor` take three inputs, `x`, `y`, and
+    All `ObjectDetectorPreprocessor` take three inputs, `x`, `y`, and
     `sample_weight`. `x`, the first input, should always be included. It can
     be a image or batch of images. See examples below. `y` and `sample_weight`
-    are optional inputs that will be passed through unaltered. Usually, `y` will
-    be the a dict of `{"boxes": Tensor(batch_size, num_boxes, 4),
+    are optional inputs that will be passed through unaltered. Usually, `y`
+    will be the a dict of `{"boxes": Tensor(batch_size, num_boxes, 4),
     "classes": (batch_size, num_boxes)}.
 
     The layer will returns either `x`, an `(x, y)` tuple if labels were
@@ -26,18 +31,18 @@ class ImageObjectDetectorPreprocessor(Preprocessor):
     were provided. `x` will be the input images after all model preprocessing
     has been applied.
 
-    All `ImageObjectDetectorPreprocessor` tasks include a `from_preset()`
-    constructor which can be used to load a pre-trained config and vocabularies.
-    You can call the `from_preset()` constructor directly on this base class, in
-    which case the correct class for your model will be automatically
-    instantiated.
+    All `ObjectDetectorPreprocessor` tasks include a `from_preset()`
+    constructor which can be used to load a pre-trained config and
+    vocabularies. You can call the `from_preset()` constructor directly on
+    this base class, in which case the correct class for your model will be
+    automatically instantiated.
 
     Args:
         image_converter: Preprocessing pipeline for images.
 
     Examples.
     ```python
-    preprocessor = keras_hub.models.ImageObjectDetectorPreprocessor.from_preset(
+    preprocessor = keras_hub.models.ObjectDetectorPreprocessor.from_preset(
         "retinanet_resnet50",
     )
     """
@@ -52,6 +57,17 @@ class ImageObjectDetectorPreprocessor(Preprocessor):
 
     @preprocessing_function
     def call(self, x, y=None, sample_weight=None):
-        if self.image_converter:
+        if y is None:
             x = self.image_converter(x)
+        else:
+            # Pass bounding boxes through image converter in the dictionary
+            # with keys format standardized by core Keras.
+            output = self.image_converter(
+                {
+                    "images": x,
+                    "bounding_boxes": y,
+                }
+            )
+            x = output["images"]
+            y = output["bounding_boxes"]
         return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)

keras_hub/src/models/retinanet/retinanet_image_converter.py

@@ -1,7 +1,6 @@
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.image_converter import ImageConverter
 from keras_hub.src.models.retinanet.retinanet_backbone import RetinaNetBackbone
-from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
 @keras_hub_export("keras_hub.layers.RetinaNetImageConverter")
@@ -10,44 +9,13 @@ class RetinaNetImageConverter(ImageConverter):
 
     def __init__(
         self,
-        image_size=None,
-        scale=None,
-        offset=None,
-        norm_mean=[0.485, 0.456, 0.406],
-        norm_std=[0.229, 0.224, 0.225],
+        *args,
         **kwargs,
     ):
-        super().__init__(**kwargs)
-        self.image_size = image_size
-        self.scale = scale
-        self.offset = offset
-        self.norm_mean = norm_mean
-        self.norm_std = norm_std
-        self.built = True
-
-    @preprocessing_function
-    def call(self, inputs):
-        # TODO: https://github.com/keras-team/keras-hub/issues/1965
-        x = inputs
-        # Rescaling Image
-        if self.scale is not None:
-            x = x * self._expand_non_channel_dims(self.scale, x)
-        if self.offset is not None:
-            x = x + self._expand_non_channel_dims(self.offset, x)
-        # By default normalize using imagenet mean and std
-        if self.norm_mean:
-            x = x - self._expand_non_channel_dims(self.norm_mean, x)
-        if self.norm_std:
-            x = x / self._expand_non_channel_dims(self.norm_std, x)
-
-        return x
-
-    def get_config(self):
-        config = super().get_config()
-        config.update(
-            {
-                "norm_mean": self.norm_mean,
-                "norm_std": self.norm_std,
-            }
-        )
-        return config
+        # TODO: update presets and remove these old config options. They were
+        # never needed.
+        if "norm_mean" in kwargs:
+            kwargs["offset"] = [-x for x in kwargs.pop("norm_mean")]
+        if "norm_std" in kwargs:
+            kwargs["scale"] = [1.0 / x for x in kwargs.pop("norm_std")]
+        super().__init__(*args, **kwargs)