From 3272d29eb1cfb7d6628dc5f16d4a0eb521b4c4f8 Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Wed, 19 Mar 2025 16:39:48 +0530
Subject: [PATCH 01/10] InceptionNet

---
 keras_hub/src/models/inception/__init__.py    |   5 +
 .../models/inception/inception_backbone.py    | 476 ++++++++++++++++++
 .../inception/inception_backbone_test.py      | 100 ++++
 .../inception/inception_image_classifier.py   |  10 +
 ...inception_image_classifier_preprocessor.py |  14 +
 .../inception_image_classifier_test.py        | 184 +++++++
 .../inception/inception_image_converter.py    |   7 +
 .../src/models/inception/inception_presets.py | 120 +++++
 8 files changed, 916 insertions(+)
 create mode 100644 keras_hub/src/models/inception/__init__.py
 create mode 100644 keras_hub/src/models/inception/inception_backbone.py
 create mode 100644 keras_hub/src/models/inception/inception_backbone_test.py
 create mode 100644 keras_hub/src/models/inception/inception_image_classifier.py
 create mode 100644 keras_hub/src/models/inception/inception_image_classifier_preprocessor.py
 create mode 100644 keras_hub/src/models/inception/inception_image_classifier_test.py
 create mode 100644 keras_hub/src/models/inception/inception_image_converter.py
 create mode 100644 keras_hub/src/models/inception/inception_presets.py

diff --git a/keras_hub/src/models/inception/__init__.py b/keras_hub/src/models/inception/__init__.py
new file mode 100644
index 0000000000..6dddd2f057
--- /dev/null
+++ b/keras_hub/src/models/inception/__init__.py
@@ -0,0 +1,5 @@
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+from keras_hub.src.models.inception.inception_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, InceptionBackbone)
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_backbone.py b/keras_hub/src/models/inception/inception_backbone.py
new file mode 100644
index 0000000000..f5ff6f2569
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_backbone.py
@@ -0,0 +1,476 @@
+import keras
+from keras import layers
+from keras import ops
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.feature_pyramid_backbone import FeaturePyramidBackbone
+from keras_hub.src.utils.keras_utils import standardize_data_format
+from keras import layers
+import tensorflow as tf
+
+
+@keras_hub_export("keras_hub.models.InceptionBackbone")
+class InceptionBackbone(FeaturePyramidBackbone):
+    """GoogleNet (Inception v1) core network with hyperparameters.
+
+    This class implements a GoogleNet (Inception v1) backbone as described in 
+    [Going Deeper with Convolutions]
+    (https://arxiv.org/abs/1409.4842) (CVPR 2015).
+    The architecture is characterized by its unique Inception modules that 
+    process input at different scales simultaneously using multiple filter sizes 
+    in parallel.
+
+    Args:
+        initial_filters: list of ints. The number of filters for the initial
+            convolutional layers.
+        initial_strides: list of ints. The strides for the initial convolutional
+            layers.
+        inception_config: list of lists. Each inner list represents an inception
+            block configuration with 
+            [1x1_filters, 3x3_reduce_filters, 3x3_filters,
+            5x5_reduce_filters, 5x5_filters, pool_proj_filters].
+        aux_classifiers: boolean. Whether to include auxiliary classifiers or 
+            not. Note: In backbone mode, these are typically not used.
+        image_shape: tuple. The input shape without the batch size.
+            Defaults to `(None, None, 3)`.
+        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"`.
+        dtype: `None` or str or `keras.mixed_precision.DTypePolicy`. The dtype
+            to use for the model's computations and weights.
+
+    Examples:
+    ```python
+    input_data = np.random.uniform(0, 1, size=(2, 224, 224, 3))
+
+    # Pretrained GoogleNet backbone.
+    model = keras_hub.models.GoogleNetBackbone.from_preset("googlenet_imagenet")
+    model(input_data)
+
+    # Randomly initialized GoogleNet backbone with a custom config.
+    model = keras_hub.models.GoogleNetBackbone(
+        initial_filters=[64, 192],
+        initial_strides=[2, 1],
+        inception_config=[
+            # Inception 3a
+            [64, 96, 128, 16, 32, 32],
+            # Inception 3b
+            [128, 128, 192, 32, 96, 64],
+        ],
+        aux_classifiers=False,
+    )
+    model(input_data)
+    ```
+    """
+
+    def __init__(
+        self,
+        initial_filters,
+        initial_strides,
+        inception_config,
+        aux_classifiers=False,
+        image_shape=(None, None, 3),
+        data_format=None,
+        dtype=None,
+        **kwargs,
+    ):
+        if len(initial_filters) != len(initial_strides):
+            raise ValueError(
+                "The length of `initial_filters` and `initial_strides` must be "
+                "the same. "
+                f"Received: initial_filters={initial_filters}, "
+                f"initial_strides={initial_strides}."
+            )
+        
+        for i, config in enumerate(inception_config):
+            if len(config) != 6:
+                raise ValueError(
+                    "Each inception config should have 6 values: "
+                    "[1x1_filters, 3x3_reduce_filters, 3x3_filters, "
+                    "5x5_reduce_filters, 5x5_filters, pool_proj_filters]. "
+                    f"Received for inception block {i}: {config}"
+                )
+
+        data_format = standardize_data_format(data_format)
+        bn_axis = -1 if data_format == "channels_last" else 1
+        
+        # === Functional Model ===
+        image_input = layers.Input(shape=image_shape)
+        x = image_input  # Intermediate result.
+        
+        # Initial convolution layers
+        for i, (filters, stride) in (
+            enumerate(zip(initial_filters, initial_strides))):
+            if stride > 1:
+                x = layers.ZeroPadding2D(
+                    padding=(3, 3) if i == 0 else (1, 1),
+                    data_format=data_format,
+                    dtype=dtype,
+                    name=f"conv{i+1}_pad",
+                )(x)
+                padding = "valid"
+            else:
+                padding = "same"
+                
+            x = layers.Conv2D(
+                filters,
+                kernel_size=7 if i == 0 else 3,
+                strides=stride,
+                padding=padding,
+                use_bias=False,
+                data_format=data_format,
+                dtype=dtype,
+                name=f"conv{i+1}",
+            )(x)
+            x = layers.BatchNormalization(
+                axis=bn_axis,
+                epsilon=1e-5,
+                momentum=0.9,
+                dtype=dtype,
+                name=f"conv{i+1}_bn",
+            )(x)
+            x = layers.ReLU(dtype=dtype, name=f"conv{i+1}_relu")(x)
+            
+            # Max pooling after first conv layer
+            if i == 0:
+                x = layers.ZeroPadding2D(
+                 (1, 1), data_format=data_format, name=f"pool{i+1}_pad"
+                )(x)
+                x = tf.cast(x, dtype)
+                x = layers.MaxPooling2D(
+                    3,
+                    strides=2,
+                    data_format=data_format,
+                    dtype=dtype,
+                    name=f"pool{i+1}_pool",
+                )(x)
+        
+        # Max pooling after initial conv layers
+        x = layers.ZeroPadding2D(
+            (1, 1), data_format=data_format, dtype=dtype, name="pool2_pad"
+        )(x)
+        x = layers.MaxPooling2D(
+            3,
+            strides=2,
+            data_format=data_format,
+            dtype=dtype,
+            name="pool2_pool",
+        )(x)
+        
+        # Inception blocks
+        pyramid_outputs = {}
+        for i, config in enumerate(inception_config):
+            block_level = i // 2 + 3  # Inception blocks start at level 3
+            block_name = f"inception_{block_level}{chr(97 + i % 2)}" #a,b,c,etc.
+            
+            x = apply_inception_module(
+                x,
+                config[0],  # 1x1 filters
+                config[1],  # 3x3 reduce filters
+                config[2],  # 3x3 filters
+                config[3],  # 5x5 reduce filters
+                config[4],  # 5x5 filters
+                config[5],  # pool proj filters
+                data_format=data_format,
+                dtype=dtype,
+                name=block_name,
+            )
+            
+            # Add to pyramid outputs after each 2 inception blocks (each level)
+            if i % 2 == 1 or i == len(inception_config) - 1:
+                pyramid_level = block_level
+                pyramid_outputs[f"P{pyramid_level}"] = x
+                
+                #Max pooling between inception levels(except after the last one)
+                if i < len(inception_config) - 1 and i % 2 == 1:
+                    x = layers.ZeroPadding2D(
+                        (1, 1), 
+                        data_format=data_format, 
+                        dtype=dtype, 
+                        name=f"pool{pyramid_level}_pad"
+                    )(x)
+                    x = layers.MaxPooling2D(
+                        3,
+                        strides=2,
+                        data_format=data_format,
+                        dtype=dtype,
+                        name=f"pool{pyramid_level}_pool",
+                    )(x)
+            
+            # Add auxiliary classifiers if requested (typically after 4a and 4d)
+            if aux_classifiers and (
+                (block_level == 4 and i % 2 == 0) or  # After 4a
+                (block_level == 4 and i % 2 == 1)     # After 4d
+            ):
+                # Auxiliary classifier output not used in backbone mode
+                apply_auxiliary_classifier(
+                    x,
+                    data_format=data_format,
+                    dtype=dtype,
+                    name=f"aux_{block_name}",
+                )
+        
+        # Apply global average pooling at the end
+        x = layers.GlobalAveragePooling2D(
+            data_format=data_format, dtype=dtype, name="avg_pool"
+        )(x)
+
+        super().__init__(
+            inputs=image_input,
+            outputs=x,  # Main output is the global average pooled features
+            dtype=dtype,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.initial_filters = initial_filters
+        self.initial_strides = initial_strides
+        self.inception_config = inception_config
+        self.aux_classifiers = aux_classifiers
+        self.image_shape = image_shape
+        self.pyramid_outputs = pyramid_outputs
+        self.data_format = data_format
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "initial_filters": self.initial_filters,
+                "initial_strides": self.initial_strides,
+                "inception_config": self.inception_config,
+                "aux_classifiers": self.aux_classifiers,
+                "image_shape": self.image_shape,
+            }
+        )
+        return config
+
+
+def apply_inception_module(
+    x,
+    filters_1x1,
+    filters_3x3_reduce,
+    filters_3x3,
+    filters_5x5_reduce,
+    filters_5x5,
+    filters_pool_proj,
+    data_format=None,
+    dtype=None,
+    name=None,
+):
+    """Applies an Inception module.
+    
+    The Inception module processes input at different scales simultaneously 
+    using multiple filter sizes in parallel.
+    
+    Args:
+        x: Tensor. The input tensor to pass through the inception module.
+        filters_1x1: int. The number of filters in the 1x1 convolution branch.
+        filters_3x3_reduce: int. The number of filters in the 3x3 reduce 
+            convolution.
+        filters_3x3: int. The number of filters in the 3x3 convolution.
+        filters_5x5_reduce: int. The number of filters in the 5x5 reduce 
+            convolution.
+        filters_5x5: int. The number of filters in the 5x5 convolution.
+        filters_pool_proj: int. The number of filters in the pool projection.
+        data_format: `None` or str. the ordering of the dimensions in the
+            inputs. Can be `"channels_last"`
+            (`(batch_size, height, width, channels)`) or`"channels_first"`
+            (`(batch_size, channels, height, width)`).
+        dtype: `None` or str or `keras.mixed_precision.DTypePolicy`. The dtype
+            to use for the models computations and weights.
+        name: str. A prefix for the layer names used in the module.
+            
+    Returns:
+        The output tensor for the Inception module.
+    """
+    data_format = data_format or keras.config.image_data_format()
+    bn_axis = -1 if data_format == "channels_last" else 1
+    
+    # 1x1 branch
+    branch1 = layers.Conv2D(
+        filters_1x1,
+        1,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_1x1_conv",
+    )(x)
+    branch1 = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_1x1_bn",
+    )(branch1)
+    branch1 = layers.ReLU(dtype=dtype, name=f"{name}_1x1_relu")(branch1)
+    
+    # 3x3 branch
+    branch2 = layers.Conv2D(
+        filters_3x3_reduce,
+        1,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_3x3_reduce_conv",
+    )(x)
+    branch2 = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_3x3_reduce_bn",
+    )(branch2)
+    branch2 = layers.ReLU(dtype=dtype, name=f"{name}_3x3_reduce_relu")(branch2)
+    branch2 = layers.Conv2D(
+        filters_3x3,
+        3,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_3x3_conv",
+    )(branch2)
+    branch2 = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_3x3_bn",
+    )(branch2)
+    branch2 = layers.ReLU(dtype=dtype, name=f"{name}_3x3_relu")(branch2)
+    
+    # 5x5 branch
+    branch3 = layers.Conv2D(
+        filters_5x5_reduce,
+        1,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_5x5_reduce_conv",
+    )(x)
+    branch3 = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_5x5_reduce_bn",
+    )(branch3)
+    branch3 = layers.ReLU(dtype=dtype, name=f"{name}_5x5_reduce_relu")(branch3)
+    branch3 = layers.Conv2D(
+        filters_5x5,
+        5,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_5x5_conv",
+    )(branch3)
+    branch3 = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_5x5_bn",
+    )(branch3)
+    branch3 = layers.ReLU(dtype=dtype, name=f"{name}_5x5_relu")(branch3)
+    
+    # Pool branch
+    branch4 = layers.MaxPooling2D(
+        3,
+        strides=1,
+        padding="same",
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_pool",
+    )(x)
+    branch4 = layers.Conv2D(
+        filters_pool_proj,
+        1,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_pool_proj_conv",
+    )(branch4)
+    branch4 = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_pool_proj_bn",
+    )(branch4)
+    branch4 = layers.ReLU(dtype=dtype, name=f"{name}_pool_proj_relu")(branch4)
+    
+    # Concatenate all branches
+    return layers.Concatenate(
+        axis=bn_axis, dtype=dtype, name=f"{name}_concat"
+    )([branch1, branch2, branch3, branch4])
+
+
+def apply_auxiliary_classifier(
+    x,
+    data_format=None,
+    dtype=None,
+    name=None,
+):
+    """Applies an auxiliary classifier.
+    
+    This function implements the auxiliary classifiers used in GoogleNet to help
+    with the vanishing gradient problem during training.
+    
+    Args:
+        x: Tensor. The input tensor to pass through the auxiliary classifier.
+        data_format: `None` or str. the ordering of the dimensions in the
+            inputs. Can be `"channels_last"`
+            (`(batch_size, height, width, channels)`) or`"channels_first"`
+            (`(batch_size, channels, height, width)`).
+        dtype: `None` or str or `keras.mixed_precision.DTypePolicy`. The dtype
+            to use for the models computations and weights.
+        name: str. A prefix for the layer names used in the classifier.
+            
+    Returns:
+        The output tensor for the auxiliary classifier.
+    """
+    data_format = data_format or keras.config.image_data_format()
+    bn_axis = -1 if data_format == "channels_last" else 1
+    
+    x = layers.AveragePooling2D(
+        5,
+        strides=3,
+        padding="valid",
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_avg_pool",
+    )(x)
+    x = layers.Conv2D(
+        128,
+        1,
+        padding="same",
+        use_bias=False,
+        data_format=data_format,
+        dtype=dtype,
+        name=f"{name}_conv",
+    )(x)
+    x = layers.BatchNormalization(
+        axis=bn_axis,
+        epsilon=1e-5,
+        momentum=0.9,
+        dtype=dtype,
+        name=f"{name}_bn",
+    )(x)
+    x = layers.Activation("relu", dtype=dtype, name=f"{name}_relu")(x)
+    
+    # Note: In a backbone, we typically don't use the classification layers
+    # These would normally include flatten, dense (1024), dropout, and final 
+    # dense layer
+    
+    return x
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_backbone_test.py b/keras_hub/src/models/inception/inception_backbone_test.py
new file mode 100644
index 0000000000..2f74aff913
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_backbone_test.py
@@ -0,0 +1,100 @@
+import numpy as np
+import pytest
+
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+from keras_hub.src.tests.test_case import TestCase
+
+
+class InceptionBackboneTest(TestCase):
+    def setUp(self):
+        self.init_kwargs = {
+            "initial_filters": [64],
+            "initial_strides": [2],
+            "inception_config": [
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            "aux_classifiers": False,
+            "image_shape": (32, 32, 3),
+        }
+        self.input_size = 32
+        self.input_data = np.ones(
+            (2, self.input_size, self.input_size, 3), dtype="float32"
+        )
+
+    def test_backbone_basics(self):
+        init_kwargs = {
+            "initial_filters": [64],
+            "initial_strides": [2],
+            "inception_config": [
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            "aux_classifiers": False,
+            "image_shape": (32, 32, 3),
+        }
+        self.run_vision_backbone_test(
+            cls=InceptionBackbone,
+            init_kwargs=init_kwargs,
+            input_data=self.input_data,
+            expected_output_shape=(2, 1, 1, 512),
+            expected_pyramid_output_keys=["P2", "P3", "P4", "P5"],
+            expected_pyramid_image_sizes=[(8, 8), (4, 4), (2, 2), (1, 1)],
+            run_mixed_precision_check=False,
+            run_data_format_check=False,
+        )
+
+    @pytest.mark.large
+    def test_saved_model(self):
+        init_kwargs = {
+            "initial_filters": [64],
+            "initial_strides": [2],
+            "inception_config": [
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            "aux_classifiers": False,
+            "image_shape": (32, 32, 3),
+        }
+        self.run_model_saving_test(
+            cls=InceptionBackbone,
+            init_kwargs=init_kwargs,
+            input_data=self.input_data,
+        )
+
+    @pytest.mark.parametrize(
+        "aux_classifiers", [True, False]
+    )
+    def test_auxiliary_branches(self, aux_classifiers):
+        kwargs = {
+            "initial_filters": [64],
+            "initial_strides": [2],
+            "inception_config": [
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            "aux_classifiers": aux_classifiers,
+            "image_shape": (32, 32, 3),
+        }
+        
+        backbone = InceptionBackbone(**kwargs)
+        outputs = backbone(self.input_data)
+        
+        if aux_classifiers:
+            self.assertIsInstance(outputs, dict)
+            self.assertIn("aux1", outputs)
+            self.assertIn("aux2", outputs)
+            self.assertIn("main", outputs)
+        else:
+            #When not using auxiliary branches, output should be a single tensor
+            # or the feature pyramid if enabled
+            if (
+                isinstance(outputs, dict) 
+                and "P2" in outputs
+            ):
+                self.assertNotIn("aux1", outputs)
+                self.assertNotIn("aux2", outputs)
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_image_classifier.py b/keras_hub/src/models/inception/inception_image_classifier.py
new file mode 100644
index 0000000000..32a510e5aa
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_image_classifier.py
@@ -0,0 +1,10 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.image_classifier import ImageClassifier
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+from keras_hub.src.models.inception import (
+    InceptionImageClassifierPreprocessor
+)
+@keras_hub_export("keras_hub.models.InceptionImageClassifier")
+class InceptionImageClassifier(ImageClassifier):
+    backbone_cls = InceptionBackbone
+    preprocessor_cls = InceptionImageClassifierPreprocessor
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_image_classifier_preprocessor.py b/keras_hub/src/models/inception/inception_image_classifier_preprocessor.py
new file mode 100644
index 0000000000..8fe012f4ae
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_image_classifier_preprocessor.py
@@ -0,0 +1,14 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.image_classifier_preprocessor import (
+    ImageClassifierPreprocessor,
+)
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+from keras_hub.src.models.inception.inception_image_converter import (
+    InceptionImageConverter,
+)
+
+
+@keras_hub_export("keras_hub.models.InceptionImageClassifierPreprocessor")
+class InceptionImageClassifierPreprocessor(ImageClassifierPreprocessor):
+    backbone_cls = InceptionBackbone
+    image_converter_cls = InceptionImageConverter
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_image_classifier_test.py b/keras_hub/src/models/inception/inception_image_classifier_test.py
new file mode 100644
index 0000000000..4941eb0a21
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_image_classifier_test.py
@@ -0,0 +1,184 @@
+import pytest
+from keras import ops
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+from keras_hub.src.models.inception.inception_image_classifier import (
+    InceptionImageClassifier,
+)
+from keras_hub.src.tests.test_case import TestCase
+
+
+class InceptionImageClassifierTest(TestCase):
+    def setUp(self):
+        self.images = ops.ones((2, 16, 16, 3))
+        self.labels = [0, 3]
+        self.backbone = InceptionBackbone(
+            initial_filters=[64, 192],
+            initial_strides=[2, 1],
+            inception_config=[
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            aux_classifiers=False,
+            image_shape=(16, 16, 3),
+        )
+        self.init_kwargs = {
+            "backbone": self.backbone,
+            "num_classes": 2,
+            "pooling": "avg",
+            "activation": "softmax",
+            "aux_classifiers": False,
+        }
+        self.train_data = (self.images, self.labels)
+
+    def test_classifier_basics(self):
+        pytest.skip(
+            reason="TODO: enable after preprocessor flow is figured out"
+        )
+        backbone = InceptionBackbone(
+            initial_filters=[64],
+            initial_strides=[2],
+            inception_config=[
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            aux_classifiers=False,
+            image_shape=(16, 16, 3),
+        )
+        init_kwargs = {
+            "backbone": backbone,
+            "num_classes": 2,
+            "pooling": "avg",
+            "activation": "softmax",
+            "aux_classifiers": False,
+        }
+        self.run_task_test(
+            cls=InceptionImageClassifier,
+            init_kwargs=init_kwargs,
+            train_data=self.train_data,
+            expected_output_shape=(2, 2),
+        )
+
+    def test_head_dtype(self):
+        model = InceptionImageClassifier(
+            backbone=InceptionBackbone(
+                initial_filters=[64],
+                initial_strides=[2],
+                inception_config=[
+                    [64, 96, 128, 16, 32, 32],
+                    [128, 128, 192, 32, 96, 64],
+                    [192, 96, 208, 16, 48, 64],
+                ],
+                aux_classifiers=False,
+                image_shape=(16, 16, 3),
+            ),
+            num_classes=2,
+            pooling="avg",
+            activation="softmax",
+            aux_classifiers=False,
+            head_dtype="bfloat16"
+        )
+        self.assertEqual(model.output_dense.compute_dtype, "bfloat16")
+
+    def test_auxiliary_branches(self):
+        # Test with auxiliary branches enabled
+        backbone = InceptionBackbone(
+            initial_filters=[64],
+            initial_strides=[2],
+            inception_config=[
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            aux_classifiers=False,
+            image_shape=(16, 16, 3),
+        )
+        
+        init_kwargs = {
+            "backbone": backbone,
+            "num_classes": 2,
+            "pooling": "avg",
+            "activation": "softmax",
+            "aux_classifiers": False,
+        }
+        
+        # Create model with auxiliary branches
+        aux_backbone = InceptionBackbone(
+            initial_filters=[64],
+            initial_strides=[2],
+            inception_config=[
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            aux_classifiers=True,
+            image_shape=(16, 16, 3),
+        )
+        
+        aux_kwargs = init_kwargs.copy()
+        aux_kwargs["backbone"] = aux_backbone
+        aux_kwargs["aux_classifiers"] = True
+        
+        model = InceptionImageClassifier(**aux_kwargs)
+        outputs = model(self.images, training=True)
+        
+        # Check if we have main and auxiliary outputs
+        self.assertIsInstance(outputs, dict)
+        self.assertIn("main", outputs)
+        self.assertIn("aux1", outputs)
+        self.assertIn("aux2", outputs)
+        
+        # Check output shapes
+        self.assertEqual(outputs["main"].shape, (2, 2))
+        self.assertEqual(outputs["aux1"].shape, (2, 2))
+        self.assertEqual(outputs["aux2"].shape, (2, 2))
+
+    @pytest.mark.large
+    def test_smallest_preset(self):
+        # Test that our forward pass is stable!
+        image_batch = self.load_test_image()[None, ...] / 255.0
+        self.run_preset_test(
+            cls=InceptionImageClassifier,
+            preset="inception_v3_imagenet",
+            input_data=image_batch,
+            expected_output_shape=(1, 1000),
+            expected_labels=[85],
+        )
+
+    @pytest.mark.large
+    def test_saved_model(self):
+        backbone = InceptionBackbone(
+            initial_filters=[64],
+            initial_strides=[2],
+            inception_config=[
+                [64, 96, 128, 16, 32, 32],
+                [128, 128, 192, 32, 96, 64],
+                [192, 96, 208, 16, 48, 64],
+            ],
+            aux_classifiers=False,
+            image_shape=(16, 16, 3),
+        )
+        init_kwargs = {
+            "backbone": backbone,
+            "num_classes": 2,
+            "pooling": "avg",
+            "activation": "softmax",
+            "aux_classifiers": False,
+        }
+        self.run_model_saving_test(
+            cls=InceptionImageClassifier,
+            init_kwargs=init_kwargs,
+            input_data=self.images,
+        )
+
+    @pytest.mark.extra_large
+    def test_all_presets(self):
+        for preset in InceptionImageClassifier.presets:
+            self.run_preset_test(
+                cls=InceptionImageClassifier,
+                preset=preset,
+                init_kwargs={"num_classes": 2},
+                input_data=self.images,
+                expected_output_shape=(2, 2),
+            )
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_image_converter.py b/keras_hub/src/models/inception/inception_image_converter.py
new file mode 100644
index 0000000000..63b6618e6f
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_image_converter.py
@@ -0,0 +1,7 @@
+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.inception.inception_backbone import InceptionBackbone
+
+@keras_hub_export("keras_hub.layers.InceptionImageConverter")
+class InceptionImageConverter(ImageConverter):
+    backbone_cls = InceptionBackbone
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_presets.py b/keras_hub/src/models/inception/inception_presets.py
new file mode 100644
index 0000000000..ea1669aba4
--- /dev/null
+++ b/keras_hub/src/models/inception/inception_presets.py
@@ -0,0 +1,120 @@
+"""InceptionNet preset configurations."""
+
+backbone_presets = {
+    "inception_v1_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV1 (GoogLeNet) model pre-trained on the ImageNet 1k "
+                "dataset at a 224x224 resolution."
+            ),
+            "params": 6998552,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv1/keras/inception_v1_imagenet/1",
+    },
+    "inception_v2_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV2 model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution. Includes batch normalization."
+            ),
+            "params": 11268392,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv2/keras/inception_v2_imagenet/1",
+    },
+    "inception_v3_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV3 model pre-trained on the ImageNet 1k dataset "
+                "at a 299x299 resolution. Features factorized convolutions "
+                "and improved pooling strategies."
+            ),
+            "params": 23851784,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv3/keras/inception_v3_imagenet/1",
+    },
+    "inception_v4_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV4 model pre-trained on the ImageNet 1k dataset "
+                "at a 299x299 resolution. Features a more uniform architecture"
+                "with more inception modules."
+            ),
+            "params": 42679816,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv4/keras/inception_v4_imagenet/1",
+    },
+    "inception_resnet_v2_imagenet": {
+        "metadata": {
+            "description": (
+                "Inception-ResNet-v2 hybrid model pre-trained on the ImageNet "
+                "1k dataset at a 299x299 resolution. Combines Inception "
+                "architecture with residual connections."
+            ),
+            "params": 55873736,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inception_resnet/keras/inception_resnet_v2_imagenet/1",
+    },
+    "inception_v3_transfer_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV3 model pre-trained on the ImageNet 1k dataset "
+                "at a 299x299 resolution, fine-tuned with transfer learning "
+                "techniques for improved accuracy."
+            ),
+            "params": 23851784,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv3/keras/inception_v3_transfer_imagenet/1",
+    },
+    "inception_v3_augmented_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV3 model pre-trained on the ImageNet 1k dataset "
+                "at a 299x299 resolution with extensive data augmentation for "
+                "improved generalization."
+            ),
+            "params": 23851784,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv3/keras/inception_v3_augmented_imagenet/1",
+    },
+    "inception_v4_transfer_imagenet": {
+        "metadata": {
+            "description": (
+                "InceptionV4 model pre-trained on the ImageNet 1k dataset "
+                "at a 299x299 resolution, fine-tuned with transfer learning "
+                "techniques for improved accuracy."
+            ),
+            "params": 42679816,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inceptionv4/keras/inception_v4_transfer_imagenet/1",
+    },
+    "inception_resnet_v2_transfer_imagenet": {
+        "metadata": {
+            "description": (
+                "Inception-ResNet-v2 hybrid model pre-trained on the ImageNet "
+                "1k dataset at a 299x299 resolution with transfer learning "
+                "techniques for improved performance."
+            ),
+            "params": 55873736,
+            "path": "inception",
+        },
+        "kaggle_handle": 
+        "kaggle://keras/inception_resnet/keras/"
+        "inception_resnet_v2_transfer_imagenet/1",
+    },
+}
\ No newline at end of file

From aeb7cd789503698c0968697bffdfbd41b9c194fd Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Tue, 25 Mar 2025 20:25:36 +0530
Subject: [PATCH 02/10] import issues

---
 keras_hub/src/models/inception/__init__.py                 | 7 ++++++-
 ...er_preprocessor.py => image_classifier_preprocessor.py} | 2 +-
 .../src/models/inception/inception_image_classifier.py     | 2 +-
 3 files changed, 8 insertions(+), 3 deletions(-)
 rename keras_hub/src/models/inception/{inception_image_classifier_preprocessor.py => image_classifier_preprocessor.py} (87%)

diff --git a/keras_hub/src/models/inception/__init__.py b/keras_hub/src/models/inception/__init__.py
index 6dddd2f057..18bd9f9985 100644
--- a/keras_hub/src/models/inception/__init__.py
+++ b/keras_hub/src/models/inception/__init__.py
@@ -1,5 +1,10 @@
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
 from keras_hub.src.models.inception.inception_presets import backbone_presets
 from keras_hub.src.utils.preset_utils import register_presets
-
+from keras_hub.src.models.inception.image_classifier_preprocessor import (
+    InceptionImageClassifierPreprocessor
+)
+from keras_hub.src.models.inception.inception_image_classifier import (
+    InceptionImageClassifier
+)
 register_presets(backbone_presets, InceptionBackbone)
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_image_classifier_preprocessor.py b/keras_hub/src/models/inception/image_classifier_preprocessor.py
similarity index 87%
rename from keras_hub/src/models/inception/inception_image_classifier_preprocessor.py
rename to keras_hub/src/models/inception/image_classifier_preprocessor.py
index 8fe012f4ae..5368769a04 100644
--- a/keras_hub/src/models/inception/inception_image_classifier_preprocessor.py
+++ b/keras_hub/src/models/inception/image_classifier_preprocessor.py
@@ -1,5 +1,5 @@
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.models.image_classifier_preprocessor import (
+from keras_hub.src.models.inception.image_classifier_preprocessor import (
     ImageClassifierPreprocessor,
 )
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
diff --git a/keras_hub/src/models/inception/inception_image_classifier.py b/keras_hub/src/models/inception/inception_image_classifier.py
index 32a510e5aa..75b2530811 100644
--- a/keras_hub/src/models/inception/inception_image_classifier.py
+++ b/keras_hub/src/models/inception/inception_image_classifier.py
@@ -1,7 +1,7 @@
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
-from keras_hub.src.models.inception import (
+from keras_hub.src.models.inception.image_classifier_preprocessor import (
     InceptionImageClassifierPreprocessor
 )
 @keras_hub_export("keras_hub.models.InceptionImageClassifier")

From b0de7e713c0ea95c0ceee031d1d57257d68a715e Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Wed, 26 Mar 2025 19:52:16 +0530
Subject: [PATCH 03/10] import issue

---
 .../src/models/inception/image_classifier_preprocessor.py     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/keras_hub/src/models/inception/image_classifier_preprocessor.py b/keras_hub/src/models/inception/image_classifier_preprocessor.py
index 5368769a04..b63eac9318 100644
--- a/keras_hub/src/models/inception/image_classifier_preprocessor.py
+++ b/keras_hub/src/models/inception/image_classifier_preprocessor.py
@@ -1,6 +1,6 @@
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.models.inception.image_classifier_preprocessor import (
-    ImageClassifierPreprocessor,
+from keras_hub.src.models.image_classifier_preprocessor import (
+    ImageClassifierPreprocessor
 )
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
 from keras_hub.src.models.inception.inception_image_converter import (

From bcd80553355f9db04df92a9d34e6ccaa06ca3e40 Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Wed, 26 Mar 2025 20:01:20 +0530
Subject: [PATCH 04/10] linting errors

---
 keras_hub/src/models/inception/__init__.py        | 11 ++++++-----
 .../src/models/inception/inception_backbone.py    | 15 ++++++---------
 .../inception/inception_image_classifier.py       |  6 ++++--
 .../inception/inception_image_classifier_test.py  |  2 ++
 .../models/inception/inception_image_converter.py |  1 +
 5 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/keras_hub/src/models/inception/__init__.py b/keras_hub/src/models/inception/__init__.py
index 18bd9f9985..34b6f92740 100644
--- a/keras_hub/src/models/inception/__init__.py
+++ b/keras_hub/src/models/inception/__init__.py
@@ -1,10 +1,11 @@
-from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
-from keras_hub.src.models.inception.inception_presets import backbone_presets
-from keras_hub.src.utils.preset_utils import register_presets
 from keras_hub.src.models.inception.image_classifier_preprocessor import (
-    InceptionImageClassifierPreprocessor
+    InceptionImageClassifierPreprocessor,
 )
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
 from keras_hub.src.models.inception.inception_image_classifier import (
-    InceptionImageClassifier
+    InceptionImageClassifier,
 )
+from keras_hub.src.models.inception.inception_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
 register_presets(backbone_presets, InceptionBackbone)
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/inception_backbone.py b/keras_hub/src/models/inception/inception_backbone.py
index f5ff6f2569..47c6b4d6c9 100644
--- a/keras_hub/src/models/inception/inception_backbone.py
+++ b/keras_hub/src/models/inception/inception_backbone.py
@@ -1,24 +1,21 @@
 import keras
+import tensorflow as tf
 from keras import layers
-from keras import ops
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.feature_pyramid_backbone import FeaturePyramidBackbone
 from keras_hub.src.utils.keras_utils import standardize_data_format
-from keras import layers
-import tensorflow as tf
 
 
 @keras_hub_export("keras_hub.models.InceptionBackbone")
 class InceptionBackbone(FeaturePyramidBackbone):
     """GoogleNet (Inception v1) core network with hyperparameters.
 
-    This class implements a GoogleNet (Inception v1) backbone as described in 
-    [Going Deeper with Convolutions]
-    (https://arxiv.org/abs/1409.4842) (CVPR 2015).
-    The architecture is characterized by its unique Inception modules that 
-    process input at different scales simultaneously using multiple filter sizes 
-    in parallel.
+    This model implements the Inception v1 (GoogLeNet) architecture from the 
+    paper "Going Deeper with Convolutions" by Christian Szegedy, et al. 
+    (https://arxiv.org/abs/1409.4842) (CVPR 2015). The architecture is 
+    characterized by its unique Inception modules that process input at 
+    different scales simultaneously using multiple filter sizes in parallel.
 
     Args:
         initial_filters: list of ints. The number of filters for the initial
diff --git a/keras_hub/src/models/inception/inception_image_classifier.py b/keras_hub/src/models/inception/inception_image_classifier.py
index 75b2530811..15d4a34f0b 100644
--- a/keras_hub/src/models/inception/inception_image_classifier.py
+++ b/keras_hub/src/models/inception/inception_image_classifier.py
@@ -1,9 +1,11 @@
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
-from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
 from keras_hub.src.models.inception.image_classifier_preprocessor import (
-    InceptionImageClassifierPreprocessor
+    InceptionImageClassifierPreprocessor,
 )
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+
+
 @keras_hub_export("keras_hub.models.InceptionImageClassifier")
 class InceptionImageClassifier(ImageClassifier):
     backbone_cls = InceptionBackbone
diff --git a/keras_hub/src/models/inception/inception_image_classifier_test.py b/keras_hub/src/models/inception/inception_image_classifier_test.py
index 4941eb0a21..9ffe25a1df 100644
--- a/keras_hub/src/models/inception/inception_image_classifier_test.py
+++ b/keras_hub/src/models/inception/inception_image_classifier_test.py
@@ -1,5 +1,7 @@
 import pytest
 from keras import ops
+
+ 
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
 from keras_hub.src.models.inception.inception_image_classifier import (
     InceptionImageClassifier,
diff --git a/keras_hub/src/models/inception/inception_image_converter.py b/keras_hub/src/models/inception/inception_image_converter.py
index 63b6618e6f..544dfd5f62 100644
--- a/keras_hub/src/models/inception/inception_image_converter.py
+++ b/keras_hub/src/models/inception/inception_image_converter.py
@@ -2,6 +2,7 @@
 from keras_hub.src.layers.preprocessing.image_converter import ImageConverter
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
 
+
 @keras_hub_export("keras_hub.layers.InceptionImageConverter")
 class InceptionImageConverter(ImageConverter):
     backbone_cls = InceptionBackbone
\ No newline at end of file

From 4236f5ea0bb41b5db78b164bbaa92f6069e31054 Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Thu, 27 Mar 2025 12:35:43 +0530
Subject: [PATCH 05/10] error resolve

---
 keras_hub/src/models/inception/inception_backbone_test.py      | 2 ++
 .../src/models/inception/inception_image_classifier_test.py    | 3 +++
 2 files changed, 5 insertions(+)

diff --git a/keras_hub/src/models/inception/inception_backbone_test.py b/keras_hub/src/models/inception/inception_backbone_test.py
index 2f74aff913..c47b08e6fc 100644
--- a/keras_hub/src/models/inception/inception_backbone_test.py
+++ b/keras_hub/src/models/inception/inception_backbone_test.py
@@ -58,6 +58,7 @@ def test_saved_model(self):
             ],
             "aux_classifiers": False,
             "image_shape": (32, 32, 3),
+            "dtype": "float32",  
         }
         self.run_model_saving_test(
             cls=InceptionBackbone,
@@ -79,6 +80,7 @@ def test_auxiliary_branches(self, aux_classifiers):
             ],
             "aux_classifiers": aux_classifiers,
             "image_shape": (32, 32, 3),
+            "dtype": "float32",  
         }
         
         backbone = InceptionBackbone(**kwargs)
diff --git a/keras_hub/src/models/inception/inception_image_classifier_test.py b/keras_hub/src/models/inception/inception_image_classifier_test.py
index 9ffe25a1df..c3268ad419 100644
--- a/keras_hub/src/models/inception/inception_image_classifier_test.py
+++ b/keras_hub/src/models/inception/inception_image_classifier_test.py
@@ -23,6 +23,7 @@ def setUp(self):
             ],
             aux_classifiers=False,
             image_shape=(16, 16, 3),
+            dtype="float32",  # Add explicit dtype
         )
         self.init_kwargs = {
             "backbone": self.backbone,
@@ -47,6 +48,7 @@ def test_classifier_basics(self):
             ],
             aux_classifiers=False,
             image_shape=(16, 16, 3),
+            dtype="float32",  # Add explicit dtype
         )
         init_kwargs = {
             "backbone": backbone,
@@ -74,6 +76,7 @@ def test_head_dtype(self):
                 ],
                 aux_classifiers=False,
                 image_shape=(16, 16, 3),
+                dtype="float32",  # Add explicit dtype
             ),
             num_classes=2,
             pooling="avg",

From 56bba1a775635ca1711638b61503ab5ed7902386 Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Thu, 27 Mar 2025 12:42:34 +0530
Subject: [PATCH 06/10] resolved conversation

---
 keras_hub/src/models/inception/__init__.py                 | 6 ------
 keras_hub/src/models/inception/inception_backbone.py       | 7 ++++---
 keras_hub/src/models/inception/inception_backbone_test.py  | 2 +-
 .../models/inception/inception_image_classifier_test.py    | 3 ---
 4 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/keras_hub/src/models/inception/__init__.py b/keras_hub/src/models/inception/__init__.py
index 34b6f92740..6dddd2f057 100644
--- a/keras_hub/src/models/inception/__init__.py
+++ b/keras_hub/src/models/inception/__init__.py
@@ -1,10 +1,4 @@
-from keras_hub.src.models.inception.image_classifier_preprocessor import (
-    InceptionImageClassifierPreprocessor,
-)
 from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
-from keras_hub.src.models.inception.inception_image_classifier import (
-    InceptionImageClassifier,
-)
 from keras_hub.src.models.inception.inception_presets import backbone_presets
 from keras_hub.src.utils.preset_utils import register_presets
 
diff --git a/keras_hub/src/models/inception/inception_backbone.py b/keras_hub/src/models/inception/inception_backbone.py
index 47c6b4d6c9..309a19f5cd 100644
--- a/keras_hub/src/models/inception/inception_backbone.py
+++ b/keras_hub/src/models/inception/inception_backbone.py
@@ -81,8 +81,8 @@ def __init__(
             raise ValueError(
                 "The length of `initial_filters` and `initial_strides` must be "
                 "the same. "
-                f"Received: initial_filters={initial_filters}, "
-                f"initial_strides={initial_strides}."
+                f"Received {initial_filters} initial_filters, "
+                f"{initial_strides} initial_strides."
             )
         
         for i, config in enumerate(inception_config):
@@ -184,7 +184,8 @@ def __init__(
                 pyramid_level = block_level
                 pyramid_outputs[f"P{pyramid_level}"] = x
                 
-                #Max pooling between inception levels(except after the last one)
+                # Max pooling between inception levels 
+                # (except after the last one)
                 if i < len(inception_config) - 1 and i % 2 == 1:
                     x = layers.ZeroPadding2D(
                         (1, 1), 
diff --git a/keras_hub/src/models/inception/inception_backbone_test.py b/keras_hub/src/models/inception/inception_backbone_test.py
index c47b08e6fc..ce81bd4ed0 100644
--- a/keras_hub/src/models/inception/inception_backbone_test.py
+++ b/keras_hub/src/models/inception/inception_backbone_test.py
@@ -92,7 +92,7 @@ def test_auxiliary_branches(self, aux_classifiers):
             self.assertIn("aux2", outputs)
             self.assertIn("main", outputs)
         else:
-            #When not using auxiliary branches, output should be a single tensor
+            # When not using auxiliary branches, output should be single tensor
             # or the feature pyramid if enabled
             if (
                 isinstance(outputs, dict) 
diff --git a/keras_hub/src/models/inception/inception_image_classifier_test.py b/keras_hub/src/models/inception/inception_image_classifier_test.py
index c3268ad419..4ac393ff27 100644
--- a/keras_hub/src/models/inception/inception_image_classifier_test.py
+++ b/keras_hub/src/models/inception/inception_image_classifier_test.py
@@ -35,9 +35,6 @@ def setUp(self):
         self.train_data = (self.images, self.labels)
 
     def test_classifier_basics(self):
-        pytest.skip(
-            reason="TODO: enable after preprocessor flow is figured out"
-        )
         backbone = InceptionBackbone(
             initial_filters=[64],
             initial_strides=[2],

From 742e21efe7974725fed5849dfbd9a45282c8c00e Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Thu, 27 Mar 2025 13:43:31 +0530
Subject: [PATCH 07/10] tests failing

---
 .../inception_image_classifier_test.py        |  33 ++-
 .../models/inception/numeric_verification.py  | 194 ++++++++++++++++++
 2 files changed, 226 insertions(+), 1 deletion(-)
 create mode 100644 keras_hub/src/models/inception/numeric_verification.py

diff --git a/keras_hub/src/models/inception/inception_image_classifier_test.py b/keras_hub/src/models/inception/inception_image_classifier_test.py
index 4ac393ff27..a95fcb3aef 100644
--- a/keras_hub/src/models/inception/inception_image_classifier_test.py
+++ b/keras_hub/src/models/inception/inception_image_classifier_test.py
@@ -8,6 +8,11 @@
 )
 from keras_hub.src.tests.test_case import TestCase
 
+class TFWrapperLayer(keras.layers.Layer):
+    def call(self, inputs):
+        # Ensure the function operates correctly within the Keras computation graph
+        return tf.identity(inputs)
+
 
 class InceptionImageClassifierTest(TestCase):
     def setUp(self):
@@ -95,6 +100,7 @@ def test_auxiliary_branches(self):
             ],
             aux_classifiers=False,
             image_shape=(16, 16, 3),
+            dtype="float32",  # Add explicit dtype
         )
         
         init_kwargs = {
@@ -116,6 +122,7 @@ def test_auxiliary_branches(self):
             ],
             aux_classifiers=True,
             image_shape=(16, 16, 3),
+            dtype="float32",  # Add explicit dtype
         )
         
         aux_kwargs = init_kwargs.copy()
@@ -183,4 +190,28 @@ def test_all_presets(self):
                 init_kwargs={"num_classes": 2},
                 input_data=self.images,
                 expected_output_shape=(2, 2),
-            )
\ No newline at end of file
+            )
+
+    def test_session(self):
+        # Create a model with the same configuration as in other tests
+        backbone = InceptionBackbone(
+        initial_filters=[64],
+        initial_strides=[2],
+        inception_config=[
+            [64, 96, 128, 16, 32, 32],
+            [128, 128, 192, 32, 96, 64],
+            [192, 96, 208, 16, 48, 64],
+        ],
+        aux_classifiers=False,
+        image_shape=(16, 16, 3),
+        dtype="float32",  # Add explicit dtype
+    )
+    
+        model = InceptionImageClassifier(
+            backbone=backbone,
+            num_classes=2,
+            pooling="avg",
+            activation="softmax",
+            aux_classifiers=False,
+        )
+    
\ No newline at end of file
diff --git a/keras_hub/src/models/inception/numeric_verification.py b/keras_hub/src/models/inception/numeric_verification.py
new file mode 100644
index 0000000000..1bc376c061
--- /dev/null
+++ b/keras_hub/src/models/inception/numeric_verification.py
@@ -0,0 +1,194 @@
+# Inception Model Numerics Verification
+# This script compares our Inception implementation with a reference implementation
+# to ensure numerical consistency within a reasonable margin of error.
+
+import os
+import sys
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import keras
+
+# Add the project root to the Python path to make imports work
+project_root = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(project_root)
+
+# Now we can import from keras_hub
+from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
+from keras_hub.src.models.inception.inception_image_classifier import (
+    InceptionImageClassifier
+)
+# Set random seed for reproducibility
+np.random.seed(42)
+tf.random.set_seed(42)
+
+def cosine_similarity(a, b):
+    """Calculate cosine similarity between two vectors."""
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+def compare_feature_maps(our_features, ref_features, layer_name):
+    """Compare feature maps between our implementation and reference."""
+    our_flat = our_features.flatten()
+    ref_flat = ref_features.flatten()
+    
+    # Calculate metrics
+    cos_sim = cosine_similarity(our_flat, ref_flat)
+    mse = np.mean((our_flat - ref_flat) ** 2)
+    max_diff = np.max(np.abs(our_flat - ref_flat))
+    
+    print(f"Layer: {layer_name}")
+    print(f"Cosine similarity: {cos_sim:.6f}")
+    print(f"Mean squared error: {mse:.6f}")
+    print(f"Maximum absolute difference: {max_diff:.6f}")
+    print("-" * 50)
+    
+    return cos_sim, mse, max_diff
+
+def visualize_feature_maps(our_features, ref_features, layer_name, num_filters=5):
+    """Visualize and compare feature maps."""
+    fig, axes = plt.subplots(2, num_filters, figsize=(15, 6))
+    
+    # Select a subset of filters to visualize
+    if len(our_features.shape) == 4:  # (batch, height, width, channels)
+        our_subset = our_features[0, :, :, :num_filters]
+        ref_subset = ref_features[0, :, :, :num_filters]
+    else:  # Handle different shapes
+        our_subset = our_features[:num_filters]
+        ref_subset = ref_features[:num_filters]
+    
+    for i in range(num_filters):
+        if len(our_features.shape) == 4:
+            our_map = our_subset[:, :, i]
+            ref_map = ref_subset[:, :, i]
+        else:
+            our_map = our_subset[i]
+            ref_map = ref_subset[i]
+            
+        # Normalize for visualization
+        our_map = (our_map - our_map.min()) / (our_map.max() - our_map.min() + 1e-8)
+        ref_map = (ref_map - ref_map.min()) / (ref_map.max() - ref_map.min() + 1e-8)
+        
+        axes[0, i].imshow(our_map, cmap='viridis')
+        axes[0, i].set_title(f"Our Filter {i}")
+        axes[0, i].axis('off')
+        
+        axes[1, i].imshow(ref_map, cmap='viridis')
+        axes[1, i].set_title(f"Ref Filter {i}")
+        axes[1, i].axis('off')
+    
+    plt.suptitle(f"Feature Map Comparison - {layer_name}")
+    plt.tight_layout()
+    plt.show()
+
+def main():
+    print("Starting Inception Numerics Verification...")
+    
+    # 1. Load Models
+    print("Loading models...")
+    
+    # Reference model (TensorFlow's InceptionV3)
+    try:
+        reference_model = tf.keras.applications.InceptionV3(
+            include_top=True,
+            weights='imagenet',
+            input_shape=(299, 299, 3)
+        )
+        print("Reference model loaded successfully.")
+    except Exception as e:
+        print(f"Error loading reference model: {e}")
+        return
+    
+    # Our implementation
+    try:
+        # If preset is not available, create a model with similar architecture
+        try:
+            our_model = InceptionImageClassifier.from_preset("inception_v3_imagenet")
+            print("Our model loaded from preset successfully.")
+        except:
+            print("Preset not available, creating custom model...")
+            # Create a backbone with similar architecture to InceptionV3
+            backbone = InceptionBackbone(
+                initial_filters=[64, 192],
+                initial_strides=[2, 1],
+                inception_config=[
+                    # Simplified inception config
+                    [64, 96, 128, 16, 32, 32],
+                    [128, 128, 192, 32, 96, 64],
+                    [192, 96, 208, 16, 48, 64],
+                    [160, 112, 224, 24, 64, 64],
+                    [128, 128, 256, 24, 64, 64],
+                    [112, 144, 288, 32, 64, 64],
+                    [256, 160, 320, 32, 128, 128],
+                    [256, 160, 320, 32, 128, 128],
+                    [384, 192, 384, 48, 128, 128],
+                ],
+                aux_classifiers=False,
+                image_shape=(299, 299, 3),
+                dtype="float32",
+            )
+            
+            our_model = InceptionImageClassifier(
+                backbone=backbone,
+                num_classes=1000,  # Same as ImageNet
+                pooling="avg",
+                activation="softmax",
+                aux_classifiers=False,
+            )
+            print("Custom model created successfully.")
+    except Exception as e:
+        print(f"Error creating our model: {e}")
+        return
+    
+    # 2. Create test input
+    print("Creating test input...")
+    test_image = np.random.uniform(0, 255, (1, 299, 299, 3)).astype(np.float32)
+    
+    # Preprocess for reference model
+    ref_preprocessed = tf.keras.applications.inception_v3.preprocess_input(
+        test_image.copy()
+    )
+    
+    # Preprocess for our model (may need adjustment based on your preprocessing)
+    our_preprocessed = test_image.copy() / 127.5 - 1.0  # Simple normalization
+    
+    # 3. Get predictions
+    print("Getting predictions...")
+    ref_predictions = reference_model.predict(ref_preprocessed)
+    our_predictions = our_model(our_preprocessed)
+    
+    # Handle different output formats
+    if isinstance(our_predictions, dict):
+        # If our model returns a dict (e.g., with auxiliary outputs)
+        our_predictions = our_predictions.get("main", our_predictions)
+    
+    # 4. Compare predictions
+    print("\nComparing predictions...")
+    
+    # Get top-5 predictions
+    ref_top5 = np.argsort(ref_predictions[0])[-5:][::-1]
+    our_top5 = np.argsort(our_predictions[0])[-5:][::-1]
+    
+    print("Reference model top-5 predictions:", ref_top5)
+    print("Our model top-5 predictions:", our_top5)
+    
+    # Calculate prediction similarity
+    pred_cos_sim = cosine_similarity(ref_predictions.flatten(), our_predictions.flatten())
+    pred_mse = np.mean((ref_predictions.flatten() - our_predictions.flatten()) ** 2)
+    
+    print(f"Prediction cosine similarity: {pred_cos_sim:.6f}")
+    print(f"Prediction MSE: {pred_mse:.6f}")
+    print(f"Top-1 match: {'Yes' if ref_top5[0] == our_top5[0] else 'No'}")
+    print(f"Top-5 overlap: {len(set(ref_top5) & set(our_top5))} out of 5")
+    
+    # 5. Conclusion
+    threshold = 0.8  # Cosine similarity threshold for acceptance
+    if pred_cos_sim > threshold:
+        print("\nCONCLUSION: Our implementation is numerically consistent with the reference!")
+    else:
+        print("\nCONCLUSION: Our implementation shows some numerical differences from the reference.")
+        print(f"Cosine similarity ({pred_cos_sim:.4f}) is below the threshold ({threshold}).")
+        print("This is expected for a re-implementation and doesn't necessarily indicate a problem.")
+        print("Consider fine-tuning the model to match the reference more closely if needed.")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file

From d4324815ff396f9ce8e061a2244cbca3464f605a Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Wed, 2 Apr 2025 15:45:40 +0530
Subject: [PATCH 08/10] test resolve

---
 keras_hub/src/models/inception/inception_backbone.py     | 9 ++++++++-
 .../models/inception/inception_image_classifier_test.py  | 6 ------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/keras_hub/src/models/inception/inception_backbone.py b/keras_hub/src/models/inception/inception_backbone.py
index 309a19f5cd..b11f43bce9 100644
--- a/keras_hub/src/models/inception/inception_backbone.py
+++ b/keras_hub/src/models/inception/inception_backbone.py
@@ -6,6 +6,13 @@
 from keras_hub.src.models.feature_pyramid_backbone import FeaturePyramidBackbone
 from keras_hub.src.utils.keras_utils import standardize_data_format
 
+class CastLayer(keras.layers.Layer):
+    def __init__(self, dtype, **kwargs):
+        super().__init__(**kwargs)
+        self.target_dtype = dtype
+        
+    def call(self, inputs):
+        return tf.cast(inputs, self.target_dtype)
 
 @keras_hub_export("keras_hub.models.InceptionBackbone")
 class InceptionBackbone(FeaturePyramidBackbone):
@@ -139,7 +146,7 @@ def __init__(
                 x = layers.ZeroPadding2D(
                  (1, 1), data_format=data_format, name=f"pool{i+1}_pad"
                 )(x)
-                x = tf.cast(x, dtype)
+                x = CastLayer(dtype=dtype)(x)
                 x = layers.MaxPooling2D(
                     3,
                     strides=2,
diff --git a/keras_hub/src/models/inception/inception_image_classifier_test.py b/keras_hub/src/models/inception/inception_image_classifier_test.py
index a95fcb3aef..ce59a7a758 100644
--- a/keras_hub/src/models/inception/inception_image_classifier_test.py
+++ b/keras_hub/src/models/inception/inception_image_classifier_test.py
@@ -8,12 +8,6 @@
 )
 from keras_hub.src.tests.test_case import TestCase
 
-class TFWrapperLayer(keras.layers.Layer):
-    def call(self, inputs):
-        # Ensure the function operates correctly within the Keras computation graph
-        return tf.identity(inputs)
-
-
 class InceptionImageClassifierTest(TestCase):
     def setUp(self):
         self.images = ops.ones((2, 16, 16, 3))

From 83dbf7e72eaeb5dc545b75c9ce3d524ef33ecd1f Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Wed, 2 Apr 2025 15:48:28 +0530
Subject: [PATCH 09/10] removed file

---
 .../models/inception/numeric_verification.py  | 194 ------------------
 1 file changed, 194 deletions(-)
 delete mode 100644 keras_hub/src/models/inception/numeric_verification.py

diff --git a/keras_hub/src/models/inception/numeric_verification.py b/keras_hub/src/models/inception/numeric_verification.py
deleted file mode 100644
index 1bc376c061..0000000000
--- a/keras_hub/src/models/inception/numeric_verification.py
+++ /dev/null
@@ -1,194 +0,0 @@
-# Inception Model Numerics Verification
-# This script compares our Inception implementation with a reference implementation
-# to ensure numerical consistency within a reasonable margin of error.
-
-import os
-import sys
-import numpy as np
-import tensorflow as tf
-import matplotlib.pyplot as plt
-import keras
-
-# Add the project root to the Python path to make imports work
-project_root = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(project_root)
-
-# Now we can import from keras_hub
-from keras_hub.src.models.inception.inception_backbone import InceptionBackbone
-from keras_hub.src.models.inception.inception_image_classifier import (
-    InceptionImageClassifier
-)
-# Set random seed for reproducibility
-np.random.seed(42)
-tf.random.set_seed(42)
-
-def cosine_similarity(a, b):
-    """Calculate cosine similarity between two vectors."""
-    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
-
-def compare_feature_maps(our_features, ref_features, layer_name):
-    """Compare feature maps between our implementation and reference."""
-    our_flat = our_features.flatten()
-    ref_flat = ref_features.flatten()
-    
-    # Calculate metrics
-    cos_sim = cosine_similarity(our_flat, ref_flat)
-    mse = np.mean((our_flat - ref_flat) ** 2)
-    max_diff = np.max(np.abs(our_flat - ref_flat))
-    
-    print(f"Layer: {layer_name}")
-    print(f"Cosine similarity: {cos_sim:.6f}")
-    print(f"Mean squared error: {mse:.6f}")
-    print(f"Maximum absolute difference: {max_diff:.6f}")
-    print("-" * 50)
-    
-    return cos_sim, mse, max_diff
-
-def visualize_feature_maps(our_features, ref_features, layer_name, num_filters=5):
-    """Visualize and compare feature maps."""
-    fig, axes = plt.subplots(2, num_filters, figsize=(15, 6))
-    
-    # Select a subset of filters to visualize
-    if len(our_features.shape) == 4:  # (batch, height, width, channels)
-        our_subset = our_features[0, :, :, :num_filters]
-        ref_subset = ref_features[0, :, :, :num_filters]
-    else:  # Handle different shapes
-        our_subset = our_features[:num_filters]
-        ref_subset = ref_features[:num_filters]
-    
-    for i in range(num_filters):
-        if len(our_features.shape) == 4:
-            our_map = our_subset[:, :, i]
-            ref_map = ref_subset[:, :, i]
-        else:
-            our_map = our_subset[i]
-            ref_map = ref_subset[i]
-            
-        # Normalize for visualization
-        our_map = (our_map - our_map.min()) / (our_map.max() - our_map.min() + 1e-8)
-        ref_map = (ref_map - ref_map.min()) / (ref_map.max() - ref_map.min() + 1e-8)
-        
-        axes[0, i].imshow(our_map, cmap='viridis')
-        axes[0, i].set_title(f"Our Filter {i}")
-        axes[0, i].axis('off')
-        
-        axes[1, i].imshow(ref_map, cmap='viridis')
-        axes[1, i].set_title(f"Ref Filter {i}")
-        axes[1, i].axis('off')
-    
-    plt.suptitle(f"Feature Map Comparison - {layer_name}")
-    plt.tight_layout()
-    plt.show()
-
-def main():
-    print("Starting Inception Numerics Verification...")
-    
-    # 1. Load Models
-    print("Loading models...")
-    
-    # Reference model (TensorFlow's InceptionV3)
-    try:
-        reference_model = tf.keras.applications.InceptionV3(
-            include_top=True,
-            weights='imagenet',
-            input_shape=(299, 299, 3)
-        )
-        print("Reference model loaded successfully.")
-    except Exception as e:
-        print(f"Error loading reference model: {e}")
-        return
-    
-    # Our implementation
-    try:
-        # If preset is not available, create a model with similar architecture
-        try:
-            our_model = InceptionImageClassifier.from_preset("inception_v3_imagenet")
-            print("Our model loaded from preset successfully.")
-        except:
-            print("Preset not available, creating custom model...")
-            # Create a backbone with similar architecture to InceptionV3
-            backbone = InceptionBackbone(
-                initial_filters=[64, 192],
-                initial_strides=[2, 1],
-                inception_config=[
-                    # Simplified inception config
-                    [64, 96, 128, 16, 32, 32],
-                    [128, 128, 192, 32, 96, 64],
-                    [192, 96, 208, 16, 48, 64],
-                    [160, 112, 224, 24, 64, 64],
-                    [128, 128, 256, 24, 64, 64],
-                    [112, 144, 288, 32, 64, 64],
-                    [256, 160, 320, 32, 128, 128],
-                    [256, 160, 320, 32, 128, 128],
-                    [384, 192, 384, 48, 128, 128],
-                ],
-                aux_classifiers=False,
-                image_shape=(299, 299, 3),
-                dtype="float32",
-            )
-            
-            our_model = InceptionImageClassifier(
-                backbone=backbone,
-                num_classes=1000,  # Same as ImageNet
-                pooling="avg",
-                activation="softmax",
-                aux_classifiers=False,
-            )
-            print("Custom model created successfully.")
-    except Exception as e:
-        print(f"Error creating our model: {e}")
-        return
-    
-    # 2. Create test input
-    print("Creating test input...")
-    test_image = np.random.uniform(0, 255, (1, 299, 299, 3)).astype(np.float32)
-    
-    # Preprocess for reference model
-    ref_preprocessed = tf.keras.applications.inception_v3.preprocess_input(
-        test_image.copy()
-    )
-    
-    # Preprocess for our model (may need adjustment based on your preprocessing)
-    our_preprocessed = test_image.copy() / 127.5 - 1.0  # Simple normalization
-    
-    # 3. Get predictions
-    print("Getting predictions...")
-    ref_predictions = reference_model.predict(ref_preprocessed)
-    our_predictions = our_model(our_preprocessed)
-    
-    # Handle different output formats
-    if isinstance(our_predictions, dict):
-        # If our model returns a dict (e.g., with auxiliary outputs)
-        our_predictions = our_predictions.get("main", our_predictions)
-    
-    # 4. Compare predictions
-    print("\nComparing predictions...")
-    
-    # Get top-5 predictions
-    ref_top5 = np.argsort(ref_predictions[0])[-5:][::-1]
-    our_top5 = np.argsort(our_predictions[0])[-5:][::-1]
-    
-    print("Reference model top-5 predictions:", ref_top5)
-    print("Our model top-5 predictions:", our_top5)
-    
-    # Calculate prediction similarity
-    pred_cos_sim = cosine_similarity(ref_predictions.flatten(), our_predictions.flatten())
-    pred_mse = np.mean((ref_predictions.flatten() - our_predictions.flatten()) ** 2)
-    
-    print(f"Prediction cosine similarity: {pred_cos_sim:.6f}")
-    print(f"Prediction MSE: {pred_mse:.6f}")
-    print(f"Top-1 match: {'Yes' if ref_top5[0] == our_top5[0] else 'No'}")
-    print(f"Top-5 overlap: {len(set(ref_top5) & set(our_top5))} out of 5")
-    
-    # 5. Conclusion
-    threshold = 0.8  # Cosine similarity threshold for acceptance
-    if pred_cos_sim > threshold:
-        print("\nCONCLUSION: Our implementation is numerically consistent with the reference!")
-    else:
-        print("\nCONCLUSION: Our implementation shows some numerical differences from the reference.")
-        print(f"Cosine similarity ({pred_cos_sim:.4f}) is below the threshold ({threshold}).")
-        print("This is expected for a re-implementation and doesn't necessarily indicate a problem.")
-        print("Consider fine-tuning the model to match the reference more closely if needed.")
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file

From f4e14ef1b5fc48b1382103533d67ffd5945ca5aa Mon Sep 17 00:00:00 2001
From: Yug Borana <yugborana000@gmail.com>
Date: Wed, 2 Apr 2025 17:23:55 +0530
Subject: [PATCH 10/10] dtype cast problem

---
 .../models/inception/inception_backbone.py    |  2 +-
 .../inception/inception_backbone_test.py      | 44 ++++++++++---------
 2 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/keras_hub/src/models/inception/inception_backbone.py b/keras_hub/src/models/inception/inception_backbone.py
index b11f43bce9..fa69c0b798 100644
--- a/keras_hub/src/models/inception/inception_backbone.py
+++ b/keras_hub/src/models/inception/inception_backbone.py
@@ -146,7 +146,7 @@ def __init__(
                 x = layers.ZeroPadding2D(
                  (1, 1), data_format=data_format, name=f"pool{i+1}_pad"
                 )(x)
-                x = CastLayer(dtype=dtype)(x)
+                x = CastLayer(dtype=dtype or "float32")(x)
                 x = layers.MaxPooling2D(
                     3,
                     strides=2,
diff --git a/keras_hub/src/models/inception/inception_backbone_test.py b/keras_hub/src/models/inception/inception_backbone_test.py
index ce81bd4ed0..0af56749fd 100644
--- a/keras_hub/src/models/inception/inception_backbone_test.py
+++ b/keras_hub/src/models/inception/inception_backbone_test.py
@@ -66,11 +66,13 @@ def test_saved_model(self):
             input_data=self.input_data,
         )
 
-    @pytest.mark.parametrize(
-        "aux_classifiers", [True, False]
-    )
-    def test_auxiliary_branches(self, aux_classifiers):
-        kwargs = {
+@pytest.mark.parametrize(
+    "aux_classifiers", [True, False]
+)
+def test_auxiliary_branches(aux_classifiers):
+    self = InceptionBackboneTest()
+    self.setUp()
+    kwargs = {
             "initial_filters": [64],
             "initial_strides": [2],
             "inception_config": [
@@ -83,20 +85,20 @@ def test_auxiliary_branches(self, aux_classifiers):
             "dtype": "float32",  
         }
         
-        backbone = InceptionBackbone(**kwargs)
-        outputs = backbone(self.input_data)
+    backbone = InceptionBackbone(**kwargs)
+    outputs = backbone(self.input_data)
         
-        if aux_classifiers:
-            self.assertIsInstance(outputs, dict)
-            self.assertIn("aux1", outputs)
-            self.assertIn("aux2", outputs)
-            self.assertIn("main", outputs)
-        else:
-            # When not using auxiliary branches, output should be single tensor
-            # or the feature pyramid if enabled
-            if (
-                isinstance(outputs, dict) 
-                and "P2" in outputs
-            ):
-                self.assertNotIn("aux1", outputs)
-                self.assertNotIn("aux2", outputs)
\ No newline at end of file
+    if aux_classifiers:
+        self.assertIsInstance(outputs, dict)
+        self.assertIn("aux1", outputs)
+        self.assertIn("aux2", outputs)
+        self.assertIn("main", outputs)
+    else:
+        # When not using auxiliary branches, output should be single tensor
+        # or the feature pyramid if enabled
+        if (
+            isinstance(outputs, dict) 
+            and "P2" in outputs
+        ):
+            self.assertNotIn("aux1", outputs)
+            self.assertNotIn("aux2", outputs)
\ No newline at end of file