keras-hub-nightly 0.22.0.dev202505300409__py3-none-any.whl → 0.22.0.dev202506010424__py3-none-any.whl

keras_hub/layers/__init__.py

@@ -78,6 +78,9 @@ from keras_hub.src.models.cspnet.cspnet_image_converter import (
 from keras_hub.src.models.deeplab_v3.deeplab_v3_image_converter import (
     DeepLabV3ImageConverter as DeepLabV3ImageConverter,
 )
+from keras_hub.src.models.deit.deit_image_converter import (
+    DeiTImageConverter as DeiTImageConverter,
+)
 from keras_hub.src.models.densenet.densenet_image_converter import (
     DenseNetImageConverter as DenseNetImageConverter,
 )

keras_hub/models/__init__.py

@@ -141,6 +141,13 @@ from keras_hub.src.models.deeplab_v3.deeplab_v3_image_segmeter_preprocessor impo
 from keras_hub.src.models.deeplab_v3.deeplab_v3_segmenter import (
     DeepLabV3ImageSegmenter as DeepLabV3ImageSegmenter,
 )
+from keras_hub.src.models.deit.deit_backbone import DeiTBackbone as DeiTBackbone
+from keras_hub.src.models.deit.deit_image_classifier import (
+    DeiTImageClassifier as DeiTImageClassifier,
+)
+from keras_hub.src.models.deit.deit_image_classifier_preprocessor import (
+    DeiTImageClassifierPreprocessor as DeiTImageClassifierPreprocessor,
+)
 from keras_hub.src.models.densenet.densenet_backbone import (
     DenseNetBackbone as DenseNetBackbone,
 )

keras_hub/src/models/deit/deit_backbone.py

@@ -0,0 +1,154 @@
+import keras
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.backbone import Backbone
+from keras_hub.src.models.deit.deit_layers import DeiTEmbeddings
+from keras_hub.src.models.deit.deit_layers import DeiTEncoder
+from keras_hub.src.utils.keras_utils import standardize_data_format
+
+
+@keras_hub_export("keras_hub.models.DeiTBackbone")
+class DeiTBackbone(Backbone):
+    """DeiT backbone.
+
+    This backbone implements the Data-efficient Image Transformer (DeiT)
+    architecture as described in [Training data-efficient image
+    transformers & distillation through attention]
+    (https://arxiv.org/abs/2012.12877).
+
+    Args:
+        image_shape: A tuple or list of 3 integers representing the shape of the
+            input image `(height, width, channels)`.
+        patch_size: tuple or int. The size of each image patch. If an int is
+            provided, it will be used for both height and width. The input image
+            will be split into patches of shape `(patch_size_h, patch_size_w)`.
+        num_layers: int. The number of transformer encoder layers.
+        num_heads: int. The number of attention heads in each Transformer
+            encoder layer.
+        hidden_dim: int. The dimensionality of the hidden representations.
+        intermediate_dim: int. The dimensionality of the intermediate MLP layer
+            in each Transformer encoder layer.
+        dropout_rate: float. The dropout rate for the Transformer encoder
+            layers.
+        attention_dropout: float. The dropout rate for the attention mechanism
+            in each Transformer encoder layer.
+        layer_norm_epsilon: float. Value used for numerical stability in layer
+            normalization.
+        use_mha_bias: bool. Whether to use bias in the multi-head attention
+            layers.
+        data_format: str. `"channels_last"` or `"channels_first"`, specifying
+            the data format for the input image. If `None`, defaults to
+            `"channels_last"`.
+        dtype: The dtype of the layer weights. Defaults to None.
+        **kwargs: Additional keyword arguments to be passed to the parent
+            `Backbone` class.
+    """
+
+    def __init__(
+        self,
+        image_shape,
+        patch_size,
+        num_layers,
+        num_heads,
+        hidden_dim,
+        intermediate_dim,
+        dropout_rate=0.0,
+        attention_dropout=0.0,
+        layer_norm_epsilon=1e-6,
+        use_mha_bias=True,
+        data_format=None,
+        dtype=None,
+        **kwargs,
+    ):
+        # === Laters ===
+        data_format = standardize_data_format(data_format)
+        if isinstance(patch_size, int):
+            patch_size = (patch_size, patch_size)
+        h_axis, w_axis, channels_axis = (
+            (-3, -2, -1) if data_format == "channels_last" else (-2, -1, -3)
+        )
+        # Check that the input image is well specified.
+        if image_shape[h_axis] is None or image_shape[w_axis] is None:
+            raise ValueError(
+                f"Image shape must have defined height and width. Found `None` "
+                f"at index {h_axis} (height) or {w_axis} (width). "
+                f"Image shape: {image_shape}"
+            )
+        # Check that image dimensions be divisible by patch size
+        if image_shape[h_axis] % patch_size[0] != 0:
+            raise ValueError(
+                f"Input height {image_shape[h_axis]} should be divisible by "
+                f"patch size {patch_size}."
+            )
+        if image_shape[w_axis] % patch_size[1] != 0:
+            raise ValueError(
+                f"Input height {image_shape[w_axis]} should be divisible by "
+                f"patch size {patch_size}."
+            )
+
+        num_channels = image_shape[channels_axis]
+
+        # === Functional Model ===
+        inputs = keras.layers.Input(shape=image_shape)
+
+        x = DeiTEmbeddings(
+            image_size=(image_shape[h_axis], image_shape[w_axis]),
+            patch_size=patch_size,
+            hidden_dim=hidden_dim,
+            num_channels=num_channels,
+            data_format=data_format,
+            dropout_rate=dropout_rate,
+            dtype=dtype,
+            name="deit_patching_and_embedding",
+        )(inputs)
+
+        output, _, _ = DeiTEncoder(
+            num_layers=num_layers,
+            num_heads=num_heads,
+            hidden_dim=hidden_dim,
+            intermediate_dim=intermediate_dim,
+            use_mha_bias=use_mha_bias,
+            dropout_rate=dropout_rate,
+            attention_dropout=attention_dropout,
+            layer_norm_epsilon=layer_norm_epsilon,
+            dtype=dtype,
+            name="deit_encoder",
+        )(x)
+
+        super().__init__(
+            inputs=inputs,
+            outputs=output,
+            dtype=dtype,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.image_shape = image_shape
+        self.patch_size = patch_size
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.hidden_dim = hidden_dim
+        self.intermediate_dim = intermediate_dim
+        self.dropout_rate = dropout_rate
+        self.attention_dropout = attention_dropout
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.use_mha_bias = use_mha_bias
+        self.data_format = data_format
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "image_shape": self.image_shape,
+                "patch_size": self.patch_size,
+                "num_layers": self.num_layers,
+                "num_heads": self.num_heads,
+                "hidden_dim": self.hidden_dim,
+                "intermediate_dim": self.intermediate_dim,
+                "dropout_rate": self.dropout_rate,
+                "attention_dropout": self.attention_dropout,
+                "layer_norm_epsilon": self.layer_norm_epsilon,
+                "use_mha_bias": self.use_mha_bias,
+            }
+        )
+        return config

keras_hub/src/models/deit/deit_image_classifier.py

@@ -0,0 +1,171 @@
+import keras
+from keras import ops
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.deit.deit_backbone import DeiTBackbone
+from keras_hub.src.models.deit.deit_image_classifier_preprocessor import (
+    DeiTImageClassifierPreprocessor,
+)
+from keras_hub.src.models.image_classifier import ImageClassifier
+from keras_hub.src.models.task import Task
+
+
+@keras_hub_export("keras_hub.models.DeiTImageClassifier")
+class DeiTImageClassifier(ImageClassifier):
+    """DeiT image classification task.
+
+    `DeiTImageClassifier` tasks wrap a `keras_hub.models.DeiTBackbone` and
+    a `keras_hub.models.Preprocessor` to create a model that can be used for
+    image classification. `DeiTImageClassifier` tasks take an additional
+    `num_classes` argument, controlling the number of predicted output classes.
+
+    To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
+    labels where `x` is a string and `y` is a integer from `[0, num_classes)`.
+
+    Not that unlike `keras_hub.model.ImageClassifier`, the `DeiTImageClassifier`
+    we pluck out `cls_token` which is first seqence from the backbone.
+
+    Args:
+        backbone: A `keras_hub.models.DeiTBackbone` instance or a `keras.Model`.
+        num_classes: int. The number of classes to predict.
+        preprocessor: `None`, a `keras_hub.models.Preprocessor` instance,
+            a `keras.Layer` instance, or a callable. If `None` no preprocessing
+            will be applied to the inputs.
+        pooling: String specifying the classification strategy. The choice
+            impacts the dimensionality and nature of the feature vector used for
+            classification.
+                `"token"`:  A single vector (class token) representing the
+                    overall image features.
+                `"gap"`: A single vector representing the average features
+                    across the spatial dimensions.
+        activation: `None`, str, or callable. The activation function to use on
+            the `Dense` layer. Set `activation=None` to return the output
+            logits. Defaults to `None`.
+        head_dtype: `None`, str, or `keras.mixed_precision.DTypePolicy`. The
+            dtype to use for the classification head's computations and weights.
+
+    Examples:
+
+    Call `predict()` to run inference.
+    ```python
+    # Load preset and train
+    images = np.random.randint(0, 256, size=(2, 384, 384, 3))
+    classifier = keras_hub.models.DeiTImageClassifier.from_preset(
+        "hf://facebook/deit-base-distilled-patch16-384"
+    )
+    classifier.predict(images)
+    ```
+
+    Call `fit()` on a single batch.
+    ```python
+    # Load preset and train
+    images = np.random.randint(0, 256, size=(2, 384, 384, 3))
+    labels = [0, 3]
+    classifier = keras_hub.models.DeiTImageClassifier.from_preset(
+        "hf://facebook/deit-base-distilled-patch16-384"
+    )
+    classifier.fit(x=images, y=labels, batch_size=2)
+    ```
+
+    Call `fit()` with custom loss, optimizer and backbone.
+    ```python
+    classifier = keras_hub.models.DeiTImageClassifier.from_preset(
+        "hf://facebook/deit-base-distilled-patch16-384"
+    )
+    classifier.compile(
+        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
+        optimizer=keras.optimizers.Adam(5e-5),
+    )
+    classifier.backbone.trainable = False
+    classifier.fit(x=images, y=labels, batch_size=2)
+    ```
+
+    Custom backbone.
+    ```python
+    images = np.random.randint(0, 256, size=(2, 384, 384, 3))
+    labels = [0, 3]
+    backbone = keras_hub.models.DeiTBackbone(
+        image_shape = (384, 384, 3),
+        patch_size=16,
+        num_layers=6,
+        num_heads=3,
+        hidden_dim=768,
+        intermediate_dim=2048
+    )
+    classifier = keras_hub.models.DeiTImageClassifier(
+        backbone=backbone,
+        num_classes=4,
+    )
+    classifier.fit(x=images, y=labels, batch_size=2)
+    ```
+    """
+
+    backbone_cls = DeiTBackbone
+    preprocessor_cls = DeiTImageClassifierPreprocessor
+
+    def __init__(
+        self,
+        backbone,
+        num_classes,
+        preprocessor=None,
+        pooling="token",
+        activation=None,
+        dropout=0.0,
+        head_dtype=None,
+        **kwargs,
+    ):
+        head_dtype = head_dtype or backbone.dtype_policy
+
+        # === Layers ===
+        self.backbone = backbone
+        self.preprocessor = preprocessor
+        self.dropout = keras.layers.Dropout(
+            rate=dropout,
+            dtype=head_dtype,
+            name="output_dropout",
+        )
+
+        self.output_dense = keras.layers.Dense(
+            num_classes,
+            activation=activation,
+            dtype=head_dtype,
+            name="predictions",
+        )
+
+        # === Functional Model ===
+        inputs = self.backbone.input
+        x = self.backbone(inputs)
+        if pooling == "token":
+            x = x[:, 0]
+        elif pooling == "gap":
+            ndim = len(ops.shape(x))
+            x = ops.mean(x, axis=list(range(1, ndim - 1)))  # (1,) or (1,2)
+
+        outputs = self.output_dense(x)
+
+        # Skip the parent class functional model.
+        Task.__init__(
+            self,
+            inputs=inputs,
+            outputs=outputs,
+            **kwargs,
+        )
+
+        # === config ===
+        self.num_classes = num_classes
+        self.pooling = pooling
+        self.activation = activation
+        self.dropout = dropout
+
+    def get_config(self):
+        # Backbone serialized in `super`
+        config = super().get_config()
+        config.update(
+            {
+                "num_classes": self.num_classes,
+                "pooling": self.pooling,
+                "activation": self.activation,
+                "dropout": self.dropout,
+            }
+        )
+        return config

keras_hub/src/models/deit/deit_image_classifier_preprocessor.py

@@ -0,0 +1,12 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.deit.deit_backbone import DeiTBackbone
+from keras_hub.src.models.deit.deit_image_converter import DeiTImageConverter
+from keras_hub.src.models.image_classifier_preprocessor import (
+    ImageClassifierPreprocessor,
+)
+
+
+@keras_hub_export("keras_hub.models.DeiTImageClassifierPreprocessor")
+class DeiTImageClassifierPreprocessor(ImageClassifierPreprocessor):
+    backbone_cls = DeiTBackbone
+    image_converter_cls = DeiTImageConverter

keras_hub/src/models/deit/deit_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.deit.deit_backbone import DeiTBackbone
+
+
+@keras_hub_export("keras_hub.layers.DeiTImageConverter")
+class DeiTImageConverter(ImageConverter):
+    backbone_cls = DeiTBackbone

keras_hub/src/models/deit/deit_layers.py

@@ -0,0 +1,519 @@
+import keras
+from keras import ops
+
+from keras_hub.src.utils.keras_utils import standardize_data_format
+
+
+class DeiTEmbeddings(keras.layers.Layer):
+    """Patches the image and embeds the patches.
+
+    Args:
+        image_size: tuple. Size of the input image (height, width).
+        patch_size: tuple. patch_size: tuple. The size of each image
+            patch as (patch_height, patch_width).
+        hidden_dim: int. Dimensionality of the patch embeddings.
+        num_channels: int. Number of channels in the input image. Defaults to
+            `3`.
+        data_format: str. `"channels_last"` or `"channels_first"`. Defaults to
+            `None` (which uses `"channels_last"`).
+        use_mask_token: bool. Whether to use a mask token. Defaults to `False`.
+        dropout_rate: float. Dropout rate. Between 0 and 1. Defaults to
+            `0.0`.
+        **kwargs: Additional keyword arguments passed to `keras.layers.Layer`
+    """
+
+    def __init__(
+        self,
+        image_size,
+        patch_size,
+        hidden_dim,
+        num_channels=3,
+        data_format=None,
+        use_mask_token=False,
+        dropout_rate=0.0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        num_patches = (image_size[0] // patch_size[0]) * (
+            image_size[1] // patch_size[1]
+        )
+        num_positions = num_patches + 2
+
+        # === Config ===
+        self.image_size = image_size
+        self.patch_size = patch_size
+        self.hidden_dim = hidden_dim
+        self.num_channels = num_channels
+        self.num_patches = num_patches
+        self.num_positions = num_positions
+        self.data_format = standardize_data_format(data_format)
+        self.use_mask_token = use_mask_token
+        self.dropout_rate = dropout_rate
+
+    def build(self, input_shape):
+        if self.use_mask_token:
+            self.mask_token = self.add_weight(
+                shape=(1, 1, self.hidden_dim),
+                initializer="zeros",
+                dtype=self.variable_dtype,
+                name="mask_token",
+            )
+        self.class_token = self.add_weight(
+            shape=(
+                1,
+                1,
+                self.hidden_dim,
+            ),
+            initializer="zeros",
+            dtype=self.variable_dtype,
+            name="class_token",
+        )
+        self.distillation_token = self.add_weight(
+            shape=(
+                1,
+                1,
+                self.hidden_dim,
+            ),
+            initializer="zeros",
+            dtype=self.variable_dtype,
+            name="distillation_token",
+        )
+        self.patch_embedding = keras.layers.Conv2D(
+            filters=self.hidden_dim,
+            kernel_size=self.patch_size,
+            strides=self.patch_size,
+            padding="valid",
+            activation=None,
+            dtype=self.dtype_policy,
+            data_format=self.data_format,
+            name="patch_embedding",
+        )
+        self.patch_embedding.build(input_shape)
+        self.position_embedding = self.add_weight(
+            shape=(
+                1,
+                self.num_positions,
+                self.hidden_dim,
+            ),  # Matches the shape in PyTorch
+            initializer=keras.initializers.RandomNormal(
+                stddev=0.02
+            ),  # Equivalent to torch.randn()
+            dtype=self.variable_dtype,
+            trainable=True,
+            name="position_embedding",
+        )
+        self.dropout = keras.layers.Dropout(
+            self.dropout_rate, dtype=self.dtype_policy, name="dropout"
+        )
+
+        self.built = True
+
+    def call(self, inputs, bool_masked_pos=None):
+        patch_embeddings = self.patch_embedding(inputs)
+        if self.data_format == "channels_first":
+            patch_embeddings = ops.transpose(
+                patch_embeddings, axes=(0, 2, 3, 1)
+            )
+        embeddings_shape = ops.shape(patch_embeddings)
+        patch_embeddings = ops.reshape(
+            patch_embeddings, [embeddings_shape[0], -1, embeddings_shape[-1]]
+        )
+
+        if bool_masked_pos is not None and self.use_mask_token:
+            # Expand dimensions to match the embeddings
+            bool_masked_pos_expanded = ops.expand_dims(
+                bool_masked_pos, axis=-1
+            )  # (batch_size, num_patches, 1)
+            mask_token_expanded = ops.expand_dims(
+                self.mask_token, axis=0
+            )  # (1, 1, hidden_size)
+            # Apply masking
+            embeddings = ops.where(
+                bool_masked_pos_expanded, mask_token_expanded, patch_embeddings
+            )
+
+        class_token = ops.tile(self.class_token, (embeddings_shape[0], 1, 1))
+        distillation_token = ops.tile(
+            self.distillation_token, (embeddings_shape[0], 1, 1)
+        )
+        embeddings = ops.concatenate(
+            [class_token, distillation_token, patch_embeddings], axis=1
+        )
+        position_embedding = self.position_embedding
+        embeddings = ops.add(embeddings, position_embedding)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+
+    def compute_output_shape(self, input_shape):
+        return (
+            input_shape[0],
+            self.num_positions,
+            self.hidden_dim,
+        )
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "image_size": self.image_size,
+                "patch_size": self.patch_size,
+                "hidden_dim": self.hidden_dim,
+                "num_channels": self.num_channels,
+                "num_patches": self.num_patches,
+                "num_positions": self.num_positions,
+                "use_mask_token": self.use_mask_token,
+                "dropout_rate": self.dropout_rate,
+            }
+        )
+        return config
+
+
+class DeiTIntermediate(keras.layers.Layer):
+    """DeiTIntermediate block.
+    Args:
+        intermediate_dim: int. Dimensionality of the intermediate MLP layer.
+        **kwargs: Additional keyword arguments passed to `keras.layers.Layer`
+    """
+
+    def __init__(
+        self,
+        intermediate_dim,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        # === Config ===
+        self.intermediate_dim = intermediate_dim
+
+    def build(self, input_shape):
+        self.dense = keras.layers.Dense(
+            units=self.intermediate_dim,
+            activation="gelu",
+            dtype=self.dtype_policy,
+            name="dense",
+        )
+        self.dense.build(input_shape)
+        self.built = True
+
+    def call(self, inputs):
+        out = self.dense(inputs)
+        return out
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "intermediate_dim": self.intermediate_dim,
+            }
+        )
+        return config
+
+
+class DeiTOutput(keras.layers.Layer):
+    """DeiT Output layer implementation.
+    Args:
+        hidden_dim: int. Dimensionality of the patch embeddings.
+        dropout_rate: float. Dropout rate. Between 0 and 1. Defaults to
+            `0.0`.
+        **kwargs: Additional keyword arguments passed to `keras.layers.Layer`
+    """
+
+    def __init__(self, hidden_dim, dropout_rate=0.1, **kwargs):
+        super().__init__(**kwargs)
+        self.hidden_dim = hidden_dim
+        self.dropout_rate = dropout_rate
+
+    def build(self, input_shape):
+        self.dense = keras.layers.Dense(
+            self.hidden_dim, dtype=self.dtype_policy, name="output"
+        )
+        self.dense.build(input_shape)
+
+        self.dropout = keras.layers.Dropout(
+            self.dropout_rate, dtype=self.dtype_policy, name="dropout"
+        )
+        # Mark this layer as built
+        self.built = True
+
+    def call(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)  # Linear transformation
+        hidden_states = self.dropout(hidden_states)  # Apply dropout
+        hidden_states = hidden_states + input_tensor  # Residual connection
+        return hidden_states
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "hidden_dim": self.hidden_dim,
+                "dropout_rate": self.dropout_rate,
+            }
+        )
+        return config
+
+
+class DeiTEncoderBlock(keras.layers.Layer):
+    """DeiT encoder block.
+    Args:
+        num_heads: int. Number of attention heads.
+        hidden_dim: int. Dimensionality of the hidden representations.
+        intermediate_dim: int. Dimensionality of the intermediate MLP layer.
+        use_mha_bias: bool. Whether to use bias in the multi-head attention
+            layer. Defaults to `True`.
+        dropout_rate: float. Dropout rate. Between 0 and 1. Defaults to
+            `0.0`.
+        attention_dropout: float. Dropout rate for the attention mechanism.
+            Between 0 and 1. Defaults to `0.0`.
+        layer_norm_epsilon: float. Small float value for layer normalization
+            stability. Defaults to `1e-6`.
+        **kwargs: Additional keyword arguments passed to `keras.layers.Layer`
+    """
+
+    def __init__(
+        self,
+        num_heads,
+        hidden_dim,
+        intermediate_dim,
+        use_mha_bias=True,
+        dropout_rate=0.0,
+        attention_dropout=0.0,
+        layer_norm_epsilon=1e-6,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        key_dim = hidden_dim // num_heads
+
+        # === Config ===
+        self.num_heads = num_heads
+        self.hidden_dim = hidden_dim
+        self.intermediate_dim = intermediate_dim
+        self.key_dim = key_dim
+        self.use_mha_bias = use_mha_bias
+        self.dropout_rate = dropout_rate
+        self.attention_dropout = attention_dropout
+        self.layer_norm_epsilon = layer_norm_epsilon
+
+    def build(self, input_shape):
+        # Attention block
+        self.layer_norm_1 = keras.layers.LayerNormalization(
+            epsilon=self.layer_norm_epsilon,
+            name="ln_1",
+            dtype=self.dtype_policy,
+        )
+        self.layer_norm_1.build(input_shape)
+        self.mha = keras.layers.MultiHeadAttention(
+            num_heads=self.num_heads,
+            key_dim=self.key_dim,
+            use_bias=self.use_mha_bias,
+            dropout=self.attention_dropout,
+            name="mha",
+            dtype=self.dtype_policy,
+        )
+        self.mha.build(input_shape, input_shape)
+
+        # MLP block
+        self.layer_norm_2 = keras.layers.LayerNormalization(
+            epsilon=self.layer_norm_epsilon,
+            name="ln_2",
+            dtype=self.dtype_policy,
+        )
+        self.layer_norm_2.build((None, None, self.hidden_dim))
+
+        # Intermediate Layer
+        self.mlp = DeiTIntermediate(
+            self.intermediate_dim, dtype=self.dtype_policy, name="mlp"
+        )
+        self.mlp.build((None, None, self.hidden_dim))
+
+        # Output Layer
+        self.output_layer = DeiTOutput(
+            self.hidden_dim,
+            self.dropout_rate,
+            dtype=self.dtype_policy,
+            name="output_layer",
+        )
+
+        self.output_layer.build((None, None, self.intermediate_dim))
+
+        self.built = True
+
+    def call(
+        self,
+        hidden_states,
+        attention_mask=None,
+        return_attention_scores=False,
+    ):
+        attention_scores = None
+        x = self.layer_norm_1(hidden_states)
+        if return_attention_scores:
+            x, attention_scores = self.mha(
+                x,
+                x,
+                attention_mask=attention_mask,
+                return_attention_scores=return_attention_scores,
+            )
+        else:
+            x = self.mha(
+                x,
+                x,
+                attention_mask=attention_mask,
+            )
+
+        x = x + hidden_states
+        y = self.layer_norm_2(x)
+        y = self.mlp(y)
+        y = self.output_layer(y, x)
+
+        return y, attention_scores
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "num_heads": self.num_heads,
+                "hidden_dim": self.hidden_dim,
+                "intermediate_dim": self.intermediate_dim,
+                "key_dim": self.key_dim,
+                "use_mha_bias": self.use_mha_bias,
+                "dropout_rate": self.dropout_rate,
+                "attention_dropout": self.attention_dropout,
+                "layer_norm_epsilon": self.layer_norm_epsilon,
+            }
+        )
+        return config
+
+
+class DeiTEncoder(keras.layers.Layer):
+    """DeiT Encoder class.
+    Args:
+        num_layers: int. Number of Transformer encoder blocks.
+        num_heads: int. Number of attention heads.
+        hidden_dim: int. Dimensionality of the hidden representations.
+        intermediate_dim: int. Dimensionality of the intermediate MLP layer.
+        use_mha_bias: bool. Whether to use bias in the multi-head attention
+            layer. Defaults to `True`.
+        dropout_rate: float. Dropout rate. Between 0 and 1. Defaults to
+            `0.0`.
+        attention_dropout: float. Dropout rate for the attention mechanism.
+            Between 0 and 1. Defaults to `0.0`.
+        layer_norm_epsilon: float. Small float value for layer normalization
+            stability. Defaults to `1e-6`.
+        **kwargs: Additional keyword arguments passed to `keras.layers.Layer`
+    """
+
+    def __init__(
+        self,
+        num_layers,
+        num_heads,
+        hidden_dim,
+        intermediate_dim,
+        use_mha_bias=True,
+        dropout_rate=0.0,
+        attention_dropout=0.0,
+        layer_norm_epsilon=1e-6,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        # === Config ===
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.hidden_dim = hidden_dim
+        self.intermediate_dim = intermediate_dim
+        self.use_mha_bias = use_mha_bias
+        self.dropout_rate = dropout_rate
+        self.attention_dropout = attention_dropout
+        self.layer_norm_epsilon = layer_norm_epsilon
+
+    def build(self, input_shape):
+        self.encoder_layers = []
+        for i in range(self.num_layers):
+            encoder_block = DeiTEncoderBlock(
+                num_heads=self.num_heads,
+                hidden_dim=self.hidden_dim,
+                intermediate_dim=self.intermediate_dim,
+                use_mha_bias=self.use_mha_bias,
+                dropout_rate=self.dropout_rate,
+                attention_dropout=self.attention_dropout,
+                layer_norm_epsilon=self.layer_norm_epsilon,
+                dtype=self.dtype_policy,
+                name=f"transformer_block_{i + 1}",
+            )
+            encoder_block.build((None, None, self.hidden_dim))
+            self.encoder_layers.append(encoder_block)
+
+        self.layer_norm = keras.layers.LayerNormalization(
+            epsilon=self.layer_norm_epsilon,
+            dtype=self.dtype_policy,
+            name="ln",
+        )
+        self.layer_norm.build((None, None, self.hidden_dim))
+
+        self.built = True
+
+    def call(
+        self,
+        hidden_states,
+        attention_masks=None,
+        output_hidden_states=False,
+        return_attention_scores=False,
+    ):
+        seq_len = ops.shape(hidden_states)[1]  # Sequence length
+        hidden_dim = ops.shape(hidden_states)[2]  # Hidden size
+
+        # Ensure valid tensor output even if disabled
+        all_hidden_states = (
+            ops.empty(shape=(0, seq_len, hidden_dim), dtype=hidden_states.dtype)
+            if not output_hidden_states
+            else ()
+        )
+
+        all_self_attentions_scores = (
+            ops.empty(
+                shape=(0, self.num_heads, seq_len, seq_len),
+                dtype=hidden_states.dtype,
+            )
+            if not return_attention_scores
+            else ()
+        )
+
+        for i in range(self.num_layers):
+            attention_mask = (
+                attention_masks[i] if attention_masks is not None else None
+            )
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            hidden_states, scores = self.encoder_layers[i](
+                hidden_states,
+                attention_mask=attention_mask,
+                return_attention_scores=return_attention_scores,
+            )
+            if return_attention_scores:
+                all_self_attentions_scores = all_self_attentions_scores + (
+                    scores,
+                )
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        hidden_states = self.layer_norm(hidden_states)
+
+        return hidden_states, all_hidden_states, all_self_attentions_scores
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "num_layers": self.num_layers,
+                "num_heads": self.num_heads,
+                "hidden_dim": self.hidden_dim,
+                "intermediate_dim": self.intermediate_dim,
+                "key_dim": self.key_dim,
+                "use_mha_bias": self.use_mha_bias,
+                "dropout_rate": self.dropout_rate,
+                "attention_dropout": self.attention_dropout,
+                "layer_norm_epsilon": self.layer_norm_epsilon,
+            }
+        )
+        return config

keras_hub/src/models/deit/deit_presets.py

@@ -0,0 +1,49 @@
+"""DeiT model preset configurations."""
+
+# Metadata for loading pretrained model weights.
+backbone_presets = {
+    "deit-base-distilled-patch16-384_imagenet": {
+        "metadata": {
+            "description": (
+                "DeiT-B16 model pre-trained on the ImageNet 1k dataset with "
+                "image resolution of 384x384 "
+            ),
+            "params": 86092032,
+            "path": "deit",
+        },
+        "kaggle_handle": "kaggle://keras/deit/keras/deit_base_distilled_patch16_384_imagenet/1",
+    },
+    "deit-base-distilled-patch16-224_imagenet": {
+        "metadata": {
+            "description": (
+                "DeiT-B16 model pre-trained on the ImageNet 1k dataset with "
+                "image resolution of 224x224 "
+            ),
+            "params": 85800192,
+            "path": "deit",
+        },
+        "kaggle_handle": "kaggle://keras/deit/keras/deit_base_distilled_patch16_224_imagenet/1",
+    },
+    "deit-tiny-distilled-patch16-224_imagenet": {
+        "metadata": {
+            "description": (
+                "DeiT-T16 model pre-trained on the ImageNet 1k dataset with "
+                "image resolution of 224x224 "
+            ),
+            "params": 5524800,
+            "path": "deit",
+        },
+        "kaggle_handle": "kaggle://keras/deit/keras/deit_tiny_distilled_patch16_224_imagenet/1",
+    },
+    "deit-small-distilled-patch16-224_imagenet": {
+        "metadata": {
+            "description": (
+                "DeiT-S16 model pre-trained on the ImageNet 1k dataset with "
+                "image resolution of 224x224 "
+            ),
+            "params": 21666432,
+            "path": "deit",
+        },
+        "kaggle_handle": "kaggle://keras/deit/keras/deit_small_distilled_patch16_224_imagenet/1",
+    },
+}

keras_hub/src/utils/transformers/convert_deit.py

@@ -0,0 +1,155 @@
+import numpy as np
+
+from keras_hub.src.models.deit.deit_backbone import DeiTBackbone
+
+backbone_cls = DeiTBackbone
+
+
+def convert_backbone_config(transformers_config):
+    image_size = transformers_config["image_size"]
+    return {
+        "image_shape": (image_size, image_size, 3),
+        "patch_size": transformers_config["patch_size"],
+        "num_layers": transformers_config["num_hidden_layers"],
+        "num_heads": transformers_config["num_attention_heads"],
+        "hidden_dim": transformers_config["hidden_size"],
+        "intermediate_dim": transformers_config["intermediate_size"],
+        "dropout_rate": transformers_config["hidden_dropout_prob"],
+        "attention_dropout": transformers_config[
+            "attention_probs_dropout_prob"
+        ],
+        "layer_norm_epsilon": transformers_config["layer_norm_eps"],
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    def port_ln(keras_variable, weight_key):
+        loader.port_weight(keras_variable.gamma, f"{weight_key}.weight")
+        loader.port_weight(keras_variable.beta, f"{weight_key}.bias")
+
+    def port_dense(keras_variable, weight_key):
+        loader.port_weight(
+            keras_variable.kernel,
+            f"{weight_key}.weight",
+            hook_fn=lambda x, _: x.T,
+        )
+        if keras_variable.bias is not None:
+            loader.port_weight(keras_variable.bias, f"{weight_key}.bias")
+
+    def port_mha(keras_variable, weight_key, num_heads, hidden_dim):
+        # query
+        loader.port_weight(
+            keras_variable.query_dense.kernel,
+            f"{weight_key}.attention.query.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (hidden_dim, num_heads, hidden_dim // num_heads)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.query_dense.bias,
+            f"{weight_key}.attention.query.bias",
+            hook_fn=lambda x, _: np.reshape(
+                x, (num_heads, hidden_dim // num_heads)
+            ),
+        )
+        # key
+        loader.port_weight(
+            keras_variable.key_dense.kernel,
+            f"{weight_key}.attention.key.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (hidden_dim, num_heads, hidden_dim // num_heads)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.key_dense.bias,
+            f"{weight_key}.attention.key.bias",
+            hook_fn=lambda x, _: np.reshape(
+                x, (num_heads, hidden_dim // num_heads)
+            ),
+        )
+        # value
+        loader.port_weight(
+            keras_variable.value_dense.kernel,
+            f"{weight_key}.attention.value.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (hidden_dim, num_heads, hidden_dim // num_heads)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.value_dense.bias,
+            f"{weight_key}.attention.value.bias",
+            hook_fn=lambda x, _: np.reshape(
+                x, (num_heads, hidden_dim // num_heads)
+            ),
+        )
+        # output
+        loader.port_weight(
+            keras_variable.output_dense.kernel,
+            f"{weight_key}.output.dense.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (num_heads, hidden_dim // num_heads, hidden_dim)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.output_dense.bias, f"{weight_key}.output.dense.bias"
+        )
+
+    loader.port_weight(
+        keras_variable=backbone.layers[1].patch_embedding.kernel,
+        hf_weight_key="deit.embeddings.patch_embeddings.projection.weight",
+        hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+    )
+
+    loader.port_weight(
+        backbone.layers[1].patch_embedding.bias,
+        "deit.embeddings.patch_embeddings.projection.bias",
+    )
+
+    loader.port_weight(
+        backbone.layers[1].class_token,
+        "deit.embeddings.cls_token",
+    )
+
+    loader.port_weight(
+        backbone.layers[1].distillation_token,
+        "deit.embeddings.distillation_token",
+    )
+
+    loader.port_weight(
+        backbone.layers[1].position_embedding,
+        "deit.embeddings.position_embeddings",
+    )
+
+    encoder_layers = backbone.layers[2].encoder_layers
+    for i, encoder_block in enumerate(encoder_layers):
+        prefix = "deit.encoder.layer"
+        num_heads = encoder_block.num_heads
+        hidden_dim = encoder_block.hidden_dim
+
+        port_mha(
+            encoder_block.mha,
+            f"{prefix}.{i}.attention",
+            num_heads,
+            hidden_dim,
+        )
+        port_ln(encoder_block.layer_norm_1, f"{prefix}.{i}.layernorm_before")
+        port_ln(encoder_block.layer_norm_2, f"{prefix}.{i}.layernorm_after")
+
+        port_dense(encoder_block.mlp.dense, f"{prefix}.{i}.intermediate.dense")
+        port_dense(
+            encoder_block.output_layer.dense, f"{prefix}.{i}.output.dense"
+        )
+    port_ln(backbone.layers[2].layer_norm, "deit.layernorm")
+
+
+def convert_head(task, loader, transformers_config):
+    prefix = "cls_classifier."
+    loader.port_weight(
+        task.output_dense.kernel,
+        hf_weight_key=prefix + "weight",
+        hook_fn=lambda x, _: x.T,
+    )
+    loader.port_weight(
+        task.output_dense.bias,
+        hf_weight_key=prefix + "bias",
+    )

keras_hub/src/utils/transformers/preset_loader.py

@@ -6,6 +6,7 @@ from keras_hub.src.utils.preset_utils import jax_memory_cleanup
 from keras_hub.src.utils.transformers import convert_albert
 from keras_hub.src.utils.transformers import convert_bart
 from keras_hub.src.utils.transformers import convert_bert
+from keras_hub.src.utils.transformers import convert_deit
 from keras_hub.src.utils.transformers import convert_distilbert
 from keras_hub.src.utils.transformers import convert_gemma
 from keras_hub.src.utils.transformers import convert_gpt2
@@ -30,6 +31,8 @@ class TransformersPresetLoader(PresetLoader):
             self.converter = convert_bart
         elif model_type == "bert":
             self.converter = convert_bert
+        elif model_type == "deit":
+            self.converter = convert_deit
         elif model_type == "distilbert":
             self.converter = convert_distilbert
         elif model_type == "gemma" or model_type == "gemma2":
@@ -82,7 +85,7 @@ class TransformersPresetLoader(PresetLoader):
                 cls, load_weights, load_task_weights, **kwargs
             )
         # Support loading the classification head for classifier models.
-        if architecture == "ViTForImageClassification":
+        if "ForImageClassification" in architecture:
             kwargs["num_classes"] = len(self.config["id2label"])
         task = super().load_task(cls, load_weights, load_task_weights, **kwargs)
         if load_task_weights:

keras_hub/src/version.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.22.0.dev202505300409"
+__version__ = "0.22.0.dev202506010424"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.22.0.dev202505300409.dist-info → keras_hub_nightly-0.22.0.dev202506010424.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-hub-nightly
-Version: 0.22.0.dev202505300409
+Version: 0.22.0.dev202506010424
 Summary: Pretrained models for Keras.
 Author-email: Keras team <keras-users@googlegroups.com>
 License-Expression: Apache-2.0

{keras_hub_nightly-0.22.0.dev202505300409.dist-info → keras_hub_nightly-0.22.0.dev202506010424.dist-info}/RECORD

@@ -1,11 +1,11 @@
 keras_hub/__init__.py,sha256=bJbUZkqwhZvTb1Tqx1fbkq6mzBYiEyq-Hin3oQIkhdE,558
-keras_hub/layers/__init__.py,sha256=gnvT-GuASB1hZwY4zrRkLs5yohSQu9Pp1SHDxsWPLY8,5081
+keras_hub/layers/__init__.py,sha256=YQ4bW0_mI39Jqj2yoc8xcnynqoaXV2FBjHJviA9Ffas,5190
 keras_hub/metrics/__init__.py,sha256=KYalsMPBnfwim9BdGHFfJ5WxUKFXOQ1QoKIMT_0lwlM,439
-keras_hub/models/__init__.py,sha256=1ZKgLK4AZ44s_cH7vu6FvmVocxf0biLAnY_lEh3dgxw,26734
+keras_hub/models/__init__.py,sha256=7MhCw7S-uIPcko-R6g5a-Jy1idKe7BwlI836PfekhHc,27076
 keras_hub/samplers/__init__.py,sha256=aFQIkiqbZpi8vjrPp2MVII4QUfE-eQjra5fMeHsoy7k,886
 keras_hub/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/api_export.py,sha256=9pQZK27JObxWZ96QPLBp1OBsjWigh1iuV6RglPGMRk0,1499
-keras_hub/src/version.py,sha256=hJyx_F3-Sy3RRaPET6xBnbg7QRtPkFgRHC4_SaxL3bw,222
+keras_hub/src/version.py,sha256=X10EJWAXrQl8oULfkImOI1c3vRPYzSyhNdVUqY-Jo1w,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
@@ -135,6 +135,13 @@ keras_hub/src/models/deeplab_v3/deeplab_v3_image_segmeter_preprocessor.py,sha256
 keras_hub/src/models/deeplab_v3/deeplab_v3_layers.py,sha256=mz9nG55gdXSTDE96AXgeTCwUFB95DIpTuqrvWIt5Lco,7840
 keras_hub/src/models/deeplab_v3/deeplab_v3_presets.py,sha256=ZKYY8A7mV2QvwXwjDUd9xAbVHo58-Hgj_IqNUbuyCIU,625
 keras_hub/src/models/deeplab_v3/deeplab_v3_segmenter.py,sha256=pubi30sPJKLOpz9fRQff2FZt_53KBvwf2uyaJ5YL7J8,3726
+keras_hub/src/models/deit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keras_hub/src/models/deit/deit_backbone.py,sha256=R5pBOqe8vcvD8VaRnsy_zIRIz6BLnUbkTeKUOoGNHPA,5942
+keras_hub/src/models/deit/deit_image_classifier.py,sha256=pUS2638yBAxEBxcJoHyLABsgjCWv_Y0Mj_8u0YgDPdI,5758
+keras_hub/src/models/deit/deit_image_classifier_preprocessor.py,sha256=s5pTcsUjlt1oIXFWIu-9gf2-sBesAyrjJIYmFOB96Xs,514
+keras_hub/src/models/deit/deit_image_converter.py,sha256=wEGCLHS_i4wF9WA4m7uUXcHNbwf6TYgvPoM6C_t0rpM,330
+keras_hub/src/models/deit/deit_layers.py,sha256=A80-UTHEUV8g5rEG-fr8OQpGe3HeoYlYwpoDCtq71ZU,17278
+keras_hub/src/models/deit/deit_presets.py,sha256=0c2jm2DIznOr6ciQoLM6QYopQTLiMx4jONGLaXvtt6g,1778
 keras_hub/src/models/densenet/__init__.py,sha256=r7StyamnWeeZxOk9r4ZYNbS_YVhu9YGPyXhNxljvdPg,269
 keras_hub/src/models/densenet/densenet_backbone.py,sha256=f2nfsXyXQert2aYHq-L-JZtp8inq1fs1K47rzZQ9nTI,6744
 keras_hub/src/models/densenet/densenet_image_classifier.py,sha256=ye-Ix3oU42pfsDoh-h1PG4di1kzldO0ZO7Nj304p_X4,544
@@ -494,6 +501,7 @@ keras_hub/src/utils/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 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
 keras_hub/src/utils/transformers/convert_bert.py,sha256=4gQqXCJzC9QWdLPDUAq741K8t_kjPIET050YjUnLeDA,5977
+keras_hub/src/utils/transformers/convert_deit.py,sha256=ubcqYzMlhWTCE2S_TsXICCMmqjN9RsQPaw_70vArnjo,5306
 keras_hub/src/utils/transformers/convert_distilbert.py,sha256=SlfIRhSRk5c1ir2HGiDPiXa5XdOId_DbcnZO9lbwyZ8,6498
 keras_hub/src/utils/transformers/convert_gemma.py,sha256=ElCgwBpSN5Q7rV5PJawTsoytPzs5ZjuwoY60YAe8y_A,6533
 keras_hub/src/utils/transformers/convert_gpt2.py,sha256=HCeHN_-GiQJRxLCM9OCJJ1watPVpIBF8ujS8pGbBOWc,5703
@@ -505,11 +513,11 @@ keras_hub/src/utils/transformers/convert_qwen.py,sha256=WUxMAEFVqRs7TRw7QU5TH3_e
 keras_hub/src/utils/transformers/convert_qwen3.py,sha256=LIormvCMWPq6X9Wo2eNbADjtFZ0nI7tFGZFBxmo4GKw,5700
 keras_hub/src/utils/transformers/convert_qwen_moe.py,sha256=a7R28aln-PdAcNuKAXdrtzvslho2Co6GypChxLMKPpc,10618
 keras_hub/src/utils/transformers/convert_vit.py,sha256=9SUZ9utNJhW_5cj3acMn9cRy47u2eIcDsrhmzj77o9k,5187
-keras_hub/src/utils/transformers/preset_loader.py,sha256=7tFnbyAiUCMcTG8VQ7Wpi-J7cvRoSZn-ZYE_l0xuh0M,4363
+keras_hub/src/utils/transformers/preset_loader.py,sha256=K5FzDAtCuXS9rmZc0Zj7UCwbz5J9_pf7ozWov1qRAfg,4495
 keras_hub/src/utils/transformers/safetensor_utils.py,sha256=CYUHyA4y-B61r7NDnCsFb4t_UmSwZ1k9L-8gzEd6KRg,3339
 keras_hub/tokenizers/__init__.py,sha256=uMjjm0mzUkRb0e4Ac_JK8aJ9cKGUi5UqmzWoWAFJprE,4164
 keras_hub/utils/__init__.py,sha256=jXPqVGBpJr_PpYmqD8aDG-fRMlxH-ulqCR2SZMn288Y,646
-keras_hub_nightly-0.22.0.dev202505300409.dist-info/METADATA,sha256=hH3xqnggYJvyKQ7DG5U0pJyM8umkP1oRPj32GKEu1E8,7393
-keras_hub_nightly-0.22.0.dev202505300409.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-keras_hub_nightly-0.22.0.dev202505300409.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
-keras_hub_nightly-0.22.0.dev202505300409.dist-info/RECORD,,
+keras_hub_nightly-0.22.0.dev202506010424.dist-info/METADATA,sha256=-J2uLLUxduaRzkjRd8memSWHfc7HhOWxihoDlOsUZks,7393
+keras_hub_nightly-0.22.0.dev202506010424.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+keras_hub_nightly-0.22.0.dev202506010424.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
+keras_hub_nightly-0.22.0.dev202506010424.dist-info/RECORD,,