keras-hub-nightly 0.16.1.dev202410020340__py3-none-any.whl → 0.16.1.dev202410040340__py3-none-any.whl

keras_hub/api/layers/__init__.py

@@ -33,10 +33,10 @@ from keras_hub.src.layers.preprocessing.multi_segment_packer import (
 )
 from keras_hub.src.layers.preprocessing.random_deletion import RandomDeletion
 from keras_hub.src.layers.preprocessing.random_swap import RandomSwap
-from keras_hub.src.layers.preprocessing.resizing_image_converter import (
-    ResizingImageConverter,
-)
 from keras_hub.src.layers.preprocessing.start_end_packer import StartEndPacker
+from keras_hub.src.models.deeplab_v3.deeplab_v3_image_converter import (
+    DeepLabV3ImageConverter,
+)
 from keras_hub.src.models.densenet.densenet_image_converter import (
     DenseNetImageConverter,
 )

keras_hub/api/models/__init__.py

@@ -85,6 +85,15 @@ from keras_hub.src.models.deberta_v3.deberta_v3_text_classifier_preprocessor imp
 from keras_hub.src.models.deberta_v3.deberta_v3_tokenizer import (
     DebertaV3Tokenizer,
 )
+from keras_hub.src.models.deeplab_v3.deeplab_v3_backbone import (
+    DeepLabV3Backbone,
+)
+from keras_hub.src.models.deeplab_v3.deeplab_v3_image_segmeter_preprocessor import (
+    DeepLabV3ImageSegmenterPreprocessor,
+)
+from keras_hub.src.models.deeplab_v3.deeplab_v3_segmenter import (
+    DeepLabV3ImageSegmenter,
+)
 from keras_hub.src.models.densenet.densenet_backbone import DenseNetBackbone
 from keras_hub.src.models.densenet.densenet_image_classifier import (
     DenseNetImageClassifier,
@@ -254,7 +263,7 @@ from keras_hub.src.models.roberta.roberta_tokenizer import RobertaTokenizer
 from keras_hub.src.models.sam.sam_backbone import SAMBackbone
 from keras_hub.src.models.sam.sam_image_segmenter import SAMImageSegmenter
 from keras_hub.src.models.sam.sam_image_segmenter_preprocessor import (
-    SAMImageSegmenterPreprocessor as SamImageSegmenterPreprocessor,
+    SAMImageSegmenterPreprocessor,
 )
 from keras_hub.src.models.seq_2_seq_lm import Seq2SeqLM
 from keras_hub.src.models.seq_2_seq_lm_preprocessor import Seq2SeqLMPreprocessor

keras_hub/src/layers/preprocessing/audio_converter.py

@@ -2,11 +2,10 @@ from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
-from keras_hub.src.utils.preset_utils import AUDIO_CONVERTER_CONFIG_FILE
 from keras_hub.src.utils.preset_utils import builtin_presets
 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 save_serialized_object
+from keras_hub.src.utils.preset_utils import get_preset_saver
 from keras_hub.src.utils.python_utils import classproperty
 
 
@@ -101,8 +100,5 @@ class AudioConverter(PreprocessingLayer):
         Args:
             preset_dir: The path to the local model preset directory.
         """
-        save_serialized_object(
-            self,
-            preset_dir,
-            config_file=AUDIO_CONVERTER_CONFIG_FILE,
-        )
+        saver = get_preset_saver(preset_dir)
+        saver.save_audio_converter(self)

keras_hub/src/layers/preprocessing/image_converter.py

@@ -1,47 +1,184 @@
+import math
+
+import keras
+import numpy as np
+from keras import ops
+
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
-from keras_hub.src.utils.preset_utils import IMAGE_CONVERTER_CONFIG_FILE
+from keras_hub.src.utils.keras_utils import standardize_data_format
 from keras_hub.src.utils.preset_utils import builtin_presets
 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 save_serialized_object
+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 preprocessing_function
 
 
 @keras_hub_export("keras_hub.layers.ImageConverter")
 class ImageConverter(PreprocessingLayer):
-    """Convert raw image for models that support image input.
+    """Preprocess raw images into model ready inputs.
+
+    This class converts from raw images to model ready inputs. This conversion
+    proceeds in the following steps:
 
-    This class converts from raw images of any size, to preprocessed
-    images for pretrained model inputs. It is meant to be a convenient way to
-    write custom preprocessing code that is not model specific. This layer
-    should be instantiated via the `from_preset()` constructor, which will
-    create the correct subclass of this layer for the model preset.
+    1. Resize the image using to `image_size`. If `image_size` is `None`, this
+       step will be skipped.
+    2. Rescale the image by multiplying by `scale`, which can be either global
+       or per channel. If `scale` is `None`, this step will be skipped.
+    3. Offset the image by adding `offset`, which can be either global
+       or per channel. If `offset` is `None`, this step will be skipped.
 
     The layer will take as input a raw image tensor in the channels last or
     channels first format, and output a preprocessed image input for modeling.
-    The exact structure of the output will vary per model, though in most cases
-    this layer will simply resize the image to the size needed by the model
-    input.
+    This tensor can be batched (rank 4), or unbatched (rank 3).
+
+    This layer can be used with the `from_preset()` constructor to load a layer
+    that will rescale and resize an image for a specific pretrained model.
+    Using the layer this way allows writing preprocessing code that does not
+    need updating when switching between model checkpoints.
+
+    Args:
+        image_size: `(int, int)` tuple or `None`. The output size of the image,
+            not including the channels axis. If `None`, the input will not be
+            resized.
+        scale: float, tuple of floats, or `None`. The scale to apply to the
+            inputs. If `scale` is a single float, the entire input will be
+            multiplied by `scale`. If `scale` is a tuple, it's assumed to
+            contain per-channel scale value multiplied against each channel of
+            the input images. If `scale` is `None`, no scaling is applied.
+        offset: float, tuple of floats, or `None`. The offset to apply to the
+            inputs. If `offset` is a single float, the entire input will be
+            summed with `offset`. If `offset` is a tuple, it's assumed to
+            contain per-channel offset value summed against each channel of the
+            input images. If `offset` is `None`, no scaling is applied.
+        crop_to_aspect_ratio: If `True`, resize the images without aspect
+            ratio distortion. When the original aspect ratio differs
+            from the target aspect ratio, the output image will be
+            cropped so as to return the
+            largest possible window in the image (of size `(height, width)`)
+            that matches the target aspect ratio. By default
+            (`crop_to_aspect_ratio=False`), aspect ratio may not be preserved.
+        interpolation: String, the interpolation method.
+            Supports `"bilinear"`, `"nearest"`, `"bicubic"`,
+            `"lanczos3"`, `"lanczos5"`. Defaults to `"bilinear"`.
+        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)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, height, width)`. It defaults to the
+            `image_data_format` value found in your Keras config file at
+            `~/.keras/keras.json`. If you never set it, then it will be
+            `"channels_last"`.
 
     Examples:
     ```python
-    # Resize images for `"pali_gemma_3b_224"`.
-    converter = keras_hub.layers.ImageConverter.from_preset("pali_gemma_3b_224")
-    converter(np.ones(2, 512, 512, 3)) # Output shape: (2, 224, 224, 3)
-    # Resize images for `"pali_gemma_3b_448"`.
-    converter = keras_hub.layers.ImageConverter.from_preset("pali_gemma_3b_448")
-    converter(np.ones(2, 512, 512, 3)) # Output shape: (2, 448, 448, 3)
+    # Resize raw images and scale them to [0, 1].
+    converter = keras_hub.layers.ImageConverter(
+        image_size=(128, 128),
+        scale=1. / 255,
+    )
+    converter(np.random.randint(0, 256, size=(2, 512, 512, 3)))
+
+    # Resize images to the specific size needed for a PaliGemma preset.
+    converter = keras_hub.layers.ImageConverter.from_preset(
+        "pali_gemma_3b_224"
+    )
+    converter(np.random.randint(0, 256, size=(2, 512, 512, 3)))
     ```
     """
 
     backbone_cls = None
 
+    def __init__(
+        self,
+        image_size=None,
+        scale=None,
+        offset=None,
+        crop_to_aspect_ratio=True,
+        interpolation="bilinear",
+        data_format=None,
+        **kwargs,
+    ):
+        # TODO: old arg names. Delete this block after resaving Kaggle assets.
+        if "height" in kwargs and "width" in kwargs:
+            image_size = (kwargs.pop("height"), kwargs.pop("width"))
+        if "variance" in kwargs and "mean" in kwargs:
+            std = [math.sqrt(v) for v in kwargs.pop("variance")]
+            scale = [scale / s for s in std]
+            offset = [-m / s for m, s in zip(kwargs.pop("mean"), std)]
+
+        super().__init__(**kwargs)
+
+        # Create the `Resizing` layer here even if it's not being used. That
+        # allows us to make `image_size` a settable property.
+        self.resizing = keras.layers.Resizing(
+            height=image_size[0] if image_size else None,
+            width=image_size[1] if image_size else None,
+            crop_to_aspect_ratio=crop_to_aspect_ratio,
+            interpolation=interpolation,
+            data_format=data_format,
+            dtype=self.dtype_policy,
+            name="resizing",
+        )
+        self.scale = scale
+        self.offset = offset
+        self.crop_to_aspect_ratio = crop_to_aspect_ratio
+        self.interpolation = interpolation
+        self.data_format = standardize_data_format(data_format)
+
+    @property
     def image_size(self):
-        """Returns the default size of a single image."""
-        return (None, None)
+        """Settable tuple of `(height, width)` ints. The output image shape."""
+        if self.resizing.height is None:
+            return None
+        return (self.resizing.height, self.resizing.width)
+
+    @image_size.setter
+    def image_size(self, value):
+        if value is None:
+            value = (None, None)
+        self.resizing.height = value[0]
+        self.resizing.width = value[1]
+
+    @preprocessing_function
+    def call(self, inputs):
+        if self.image_size is not None:
+            x = self.resizing(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
+
+    def _expand_non_channel_dims(self, value, inputs):
+        unbatched = len(ops.shape(inputs)) == 3
+        channels_first = self.data_format == "channels_first"
+        if unbatched:
+            broadcast_dims = (1, 2) if channels_first else (0, 1)
+        else:
+            broadcast_dims = (0, 2, 3) if channels_first else (0, 1, 2)
+        # If inputs are not a tensor type, return a numpy array.
+        # This might happen when running under tf.data.
+        if ops.is_tensor(inputs):
+            return ops.expand_dims(value, broadcast_dims)
+        else:
+            return np.expand_dims(value, broadcast_dims)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "image_size": self.image_size,
+                "scale": self.scale,
+                "offset": self.offset,
+                "interpolation": self.interpolation,
+                "crop_to_aspect_ratio": self.crop_to_aspect_ratio,
+            }
+        )
+        return config
 
     @classproperty
     def presets(cls):
@@ -69,13 +206,6 @@ class ImageConverter(PreprocessingLayer):
         You can run `cls.presets.keys()` to list all built-in presets available
         on the class.
 
-        This constructor can be called in one of two ways. Either from the base
-        class like `keras_hub.models.ImageConverter.from_preset()`, or from a
-        model class like
-        `keras_hub.models.PaliGemmaImageConverter.from_preset()`. If calling
-        from the base class, the subclass of the returning object will be
-        inferred from the config in the preset directory.
-
         Args:
             preset: string. A built-in preset identifier, a Kaggle Models
                 handle, a Hugging Face handle, or a path to a local directory.
@@ -85,17 +215,20 @@ class ImageConverter(PreprocessingLayer):
 
         Examples:
         ```python
+        batch = np.random.randint(0, 256, size=(2, 512, 512, 3))
+
         # Resize images for `"pali_gemma_3b_224"`.
         converter = keras_hub.layers.ImageConverter.from_preset(
             "pali_gemma_3b_224"
         )
-        converter(np.ones(2, 512, 512, 3)) # Output shape: (2, 224, 224, 3)
-        # Override arguments on the base class.
+        converter(batch) # Output shape: (2, 224, 224, 3)
+
+        # Resize images for `"pali_gemma_3b_448"` without cropping.
         converter = keras_hub.layers.ImageConverter.from_preset(
             "pali_gemma_3b_448",
             crop_to_aspect_ratio=False,
         )
-        converter(np.ones(2, 512, 512, 3)) # (2, 448, 448, 3)
+        converter(batch) # Output shape: (2, 448, 448, 3)
         ```
         """
         loader = get_preset_loader(preset)
@@ -110,8 +243,5 @@ class ImageConverter(PreprocessingLayer):
         Args:
             preset_dir: The path to the local model preset directory.
         """
-        save_serialized_object(
-            self,
-            preset_dir,
-            config_file=IMAGE_CONVERTER_CONFIG_FILE,
-        )
+        saver = get_preset_saver(preset_dir)
+        saver.save_image_converter(self)

keras_hub/src/models/backbone.py

@@ -1,15 +1,10 @@
-import os
-
 import keras
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.utils.keras_utils import assert_quantization_support
-from keras_hub.src.utils.preset_utils import CONFIG_FILE
-from keras_hub.src.utils.preset_utils import MODEL_WEIGHTS_FILE
 from keras_hub.src.utils.preset_utils import builtin_presets
 from keras_hub.src.utils.preset_utils import get_preset_loader
-from keras_hub.src.utils.preset_utils import save_metadata
-from keras_hub.src.utils.preset_utils import save_serialized_object
+from keras_hub.src.utils.preset_utils import get_preset_saver
 from keras_hub.src.utils.python_utils import classproperty
 
 
@@ -193,9 +188,8 @@ class Backbone(keras.Model):
         Args:
             preset_dir: The path to the local model preset directory.
         """
-        save_serialized_object(self, preset_dir, config_file=CONFIG_FILE)
-        self.save_weights(os.path.join(preset_dir, MODEL_WEIGHTS_FILE))
-        save_metadata(self, preset_dir)
+        saver = get_preset_saver(preset_dir)
+        saver.save_backbone(self)
 
     def enable_lora(self, rank):
         """Enable Lora on the backbone.

keras_hub/src/models/csp_darknet/csp_darknet_image_classifier.py

@@ -1,5 +1,3 @@
-import keras
-
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.csp_darknet.csp_darknet_backbone import (
     CSPDarkNetBackbone,
@@ -9,111 +7,4 @@ from keras_hub.src.models.image_classifier import ImageClassifier
 
 @keras_hub_export("keras_hub.models.CSPDarkNetImageClassifier")
 class CSPDarkNetImageClassifier(ImageClassifier):
-    """CSPDarkNet image classifier task model.
-
-    Args:
-        backbone: A `keras_hub.models.CSPDarkNetBackbone` 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"`.
-
-    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.CSPDarkNetImageClassifier.from_preset(
-        "csp_darknet_tiny_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.CSPDarkNetImageClassifier.from_preset(
-        "csp_darknet_tiny_imagenet")
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Call `fit()` with custom loss, optimizer and backbone.
-    ```python
-    classifier = keras_hub.models.CSPDarkNetImageClassifier.from_preset(
-        "csp_darknet_tiny_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.CSPDarkNetBackbone(
-        stackwise_num_filters=[128, 256, 512, 1024],
-        stackwise_depth=[3, 9, 9, 3],
-        block_type="basic_block",
-        image_shape = (224, 224, 3),
-    )
-    classifier = keras_hub.models.CSPDarkNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = CSPDarkNetBackbone
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        activation="softmax",
-        preprocessor=None,  # adding this dummy arg for saved model test
-        # TODO: once preprocessor flow is figured out, this needs to be updated
-        **kwargs,
-    ):
-        # === Layers ===
-        self.backbone = backbone
-        self.output_dense = keras.layers.Dense(
-            num_classes,
-            activation=activation,
-            name="predictions",
-        )
-
-        # === Functional Model ===
-        inputs = self.backbone.input
-        x = self.backbone(inputs)
-        outputs = self.output_dense(x)
-        super().__init__(
-            inputs=inputs,
-            outputs=outputs,
-            **kwargs,
-        )
-
-        # === Config ===
-        self.num_classes = num_classes
-        self.activation = activation
-
-    def get_config(self):
-        # Backbone serialized in `super`
-        config = super().get_config()
-        config.update(
-            {
-                "num_classes": self.num_classes,
-                "activation": self.activation,
-            }
-        )
-        return config

keras_hub/src/models/deeplab_v3/__init__.py

@@ -0,0 +1,7 @@
+from keras_hub.src.models.deeplab_v3.deeplab_v3_backbone import (
+    DeepLabV3Backbone,
+)
+from keras_hub.src.models.deeplab_v3.deeplab_v3_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, DeepLabV3Backbone)

keras_hub/src/models/deeplab_v3/deeplab_v3_backbone.py

@@ -0,0 +1,196 @@
+import keras
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.backbone import Backbone
+from keras_hub.src.models.deeplab_v3.deeplab_v3_layers import (
+    SpatialPyramidPooling,
+)
+
+
+@keras_hub_export("keras_hub.models.DeepLabV3Backbone")
+class DeepLabV3Backbone(Backbone):
+    """DeepLabV3 & DeepLabV3Plus architecture for semantic segmentation.
+
+    This class implements a DeepLabV3 & DeepLabV3Plus architecture as described
+    in [Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation](
+        https://arxiv.org/abs/1802.02611)(ECCV 2018)
+    and [Rethinking Atrous Convolution for Semantic Image Segmentation](
+        https://arxiv.org/abs/1706.05587)(CVPR 2017)
+
+    Args:
+        image_encoder: `keras.Model`. An instance that is used as a feature
+            extractor for the Encoder. Should either be a
+            `keras_hub.models.Backbone` or a `keras.Model` that implements the
+            `pyramid_outputs` property with keys "P2", "P3" etc as values.
+            A somewhat sensible backbone to use in many cases is
+            the `keras_hub.models.ResNetBackbone.from_preset("resnet_v2_50")`.
+        projection_filters: int. Number of filters in the convolution layer
+            projecting low-level features from the `image_encoder`.
+        spatial_pyramid_pooling_key: str. A layer level to extract and perform
+            `spatial_pyramid_pooling`, one of the key from the `image_encoder`
+            `pyramid_outputs` property such as  "P4", "P5" etc.
+        upsampling_size: int or tuple of 2 integers. The upsampling factors for
+            rows and columns of `spatial_pyramid_pooling` layer.
+            If `low_level_feature_key` is given then `spatial_pyramid_pooling`s
+            layer resolution should match with the `low_level_feature`s layer
+            resolution to concatenate both the layers for combined encoder
+            outputs.
+        dilation_rates: list. A `list` of integers for parallel dilated conv applied to
+        `SpatialPyramidPooling`. Usually a
+            sample choice of rates are `[6, 12, 18]`.
+        low_level_feature_key: str optional. A layer level to extract the feature
+            from one of the key from the `image_encoder`s `pyramid_outputs`
+            property such as  "P2", "P3" etc which will be the Decoder block.
+            Required only when the DeepLabV3Plus architecture needs to be applied.
+        image_shape: tuple. The input shape without the batch size.
+            Defaults to `(None, None, 3)`.
+
+    Example:
+    ```python
+    # Load a trained backbone to extract features from it's `pyramid_outputs`.
+    image_encoder = keras_hub.models.ResNetBackbone.from_preset("resnet_50_imagenet")
+
+    model = keras_hub.models.DeepLabV3Backbone(
+        image_encoder=image_encoder,
+        projection_filters=48,
+        low_level_feature_key="P2",
+        spatial_pyramid_pooling_key="P5",
+        upsampling_size = 8,
+        dilation_rates = [6, 12, 18]
+    )
+    ```
+    """
+
+    def __init__(
+        self,
+        image_encoder,
+        spatial_pyramid_pooling_key,
+        upsampling_size,
+        dilation_rates,
+        low_level_feature_key=None,
+        projection_filters=48,
+        image_shape=(None, None, 3),
+        **kwargs,
+    ):
+        if not isinstance(image_encoder, keras.Model):
+            raise ValueError(
+                "Argument `image_encoder` must be a `keras.Model` instance. Received instead "
+                f"{image_encoder} (of type {type(image_encoder)})."
+            )
+        data_format = keras.config.image_data_format()
+        channel_axis = -1 if data_format == "channels_last" else 1
+
+        # === Layers ===
+        inputs = keras.layers.Input(image_shape, name="inputs")
+
+        fpn_model = keras.Model(
+            image_encoder.inputs, image_encoder.pyramid_outputs
+        )
+
+        fpn_outputs = fpn_model(inputs)
+
+        spatial_pyramid_pooling = SpatialPyramidPooling(
+            dilation_rates=dilation_rates
+        )
+        spatial_backbone_features = fpn_outputs[spatial_pyramid_pooling_key]
+        spp_outputs = spatial_pyramid_pooling(spatial_backbone_features)
+
+        encoder_outputs = keras.layers.UpSampling2D(
+            size=upsampling_size,
+            interpolation="bilinear",
+            name="encoder_output_upsampling",
+            data_format=data_format,
+        )(spp_outputs)
+
+        if low_level_feature_key:
+            decoder_feature = fpn_outputs[low_level_feature_key]
+            low_level_projected_features = apply_low_level_feature_network(
+                decoder_feature, projection_filters, channel_axis
+            )
+
+            encoder_outputs = keras.layers.Concatenate(
+                axis=channel_axis, name="encoder_decoder_concat"
+            )([encoder_outputs, low_level_projected_features])
+        # upsampling to the original image size
+        upsampling = (2 ** int(spatial_pyramid_pooling_key[-1])) // (
+            int(upsampling_size[0])
+            if isinstance(upsampling_size, tuple)
+            else upsampling_size
+        )
+        # === Functional Model ===
+        x = keras.layers.Conv2D(
+            name="segmentation_head_conv",
+            filters=256,
+            kernel_size=1,
+            padding="same",
+            use_bias=False,
+            data_format=data_format,
+        )(encoder_outputs)
+        x = keras.layers.BatchNormalization(
+            name="segmentation_head_norm", axis=channel_axis
+        )(x)
+        x = keras.layers.ReLU(name="segmentation_head_relu")(x)
+        x = keras.layers.UpSampling2D(
+            size=upsampling,
+            interpolation="bilinear",
+            data_format=data_format,
+            name="backbone_output_upsampling",
+        )(x)
+
+        super().__init__(inputs=inputs, outputs=x, **kwargs)
+
+        # === Config ===
+        self.image_shape = image_shape
+        self.image_encoder = image_encoder
+        self.projection_filters = projection_filters
+        self.upsampling_size = upsampling_size
+        self.dilation_rates = dilation_rates
+        self.low_level_feature_key = low_level_feature_key
+        self.spatial_pyramid_pooling_key = spatial_pyramid_pooling_key
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "image_encoder": keras.saving.serialize_keras_object(
+                    self.image_encoder
+                ),
+                "projection_filters": self.projection_filters,
+                "dilation_rates": self.dilation_rates,
+                "upsampling_size": self.upsampling_size,
+                "low_level_feature_key": self.low_level_feature_key,
+                "spatial_pyramid_pooling_key": self.spatial_pyramid_pooling_key,
+                "image_shape": self.image_shape,
+            }
+        )
+        return config
+
+    @classmethod
+    def from_config(cls, config):
+        if "image_encoder" in config and isinstance(
+            config["image_encoder"], dict
+        ):
+            config["image_encoder"] = keras.layers.deserialize(
+                config["image_encoder"]
+            )
+        return super().from_config(config)
+
+
+def apply_low_level_feature_network(
+    input_tensor, projection_filters, channel_axis
+):
+    data_format = keras.config.image_data_format()
+    x = keras.layers.Conv2D(
+        name="decoder_conv",
+        filters=projection_filters,
+        kernel_size=1,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+    )(input_tensor)
+
+    x = keras.layers.BatchNormalization(name="decoder_norm", axis=channel_axis)(
+        x
+    )
+    x = keras.layers.ReLU(name="decoder_relu")(x)
+    return x

keras_hub/src/models/deeplab_v3/deeplab_v3_image_converter.py

@@ -0,0 +1,10 @@
+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.deeplab_v3.deeplab_v3_backbone import (
+    DeepLabV3Backbone,
+)
+
+
+@keras_hub_export("keras_hub.layers.DeepLabV3ImageConverter")
+class DeepLabV3ImageConverter(ImageConverter):
+    backbone_cls = DeepLabV3Backbone