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

keras_hub/src/models/clip/clip_vision_embedding.py

@@ -0,0 +1,101 @@
+from keras import layers
+from keras import ops
+
+from keras_hub.src.utils.keras_utils import standardize_data_format
+
+
+class CLIPVisionEmbedding(layers.Layer):
+    def __init__(
+        self,
+        hidden_dim,
+        patch_size,
+        image_size,
+        data_format=None,
+        dtype=None,
+        **kwargs,
+    ):
+        super().__init__(dtype=dtype, **kwargs)
+        self.hidden_dim = int(hidden_dim)
+        self.patch_size = int(patch_size)
+        self.image_size = int(image_size)
+        data_format = standardize_data_format(data_format)
+        self.data_format = data_format
+        num_patches = (image_size // patch_size) ** 2
+        self.num_positions = num_patches + 1
+
+        self.patch_embedding = layers.Conv2D(
+            hidden_dim,
+            kernel_size=patch_size,
+            strides=patch_size,
+            data_format=data_format,
+            use_bias=False,
+            dtype=dtype,
+            name="patch_embedding",
+        )
+        self.position_embedding = layers.Embedding(
+            num_patches + 1, hidden_dim, dtype=dtype, name="position_embedding"
+        )
+
+    def build(self, input_shape):
+        self.class_embedding = self.add_weight(
+            shape=(self.hidden_dim,),
+            initializer="random_normal",
+            dtype=self.variable_dtype,
+            name="class_embedding",
+        )
+        self.position_ids = self.add_weight(
+            shape=(1, self.num_positions),
+            initializer="zeros",
+            # Let the backend determine the int dtype. For example, tf
+            # requires int64 for correct device placement, whereas jax and torch
+            # don't.
+            dtype=int,
+            trainable=False,
+            name="position_ids",
+        )
+        self.patch_embedding.build(input_shape)
+        self.position_embedding.build(self.position_ids.shape)
+
+    def call(self, inputs, training=None):
+        x = inputs
+        batch_size = ops.shape(x)[0]
+        patch_embeddings = self.patch_embedding(x, training=training)
+        if self.data_format == "channels_last":
+            patch_embeddings = ops.reshape(
+                patch_embeddings, (batch_size, -1, self.hidden_dim)
+            )
+        else:
+            patch_embeddings = ops.reshape(
+                patch_embeddings, (batch_size, self.hidden_dim, -1)
+            )
+            patch_embeddings = ops.transpose(patch_embeddings, (0, 2, 1))
+        class_embeddings = ops.expand_dims(self.class_embedding, axis=(0, 1))
+        class_embeddings = ops.tile(class_embeddings, (batch_size, 1, 1))
+        position_embeddings = self.position_embedding(self.position_ids)
+        embeddings = ops.concatenate(
+            [class_embeddings, patch_embeddings], axis=1
+        )
+        return ops.add(embeddings, position_embeddings)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "hidden_dim": self.hidden_dim,
+                "patch_size": self.patch_size,
+                "image_size": self.image_size,
+            }
+        )
+        return config
+
+    def compute_output_shape(self, input_shape):
+        output_shape = [input_shape[0], None, self.hidden_dim]
+        if self.data_format == "channels_last":
+            if input_shape[1] is not None and input_shape[2] is not None:
+                patch_num = input_shape[1] // self.patch_size
+                output_shape[1] = patch_num**2 + 1
+        else:
+            if input_shape[2] is not None and input_shape[3] is not None:
+                patch_num = input_shape[2] // self.patch_size
+                output_shape[1] = patch_num**2 + 1
+        return output_shape

keras_hub/src/models/clip/clip_vision_encoder.py

@@ -0,0 +1,159 @@
+from keras import layers
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.backbone import Backbone
+from keras_hub.src.models.clip.clip_encoder_block import CLIPEncoderBlock
+from keras_hub.src.models.clip.clip_vision_embedding import CLIPVisionEmbedding
+from keras_hub.src.utils.keras_utils import standardize_data_format
+
+
+@keras_hub_export("keras_hub.models.CLIPVisionEncoder")
+class CLIPVisionEncoder(Backbone):
+    """CLIP vision core network with hyperparameters.
+
+    Args:
+        patch_size: int. The size of each square patch in the input image.
+        hidden_dim: int. The size of the transformer hidden state at the end
+            of each transformer layer.
+        num_layers: int. The number of transformer layers.
+        num_heads: int. The number of attention heads for each transformer.
+        intermediate_dim: int. The output dimension of the first Dense layer in
+            a two-layer feedforward network for each transformer.
+        intermediate_activation: activation function. The activation that
+            is used for the first Dense layer in a two-layer feedforward network
+            for each transformer.
+        intermediate_output_index: optional int. The index of the intermediate
+            output. If specified, the output will become a dictionary with two
+            keys `"sequence_output"` and `"intermediate_output"`.
+        image_shape: tuple. The input shape without the batch size. Defaults to
+            `(224, 224, 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: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
+            for the models computations and weights. Note that some
+            computations, such as softmax and layer normalization will always
+            be done a float32 precision regardless of dtype.
+    """
+
+    def __init__(
+        self,
+        patch_size,
+        hidden_dim,
+        num_layers,
+        num_heads,
+        intermediate_dim,
+        intermediate_activation="quick_gelu",
+        intermediate_output_index=None,
+        image_shape=(224, 224, 3),
+        data_format=None,
+        dtype=None,
+        name=None,
+        **kwargs,
+    ):
+        data_format = standardize_data_format(data_format)
+        if data_format == "channels_last":
+            height, width = image_shape[0], image_shape[1]
+        else:
+            height, width = image_shape[1], image_shape[2]
+        if height != width:
+            raise ValueError(
+                "`CLIPVisionEncoder` expects the height and width to be the "
+                f"same in `image_shape`. Received: image_shape={image_shape}"
+            )
+
+        if (
+            intermediate_output_index is not None
+            and intermediate_output_index < 0
+        ):
+            intermediate_output_index += num_layers
+
+        # `prefix` is used to prevent duplicate name when utilizing multiple
+        # CLIP models within a single model, such as in StableDiffusion3.
+        prefix = str(name) + "_" if name is not None else ""
+
+        # === Layers ===
+        self.embedding = CLIPVisionEmbedding(
+            hidden_dim=hidden_dim,
+            patch_size=patch_size,
+            image_size=height,
+            data_format=data_format,
+            dtype=dtype,
+            name=f"{prefix}embedding",
+        )
+        self.pre_layer_norm = layers.LayerNormalization(
+            epsilon=1e-5, dtype=dtype, name=f"{prefix}pre_layer_norm"
+        )
+        self.encoder_layers = [
+            CLIPEncoderBlock(
+                hidden_dim,
+                num_heads,
+                intermediate_dim,
+                intermediate_activation,
+                use_causal_mask=False,  # `False` in the vision encoder.
+                dtype=dtype,
+                name=f"{prefix}encoder_block_{i}",
+            )
+            for i in range(num_layers)
+        ]
+        self.layer_norm = layers.LayerNormalization(
+            epsilon=1e-5, dtype=dtype, name=f"{prefix}layer_norm"
+        )
+
+        # === Functional Model ===
+        image_input = layers.Input(shape=image_shape, name="images")
+        x = self.embedding(image_input)
+        x = self.pre_layer_norm(x)
+        intermediate_output = None
+        for i, block in enumerate(self.encoder_layers):
+            x = block(x)
+            if i == intermediate_output_index:
+                intermediate_output = x
+        sequence_output = self.layer_norm(x)
+
+        if intermediate_output_index is not None:
+            outputs = {
+                "sequence_output": sequence_output,
+                "intermediate_output": intermediate_output,
+            }
+        else:
+            outputs = sequence_output
+        super().__init__(
+            inputs={"images": image_input},
+            outputs=outputs,
+            dtype=dtype,
+            name=name,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.patch_size = patch_size
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.intermediate_dim = intermediate_dim
+        self.intermediate_activation = intermediate_activation
+        self.intermediate_output_index = intermediate_output_index
+        self.image_shape = image_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "patch_size": self.patch_size,
+                "hidden_dim": self.hidden_dim,
+                "num_layers": self.num_layers,
+                "num_heads": self.num_heads,
+                "intermediate_dim": self.intermediate_dim,
+                "intermediate_activation": self.intermediate_activation,
+                "intermediate_output_index": self.intermediate_output_index,
+                "image_shape": self.image_shape,
+            }
+        )
+        return config

keras_hub/src/models/csp_darknet/csp_darknet_backbone.py

@@ -360,7 +360,8 @@ def apply_cross_stage_partial(
     """
 
     if name is None:
-        name = f"cross_stage_partial_{keras.backend.get_uid('cross_stage_partial')}"
+        uid = keras.backend.get_uid("cross_stage_partial")
+        name = f"cross_stage_partial_{uid}"
 
     def apply(inputs):
         hidden_channels = filters // 2

keras_hub/src/models/csp_darknet/csp_darknet_image_classifier.py

@@ -1,5 +1,3 @@
-import keras
-
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.csp_darknet.csp_darknet_backbone import (
     CSPDarkNetBackbone,
@@ -9,111 +7,4 @@ from keras_hub.src.models.image_classifier import ImageClassifier
 
 @keras_hub_export("keras_hub.models.CSPDarkNetImageClassifier")
 class CSPDarkNetImageClassifier(ImageClassifier):
-    """CSPDarkNet image classifier task model.
-
-    Args:
-        backbone: A `keras_hub.models.CSPDarkNetBackbone` instance.
-        num_classes: int. The number of classes to predict.
-        activation: `None`, str or callable. The activation function to use on
-            the `Dense` layer. Set `activation=None` to return the output
-            logits. Defaults to `"softmax"`.
-
-    To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
-    where `x` is a tensor and `y` is a integer from `[0, num_classes)`.
-    All `ImageClassifier` tasks include a `from_preset()` constructor which can
-    be used to load a pre-trained config and weights.
-
-    Examples:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.CSPDarkNetImageClassifier.from_preset(
-        "csp_darknet_tiny_imagenet")
-    classifier.predict(images)
-    ```
-
-    Call `fit()` on a single batch.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    classifier = keras_hub.models.CSPDarkNetImageClassifier.from_preset(
-        "csp_darknet_tiny_imagenet")
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Call `fit()` with custom loss, optimizer and backbone.
-    ```python
-    classifier = keras_hub.models.CSPDarkNetImageClassifier.from_preset(
-        "csp_darknet_tiny_imagenet")
-    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.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    backbone = keras_hub.models.CSPDarkNetBackbone(
-        stackwise_num_filters=[128, 256, 512, 1024],
-        stackwise_depth=[3, 9, 9, 3],
-        block_type="basic_block",
-        image_shape = (224, 224, 3),
-    )
-    classifier = keras_hub.models.CSPDarkNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = CSPDarkNetBackbone
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        activation="softmax",
-        preprocessor=None,  # adding this dummy arg for saved model test
-        # TODO: once preprocessor flow is figured out, this needs to be updated
-        **kwargs,
-    ):
-        # === Layers ===
-        self.backbone = backbone
-        self.output_dense = keras.layers.Dense(
-            num_classes,
-            activation=activation,
-            name="predictions",
-        )
-
-        # === Functional Model ===
-        inputs = self.backbone.input
-        x = self.backbone(inputs)
-        outputs = self.output_dense(x)
-        super().__init__(
-            inputs=inputs,
-            outputs=outputs,
-            **kwargs,
-        )
-
-        # === Config ===
-        self.num_classes = num_classes
-        self.activation = activation
-
-    def get_config(self):
-        # Backbone serialized in `super`
-        config = super().get_config()
-        config.update(
-            {
-                "num_classes": self.num_classes,
-                "activation": self.activation,
-            }
-        )
-        return config

keras_hub/src/models/deberta_v3/deberta_v3_backbone.py

@@ -83,7 +83,7 @@ class DebertaV3Backbone(Backbone):
     # Call the model on the input data.
     model(input_data)
     ```
-    """
+    """  # noqa: E501
 
     def __init__(
         self,

keras_hub/src/models/deberta_v3/deberta_v3_presets.py

@@ -8,11 +8,9 @@ backbone_presets = {
                 "Trained on English Wikipedia, BookCorpus and OpenWebText."
             ),
             "params": 70682112,
-            "official_name": "DeBERTaV3",
             "path": "deberta_v3",
-            "model_card": "https://huggingface.co/microsoft/deberta-v3-xsmall",
         },
-        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_extra_small_en/2",
+        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_extra_small_en/3",
     },
     "deberta_v3_small_en": {
         "metadata": {
@@ -21,11 +19,9 @@ backbone_presets = {
                 "Trained on English Wikipedia, BookCorpus and OpenWebText."
             ),
             "params": 141304320,
-            "official_name": "DeBERTaV3",
             "path": "deberta_v3",
-            "model_card": "https://huggingface.co/microsoft/deberta-v3-small",
         },
-        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_small_en/2",
+        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_small_en/3",
     },
     "deberta_v3_base_en": {
         "metadata": {
@@ -34,11 +30,9 @@ backbone_presets = {
                 "Trained on English Wikipedia, BookCorpus and OpenWebText."
             ),
             "params": 183831552,
-            "official_name": "DeBERTaV3",
             "path": "deberta_v3",
-            "model_card": "https://huggingface.co/microsoft/deberta-v3-base",
         },
-        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_base_en/2",
+        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_base_en/3",
     },
     "deberta_v3_large_en": {
         "metadata": {
@@ -47,11 +41,9 @@ backbone_presets = {
                 "Trained on English Wikipedia, BookCorpus and OpenWebText."
             ),
             "params": 434012160,
-            "official_name": "DeBERTaV3",
             "path": "deberta_v3",
-            "model_card": "https://huggingface.co/microsoft/deberta-v3-large",
         },
-        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_large_en/2",
+        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_large_en/3",
     },
     "deberta_v3_base_multi": {
         "metadata": {
@@ -60,10 +52,8 @@ backbone_presets = {
                 "Trained on the 2.5TB multilingual CC100 dataset."
             ),
             "params": 278218752,
-            "official_name": "DeBERTaV3",
             "path": "deberta_v3",
-            "model_card": "https://huggingface.co/microsoft/mdeberta-v3-base",
         },
-        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_base_multi/2",
+        "kaggle_handle": "kaggle://keras/deberta_v3/keras/deberta_v3_base_multi/3",
     },
 }

keras_hub/src/models/deberta_v3/deberta_v3_text_classifier.py

@@ -7,7 +7,7 @@ from keras_hub.src.models.deberta_v3.deberta_v3_backbone import (
 from keras_hub.src.models.deberta_v3.deberta_v3_backbone import (
     deberta_kernel_initializer,
 )
-from keras_hub.src.models.deberta_v3.deberta_v3_text_classifier_preprocessor import (
+from keras_hub.src.models.deberta_v3.deberta_v3_text_classifier_preprocessor import (  # noqa: E501
     DebertaV3TextClassifierPreprocessor,
 )
 from keras_hub.src.models.text_classifier import TextClassifier
@@ -43,9 +43,9 @@ class DebertaV3TextClassifier(TextClassifier):
     Args:
         backbone: A `keras_hub.models.DebertaV3` instance.
         num_classes: int. Number of classes to predict.
-        preprocessor: A `keras_hub.models.DebertaV3TextClassifierPreprocessor` or `None`. If
-            `None`, this model will not apply preprocessing, and inputs should
-            be preprocessed before calling the model.
+        preprocessor: A `keras_hub.models.DebertaV3TextClassifierPreprocessor`
+            or `None`. If `None`, this model will not apply preprocessing, and
+            inputs should be preprocessed before calling the model.
         activation: Optional `str` or callable. The
             activation function to use on the model outputs. Set
             `activation="softmax"` to return output probabilities.

keras_hub/src/models/deberta_v3/disentangled_attention_encoder.py

@@ -45,7 +45,7 @@ class DisentangledAttentionEncoder(keras.layers.Layer):
         bias_initializer: string or `keras.initializers` initializer.
             The bias initializer for the dense and disentangled
             self-attention layers. Defaults to `"zeros"`.
-    """
+    """  # noqa: E501
 
     def __init__(
         self,
@@ -58,7 +58,7 @@ class DisentangledAttentionEncoder(keras.layers.Layer):
         layer_norm_epsilon=1e-05,
         kernel_initializer="glorot_uniform",
         bias_initializer="zeros",
-        **kwargs
+        **kwargs,
     ):
         super().__init__(**kwargs)
         self.intermediate_dim = intermediate_dim
@@ -145,8 +145,8 @@ class DisentangledAttentionEncoder(keras.layers.Layer):
         """Forward pass of `DisentangledAttentionEncoder`.
 
         Args:
-            inputs: a Tensor. The input data to `DisentangledAttentionEncoder`, should be
-                of shape [batch_size, sequence_length, hidden_dim].
+            inputs: a Tensor. The input data to `DisentangledAttentionEncoder`,
+                should be of shape [batch_size, sequence_length, hidden_dim].
             rel_embeddings: a Tensor. The relative position embedding matrix,
                 should be of shape `[batch_size, 2 * bucket_size, hidden_dim]`.
             padding_mask: a boolean Tensor. It indicates if the token should be

keras_hub/src/models/deberta_v3/disentangled_self_attention.py

@@ -31,7 +31,7 @@ class DisentangledSelfAttention(keras.layers.Layer):
         bias_initializer: string or `keras.initializers` initializer.
             The bias initializer for the dense layers.
             Defaults to `"zeros"`.
-    """
+    """  # noqa: E501
 
     def __init__(
         self,
@@ -363,7 +363,8 @@ class DisentangledSelfAttention(keras.layers.Layer):
             training=training,
         )
 
-        # Reshape `attention_output` to `(batch_size, sequence_length, hidden_dim)`.
+        # Reshape `attention_output` to
+        # `(batch_size, sequence_length, hidden_dim)`.
         attention_output = ops.reshape(
             attention_output,
             [

keras_hub/src/models/deberta_v3/relative_embedding.py

@@ -20,7 +20,7 @@ class RelativeEmbedding(keras.layers.Layer):
         kernel_initializer: string or `keras.initializers` initializer.
             The kernel initializer for the dense embedding.
             Defaults to `"glorot_uniform"`.
-    """
+    """  # noqa: E501
 
     def __init__(
         self,

keras_hub/src/models/deeplab_v3/__init__.py

@@ -0,0 +1,7 @@
+from keras_hub.src.models.deeplab_v3.deeplab_v3_backbone import (
+    DeepLabV3Backbone,
+)
+from keras_hub.src.models.deeplab_v3.deeplab_v3_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, DeepLabV3Backbone)