keras-hub-nightly 0.22.0.dev202507100418__py3-none-any.whl → 0.22.0.dev202507120419__py3-none-any.whl

keras_hub/layers/__init__.py

@@ -90,6 +90,9 @@ from keras_hub.src.models.efficientnet.efficientnet_image_converter import (
 from keras_hub.src.models.gemma3.gemma3_image_converter import (
     Gemma3ImageConverter as Gemma3ImageConverter,
 )
+from keras_hub.src.models.hgnetv2.hgnetv2_image_converter import (
+    HGNetV2ImageConverter as HGNetV2ImageConverter,
+)
 from keras_hub.src.models.mit.mit_image_converter import (
     MiTImageConverter as MiTImageConverter,
 )

keras_hub/models/__init__.py

@@ -294,6 +294,15 @@ from keras_hub.src.models.gpt_neo_x.gpt_neo_x_causal_lm_preprocessor import (
 from keras_hub.src.models.gpt_neo_x.gpt_neo_x_tokenizer import (
     GPTNeoXTokenizer as GPTNeoXTokenizer,
 )
+from keras_hub.src.models.hgnetv2.hgnetv2_backbone import (
+    HGNetV2Backbone as HGNetV2Backbone,
+)
+from keras_hub.src.models.hgnetv2.hgnetv2_image_classifier import (
+    HGNetV2ImageClassifier as HGNetV2ImageClassifier,
+)
+from keras_hub.src.models.hgnetv2.hgnetv2_image_classifier_preprocessor import (
+    HGNetV2ImageClassifierPreprocessor as HGNetV2ImageClassifierPreprocessor,
+)
 from keras_hub.src.models.image_classifier import (
     ImageClassifier as ImageClassifier,
 )
@@ -454,6 +463,9 @@ from keras_hub.src.models.qwen.qwen_tokenizer import (
 from keras_hub.src.models.qwen3.qwen3_backbone import (
     Qwen3Backbone as Qwen3Backbone,
 )
+from keras_hub.src.models.qwen3.qwen3_causal_lm import (
+    Qwen3CausalLM as Qwen3CausalLM,
+)
 from keras_hub.src.models.qwen3.qwen3_causal_lm_preprocessor import (
     Qwen3CausalLMPreprocessor as Qwen3CausalLMPreprocessor,
 )

keras_hub/src/models/gemma/gemma_attention.py

@@ -152,7 +152,7 @@ class CachedGemmaAttention(keras.layers.Layer):
                 attention_mask = ops.expand_dims(attention_mask, axis=1)
                 attention_mask = ops.cast(attention_mask, dtype="bool")
             # Only pass soft cap if needed as not all keras versions support.
-            if self.logit_soft_cap:
+            if self.logit_soft_cap is not None:
                 kwargs = {"attn_logits_soft_cap": self.logit_soft_cap}
             else:
                 kwargs = {}

keras_hub/src/models/hgnetv2/hgnetv2_backbone.py

@@ -0,0 +1,193 @@
+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.hgnetv2.hgnetv2_encoder import HGNetV2Encoder
+from keras_hub.src.models.hgnetv2.hgnetv2_layers import HGNetV2Embeddings
+from keras_hub.src.utils.keras_utils import standardize_data_format
+
+
+@keras_hub_export("keras_hub.models.HGNetV2Backbone")
+class HGNetV2Backbone(Backbone):
+    """This class represents a Keras Backbone of the HGNetV2 model.
+
+    This class implements an HGNetV2 backbone architecture, a convolutional
+    neural network (CNN) optimized for GPU efficiency. HGNetV2 is frequently
+    used as a lightweight CNN backbone in object detection pipelines like
+    RT-DETR and YOLO variants, delivering strong performance on classification
+    and detection tasks, with speed-ups and accuracy gains compared to larger
+    CNN backbones.
+
+    Args:
+        depths: list of ints, the number of blocks in each stage.
+        embedding_size: int, the size of the embedding layer.
+        hidden_sizes: list of ints, the sizes of the hidden layers.
+        stem_channels: list of ints, the channels for the stem part.
+        hidden_act: str, the activation function for hidden layers.
+        use_learnable_affine_block: bool, whether to use learnable affine
+            transformations.
+        stackwise_stage_filters: list of tuples, where each tuple contains
+            configuration for a stage: (stage_in_channels, stage_mid_channels,
+            stage_out_channels, stage_num_blocks, stage_num_of_layers,
+            stage_kernel_size).
+            - stage_in_channels: int, input channels for the stage
+            - stage_mid_channels: int, middle channels for the stage
+            - stage_out_channels: int, output channels for the stage
+            - stage_num_blocks: int, number of blocks in the stage
+            - stage_num_of_layers: int, number of layers in each block
+            - stage_kernel_size: int, kernel size for the stage
+        apply_downsample: list of bools, whether to downsample in each stage.
+        use_lightweight_conv_block: list of bools, whether to use HGNetV2
+            lightweight convolutional blocks in each stage.
+        image_shape: tuple, the shape of the input image without the batch size.
+            Defaults to `(None, None, 3)`.
+        data_format: `None` or str, the data format ('channels_last' or
+            'channels_first'). If not specified, defaults to the
+            `image_data_format` value in your Keras config.
+        out_features: list of str or `None`, the names of the output features to
+            return. If `None`, returns all available features from all stages.
+            Defaults to `None`.
+        dtype: `None` or str or `keras.mixed_precision.DTypePolicy`, the data
+            type for computations and weights.
+
+    Examples:
+    ```python
+    import numpy as np
+    from keras_hub.src.models.hgnetv2.hgnetv2_backbone import HGNetV2Backbone
+    input_data = np.ones(shape=(8, 224, 224, 3))
+
+    # Pretrained backbone.
+    model = keras_hub.models.HGNetV2Backbone.from_preset(
+        "hgnetv2_b5_ssld_stage2_ft_in1k"
+    )
+    model(input_data)
+
+    # Randomly initialized backbone with a custom config.
+    model = HGNetV2Backbone(
+        depths=[1, 2, 4],
+        embedding_size=32,
+        hidden_sizes=[64, 128, 256],
+        stem_channels=[3, 16, 32],
+        hidden_act="relu",
+        use_learnable_affine_block=False,
+        stackwise_stage_filters=[
+            (32, 16, 64, 1, 1, 3),     # Stage 0
+            (64, 32, 128, 2, 1, 3),    # Stage 1
+            (128, 64, 256, 4, 1, 3),   # Stage 2
+        ],
+        apply_downsample=[False, True, True],
+        use_lightweight_conv_block=[False, False, False],
+        image_shape=(224, 224, 3),
+    )
+    model(input_data)
+    ```
+    """
+
+    def __init__(
+        self,
+        depths,
+        embedding_size,
+        hidden_sizes,
+        stem_channels,
+        hidden_act,
+        use_learnable_affine_block,
+        stackwise_stage_filters,
+        apply_downsample,
+        use_lightweight_conv_block,
+        image_shape=(None, None, 3),
+        data_format=None,
+        out_features=None,
+        dtype=None,
+        **kwargs,
+    ):
+        name = kwargs.get("name", None)
+        data_format = standardize_data_format(data_format)
+        channel_axis = -1 if data_format == "channels_last" else 1
+        self.image_shape = image_shape
+        (
+            stage_in_channels,
+            stage_mid_channels,
+            stage_out_filters,
+            stage_num_blocks,
+            stage_num_of_layers,
+            stage_kernel_size,
+        ) = zip(*stackwise_stage_filters)
+
+        # === Layers ===
+        self.embedder_layer = HGNetV2Embeddings(
+            stem_channels=stem_channels,
+            hidden_act=hidden_act,
+            use_learnable_affine_block=use_learnable_affine_block,
+            data_format=data_format,
+            channel_axis=channel_axis,
+            name=f"{name}_embedder" if name else "embedder",
+            dtype=dtype,
+        )
+        self.encoder_layer = HGNetV2Encoder(
+            stage_in_channels=stage_in_channels,
+            stage_mid_channels=stage_mid_channels,
+            stage_out_channels=stage_out_filters,
+            stage_num_blocks=stage_num_blocks,
+            stage_num_of_layers=stage_num_of_layers,
+            apply_downsample=apply_downsample,
+            use_lightweight_conv_block=use_lightweight_conv_block,
+            stage_kernel_size=stage_kernel_size,
+            use_learnable_affine_block=use_learnable_affine_block,
+            data_format=data_format,
+            channel_axis=channel_axis,
+            name=f"{name}_encoder" if name else "encoder",
+            dtype=dtype,
+        )
+        self.stage_names = ["stem"] + [
+            f"stage{i + 1}" for i in range(len(stackwise_stage_filters))
+        ]
+        self.out_features = (
+            out_features if out_features is not None else self.stage_names
+        )
+
+        # === Functional Model ===
+        pixel_values = keras.layers.Input(
+            shape=image_shape, name="pixel_values_input"
+        )
+        embedding_output = self.embedder_layer(pixel_values)
+        all_encoder_hidden_states_tuple = self.encoder_layer(embedding_output)
+        feature_maps_output = {
+            stage_name: all_encoder_hidden_states_tuple[idx]
+            for idx, stage_name in enumerate(self.stage_names)
+            if stage_name in self.out_features
+        }
+        super().__init__(
+            inputs=pixel_values, outputs=feature_maps_output, **kwargs
+        )
+
+        # === Config ===
+        self.depths = depths
+        self.embedding_size = embedding_size
+        self.hidden_sizes = hidden_sizes
+        self.stem_channels = stem_channels
+        self.hidden_act = hidden_act
+        self.use_learnable_affine_block = use_learnable_affine_block
+        self.stackwise_stage_filters = stackwise_stage_filters
+        self.apply_downsample = apply_downsample
+        self.use_lightweight_conv_block = use_lightweight_conv_block
+        self.data_format = data_format
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "depths": self.depths,
+                "embedding_size": self.embedding_size,
+                "hidden_sizes": self.hidden_sizes,
+                "stem_channels": self.stem_channels,
+                "hidden_act": self.hidden_act,
+                "use_learnable_affine_block": self.use_learnable_affine_block,
+                "stackwise_stage_filters": self.stackwise_stage_filters,
+                "apply_downsample": self.apply_downsample,
+                "use_lightweight_conv_block": self.use_lightweight_conv_block,
+                "image_shape": self.image_shape,
+                "out_features": self.out_features,
+                "data_format": self.data_format,
+            }
+        )
+        return config

keras_hub/src/models/hgnetv2/hgnetv2_encoder.py

@@ -0,0 +1,148 @@
+import keras
+
+from keras_hub.src.models.hgnetv2.hgnetv2_layers import HGNetV2Stage
+
+
+@keras.saving.register_keras_serializable(package="keras_hub")
+class HGNetV2Encoder(keras.layers.Layer):
+    """This class represents the encoder of the HGNetV2 model.
+
+    This class implements the encoder part of the HGNetV2 architecture, which
+    consists of multiple stages. Each stage is an instance of `HGNetV2Stage`,
+    and the encoder processes the input through these stages sequentially,
+    collecting the hidden states at each stage.
+
+    Args:
+        stage_in_channels: A list of integers, specifying the input channels
+            for each stage.
+        stage_mid_channels: A list of integers, specifying the mid channels for
+            each stage.
+        stage_out_channels: A list of integers, specifying the output channels
+            for each stage.
+        stage_num_blocks: A list of integers, specifying the number of blocks
+            in each stage.
+        stage_num_of_layers: A list of integers, specifying the number of
+            layers in each block of each stage.
+        apply_downsample: A list of booleans or integers, indicating whether to
+            downsample in each stage.
+        use_lightweight_conv_block: A list of booleans, indicating whether to
+            use HGNetV2 lightweight convolutional blocks in each stage.
+        stage_kernel_size: A list of integers or tuples, specifying the kernel
+            size for each stage.
+        use_learnable_affine_block: A boolean, indicating whether to use
+            learnable affine transformations in the blocks.
+        data_format: `None` or str. If specified, either `"channels_last"` or
+            `"channels_first"`. The ordering of the dimensions in the inputs.
+            `"channels_last"` corresponds to inputs with shape
+            `(batch_size, height, width, channels)` while `"channels_first"`
+            corresponds to inputs with shape `(batch_size, 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"`.
+        channel_axis: int, the axis that represents the channels.
+        **kwargs: Additional keyword arguments passed to the parent class.
+    """
+
+    def __init__(
+        self,
+        stage_in_channels,
+        stage_mid_channels,
+        stage_out_channels,
+        stage_num_blocks,
+        stage_num_of_layers,
+        apply_downsample,
+        use_lightweight_conv_block,
+        stage_kernel_size,
+        use_learnable_affine_block,
+        data_format=None,
+        channel_axis=None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.stage_in_channels = stage_in_channels
+        self.stage_mid_channels = stage_mid_channels
+        self.stage_out_channels = stage_out_channels
+        self.stage_num_blocks = stage_num_blocks
+        self.stage_num_of_layers = stage_num_of_layers
+        self.apply_downsample = apply_downsample
+        self.use_lightweight_conv_block = use_lightweight_conv_block
+        self.stage_kernel_size = stage_kernel_size
+        self.use_learnable_affine_block = use_learnable_affine_block
+        self.data_format = data_format
+        self.channel_axis = channel_axis
+
+        self.stages_list = []
+        for stage_idx in range(len(self.stage_in_channels)):
+            stage_layer = HGNetV2Stage(
+                stage_in_channels=self.stage_in_channels,
+                stage_mid_channels=self.stage_mid_channels,
+                stage_out_channels=self.stage_out_channels,
+                stage_num_blocks=self.stage_num_blocks,
+                stage_num_of_layers=self.stage_num_of_layers,
+                apply_downsample=self.apply_downsample,
+                use_lightweight_conv_block=self.use_lightweight_conv_block,
+                stage_kernel_size=self.stage_kernel_size,
+                use_learnable_affine_block=self.use_learnable_affine_block,
+                stage_index=stage_idx,
+                data_format=self.data_format,
+                channel_axis=self.channel_axis,
+                drop_path=0.0,
+                name=f"{self.name}_stage_{stage_idx}"
+                if self.name
+                else f"stage_{stage_idx}",
+                dtype=self.dtype,
+            )
+            self.stages_list.append(stage_layer)
+
+    def build(self, input_shape):
+        super().build(input_shape)
+        current_input_shape = input_shape
+        for stage_keras_layer in self.stages_list:
+            stage_keras_layer.build(current_input_shape)
+            current_input_shape = stage_keras_layer.compute_output_shape(
+                current_input_shape
+            )
+
+    def call(
+        self,
+        hidden_state,
+        training=None,
+    ):
+        all_hidden_states_list = []
+        current_hidden_state = hidden_state
+        for stage_keras_layer in self.stages_list:
+            all_hidden_states_list.append(current_hidden_state)
+            current_hidden_state = stage_keras_layer(
+                current_hidden_state, training=training
+            )
+        all_hidden_states_list.append(current_hidden_state)
+        return tuple(all_hidden_states_list)
+
+    def compute_output_shape(self, input_shape):
+        current_shape = input_shape
+        all_hidden_shapes = [input_shape]
+        for stage_keras_layer in self.stages_list:
+            current_shape = stage_keras_layer.compute_output_shape(
+                current_shape
+            )
+            all_hidden_shapes.append(current_shape)
+        return tuple(all_hidden_shapes)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "stage_in_channels": self.stage_in_channels,
+                "stage_mid_channels": self.stage_mid_channels,
+                "stage_out_channels": self.stage_out_channels,
+                "stage_num_blocks": self.stage_num_blocks,
+                "stage_num_of_layers": self.stage_num_of_layers,
+                "apply_downsample": self.apply_downsample,
+                "use_lightweight_conv_block": self.use_lightweight_conv_block,
+                "stage_kernel_size": self.stage_kernel_size,
+                "use_learnable_affine_block": self.use_learnable_affine_block,
+                "data_format": self.data_format,
+                "channel_axis": self.channel_axis,
+            }
+        )
+        return config

keras_hub/src/models/hgnetv2/hgnetv2_image_classifier.py

@@ -0,0 +1,216 @@
+import keras
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.hgnetv2.hgnetv2_backbone import HGNetV2Backbone
+from keras_hub.src.models.hgnetv2.hgnetv2_image_classifier_preprocessor import (
+    HGNetV2ImageClassifierPreprocessor,
+)
+from keras_hub.src.models.hgnetv2.hgnetv2_layers import HGNetV2ConvLayer
+from keras_hub.src.models.image_classifier import ImageClassifier
+from keras_hub.src.models.task import Task
+
+
+@keras_hub_export("keras_hub.models.HGNetV2ImageClassifier")
+class HGNetV2ImageClassifier(ImageClassifier):
+    """HGNetV2 image classification model.
+
+    `HGNetV2ImageClassifier` wraps a `HGNetV2Backbone` and
+    a `HGNetV2ImageClassifierPreprocessor` to create a model that can be used
+    for image classification tasks. This model implements the HGNetV2
+    architecture with an additional classification head including a 1x1
+    convolution layer, global pooling, and a dense output layer.
+
+    The model takes an additional `num_classes` argument, controlling the number
+    of predicted output classes, and optionally, a `head_filters` argument to
+    specify the number of filters in the classification head's convolution
+    layer. To fine-tune with `fit()`, pass a dataset containing tuples of
+    `(x, y)` labels where `x` is an image tensor and `y` is an integer from
+    `[0, num_classes)`.
+
+    Args:
+        backbone: A `HGNetV2Backbone` instance.
+        preprocessor: A `HGNetV2ImageClassifierPreprocessor` instance,
+            a `keras.Layer` instance, or a callable. If `None` no preprocessing
+            will be applied to the inputs.
+        num_classes: int. The number of classes to predict.
+        head_filters: int, optional. The number of filters in the
+            classification head's 1x1 convolution layer. If `None`, it defaults
+            to the last value of `hidden_sizes` from the backbone.
+        pooling: `"avg"` or `"max"`. The type of global pooling to apply after
+            the head convolution. Defaults to `"avg"`.
+        activation: `None`, str, or callable. The activation function to use on
+            the final `Dense` layer. Set `activation=None` to return the output
+            logits. Defaults to `None`.
+        dropout: float. Dropout rate applied before the final dense layer.
+            Defaults to 0.0.
+        head_dtype: `None`, str, or `keras.mixed_precision.DTypePolicy`. The
+            dtype to use for the classification head's computations and weights.
+
+    Examples:
+
+    Call `predict()` to run inference.
+    ```python
+    # Load preset and predict.
+    images = np.random.randint(0, 256, size=(2, 224, 224, 3))
+    classifier = keras_hub.models.HGNetV2ImageClassifier.from_preset(
+        "hgnetv2_b5_ssld_stage2_ft_in1k"
+    )
+    classifier.predict(images)
+    ```
+
+    Call `fit()` on a single batch.
+    ```python
+    # Load preset and train.
+    images = np.random.randint(0, 256, size=(2, 224, 224, 3))
+    labels = [0, 3]
+    classifier = keras_hub.models.HGNetV2ImageClassifier.from_preset(
+        "hgnetv2_b5_ssld_stage2_ft_in1k"
+    )
+    classifier.fit(x=images, y=labels, batch_size=2)
+    ```
+
+    Call `fit()` with custom loss, optimizer and frozen backbone.
+    ```python
+    classifier = keras_hub.models.HGNetV2ImageClassifier.from_preset(
+        "hgnetv2_b5_ssld_stage2_ft_in1k"
+    )
+    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)
+    ```
+
+    Create a custom HGNetV2 classifier with specific head configuration.
+    ```python
+    backbone = keras_hub.models.HGNetV2Backbone.from_preset(
+        "hgnetv2_b5_ssld_stage2_ft_in1k"
+    )
+    preproc = keras_hub.models.HGNetV2ImageClassifierPreprocessor.from_preset(
+        "hgnetv2_b5_ssld_stage2_ft_in1k"
+    )
+    classifier = keras_hub.models.HGNetV2ImageClassifier(
+        backbone=backbone,
+        preprocessor=preproc,
+        num_classes=10,
+        pooling="avg",
+        dropout=0.2,
+    )
+    ```
+    """
+
+    backbone_cls = HGNetV2Backbone
+    preprocessor_cls = HGNetV2ImageClassifierPreprocessor
+
+    def __init__(
+        self,
+        backbone,
+        preprocessor,
+        num_classes,
+        head_filters=None,
+        pooling="avg",
+        activation=None,
+        dropout=0.0,
+        head_dtype=None,
+        **kwargs,
+    ):
+        name = kwargs.get("name", "hgnetv2_image_classifier")
+        head_dtype = head_dtype or backbone.dtype_policy
+        data_format = getattr(backbone, "data_format", "channels_last")
+        channel_axis = -1 if data_format == "channels_last" else 1
+        self.head_filters = (
+            head_filters
+            if head_filters is not None
+            else backbone.hidden_sizes[-1]
+        )
+        self.activation = activation
+
+        # === Layers ===
+        self.backbone = backbone
+        self.preprocessor = preprocessor
+        self.last_conv = HGNetV2ConvLayer(
+            in_channels=backbone.hidden_sizes[-1],
+            out_channels=self.head_filters,
+            kernel_size=1,
+            stride=1,
+            groups=1,
+            activation="relu",
+            use_learnable_affine_block=self.backbone.use_learnable_affine_block,
+            data_format=data_format,
+            channel_axis=channel_axis,
+            name="head_last",
+            dtype=head_dtype,
+        )
+        if pooling == "avg":
+            self.pooler = keras.layers.GlobalAveragePooling2D(
+                data_format=data_format,
+                dtype=head_dtype,
+                name=f"{name}_avg_pool" if name else "avg_pool",
+            )
+        elif pooling == "max":
+            self.pooler = keras.layers.GlobalMaxPooling2D(
+                data_format=data_format,
+                dtype=head_dtype,
+                name=f"{name}_max_pool" if name else "max_pool",
+            )
+        # Check valid pooling.
+        else:
+            raise ValueError(
+                "Unknown `pooling` type. Polling should be either `'avg'` or "
+                f"`'max'`. Received: pooling={pooling}."
+            )
+
+        self.flatten_layer = keras.layers.Flatten(
+            dtype=head_dtype,
+            name=f"{name}_flatten" if name else "flatten",
+        )
+        self.output_dropout = keras.layers.Dropout(
+            rate=dropout,
+            dtype=head_dtype,
+            name=f"{name}_output_dropout" if name else "output_dropout",
+        )
+        if num_classes > 0:
+            self.output_dense = keras.layers.Dense(
+                units=num_classes,
+                activation=activation,
+                dtype=head_dtype,
+                name="predictions",
+            )
+        else:
+            self.output_dense = keras.layers.Identity(name="predictions")
+
+        # === Functional Model ===
+        inputs = backbone.input
+        feature_maps = backbone(inputs)
+        last_stage_name = backbone.stage_names[-1]
+        last_hidden_state_for_pooling = feature_maps[last_stage_name]
+        x = self.last_conv(last_hidden_state_for_pooling)
+        x = self.pooler(x)
+        x = self.flatten_layer(x)
+        x = self.output_dropout(x)
+        outputs = self.output_dense(x)
+        Task.__init__(
+            self,
+            inputs=inputs,
+            outputs=outputs,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.pooling = pooling
+        self.dropout = dropout
+        self.num_classes = num_classes
+
+    def get_config(self):
+        config = Task.get_config(self)
+        config.update(
+            {
+                "num_classes": self.num_classes,
+                "pooling": self.pooling,
+                "activation": self.activation,
+                "dropout": self.dropout,
+                "head_filters": self.head_filters,
+            }
+        )
+        return config

keras_hub/src/models/hgnetv2/hgnetv2_image_classifier_preprocessor.py

@@ -0,0 +1,14 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.hgnetv2.hgnetv2_backbone import HGNetV2Backbone
+from keras_hub.src.models.hgnetv2.hgnetv2_image_converter import (
+    HGNetV2ImageConverter,
+)
+from keras_hub.src.models.image_classifier_preprocessor import (
+    ImageClassifierPreprocessor,
+)
+
+
+@keras_hub_export("keras_hub.models.HGNetV2ImageClassifierPreprocessor")
+class HGNetV2ImageClassifierPreprocessor(ImageClassifierPreprocessor):
+    backbone_cls = HGNetV2Backbone
+    image_converter_cls = HGNetV2ImageConverter

keras_hub/src/models/hgnetv2/hgnetv2_image_converter.py

@@ -0,0 +1,8 @@
+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.hgnetv2.hgnetv2_backbone import HGNetV2Backbone
+
+
+@keras_hub_export("keras_hub.layers.HGNetV2ImageConverter")
+class HGNetV2ImageConverter(ImageConverter):
+    backbone_cls = HGNetV2Backbone