keras-hub-nightly 0.19.0.dev202502090345__py3-none-any.whl → 0.19.0.dev202502110348__py3-none-any.whl

keras_hub/src/models/mobilenet/mobilenet_image_classifier.py

@@ -1,8 +1,81 @@
+import keras
+
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.mobilenet.mobilenet_backbone import MobileNetBackbone
+from keras_hub.src.models.mobilenet.mobilenet_image_classifier_preprocessor import (  # noqa: E501
+    MobileNetImageClassifierPreprocessor,
+)
+from keras_hub.src.models.task import Task
 
 
 @keras_hub_export("keras_hub.models.MobileNetImageClassifier")
 class MobileNetImageClassifier(ImageClassifier):
     backbone_cls = MobileNetBackbone
+    preprocessor_cls = MobileNetImageClassifierPreprocessor
+
+    def __init__(
+        self,
+        backbone,
+        num_classes,
+        preprocessor=None,
+        head_dtype=None,
+        **kwargs,
+    ):
+        head_dtype = head_dtype or backbone.dtype_policy
+        data_format = getattr(backbone, "data_format", None)
+
+        # === Layers ===
+        self.backbone = backbone
+        self.preprocessor = preprocessor
+        self.pooler = keras.layers.GlobalAveragePooling2D(
+            data_format, keepdims=True, dtype=head_dtype, name="pooler"
+        )
+
+        self.output_conv = keras.layers.Conv2D(
+            filters=1024,
+            kernel_size=(1, 1),
+            strides=(1, 1),
+            use_bias=True,
+            padding="valid",
+            activation="hard_silu",
+            name="classifier_conv",
+            dtype=head_dtype,
+        )
+
+        self.flatten = keras.layers.Flatten(
+            dtype=head_dtype,
+        )
+
+        self.output_dense = keras.layers.Dense(
+            num_classes,
+            dtype=head_dtype,
+            name="predictions",
+        )
+
+        # === Functional Model ===
+        inputs = self.backbone.input
+        x = self.backbone(inputs)
+        x = self.pooler(x)
+        x = self.output_conv(x)
+        x = self.flatten(x)
+        outputs = self.output_dense(x)
+        Task.__init__(
+            self,
+            inputs=inputs,
+            outputs=outputs,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.num_classes = num_classes
+
+    def get_config(self):
+        # Skip ImageClassifier
+        config = Task.get_config(self)
+        config.update(
+            {
+                "num_classes": self.num_classes,
+            }
+        )
+        return config

keras_hub/src/models/mobilenet/mobilenet_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.mobilenet.mobilenet_backbone import MobileNetBackbone
+from keras_hub.src.models.mobilenet.mobilenet_image_converter import (
+    MobileNetImageConverter,
+)
+
+
+@keras_hub_export("keras_hub.models.MobileNetImageClassifierPreprocessor")
+class MobileNetImageClassifierPreprocessor(ImageClassifierPreprocessor):
+    backbone_cls = MobileNetBackbone
+    image_converter_cls = MobileNetImageConverter

keras_hub/src/models/mobilenet/mobilenet_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.mobilenet.mobilenet_backbone import MobileNetBackbone
+
+
+@keras_hub_export("keras_hub.layers.MobileNetImageConverter")
+class MobileNetImageConverter(ImageConverter):
+    backbone_cls = MobileNetBackbone

keras_hub/src/models/mobilenet/mobilenet_presets.py

@@ -0,0 +1,15 @@
+"""MobileNet preset configurations."""
+
+backbone_presets = {
+    "mobilenetv3_small_050": {
+        "metadata": {
+            "description": (
+                "Small MObilenet V3 model pre-trained on the ImageNet 1k "
+                "dataset at a 224x224 resolution."
+            ),
+            "official_name": "MobileNet",
+            "path": "mobilenet3",
+        },
+        "kaggle_handle": "kaggle://keras/mobilenet/keras/mobilenetv3_small_050",
+    },
+}

keras_hub/src/models/mobilenet/util.py

@@ -0,0 +1,23 @@
+def adjust_channels(x, divisor=8, min_value=None):
+    """Ensure that all layers have a channel number divisible by the `divisor`.
+
+    Args:
+        x: integer, input value.
+        divisor: integer, the value by which a channel number should be
+            divisible, defaults to 8.
+        min_value: float, optional minimum value for the new tensor. If None,
+            defaults to value of divisor.
+
+    Returns:
+        the updated input scalar.
+    """
+
+    if min_value is None:
+        min_value = divisor
+
+    new_x = max(min_value, int(x + divisor / 2) // divisor * divisor)
+
+    # make sure that round down does not go down by more than 10%.
+    if new_x < 0.9 * x:
+        new_x += divisor
+    return new_x

keras_hub/src/utils/preset_utils.py

@@ -27,11 +27,12 @@ except ImportError:
 KAGGLE_PREFIX = "kaggle://"
 GS_PREFIX = "gs://"
 HF_PREFIX = "hf://"
+MODELSCOPE_PREFIX = "modelscope://"
 
 KAGGLE_SCHEME = "kaggle"
 GS_SCHEME = "gs"
 HF_SCHEME = "hf"
-
+MODELSCOPE_SCHEME = "modelscope"
 ASSET_DIR = "assets"
 TOKENIZER_ASSET_DIR = f"{ASSET_DIR}/tokenizer"
 
@@ -165,6 +166,37 @@ def get_file(preset, path):
                 raise ValueError(message)
     elif scheme in tf_registered_schemes():
         return tf_copy_gfile_to_cache(preset, path)
+    elif scheme == MODELSCOPE_SCHEME:
+        try:
+            from modelscope.hub.snapshot_download import snapshot_download
+        except ImportError:
+            raise ImportError(
+                "To load a preset from ModelScope {preset} using from_preset,"
+                "install the modelscope package with: pip install modelscope."
+            )
+        modelscope_handle = preset.removeprefix(MODELSCOPE_SCHEME + "://")
+        try:
+            return_path = snapshot_download(modelscope_handle) + "/" + path
+            if os.path.exists(return_path):
+                return return_path
+            raise FileNotFoundError(
+                f"`{return_path}` doesn't exist in preset directory `{preset}`."
+            )
+        except ValueError as e:
+            raise ValueError(
+                "ModelScope handles should follow the format "
+                f"'modelscope://{{org}}/{{model}}'  "
+                "(e.g., 'modelscope://username/bert_base_en')."
+                f"Received: preset='{preset}.'"
+            ) from e
+        except EntryNotFoundError as e:
+            message = str(e)
+            if message.find("403 Client Error"):
+                raise FileNotFoundError(
+                    f"`{path}` not exist in preset directory `{preset}`."
+                )
+            else:
+                raise ValueError(message)
     elif scheme == HF_SCHEME:
         if huggingface_hub is None:
             raise ImportError(

keras_hub/src/utils/timm/convert_mobilenet.py

@@ -0,0 +1,201 @@
+import numpy as np
+
+from keras_hub.src.models.mobilenet.mobilenet_backbone import MobileNetBackbone
+
+backbone_cls = MobileNetBackbone
+
+
+def convert_backbone_config(timm_config):
+    timm_architecture = timm_config["architecture"]
+
+    if "mobilenetv3_" in timm_architecture:
+        input_activation = "hard_swish"
+        output_activation = "hard_swish"
+    else:
+        input_activation = "relu6"
+        output_activation = "relu6"
+
+    if timm_architecture == "mobilenetv3_small_050":
+        stackwise_num_blocks = [2, 3, 2, 3]
+        stackwise_expansion = [
+            [40, 56],
+            [64, 144, 144],
+            [72, 72],
+            [144, 288, 288],
+        ]
+        stackwise_num_filters = [[16, 16], [24, 24, 24], [24, 24], [48, 48, 48]]
+        stackwise_kernel_size = [[3, 3], [5, 5, 5], [5, 5], [5, 5, 5]]
+        stackwise_num_strides = [[2, 1], [2, 1, 1], [1, 1], [2, 1, 1]]
+        stackwise_se_ratio = [
+            [None, None],
+            [0.25, 0.25, 0.25],
+            [0.25, 0.25],
+            [0.25, 0.25, 0.25],
+        ]
+        stackwise_activation = [
+            ["relu", "relu"],
+            ["hard_swish", "hard_swish", "hard_swish"],
+            ["hard_swish", "hard_swish"],
+            ["hard_swish", "hard_swish", "hard_swish"],
+        ]
+        stackwise_padding = [[1, 1], [2, 2, 2], [2, 2], [2, 2, 2]]
+        output_num_filters = 1024
+        input_num_filters = 16
+        depthwise_filters = 8
+        squeeze_and_excite = 0.5
+        last_layer_filter = 288
+    else:
+        raise ValueError(
+            f"Currently, the architecture {timm_architecture} is not supported."
+        )
+
+    return dict(
+        input_num_filters=input_num_filters,
+        input_activation=input_activation,
+        depthwise_filters=depthwise_filters,
+        squeeze_and_excite=squeeze_and_excite,
+        stackwise_num_blocks=stackwise_num_blocks,
+        stackwise_expansion=stackwise_expansion,
+        stackwise_num_filters=stackwise_num_filters,
+        stackwise_kernel_size=stackwise_kernel_size,
+        stackwise_num_strides=stackwise_num_strides,
+        stackwise_se_ratio=stackwise_se_ratio,
+        stackwise_activation=stackwise_activation,
+        stackwise_padding=stackwise_padding,
+        output_num_filters=output_num_filters,
+        output_activation=output_activation,
+        last_layer_filter=last_layer_filter,
+    )
+
+
+def convert_weights(backbone, loader, timm_config):
+    def port_conv2d(keras_layer, hf_weight_prefix, port_bias=False):
+        print(f"porting weights {hf_weight_prefix} -> {keras_layer}")
+        loader.port_weight(
+            keras_layer.kernel,
+            hf_weight_key=f"{hf_weight_prefix}.weight",
+            hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+        )
+
+        if port_bias:
+            print(f"porting bias {hf_weight_prefix} -> {keras_layer}")
+            loader.port_weight(
+                keras_layer.bias,
+                hf_weight_key=f"{hf_weight_prefix}.bias",
+            )
+
+    def port_batch_normalization(keras_layer, hf_weight_prefix):
+        print(f"porting weights {hf_weight_prefix} -> {keras_layer}")
+        loader.port_weight(
+            keras_layer.gamma,
+            hf_weight_key=f"{hf_weight_prefix}.weight",
+        )
+        loader.port_weight(
+            keras_layer.beta,
+            hf_weight_key=f"{hf_weight_prefix}.bias",
+        )
+        loader.port_weight(
+            keras_layer.moving_mean,
+            hf_weight_key=f"{hf_weight_prefix}.running_mean",
+        )
+        loader.port_weight(
+            keras_layer.moving_variance,
+            hf_weight_key=f"{hf_weight_prefix}.running_var",
+        )
+        loader.port_weight(
+            keras_layer.moving_variance,
+            hf_weight_key=f"{hf_weight_prefix}.running_var",
+        )
+
+    # Stem
+    port_conv2d(backbone.get_layer("input_conv"), "conv_stem")
+    port_batch_normalization(backbone.get_layer("input_batch_norm"), "bn1")
+
+    # DepthWise Block  (block 0)
+    hf_name = "blocks.0.0"
+    keras_name = "block_0_0"
+
+    stem_block = backbone.get_layer(keras_name)
+
+    port_conv2d(stem_block.conv1, f"{hf_name}.conv_dw")
+    port_batch_normalization(stem_block.batch_normalization1, f"{hf_name}.bn1")
+
+    stem_se_block = stem_block.se_layer
+    port_conv2d(stem_se_block.conv_reduce, f"{hf_name}.se.conv_reduce", True)
+    port_conv2d(stem_se_block.conv_expand, f"{hf_name}.se.conv_expand", True)
+
+    port_conv2d(stem_block.conv2, f"{hf_name}.conv_pw")
+    port_batch_normalization(stem_block.batch_normalization2, f"{hf_name}.bn2")
+
+    # Stages
+    num_stacks = len(backbone.stackwise_num_blocks)
+    for block_idx in range(num_stacks):
+        for inverted_block in range(backbone.stackwise_num_blocks[block_idx]):
+            keras_name = f"block_{block_idx + 1}_{inverted_block}"
+            hf_name = f"blocks.{block_idx + 1}.{inverted_block}"
+
+            # Inverted Residual Block
+            ir_block = backbone.get_layer(keras_name)
+            port_conv2d(ir_block.conv1, f"{hf_name}.conv_pw")
+            port_batch_normalization(
+                ir_block.batch_normalization1, f"{hf_name}.bn1"
+            )
+            port_conv2d(ir_block.conv2, f"{hf_name}.conv_dw")
+            port_batch_normalization(
+                ir_block.batch_normalization2, f"{hf_name}.bn2"
+            )
+
+            if backbone.stackwise_se_ratio[block_idx][inverted_block]:
+                ir_se_block = ir_block.squeeze_excite
+                port_conv2d(
+                    ir_se_block.conv_reduce,
+                    f"{hf_name}.se.conv_reduce",
+                    True,
+                )
+                port_conv2d(
+                    ir_se_block.conv_expand,
+                    f"{hf_name}.se.conv_expand",
+                    True,
+                )
+
+            port_conv2d(ir_block.conv3, f"{hf_name}.conv_pwl")
+            port_batch_normalization(
+                ir_block.batch_normalization3, f"{hf_name}.bn3"
+            )
+
+    # ConvBnAct Block
+    cba_block_name = f"block_{num_stacks + 1}_0"
+    cba_block = backbone.get_layer(cba_block_name)
+    port_conv2d(cba_block.conv, f"blocks.{num_stacks + 1}.0.conv")
+    port_batch_normalization(
+        cba_block.batch_normalization, f"blocks.{num_stacks + 1}.0.bn1"
+    )
+
+
+def convert_head(task, loader, timm_config):
+    def port_conv2d(keras_layer, hf_weight_prefix, port_bias=False):
+        print(f"porting weights {hf_weight_prefix} -> {keras_layer}")
+        loader.port_weight(
+            keras_layer.kernel,
+            hf_weight_key=f"{hf_weight_prefix}.weight",
+            hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+        )
+
+        if port_bias:
+            print(f"porting bias {hf_weight_prefix} -> {keras_layer}")
+            loader.port_weight(
+                keras_layer.bias,
+                hf_weight_key=f"{hf_weight_prefix}.bias",
+            )
+
+    port_conv2d(task.output_conv, "conv_head", True)
+    prefix = "classifier."
+    loader.port_weight(
+        task.output_dense.kernel,
+        hf_weight_key=prefix + "weight",
+        hook_fn=lambda x, _: np.transpose(np.squeeze(x)),
+    )
+    loader.port_weight(
+        task.output_dense.bias,
+        hf_weight_key=prefix + "bias",
+    )

keras_hub/src/utils/timm/preset_loader.py

@@ -5,6 +5,7 @@ from keras_hub.src.utils.preset_utils import PresetLoader
 from keras_hub.src.utils.preset_utils import jax_memory_cleanup
 from keras_hub.src.utils.timm import convert_densenet
 from keras_hub.src.utils.timm import convert_efficientnet
+from keras_hub.src.utils.timm import convert_mobilenet
 from keras_hub.src.utils.timm import convert_resnet
 from keras_hub.src.utils.timm import convert_vgg
 from keras_hub.src.utils.transformers.safetensor_utils import SafetensorLoader
@@ -18,6 +19,8 @@ class TimmPresetLoader(PresetLoader):
             self.converter = convert_resnet
         elif "densenet" in architecture:
             self.converter = convert_densenet
+        elif "mobilenet" in architecture:
+            self.converter = convert_mobilenet
         elif "vgg" in architecture:
             self.converter = convert_vgg
         elif "efficientnet" in architecture:

keras_hub/src/version_utils.py

@@ -1,7 +1,7 @@
 from keras_hub.src.api_export import keras_hub_export
 
 # Unique source of truth for the version number.
-__version__ = "0.19.0.dev202502090345"
+__version__ = "0.19.0.dev202502110348"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.19.0.dev202502090345.dist-info → keras_hub_nightly-0.19.0.dev202502110348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: keras-hub-nightly
-Version: 0.19.0.dev202502090345
+Version: 0.19.0.dev202502110348
 Summary: Industry-strength Natural Language Processing extensions for Keras.
 Home-page: https://github.com/keras-team/keras-hub
 Author: Keras team

{keras_hub_nightly-0.19.0.dev202502090345.dist-info → keras_hub_nightly-0.19.0.dev202502110348.dist-info}/RECORD

@@ -1,14 +1,14 @@
 keras_hub/__init__.py,sha256=QGdXyHgYt6cMUAP1ebxwc6oR86dE0dkMxNy2eOCQtFo,855
 keras_hub/api/__init__.py,sha256=EzR6D-XWsm_gDrX5LDwKEmrah_gu3ffpj8GKBudE0yI,485
-keras_hub/api/layers/__init__.py,sha256=oHP3UTIAom7bK1E3nCZzK8wQ-TdYKtgF-wL9_-xzyhQ,3338
+keras_hub/api/layers/__init__.py,sha256=SJBSu8wXHIw5aTCp4LJ8NHyzvUD4ecw8zf2Gg-jkOwo,3440
 keras_hub/api/metrics/__init__.py,sha256=So8Ec-lOcTzn_UUMmAdzDm8RKkPu2dbRUm2px8gpUEI,381
-keras_hub/api/models/__init__.py,sha256=YqsLw0u69F93OpS6E677hIeka_hIgjIleSt-xjVqqrk,17002
+keras_hub/api/models/__init__.py,sha256=HXkKL1jkOQDO0QCF-V2HLzq3h0MZiz_QvI2iCmUGyqE,17131
 keras_hub/api/samplers/__init__.py,sha256=n-_SEXxr2LNUzK2FqVFN7alsrkx1P_HOVTeLZKeGCdE,730
 keras_hub/api/tokenizers/__init__.py,sha256=mtJgQy1spfQnPAkeLoeinsT_W9iCWHlJXwzcol5W1aU,2524
 keras_hub/api/utils/__init__.py,sha256=Gp1E6gG-RtKQS3PBEQEOz9PQvXkXaJ0ySGMqZ7myN7A,215
 keras_hub/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/api_export.py,sha256=9pQZK27JObxWZ96QPLBp1OBsjWigh1iuV6RglPGMRk0,1499
-keras_hub/src/version_utils.py,sha256=MPrNlHBnjVfWiCh9pKmagExHTIr8HGxFDh5Ajc8vbyo,222
+keras_hub/src/version_utils.py,sha256=FneQdFaevL30uXjE0jJPrD-FtPxtkJ6P_4pRtsyUc2c,222
 keras_hub/src/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/layers/modeling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/layers/modeling/alibi_bias.py,sha256=1XBTHI52L_iJDhN_w5ydu_iMhCuTgQAxEPwcLA6BPuk,4411
@@ -237,8 +237,12 @@ keras_hub/src/models/mit/mit_image_converter.py,sha256=Mw7nV-OzyBveGuZUNFsPPKyq9
 keras_hub/src/models/mit/mit_layers.py,sha256=HUJO5uhJ6jgwANpwbQdPlEVwLRVb3BZQ-Ftjg3B9XvY,9734
 keras_hub/src/models/mit/mit_presets.py,sha256=ooLrh2OoGZKxnCGnhB6BynYJtVCXH7nDDFhgQRWt36U,4528
 keras_hub/src/models/mobilenet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-keras_hub/src/models/mobilenet/mobilenet_backbone.py,sha256=oIhNjPRWVtJvQbjaWxXzgIQwtRV10-dIWVR7LJM4Ev0,18192
-keras_hub/src/models/mobilenet/mobilenet_image_classifier.py,sha256=l5jo99I0fLlbwLub5jHw07CjC-NnmuV-ySJwXGI20Ek,351
+keras_hub/src/models/mobilenet/mobilenet_backbone.py,sha256=kUEDzML7MzXjUVKDY0BFn-sjGFJbu8IB8DBvG8t2nLA,28880
+keras_hub/src/models/mobilenet/mobilenet_image_classifier.py,sha256=jgyEn_WO5zLqC9UIuRV564rIY_8bMsmuUBaJA9ag5N0,2310
+keras_hub/src/models/mobilenet/mobilenet_image_classifier_preprocessor.py,sha256=yqM4wQ3ae7wXTBO0aMuvJx6XqllA7Psqzjvpm2NABXM,573
+keras_hub/src/models/mobilenet/mobilenet_image_converter.py,sha256=a3Ka0UYYK5wHSOjf2oMHSgofRazTAeUfttklVefq14w,360
+keras_hub/src/models/mobilenet/mobilenet_presets.py,sha256=6LBAiUF7DWIzfKTfC5QeYYapRK2Ov8M-NVACWdHZfHU,461
+keras_hub/src/models/mobilenet/util.py,sha256=S7j4UacmVIJ3fU8cymyAoK49eHcpWIKTOyUQiEjcbzQ,721
 keras_hub/src/models/opt/__init__.py,sha256=6Ybj8etxNaPsVcuZvaeHnKB3As92Px--dbiFAqOCIT0,239
 keras_hub/src/models/opt/opt_backbone.py,sha256=mK5z_E5mSiIX5s0w4hr4IVQpT7K46W2ajZBmuMjxwaY,5873
 keras_hub/src/models/opt/opt_causal_lm.py,sha256=UqN6E3vJDMx1Wgc5tpptsdFu6wadRgdHqgOLTAMiazw,10851
@@ -384,7 +388,7 @@ keras_hub/src/tokenizers/word_piece_tokenizer_trainer.py,sha256=cylrs02ZrYQ1TuZr
 keras_hub/src/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/utils/keras_utils.py,sha256=ZULqIQylAQen-_pNC96htvLaxSJbfAenNoCo3ZSvY5g,1843
 keras_hub/src/utils/pipeline_model.py,sha256=jgzB6NQPSl0KOu08N-TazfOnXnUJbZjH2EXXhx25Ftg,9084
-keras_hub/src/utils/preset_utils.py,sha256=cRsviMUs-Xskg5KefJ-bQCL9y30yJFyVg3RtvmVCo8o,30504
+keras_hub/src/utils/preset_utils.py,sha256=ZbSEUSacKlr_mgHyB3ChUohgOQN7nMCkE6E2lGxt2HA,31927
 keras_hub/src/utils/python_utils.py,sha256=N8nWeO3san4YnGkffRXG3Ix7VEIMTKSN21FX5TuL7G8,202
 keras_hub/src/utils/tensor_utils.py,sha256=lczQWgPVJU09cLtNbo8MErVFNV9ne4gNlrzbNVQazg4,15042
 keras_hub/src/utils/imagenet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -392,9 +396,10 @@ keras_hub/src/utils/imagenet/imagenet_utils.py,sha256=MvIvv1WJo51ZXBxy4S7t_DsN3Z
 keras_hub/src/utils/timm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/utils/timm/convert_densenet.py,sha256=fu8HBIQis5o3ib2tyI2qnmYScVrVIQySok8vTfa1qJ8,3393
 keras_hub/src/utils/timm/convert_efficientnet.py,sha256=SgEIlyyinS04qoQpEgh3WazHq544zNUCCpfmWh3EjSs,17100
+keras_hub/src/utils/timm/convert_mobilenet.py,sha256=0CHzc2kk36C1aaxt8x1UmfcxPtywQ8Jvfgt_6N8xICw,7215
 keras_hub/src/utils/timm/convert_resnet.py,sha256=8JFkVtdpy5z9h83LJ97rD-a8FRejXPZvMNksNuStqjM,5834
 keras_hub/src/utils/timm/convert_vgg.py,sha256=MT5jGnLrzenPpe66Af_Lp1IdR9KGtsSrcmn6_UPqHvQ,2419
-keras_hub/src/utils/timm/preset_loader.py,sha256=cdZDjthZdTD2myMOenQar4ACyi7VTuIzNRg24LuqS-4,3374
+keras_hub/src/utils/timm/preset_loader.py,sha256=yhEV8D99GszCCpOw4I9GdOzAWJB0_gBnlS6ecaaIRGk,3518
 keras_hub/src/utils/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/utils/transformers/convert_albert.py,sha256=VdKclZpCxtDWq3UbUUQZf4fR9DJK_JYZ73B4O_G9skg,7695
 keras_hub/src/utils/transformers/convert_bart.py,sha256=Tk4h9Md9rwN5wjQbGIVrC7qzDpF8kI8qm-FKL8HlUok,14411
@@ -408,7 +413,7 @@ keras_hub/src/utils/transformers/convert_pali_gemma.py,sha256=B1leeDw96Yvu81hYum
 keras_hub/src/utils/transformers/convert_vit.py,sha256=9SUZ9utNJhW_5cj3acMn9cRy47u2eIcDsrhmzj77o9k,5187
 keras_hub/src/utils/transformers/preset_loader.py,sha256=DgGJXbTSB9Na8FIR-YWWVqQPOFxHwWrGm41EwcS_EFs,3797
 keras_hub/src/utils/transformers/safetensor_utils.py,sha256=CYUHyA4y-B61r7NDnCsFb4t_UmSwZ1k9L-8gzEd6KRg,3339
-keras_hub_nightly-0.19.0.dev202502090345.dist-info/METADATA,sha256=POgUExivaP3IA5lb7Owe6ukVAFjyD497U7q5wO3MSww,7498
-keras_hub_nightly-0.19.0.dev202502090345.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-keras_hub_nightly-0.19.0.dev202502090345.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
-keras_hub_nightly-0.19.0.dev202502090345.dist-info/RECORD,,
+keras_hub_nightly-0.19.0.dev202502110348.dist-info/METADATA,sha256=BTyTx2Yps11VrmGpPRYcEHaKLSxHCv5c3NQeiBbZO84,7498
+keras_hub_nightly-0.19.0.dev202502110348.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+keras_hub_nightly-0.19.0.dev202502110348.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
+keras_hub_nightly-0.19.0.dev202502110348.dist-info/RECORD,,