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

keras_hub/src/models/mit/mit_presets.py

@@ -0,0 +1,139 @@
+# 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.
+"""MiT model preset configurations."""
+
+backbone_presets_with_weights = {
+    "mit_b0_ade20k_512": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 8 transformer blocks."
+            ),
+            "params": 3321962,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b0_ade20k_512/4",
+    },
+    "mit_b1_ade20k_512": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 8 transformer blocks."
+            ),
+            "params": 13156554,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b1_ade20k_512/4",
+    },
+    "mit_b2_ade20k_512": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 16 transformer blocks."
+            ),
+            "params": 24201418,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b2_ade20k_512/4",
+    },
+    "mit_b3_ade20k_512": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 28 transformer blocks."
+            ),
+            "params": 44077258,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b3_ade20k_512/3",
+    },
+    "mit_b4_ade20k_512": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 41 transformer blocks."
+            ),
+            "params": 60847818,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b4_ade20k_512/3",
+    },
+    "mit_b5_ade20k_640": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 52 transformer blocks."
+            ),
+            "params": 81448138,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b5_ade20k_640/3",
+    },
+    "mit_b0_cityscapes_1024": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 8 transformer blocks."
+            ),
+            "params": 3321962,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b0_cityscapes_1024/3",
+    },
+    "mit_b1_cityscapes_1024": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 8 transformer blocks."
+            ),
+            "params": 13156554,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b1_cityscapes_1024/3",
+    },
+    "mit_b2_cityscapes_1024": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 16 transformer blocks."
+            ),
+            "params": 24201418,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b2_cityscapes_1024/3",
+    },
+    "mit_b3_cityscapes_1024": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 28 transformer blocks."
+            ),
+            "params": 44077258,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b3_cityscapes_1024/3",
+    },
+    "mit_b4_cityscapes_1024": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 41 transformer blocks."
+            ),
+            "params": 60847818,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b4_cityscapes_1024/3",
+    },
+    "mit_b5_cityscapes_1024": {
+        "metadata": {
+            "description": (
+                "MiT (MixTransformer) model with 52 transformer blocks."
+            ),
+            "params": 81448138,
+            "path": "mit",
+        },
+        "kaggle_handle": "kaggle://keras/mit/keras/mit_b5_cityscapes_1024/3",
+    },
+}
+
+backbone_presets = {
+    **backbone_presets_with_weights,
+}

keras_hub/src/models/mobilenet/mobilenet_backbone.py

@@ -47,11 +47,11 @@ class MobileNetBackbone(Backbone):
                 of filters in each layer.
             - If `depth_multiplier` > 1.0, proportionally increases the number
                 of filters in each layer.
-            - If `depth_multiplier` = 1, default number of filters from the paper
-                are used at each layer.
+            - If `depth_multiplier` = 1, default number of filters from the
+                paper are used at each layer.
         input_num_filters: number of filters in first convolution layer
-        output_num_filters: specifies whether to add conv and batch_norm in the end,
-            if set to None, it will not add these layers in the end.
+        output_num_filters: specifies whether to add conv and batch_norm in the
+            end, if set to None, it will not add these layers in the end.
             'None' for MobileNetV1
         input_activation: activation function to be used in the input layer
             'hard_swish' for MobileNetV3,
@@ -96,7 +96,7 @@ class MobileNetBackbone(Backbone):
         stackwise_activation,
         output_num_filters,
         inverted_res_block,
-        image_shape=(224, 224, 3),
+        image_shape=(None, None, 3),
         input_activation="hard_swish",
         output_activation="hard_swish",
         depth_multiplier=1.0,
@@ -365,7 +365,7 @@ def apply_depthwise_conv_block(
     batch normalization and relu6 activation.
 
     Args:
-        x: Input tensor of shape `(rows, cols, channels)
+        x: Input tensor of shape `(rows, cols, channels)`
         filters: Integer, the dimensionality of the output space
             (i.e. the number of output filters in the pointwise convolution).
         depth_multiplier: controls the width of the network.
@@ -383,8 +383,8 @@ def apply_depthwise_conv_block(
         block_id: Integer, a unique identification designating the block number.
 
     Input shape:
-        4D tensor with shape: `(batch, rows, cols, channels)` in "channels_last"
-        4D tensor with shape: `(batch, channels, rows, cols)` in "channels_first"
+        4D tensor with shape `(batch, rows, cols, channels)` in "channels_last"
+        4D tensor with shape `(batch, channels, rows, cols)` in "channels_first"
     Returns:
         Output tensor of block.
     """

keras_hub/src/models/mobilenet/mobilenet_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.mobilenet.mobilenet_backbone import MobileNetBackbone
@@ -7,94 +5,4 @@ from keras_hub.src.models.mobilenet.mobilenet_backbone import MobileNetBackbone
 
 @keras_hub_export("keras_hub.models.MobileNetImageClassifier")
 class MobileNetImageClassifier(ImageClassifier):
-    """MobileNetV3 image classifier task model.
-
-    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.
-
-    Args:
-        backbone: A `keras_hub.models.MobileNetBackbone` 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"`.
-
-    Examples:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.MobileNetImageClassifier.from_preset(
-        "mobilenet_v3_small_imagenet")
-    classifier.predict(images)
-    ```
-
-    Custom backbone.
-    ```python
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    model = MobileNetBackbone(
-        stackwise_expansion = [1, 4, 6],
-        stackwise_filters = [4, 8, 16],
-        stackwise_kernel_size = [3, 3, 5],
-        stackwise_stride = [2, 2, 1],
-        stackwise_se_ratio = [ 0.25, None, 0.25],
-        stackwise_activation = ["relu", "relu", "hard_swish"],
-        output_filter=1280,
-        activation="hard_swish",
-        inverted_res_block=True,
-    )
-    classifier = keras_hub.models.MobileNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = MobileNetBackbone
-
-    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/opt/opt_causal_lm.py

@@ -171,8 +171,8 @@ class OPTCausalLM(CausalLM):
         Args:
             token_ids: a dense int Tensor with shape `(batch_size, max_length)`.
             cache: a dense float Tensor, the cache of key and value.
-            cache_update_index: int, or int Tensor. The index of current inputs in the
-                whole sequence.
+            cache_update_index: int, or int Tensor. The index of current inputs
+                in the whole sequence.
 
         Returns:
             A (logits, hidden_states, cache) tuple. Where `logits` is the

keras_hub/src/models/opt/opt_presets.py

@@ -9,11 +9,9 @@ backbone_presets = {
                 "BookCorpus, CommonCrawl, Pile, and PushShift.io corpora."
             ),
             "params": 125237760,
-            "official_name": "OPT",
             "path": "opt",
-            "model_card": "https://github.com/facebookresearch/metaseq/blob/main/projects/OPT/model_card.md",
         },
-        "kaggle_handle": "kaggle://keras/opt/keras/opt_125m_en/2",
+        "kaggle_handle": "kaggle://keras/opt/keras/opt_125m_en/3",
     },
     # We skip the 350m checkpoint because it does not match the structure of
     # other checkpoints.
@@ -24,11 +22,9 @@ backbone_presets = {
                 "BookCorpus, CommonCrawl, Pile, and PushShift.io corpora."
             ),
             "params": 1315753984,
-            "official_name": "OPT",
             "path": "opt",
-            "model_card": "https://github.com/facebookresearch/metaseq/blob/main/projects/OPT/model_card.md",
         },
-        "kaggle_handle": "kaggle://keras/opt/keras/opt_1.3b_en/2",
+        "kaggle_handle": "kaggle://keras/opt/keras/opt_1.3b_en/3",
     },
     "opt_2.7b_en": {
         "metadata": {
@@ -37,11 +33,9 @@ backbone_presets = {
                 "BookCorpus, CommonCrawl, Pile, and PushShift.io corpora."
             ),
             "params": 2700000000,
-            "official_name": "OPT",
             "path": "opt",
-            "model_card": "https://github.com/facebookresearch/metaseq/blob/main/projects/OPT/model_card.md",
         },
-        "kaggle_handle": "kaggle://keras/opt/keras/opt_2.7b_en/2",
+        "kaggle_handle": "kaggle://keras/opt/keras/opt_2.7b_en/3",
     },
     "opt_6.7b_en": {
         "metadata": {
@@ -50,10 +44,8 @@ backbone_presets = {
                 "BookCorpus, CommonCrawl, Pile, and PushShift.io corpora."
             ),
             "params": 6700000000,
-            "official_name": "OPT",
             "path": "opt",
-            "model_card": "https://github.com/facebookresearch/metaseq/blob/main/projects/OPT/model_card.md",
         },
-        "kaggle_handle": "kaggle://keras/opt/keras/opt_6.7b_en/2",
+        "kaggle_handle": "kaggle://keras/opt/keras/opt_6.7b_en/3",
     },
 }

keras_hub/src/models/pali_gemma/pali_gemma_backbone.py

@@ -48,24 +48,40 @@ class PaliGemmaBackbone(Backbone):
             a two-layer feedforward network for each transformer decoder block.
         head_dim: int. The size of each attention head in the mixed decoder.
         vit_patch_size: int. The size of each square patch in the input image.
-        vit_num_heads: int. The number of attention heads for the vision(image)
+        vit_num_heads: int. The number of attention heads for the vision (image)
             transformer encoder.
         vit_hidden_dim: int. The size of the transformer hidden state at the end
             of each vision transformer layer.
         vit_num_layers: int. The number of vision transformer layers.
         vit_intermediate_dim: int. The output dimension of the first Dense layer
-            in a two-layer feedforward network for vision transformer.
-        vit_pooling: string. The encoded vision embeddings are pooled using the
-            specified polling setting. The accepted values are `"map"`, `"gap"`,
-            `"0"` or `"none"`. Defaults to `"none"`.
+            in a two-layer feedforward network for vision transformer. Defaults
+            to `4304`.
+        vit_pooling: `None` or string. The encoded vision embeddings are pooled
+            using the specified polling setting. The accepted values are
+            `"map"`, `"gap"`, `"0"` or `None`. Defaults to `None`.
         vit_classifier_activation: activation function. The activation that
             is used for final output classification in the vision transformer.
+            Defaults to `None`.
         vit_name: string. The name used for vision transformer layers.
-        include_rescaling: bool. If true, the image input will be rescaled from
-            the range `[0, 255]`, to the range `[0, 1]`.
+        query_head_dim_normalize: boolean. If `True` normalize the query before
+            attention with `head_dim`. If `False`, normalize the query with
+            `hidden_dim / num_query_heads`. Defaults to `True`.
+        use_post_ffw_norm: boolean. Whether to normalize after the feedforward
+            block. Defaults to `False`.
+        use_post_attention_norm: boolean. Whether to normalize after the
+            attention block. Defaults to `False`.
+        attention_logit_soft_cap: `None` or int. Soft cap for the attention
+            logits. Defaults to `None`.
+        final_logit_soft_cap: `None` or int. Soft cap for the final logits.
+            Defaults to `None`.
+        use_sliding_window_attention: boolean. Whether to use sliding local
+          window attention. Defaults to `False`.
+        sliding_window_size: int. Size of the sliding local window. Defaults to
+            `4096`.
         layer_norm_epsilon: float. The epsilon value user for every layer norm
-            in all transformer blocks.
+            in all transformer blocks. Defaults to `1e-6`.
         dropout: float. Dropout probability for the Transformer decoder blocks.
+            Defaults to `0`.
         dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
             for the models computations and weights. Note that some
             computations, such as softmax and layer normalization will always
@@ -121,7 +137,13 @@ class PaliGemmaBackbone(Backbone):
         vit_pooling=None,
         vit_classifier_activation=None,
         vit_name=None,
-        include_rescaling=True,
+        query_head_dim_normalize=True,
+        use_post_ffw_norm=False,
+        use_post_attention_norm=False,
+        attention_logit_soft_cap=None,
+        final_logit_soft_cap=None,
+        use_sliding_window_attention=False,
+        sliding_window_size=4096,
         layer_norm_epsilon=1e-6,
         dropout=0,
         dtype=None,
@@ -139,13 +161,13 @@ class PaliGemmaBackbone(Backbone):
                 seed=None,
             ),
             dtype=dtype,
+            logit_soft_cap=final_logit_soft_cap,
             name="token_embedding",
         )
         # TODO Remove this. Work around for previous serialization bug.
         vit_intermediate_dim = vit_intermediate_dim or 4304
         self.vit_encoder = PaliGemmaVit(
             image_size=image_size,
-            include_rescaling=include_rescaling,
             patch_size=vit_patch_size,
             num_heads=vit_num_heads,
             hidden_dim=vit_hidden_dim,
@@ -159,12 +181,19 @@ class PaliGemmaBackbone(Backbone):
         )
         self.transformer_layers = []
         for i in range(num_layers):
+            sliding_window = use_sliding_window_attention and (i % 2 == 0)
             layer = PaliGemmaDecoderBlock(
                 hidden_dim=hidden_dim,
                 intermediate_dim=intermediate_dim,
-                num_query_heads=num_query_heads,
                 head_dim=head_dim,
+                num_query_heads=num_query_heads,
                 num_key_value_heads=num_key_value_heads,
+                query_head_dim_normalize=query_head_dim_normalize,
+                use_post_ffw_norm=use_post_ffw_norm,
+                use_post_attention_norm=use_post_attention_norm,
+                logit_soft_cap=attention_logit_soft_cap,
+                use_sliding_window_attention=sliding_window,
+                sliding_window_size=sliding_window_size,
                 dropout=dropout,
                 dtype=dtype,
                 name=f"decoder_block_{i}",
@@ -177,7 +206,9 @@ class PaliGemmaBackbone(Backbone):
         )
 
         # === Functional Model ===
-        image_input = self.vit_encoder.inputs[0]
+        image_input = keras.Input(
+            shape=(image_size, image_size, 3), name="images"
+        )
         token_id_input = keras.Input(
             shape=(None,), dtype="int32", name="token_ids"
         )
@@ -215,7 +246,6 @@ class PaliGemmaBackbone(Backbone):
         # === Config ===
         self.vocabulary_size = vocabulary_size
         self.image_size = image_size
-        self.include_rescaling = include_rescaling
         self.num_layers = num_layers
         self.num_query_heads = num_query_heads
         self.num_key_value_heads = num_key_value_heads
@@ -224,7 +254,15 @@ class PaliGemmaBackbone(Backbone):
         self.head_dim = head_dim
         self.layer_norm_epsilon = layer_norm_epsilon
         self.dropout = dropout
-        # VIT Params
+        # Gemma2 params
+        self.query_head_dim_normalize = query_head_dim_normalize
+        self.use_post_ffw_norm = use_post_ffw_norm
+        self.use_post_attention_norm = use_post_attention_norm
+        self.attention_logit_soft_cap = attention_logit_soft_cap
+        self.final_logit_soft_cap = final_logit_soft_cap
+        self.sliding_window_size = sliding_window_size
+        self.use_sliding_window_attention = use_sliding_window_attention
+        # ViT params
         self.vit_patch_size = vit_patch_size
         self.vit_num_heads = vit_num_heads
         self.vit_hidden_dim = vit_hidden_dim
@@ -242,15 +280,12 @@ class PaliGemmaBackbone(Backbone):
             {
                 "vocabulary_size": self.vocabulary_size,
                 "image_size": self.image_size,
-                "include_rescaling": self.include_rescaling,
                 "num_layers": self.num_layers,
                 "num_query_heads": self.num_query_heads,
                 "num_key_value_heads": self.num_key_value_heads,
                 "hidden_dim": self.hidden_dim,
                 "intermediate_dim": self.intermediate_dim,
                 "head_dim": self.head_dim,
-                "layer_norm_epsilon": self.layer_norm_epsilon,
-                "dropout": self.dropout,
                 "vit_patch_size": self.vit_patch_size,
                 "vit_num_heads": self.vit_num_heads,
                 "vit_hidden_dim": self.vit_hidden_dim,
@@ -259,6 +294,17 @@ class PaliGemmaBackbone(Backbone):
                 "vit_pooling": self.vit_pooling,
                 "vit_classifier_activation": self.vit_classifier_activation,
                 "vit_name": self.vit_name,
+                "query_head_dim_normalize": self.query_head_dim_normalize,
+                "use_post_ffw_norm": self.use_post_ffw_norm,
+                "use_post_attention_norm": self.use_post_attention_norm,
+                "final_logit_soft_cap": self.final_logit_soft_cap,
+                "attention_logit_soft_cap": self.attention_logit_soft_cap,
+                "sliding_window_size": self.sliding_window_size,
+                "use_sliding_window_attention": (
+                    self.use_sliding_window_attention
+                ),
+                "layer_norm_epsilon": self.layer_norm_epsilon,
+                "dropout": self.dropout,
             }
         )
         return config

keras_hub/src/models/pali_gemma/pali_gemma_causal_lm.py

@@ -110,7 +110,9 @@ class PaliGemmaCausalLM(CausalLM):
         self.backbone = backbone
 
         # === Functional Model ===
-        inputs = backbone.inputs
+        # This must be "backbone.input" i.e. the full input structure,
+        # rather than "backbone.inputs" which is the flattened list of inputs.
+        inputs = backbone.input
         hidden_state = backbone(inputs=inputs)
         outputs = backbone.token_embedding(hidden_state, reverse=True)
         outputs = outputs[:, backbone.image_sequence_length :, :]

keras_hub/src/models/pali_gemma/pali_gemma_decoder_block.py

@@ -31,33 +31,25 @@ class PaliGemmaDecoderBlock(GemmaDecoderBlock):
             the attention layer.
         num_key_value_heads: int. The number of heads for the key and value
             projections in the attention layer.
+        query_head_dim_normalize: boolean. If `True` normalize the query before
+            attention with `head_dim`. If `False`, normalize the query with
+            `hidden_dim / num_query_heads`. Defaults to `True`.
+        use_post_ffw_norm: boolean. Whether to normalize after the feedforward
+            block. Defaults to `False`.
+        use_post_attention_norm: boolean. Whether to normalize after the
+            attention block. Defaults to `False`.
+        logit_soft_cap: `None` or int. Soft cap for the attention logits.
+            Defaults to `None`.
+        use_sliding_window_attention: boolean. Whether to use sliding local
+          window attention. Defaults to `False`.
+        sliding_window_size: int. Size of the sliding local window. Defaults to
+            `4096`.
         layer_norm_epsilon: float. The epsilon hyperparameter used for layer
-            normalization.
+            normalization. Defaults to `1e-6`.
         dropout: float. The dropout rate for the transformer attention layer.
+            Defaults to `0`.
     """
 
-    def __init__(
-        self,
-        hidden_dim,
-        intermediate_dim,
-        head_dim,
-        num_query_heads,
-        num_key_value_heads,
-        layer_norm_epsilon=1e-6,
-        dropout=0,
-        **kwargs,
-    ):
-        super().__init__(
-            hidden_dim=hidden_dim,
-            intermediate_dim=intermediate_dim,
-            head_dim=head_dim,
-            num_query_heads=num_query_heads,
-            num_key_value_heads=num_key_value_heads,
-            layer_norm_epsilon=layer_norm_epsilon,
-            dropout=dropout,
-            **kwargs,
-        )
-
     def call(
         self,
         x,
@@ -83,6 +75,9 @@ class PaliGemmaDecoderBlock(GemmaDecoderBlock):
                 attention_mask=attention_mask,
             )
 
+        if self.use_post_attention_norm:
+            attention = self.post_attention_norm(attention)
+
         if self.dropout:
             attention = self.attention_dropout(attention)
 
@@ -94,6 +89,9 @@ class PaliGemmaDecoderBlock(GemmaDecoderBlock):
         x = keras.activations.gelu(x1, approximate=True) * x2
         x = self.ffw_linear(x)
 
+        if self.use_post_ffw_norm:
+            x = self.post_ffw_norm(x)
+
         x = x + attention_x
 
         if cache is not None:

keras_hub/src/models/pali_gemma/pali_gemma_image_converter.py

@@ -1,12 +1,10 @@
 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.pali_gemma.pali_gemma_backbone import (
     PaliGemmaBackbone,
 )
 
 
 @keras_hub_export("keras_hub.layers.PaliGemmaImageConverter")
-class PaliGemmaImageConverter(ResizingImageConverter):
+class PaliGemmaImageConverter(ImageConverter):
     backbone_cls = PaliGemmaBackbone