PyPI - keras-hub-nightly - Versions diffs - 0.21.0.dev202505260411__tar.gz → 0.21.0.dev202505280410__tar.gz - Mend

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

@@ -3,6 +3,7 @@ from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
 from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
+from keras_hub.src.utils.tensor_utils import pad
 from keras_hub.src.utils.tensor_utils import preprocessing_function
 try:
@@ -66,6 +67,8 @@ class MultiSegmentPacker(PreprocessingLayer):
                 "waterfall" algorithm that allocates quota in a
                 left-to-right manner and fills up the buckets until we run
                 out of budget. It support arbitrary number of segments.
+        padding_side: str. Whether to pad the input on the "left" or "right".
+            Defaults to "right".
     Returns:
         A tuple with two elements. The first is the dense, packed token
@@ -124,6 +127,7 @@ class MultiSegmentPacker(PreprocessingLayer):
         sep_value=None,
         pad_value=None,
         truncate="round_robin",
+        padding_side="right",
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -162,6 +166,7 @@ class MultiSegmentPacker(PreprocessingLayer):
         self.end_value = end_value
         self.pad_value = pad_value
+        self.padding_side = padding_side
     def get_config(self):
         config = super().get_config()
@@ -173,6 +178,7 @@ class MultiSegmentPacker(PreprocessingLayer):
                 "sep_value": self._sep_value,
                 "pad_value": self.pad_value,
                 "truncate": self.truncate,
+                "padding_side": self.padding_side,
             }
         )
         return config
@@ -287,10 +293,18 @@ class MultiSegmentPacker(PreprocessingLayer):
         # Pad to dense tensor output.
         sequence_length = sequence_length or self.sequence_length
         shape = tf.cast([-1, sequence_length], "int64")
-        token_ids = token_ids.to_tensor(
-            shape=shape, default_value=self.pad_value
+        token_ids = pad(
+            token_ids,
+            shape=shape,
+            padding_side=self.padding_side,
+            pad_value=self.pad_value,
+        )
+        segment_ids = pad(
+            segment_ids,
+            shape=shape,
+            padding_side=self.padding_side,
+            pad_value=0,
         )
-        segment_ids = segment_ids.to_tensor(shape=shape)
         # Remove the batch dim if added.
         if unbatched:
             token_ids = tf.squeeze(token_ids, 0)

@@ -3,6 +3,7 @@ from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
 from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
+from keras_hub.src.utils.tensor_utils import pad
 from keras_hub.src.utils.tensor_utils import preprocessing_function
 try:
@@ -39,6 +40,8 @@ class StartEndPacker(PreprocessingLayer):
             0 or "" will be added depending on the dtype of the input tensor.
         return_padding_mask: bool. Whether to return a boolean padding mask of
             all locations that are filled in with the `pad_value`.
+        padding_side: str. Whether to pad the input on the "left" or "right".
+            Defaults to "right".
     Call arguments:
         inputs: A `tf.Tensor`, `tf.RaggedTensor`, or list of python strings.
@@ -111,6 +114,7 @@ class StartEndPacker(PreprocessingLayer):
         pad_value=None,
         return_padding_mask=False,
         name=None,
+        padding_side="right",
         **kwargs,
     ):
         super().__init__(name=name, **kwargs)
@@ -139,6 +143,7 @@ class StartEndPacker(PreprocessingLayer):
         self.pad_value = pad_value
         self.return_padding_mask = return_padding_mask
+        self.padding_side = padding_side
     @preprocessing_function
     def call(
@@ -154,6 +159,13 @@ class StartEndPacker(PreprocessingLayer):
         batch_size = tf.shape(x)[0]
         sequence_length = sequence_length or self.sequence_length
         dtype = inputs.dtype
+        # Truncate.
+        truncation_length = sequence_length
+        if add_start_value and self.start_value is not None:
+            truncation_length -= len(self.start_value)
+        if add_end_value and self.end_value is not None:
+            truncation_length -= len(self.end_value)
+        x = x[..., :truncation_length]
         # Concatenate start and end tokens.
         if add_start_value and self.start_value is not None:
@@ -167,23 +179,28 @@ class StartEndPacker(PreprocessingLayer):
             end_token_id_tensor = tf.repeat(
                 end_value[tf.newaxis, :], repeats=batch_size, axis=0
             )
-            # Trim to leave room for end token.
-            x = x[..., : sequence_length - len(self.end_value)]
             x = tf.concat([x, end_token_id_tensor], axis=-1)
         # Pad to desired length.
-        outputs = x.to_tensor(
-            default_value=self.pad_value,
+        outputs = pad(
+            x,
+            pad_value=self.pad_value,
+            padding_side=self.padding_side,
             shape=(batch_size, sequence_length),
         )
         outputs = tf.squeeze(outputs, axis=0) if unbatched else outputs
         if self.return_padding_mask:
             mask = tf.ones_like(x, dtype="bool")
-            mask = mask.to_tensor(shape=(batch_size, sequence_length))
+            mask = pad(
+                mask,
+                pad_value=False,
+                padding_side=self.padding_side,
+                shape=(batch_size, sequence_length),
+            )
             mask = tf.squeeze(mask, axis=0) if unbatched else mask
             return outputs, mask
         return outputs
     def get_config(self):
@@ -195,6 +212,7 @@ class StartEndPacker(PreprocessingLayer):
                 "end_value": self._end_value,
                 "pad_value": self.pad_value,
                 "return_padding_mask": self.return_padding_mask,
+                "padding_side": self.padding_side,
             }
         )
         return config

@@ -189,23 +189,26 @@ class Backbone(keras.Model):
         saver = get_preset_saver(preset_dir)
         saver.save_backbone(self, max_shard_size=max_shard_size)
-    def get_lora_target_names(self):
-        """Returns list of layer names which are to be LoRA-fied.
-        Subclasses can override this method if the names of layers to be
-        LoRa-fied are different.
-        """
+    def default_lora_layer_names(self):
+        """Returns list of layer names which are to be LoRA-fied."""
         return ["query_dense", "value_dense", "query", "value"]
-    def enable_lora(self, rank, target_names=None):
+    def enable_lora(self, rank, target_layer_names=None):
         """Enable Lora on the backbone.
         Calling this method will freeze all weights on the backbone,
         while enabling Lora on the query & value `EinsumDense` layers
         of the attention layers.
+        Args:
+            rank: The rank of the LoRA factorization.
+            target_layer_names: A list of strings, the names of the layers to
+                apply LoRA to. If `None`, this will be populated with the
+                default LoRA layer names as returned by
+                `backbone.default_lora_layer_names()`.
         """
-        if target_names is None:
-            target_names = self.get_lora_target_names()
+        if target_layer_names is None:
+            target_layer_names = self.default_lora_layer_names()
         self.trainable = True
         self._lora_enabled_layers = []
         self._lora_rank = rank
@@ -214,7 +217,7 @@ class Backbone(keras.Model):
         all_layers = self._flatten_layers(include_self=False)
         all_layers = [lyr for lyr in all_layers if lyr.weights]
         for i, layer in enumerate(all_layers):
-            for name in target_names:
+            for name in target_layer_names:
                 if layer.name == name:
                     if hasattr(layer, "enable_lora"):
                         layer.trainable = True

@@ -402,8 +402,8 @@ class Gemma3Backbone(Backbone):
         )
         return config
-    def get_lora_target_names(self):
-        target_names = super().get_lora_target_names()
+    def default_lora_layer_names(self):
+        target_names = super().default_lora_layer_names()
         # Add these for `Gemma3VITAttention`.
         if not self.text_only_model:

@@ -274,8 +274,8 @@ class PaliGemmaBackbone(Backbone):
         # Keep the image_sequence_length as a backbone property for easy access.
         self.image_sequence_length = self.vit_encoder.image_sequence_length
-    def get_lora_target_names(self):
-        target_names = super().get_lora_target_names()
+    def default_lora_layer_names(self):
+        target_names = super().default_lora_layer_names()
         # Add these for `PaliGemmaVITAttention`.
         target_names += ["query_proj", "value_proj"]

@@ -21,6 +21,20 @@ except ImportError:
 NO_CONVERT_COUNTER = threading.local()
+def pad(x, shape, padding_side, pad_value):
+    if padding_side == "left":
+        x = x[..., ::-1]
+    outputs = x.to_tensor(
+        default_value=pad_value,
+        shape=shape,
+    )
+    if padding_side == "left":
+        outputs = outputs[..., ::-1]
+    return outputs
 @contextlib.contextmanager
 def no_convert_scope():
     try:

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

keras-hub-nightly 0.21.0.dev202505260411__tar.gz → 0.21.0.dev202505280410__tar.gz

keras-hub-nightly 0.21.0.dev202505260411tar.gz → 0.21.0.dev202505280410tar.gz