keras-hub-nightly 0.16.1.dev202409240339__py3-none-any.whl → 0.16.1.dev202409250340__py3-none-any.whl

keras_hub/src/models/sam/sam_prompt_encoder.py

@@ -0,0 +1,336 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import keras
+from keras import ops
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.sam.sam_layers import (
+    RandomFrequencyPositionalEmbeddings,
+)
+
+
+@keras_hub_export("keras_hub.layers.SAMPromptEncoder")
+class SAMPromptEncoder(keras.layers.Layer):
+    """Prompt Encoder for the Segment Anything Model (SAM).
+
+    The prompt encoder generates encodings for three types of prompts:
+    - Point prompts: Points on the image along with a label indicating whether
+        the point is in the foreground (part of the mask) or in the background
+        (not a part of the mask).
+    - Box prompts: A batch of bounding boxes with format [(x1, y1), (x2, y2)]
+        used to determine the location of the masks in the image.
+    - Masks: An input mask can be passed to refine the positional embeddings
+        for the output mask.
+
+    First, the point prompts and box prompts are concatenated and positional
+    encodings are generated using random spatial frequencies. A point is
+    represented as the sum of a positional encoding of the point's location
+    and one of two learned embeddings that indicate if the point is either in
+    the foreground or background. A box is represented by an embedding pair:
+    (1) the positional encoding of its top-left corner summed with a learned
+    embedding representing "top-left corner" and
+    (2) the same structure but using a learned embedding indicating
+    "bottom-right corner".
+    The box and point encodings are referred to as "prompt_sparse encodings"
+    If a mask prompt is passed, a convolutional neural net is used to
+    downscale it to generate "dense encodings". If no mask prompt is passed,
+    an embedding layer is used instead to generate a "no mask" embedding.
+
+
+    Args:
+        hidden_size: int, optional. The number of features in the output
+            embeddings. Defaults to `256`.
+        image_embedding_size: int, optional. The number of features in the
+            image embeddings generated by an image encoder. Defaults to
+            `(64, 64)`.
+        input_image_size: tuple[int], optional. A tuple of the height and
+            width of the image being prompted. Defaults to `(1024, 1024)`.
+        mask_in_channels: int, optional. The number of channels of the mask
+            prompt. Defaults to `16`.
+        activation: str, optional. The activation to use in the mask
+            downscaler neural net. Defaults to `"gelu"`.
+    """
+
+    def __init__(
+        self,
+        *,
+        hidden_size=256,
+        image_embedding_size=(64, 64),
+        input_image_size=(1024, 1024),
+        mask_in_channels=16,
+        activation="gelu",
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.hidden_size = hidden_size
+        self.image_embedding_size = image_embedding_size
+        self.input_image_size = input_image_size
+        self.mask_in_channels = mask_in_channels
+        self.activation = activation
+
+        self.positional_embedding_layer = RandomFrequencyPositionalEmbeddings(
+            num_positional_features=self.hidden_size // 2, scale=1
+        )
+
+        self.foreground_point_embed = keras.layers.Embedding(
+            1, hidden_size, name="foreground_point_embed"
+        )
+        self.background_point_embed = keras.layers.Embedding(
+            1, hidden_size, name="background_point_embed"
+        )
+        self.top_left_corner_embed = keras.layers.Embedding(
+            1, hidden_size, name="top_left_corner_embed"
+        )
+        self.bottom_right_corner_embed = keras.layers.Embedding(
+            1, hidden_size, name="bottom_right_corner_embed"
+        )
+        self.not_a_point_embed = keras.layers.Embedding(
+            1, hidden_size, name="not_a_point_embed"
+        )
+
+        self.mask_downscaler = keras.models.Sequential(
+            [
+                keras.layers.Conv2D(
+                    mask_in_channels // 4, kernel_size=2, strides=2
+                ),
+                keras.layers.LayerNormalization(epsilon=1e-6),
+                keras.layers.Activation(activation),
+                keras.layers.Conv2D(mask_in_channels, kernel_size=2, strides=2),
+                keras.layers.LayerNormalization(epsilon=1e-6),
+                keras.layers.Activation(activation),
+                keras.layers.Conv2D(hidden_size, kernel_size=1),
+            ],
+            name="mask_downscaler",
+        )
+        self.no_mask_embed = keras.layers.Embedding(
+            1, hidden_size, name="no_mask_embed"
+        )
+
+    def build(
+        self,
+        points_shape=None,
+        labels_shape=None,
+        boxes_shape=None,
+        masks_shape=None,
+    ):
+        self.positional_embedding_layer.build()
+        for layer in [
+            self.foreground_point_embed,
+            self.background_point_embed,
+            self.top_left_corner_embed,
+            self.bottom_right_corner_embed,
+            self.not_a_point_embed,
+            self.no_mask_embed,
+        ]:
+            layer.build([None])
+        self.mask_downscaler.build(
+            [
+                None,
+                4 * self.image_embedding_size[0],
+                4 * self.image_embedding_size[1],
+                1,
+            ]
+        )
+        self.built = True
+
+    def compute_output_shape(
+        self,
+        points_shape=None,
+        labels_shape=None,
+        boxes_shape=None,
+        masks_shape=None,
+    ):
+        batch_size = None
+        for shape in (points_shape, labels_shape, boxes_shape, masks_shape):
+            if shape is not None:
+                batch_size = shape[0]
+                break
+        return {
+            "prompt_sparse_embeddings": (
+                batch_size,
+                None,
+                self.hidden_size,
+            ),
+            "prompt_dense_embeddings": (
+                batch_size,
+                self.image_embedding_size[0],
+                self.image_embedding_size[1],
+                self.hidden_size,
+            ),
+            "prompt_dense_positional_embeddings": (
+                batch_size,
+                self.image_embedding_size[0],
+                self.image_embedding_size[1],
+                self.hidden_size,
+            ),
+        }
+
+    def _embed_points(self, points, labels):
+        points = points + 0.5
+        indices = ops.arange(1, dtype="int32")
+
+        point_embeddings = self.positional_embedding_layer.encode_coordinates(
+            points, self.input_image_size
+        )
+        labels = ops.broadcast_to(
+            labels[..., None], ops.shape(point_embeddings)
+        )
+        point_embeddings = ops.where(
+            labels == 0,
+            point_embeddings + self.background_point_embed(indices),
+            point_embeddings + self.foreground_point_embed(indices),
+        )
+        point_embeddings = ops.where(
+            labels == -1,
+            self.not_a_point_embed(indices),
+            point_embeddings,
+        )
+        return point_embeddings
+
+    def _embed_box(self, box):
+        shape = ops.shape(box)
+        batch_size, N = shape[0], shape[1]
+        box = box + 0.5
+        indices = ops.arange(1, dtype="int32")
+        corner_embedding = self.positional_embedding_layer.encode_coordinates(
+            box, self.input_image_size
+        )
+        top_left_embedding = corner_embedding[
+            :, :, 0, :
+        ] + self.top_left_corner_embed(indices)
+        bottom_right_embedding = corner_embedding[
+            :, :, 1, :
+        ] + self.bottom_right_corner_embed(indices)
+        corner_embedding = ops.stack(
+            [top_left_embedding, bottom_right_embedding], axis=2
+        )
+        return ops.reshape(
+            corner_embedding, (batch_size, N * 2, self.hidden_size)
+        )
+
+    def _embed_mask(self, mask):
+        mask_embedding = self.mask_downscaler(mask)
+        return mask_embedding
+
+    def call(
+        self, images=None, points=None, labels=None, boxes=None, masks=None
+    ):
+        # Get the batch shape based on any arbitrary input, because batch
+        # shapes must all match.
+        valid_inputs = [
+            x for x in (points, labels, boxes, masks) if x is not None
+        ]
+
+        batch_size = ops.shape(valid_inputs[0])[0]
+        if points is None:
+            points = ops.zeros((batch_size, 0, 2))
+        if labels is None:
+            labels = ops.zeros((batch_size, 0))
+        if boxes is None:
+            boxes = ops.zeros((batch_size, 0, 2, 2))
+        if masks is None:
+            masks = ops.zeros((batch_size, 0, 256, 256, 1))
+
+        # Compute point embeddings
+        point_embeddings = self._embed_points(points, labels)
+
+        # Compute box embeddings
+        box_embeddings = self._embed_box(boxes)
+
+        # Concatenate both into a sparse embeddings tensor
+        sparse_embeddings = ops.concatenate(
+            [point_embeddings, box_embeddings], axis=1
+        )
+
+        # Compute the mask embeddings
+        def _no_mask_embed():
+            reshaped_embed = ops.reshape(
+                self.no_mask_embed(ops.arange(1, dtype="int32")),
+                (1, 1, 1, self.hidden_size),
+            )
+            broadcasted_embed = ops.broadcast_to(
+                reshaped_embed,
+                shape=(
+                    batch_size,
+                    self.image_embedding_size[0],
+                    self.image_embedding_size[1],
+                    self.hidden_size,
+                ),
+            )
+            return broadcasted_embed
+
+        def _maybe_input_mask_embed():
+            # Keras passes the masks as concrete tensors for both the
+            # true and false functions to build the output shape. So, we
+            # need to handle the case when 0 size masks is passed and
+            # dispatch the call to `_no_mask_embed`. Note that we can't call
+            # the lambda directly since the inputs are bound to different
+            # values when called with concrete values.
+            if masks.shape[1] == 0:
+                return ops.broadcast_to(
+                    ops.reshape(
+                        self.no_mask_embed(ops.arange(1, dtype="int32")),
+                        (1, 1, 1, self.hidden_size),
+                    ),
+                    shape=(
+                        batch_size,
+                        self.image_embedding_size[0],
+                        self.image_embedding_size[1],
+                        self.hidden_size,
+                    ),
+                )
+            shape = ops.shape(masks)
+            BM, N, height, width, channels = (
+                shape[0],
+                shape[1],
+                shape[2],
+                shape[3],
+                shape[4],
+            )
+            return self._embed_mask(
+                ops.reshape(masks, (BM * N, height, width, channels))
+            )
+
+        dense_embeddings = ops.cond(
+            ops.equal(ops.size(masks), 0),
+            _no_mask_embed,
+            _maybe_input_mask_embed,
+        )
+
+        # Compute the dense positional embeddings
+        prompt_dense_positional_embeddings = (
+            self.positional_embedding_layer.encode_image(
+                self.image_embedding_size
+            )[None, ...]
+        )
+
+        return {
+            "prompt_sparse_embeddings": sparse_embeddings,
+            "prompt_dense_embeddings": dense_embeddings,
+            "prompt_dense_positional_embeddings": prompt_dense_positional_embeddings,
+        }
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "hidden_size": self.hidden_size,
+                "image_embedding_size": self.image_embedding_size,
+                "input_image_size": self.input_image_size,
+                "mask_in_channels": self.mask_in_channels,
+                "activation": self.activation,
+            }
+        )
+        return config

keras_hub/src/models/sam/sam_transformer.py

@@ -0,0 +1,159 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import keras
+from keras import ops
+
+from keras_hub.src.models.sam.sam_layers import (
+    MultiHeadAttentionWithDownsampling,
+)
+from keras_hub.src.models.sam.sam_layers import TwoWayMultiHeadAttention
+
+
+class TwoWayTransformer(keras.layers.Layer):
+    """A two-way cross-attention transformer decoder.
+
+    A transformer decoder that attends to an input image using
+    queries whose positional embedding is supplied.
+    The transformer decoder design is shown in
+    [1](https://arxiv.org/abs/2304.02643).
+    Each decoder layer performs 4 steps:
+    (1) self-attention on the tokens,
+    (2) cross-attention from tokens (as queries) to the image embedding,
+    (3) a point-wise MLPupdates each token, and
+    (4) cross-attention from the image embedding (as
+    queries) to tokens. This last step updates the image embedding with prompt
+    information. Each self/cross-attention and MLP has a residual connection
+    and layer normalization.
+    To ensure the decoder has access to critical geometric information the
+    positional encodings are added to the image embedding whenever they
+    participate in an attention layer. Additionally, the entire original
+    prompt tokens (including their positional encodings) are re-added to the
+    updated tokens whenever they participate in an attention layer. This
+    allows for a strong dependence on both the prompt token's geometric
+    location and type.
+
+    Args:
+        num_layers: int, optional. The num_layers of the attention blocks (the number
+            of attention blocks to use). Defaults to `2`.
+        hidden_size: int, optional. The number of features of the input image
+            and point embeddings. Defaults to `256`.
+        num_heads: int, optional. Number of heads to use in the attention
+            layers. Defaults to `8`.
+        intermediate_dim: int, optional. The number of units in the hidden layer of
+            the MLP block used in the attention layers. Defaults to `2048`.
+        activation: str, optional. The activation of the MLP block's output
+            layer used in the attention layers. Defaults to `"relu"`.
+        attention_downsample_rate: int, optional. The downsample rate of the
+            attention layers. Defaults to `2`.
+    """
+
+    def __init__(
+        self,
+        *,
+        num_layers=2,
+        hidden_size=256,
+        num_heads=8,
+        intermediate_dim=2048,
+        activation="relu",
+        attention_downsample_rate=2,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.num_layers = num_layers
+        self.hidden_size = hidden_size
+        self.num_heads = num_heads
+        self.intermediate_dim = intermediate_dim
+        self.activation = activation
+        self.attention_downsample_rate = attention_downsample_rate
+        self.layers = []
+        for i in range(num_layers):
+            self.layers.append(
+                TwoWayMultiHeadAttention(
+                    num_heads=num_heads,
+                    key_dim=hidden_size // num_heads,
+                    intermediate_dim=intermediate_dim,
+                    skip_first_layer_pos_embedding=(i == 0),
+                    attention_downsample_rate=attention_downsample_rate,
+                    activation=activation,
+                    dtype=self.dtype_policy,
+                )
+            )
+        self.final_attention_token_to_image = (
+            MultiHeadAttentionWithDownsampling(
+                num_heads=num_heads,
+                key_dim=hidden_size // num_heads,
+                downsample_rate=attention_downsample_rate,
+                dtype=self.dtype_policy,
+            )
+        )
+        self.final_layer_norm = keras.layers.LayerNormalization(
+            epsilon=1e-5, dtype=self.dtype_policy
+        )
+
+    def build(self, input_shape=None):
+        for layer in self.layers:
+            layer.build()
+        self.final_attention_token_to_image.build()
+        self.final_layer_norm.build([None, None, self.hidden_size])
+        self.built = True
+
+    def call(
+        self, image_embedding, image_positional_embeddings, point_embedding
+    ):
+        shape = ops.shape(image_embedding)
+        B, H, W, C = shape[0], shape[1], shape[2], shape[3]
+        image_embedding = ops.reshape(image_embedding, (B, H * W, C))
+
+        shape = ops.shape(image_positional_embeddings)
+        B, H, W, C = shape[0], shape[1], shape[2], shape[3]
+        image_positional_embeddings = ops.reshape(
+            image_positional_embeddings, (B, H * W, C)
+        )
+        queries = point_embedding
+        keys = image_embedding
+
+        for layer in self.layers:
+            queries, keys = layer(
+                queries=queries,
+                keys=keys,
+                query_pos_embedding=point_embedding,
+                key_pos_embedding=image_positional_embeddings,
+            )
+
+        queries_with_pos_embedding = queries + point_embedding
+        keys_with_pos_embedding = keys + image_positional_embeddings
+        attention_map = self.final_attention_token_to_image(
+            query=queries_with_pos_embedding,
+            key=keys_with_pos_embedding,
+            value=keys,
+        )
+        queries = queries + attention_map
+        queries = self.final_layer_norm(queries)
+
+        return queries, keys
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "num_layers": self.num_layers,
+                "hidden_size": self.hidden_size,
+                "num_heads": self.num_heads,
+                "intermediate_dim": self.intermediate_dim,
+                "activation": self.activation,
+                "attention_downsample_rate": self.attention_downsample_rate,
+            }
+        )
+        return config

keras_hub/src/models/vit_det/vit_det_backbone.py

@@ -104,7 +104,7 @@ class ViTDetBackbone(Backbone):
         **kwargs
     ):
         # === Functional model ===
-        img_input = keras.layers.Input(shape=image_shape)
+        img_input = keras.layers.Input(shape=image_shape, name="images")
         # Check that the input image is well specified.
         if img_input.shape[-3] is None or img_input.shape[-2] is None:
             raise ValueError(
@@ -144,17 +144,22 @@ class ViTDetBackbone(Backbone):
                 ),
                 input_size=(img_size // patch_size, img_size // patch_size),
             )(x)
-        x = keras.layers.Conv2D(
-            filters=num_output_channels, kernel_size=1, use_bias=False
-        )(x)
-        x = keras.layers.LayerNormalization(epsilon=1e-6)(x)
-        x = keras.layers.Conv2D(
-            filters=num_output_channels,
-            kernel_size=3,
-            padding="same",
-            use_bias=False,
-        )(x)
-        x = keras.layers.LayerNormalization(epsilon=1e-6)(x)
+        self.neck = keras.models.Sequential(
+            [
+                keras.layers.Conv2D(
+                    filters=num_output_channels, kernel_size=1, use_bias=False
+                ),
+                keras.layers.LayerNormalization(epsilon=1e-6),
+                keras.layers.Conv2D(
+                    filters=num_output_channels,
+                    kernel_size=3,
+                    padding="same",
+                    use_bias=False,
+                ),
+                keras.layers.LayerNormalization(epsilon=1e-6),
+            ]
+        )
+        x = self.neck(x)
 
         super().__init__(inputs=img_input, outputs=x, **kwargs)
 

keras_hub/src/version_utils.py

@@ -15,7 +15,7 @@
 from keras_hub.src.api_export import keras_hub_export
 
 # Unique source of truth for the version number.
-__version__ = "0.16.1.dev202409240339"
+__version__ = "0.16.1.dev202409250340"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.16.1.dev202409240339.dist-info → keras_hub_nightly-0.16.1.dev202409250340.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: keras-hub-nightly
-Version: 0.16.1.dev202409240339
+Version: 0.16.1.dev202409250340
 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.16.1.dev202409240339.dist-info → keras_hub_nightly-0.16.1.dev202409250340.dist-info}/RECORD

@@ -1,15 +1,15 @@
 keras_hub/__init__.py,sha256=La-s5SQDd0312puWDSbPJ2XYxFXtg0jsCdUa2LMY-Z8,1440
 keras_hub/api/__init__.py,sha256=8EwhEBO-o-92lvGv6M5zOdkNL9Bd3xfutlfGNJ8QwBE,1109
 keras_hub/api/bounding_box/__init__.py,sha256=LNSVZLB1WJ9hMg0wxt7HTfFFd9uAFviH9x9CnfJYzBA,1682
-keras_hub/api/layers/__init__.py,sha256=4OlmzaQ0I8RuHp7Ot9580loeElsV4QeB2Lon8ZB_a1Q,2600
+keras_hub/api/layers/__init__.py,sha256=q-W0iSlSnbanCmfeXEfnzeM2Z_akIf0o0wXGI9eoXK4,2742
 keras_hub/api/metrics/__init__.py,sha256=tgQfooPHzlq6w34RHfro6vO8IUITLTf-jU2IWEBxxUM,966
-keras_hub/api/models/__init__.py,sha256=0BRVIXtv8DrIbE5n1JeAR_gVeF1_sG_zeMI0cR0rjBI,13396
+keras_hub/api/models/__init__.py,sha256=FzHm8wzz4zFS9o47h74wZqD543M-YBpJBbg0MxVXrPQ,13597
 keras_hub/api/samplers/__init__.py,sha256=l56H4y3h_HlRn_PpeMyZ6vC7228EH_BVFo4Caay-zQ8,1315
 keras_hub/api/tokenizers/__init__.py,sha256=nzMwKmxkMCOiYB35BIgxHNveCM9WoYRp7ChhmVK8MIM,3042
 keras_hub/api/utils/__init__.py,sha256=4IXDgmXqFzqrCK2MPgkih0Ye1s-8hrlBaUk-n5Kqwl4,800
 keras_hub/src/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/api_export.py,sha256=82JzmDgnWTJR-PRJI9L_vjhW2Svz8gilbE1NMGZ2JgA,2085
-keras_hub/src/version_utils.py,sha256=i_AT_prEzLhyI7l52vHMFFHNaayHc6VB54FNwdhAm6o,808
+keras_hub/src/version_utils.py,sha256=DfqQUnCphubGoSlfFEJS5b7zQfHnTOCqwLSi0WgDvfI,808
 keras_hub/src/bounding_box/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/bounding_box/converters.py,sha256=V2ti6xPpaBgeLKbTpCsHsABdYOYASerIKX9oWqeOjHo,18450
 keras_hub/src/bounding_box/formats.py,sha256=5bbHO-n2ADsKIOBJDHMvIPCeNBaV1_mj-NVCgBKNiu8,4453
@@ -56,6 +56,7 @@ keras_hub/src/models/causal_lm_preprocessor.py,sha256=VvHwIwnQyKzMDKTtW0CuWQ0faR
 keras_hub/src/models/feature_pyramid_backbone.py,sha256=p4z7urzAAz0V6Q9WS57heaxWVLKW-11LoFKnXYxetUA,2832
 keras_hub/src/models/image_classifier.py,sha256=72qxEL01DSKE-Ugg4tpZqkLQpYf15bPfpknBnbx_G8Q,3754
 keras_hub/src/models/image_classifier_preprocessor.py,sha256=Az9596ow470lqCzYF0I-GUkHbVfWx4GiynvpwGws6f0,3199
+keras_hub/src/models/image_segmenter.py,sha256=J8kcZzrVgQxQi21juGsOmCJaNWLYx_S8aGq6qss5TLA,3599
 keras_hub/src/models/masked_lm.py,sha256=x8jeqgYsKsgeVPAirVRPHDdT21FAhqJ45pb8mIPc410,4161
 keras_hub/src/models/masked_lm_preprocessor.py,sha256=Z6mo0szZp5Kfn6LmtY7EjZWGxLdR4c75hfw97V310Kc,6241
 keras_hub/src/models/preprocessor.py,sha256=PZruA4xHS_w0-9hWLD1iJ79aOQMP81aJPYXl5SpjXak,7174
@@ -240,6 +241,13 @@ keras_hub/src/models/roberta/roberta_presets.py,sha256=Ys5WnfBCzrRDLVLrAm412ojHY
 keras_hub/src/models/roberta/roberta_text_classifier.py,sha256=A4psd1Ef0ZSPMCsBpSLe5xmZqsFSn5XZ8gr_ekL9EoU,7268
 keras_hub/src/models/roberta/roberta_text_classifier_preprocessor.py,sha256=xK0dGPi3nZ5mUoRtTSE8OhibQSaOvzkGELhPAJAB5sc,6579
 keras_hub/src/models/roberta/roberta_tokenizer.py,sha256=RlKxa0eo7KYgRH5HSHrflna2LkB9pS6qjm2cr4DbuBg,3299
+keras_hub/src/models/sam/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
+keras_hub/src/models/sam/sam_backbone.py,sha256=Gv535P33JczvBxP7Z8n4vQCXJnzJAKd5YGdUn6ni3uQ,4937
+keras_hub/src/models/sam/sam_image_segmenter.py,sha256=QW00mR0fVhqiSFVnYORCIGAa9HhDJNLYWi1fA6Kp1uM,8091
+keras_hub/src/models/sam/sam_layers.py,sha256=6A4H2qiJSmpSUjp0xwaGzhQeAAUWi-lsETJjyfHiMV8,14448
+keras_hub/src/models/sam/sam_mask_decoder.py,sha256=Iwq9-YQYVXtFXg7fUnu0BRyUMS6D_56AV2IOCVdlGb8,10135
+keras_hub/src/models/sam/sam_prompt_encoder.py,sha256=rUinjN0yI8h6ewA_n0GWMJAg5FszS0x25ADdKiGAaBA,12387
+keras_hub/src/models/sam/sam_transformer.py,sha256=V3UfDYldxXVW2jngVUS9Klu7HXwKf5ROfpTm3fPEtOo,6316
 keras_hub/src/models/stable_diffusion_v3/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/models/stable_diffusion_v3/clip_encoder_block.py,sha256=6-bOVTGHCSniDYf616UhKmDHM239y8J5wdjZATXgxig,3556
 keras_hub/src/models/stable_diffusion_v3/clip_preprocessor.py,sha256=90QYFvAlSk_F1HC80VG6IceVN0Q8paIHZQpbaG2pMec,3172
@@ -262,7 +270,7 @@ keras_hub/src/models/vgg/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5
 keras_hub/src/models/vgg/vgg_backbone.py,sha256=O6onZEduEPt1J4v2HFgtHsxu-SheqpUwY2pYoeLa6uE,5080
 keras_hub/src/models/vgg/vgg_image_classifier.py,sha256=cDcmHoHU1BZ211JakGPw3Z9lV22oMmK8J4-Ng8S07G0,4071
 keras_hub/src/models/vit_det/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
-keras_hub/src/models/vit_det/vit_det_backbone.py,sha256=4b3CUk4zg8gjFJvDU-QJZP72CV8jqw3TnaoCzUC-vyo,8054
+keras_hub/src/models/vit_det/vit_det_backbone.py,sha256=wRtFHqKSQ-d7Bzv4LJ-Uhjn013AsIP86wvHOrXfGzGU,8241
 keras_hub/src/models/vit_det/vit_layers.py,sha256=JeUzOT2jmSOoJ_OiHOfLSkkCUZ5mlK5Mfd21DwudRCQ,20436
 keras_hub/src/models/whisper/__init__.py,sha256=FI-xj6FwZDAAdCfKhOrE1_roQ8cXhD1gK4G6CLTvPQo,849
 keras_hub/src/models/whisper/whisper_audio_converter.py,sha256=JqtA2kLUMFKZ4FrI8g2piEjahE-0-F3Yp4qQXS1cYf4,8973
@@ -328,7 +336,7 @@ keras_hub/src/utils/transformers/convert_mistral.py,sha256=4QStizMS6ESEPjSI-ls6j
 keras_hub/src/utils/transformers/convert_pali_gemma.py,sha256=BT5eX1QzbjCQCopbMstiejQQWQiB_N77bpD5FMUygEo,11234
 keras_hub/src/utils/transformers/preset_loader.py,sha256=9x9hLhDh_6PAHG5gay5rVoEVyt-gXTQGrnprjMLKvCM,3294
 keras_hub/src/utils/transformers/safetensor_utils.py,sha256=2O8lcCf9yIFt5xiRVOtF1ZkPb5pfhOfDJotBaanD9Zo,3547
-keras_hub_nightly-0.16.1.dev202409240339.dist-info/METADATA,sha256=m5_uFvpe9Xgs6a0BxLOQsc3DumB76ZPDZHoP6ZQaQxE,7061
-keras_hub_nightly-0.16.1.dev202409240339.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-keras_hub_nightly-0.16.1.dev202409240339.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
-keras_hub_nightly-0.16.1.dev202409240339.dist-info/RECORD,,
+keras_hub_nightly-0.16.1.dev202409250340.dist-info/METADATA,sha256=I0qfaK-EcBkBLd3AKkbeGymIVDvZaufV75SvbuwSeOA,7061
+keras_hub_nightly-0.16.1.dev202409250340.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+keras_hub_nightly-0.16.1.dev202409250340.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
+keras_hub_nightly-0.16.1.dev202409250340.dist-info/RECORD,,