keras-hub 0.21.1__tar.gz → 0.22.0.dev0__tar.gz

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-hub
-Version: 0.21.1
+Version: 0.22.0.dev0
 Summary: Pretrained models for Keras.
 Author-email: Keras team <keras-users@googlegroups.com>
 License-Expression: Apache-2.0
@@ -18,9 +18,9 @@ Classifier: Operating System :: MacOS
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: keras>=3.5
+Requires-Dist: keras>=3.8
 Requires-Dist: absl-py
 Requires-Dist: numpy
 Requires-Dist: packaging
@@ -31,7 +31,7 @@ Requires-Dist: tensorflow-text; platform_system != "Windows"
 
 # KerasHub: Multi-framework Pretrained Models
 [![](https://github.com/keras-team/keras-hub/workflows/Tests/badge.svg?branch=master)](https://github.com/keras-team/keras-hub/actions?query=workflow%3ATests+branch%3Amaster)
-![Python](https://img.shields.io/badge/python-v3.9.0+-success.svg)
+![Python](https://img.shields.io/badge/python-v3.10.0+-success.svg)
 [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/keras-team/keras-hub/issues)
 
 > [!IMPORTANT]

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/README.md

@@ -1,6 +1,6 @@
 # KerasHub: Multi-framework Pretrained Models
 [![](https://github.com/keras-team/keras-hub/workflows/Tests/badge.svg?branch=master)](https://github.com/keras-team/keras-hub/actions?query=workflow%3ATests+branch%3Amaster)
-![Python](https://img.shields.io/badge/python-v3.9.0+-success.svg)
+![Python](https://img.shields.io/badge/python-v3.10.0+-success.svg)
 [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/keras-team/keras-hub/issues)
 
 > [!IMPORTANT]

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/api/layers/__init__.py

@@ -78,15 +78,24 @@ 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,
 )
+from keras_hub.src.models.dinov2.dinov2_image_converter import (
+    DINOV2ImageConverter as DINOV2ImageConverter,
+)
 from keras_hub.src.models.efficientnet.efficientnet_image_converter import (
     EfficientNetImageConverter as EfficientNetImageConverter,
 )
 from keras_hub.src.models.gemma3.gemma3_image_converter import (
     Gemma3ImageConverter as Gemma3ImageConverter,
 )
+from keras_hub.src.models.hgnetv2.hgnetv2_image_converter import (
+    HGNetV2ImageConverter as HGNetV2ImageConverter,
+)
 from keras_hub.src.models.mit.mit_image_converter import (
     MiTImageConverter as MiTImageConverter,
 )

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/api/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,
 )
@@ -150,6 +157,9 @@ from keras_hub.src.models.densenet.densenet_image_classifier import (
 from keras_hub.src.models.densenet.densenet_image_classifier_preprocessor import (
     DenseNetImageClassifierPreprocessor as DenseNetImageClassifierPreprocessor,
 )
+from keras_hub.src.models.dinov2.dinov2_backbone import (
+    DINOV2Backbone as DINOV2Backbone,
+)
 from keras_hub.src.models.distil_bert.distil_bert_backbone import (
     DistilBertBackbone as DistilBertBackbone,
 )
@@ -189,6 +199,22 @@ from keras_hub.src.models.electra.electra_backbone import (
 from keras_hub.src.models.electra.electra_tokenizer import (
     ElectraTokenizer as ElectraTokenizer,
 )
+from keras_hub.src.models.esm.esm_backbone import ESMBackbone as ESM2Backbone
+from keras_hub.src.models.esm.esm_backbone import ESMBackbone as ESMBackbone
+from keras_hub.src.models.esm.esm_classifier import (
+    ESMProteinClassifier as ESMProteinClassifier,
+)
+from keras_hub.src.models.esm.esm_classifier_preprocessor import (
+    ESMProteinClassifierPreprocessor as ESMProteinClassifierPreprocessor,
+)
+from keras_hub.src.models.esm.esm_masked_plm import (
+    ESMMaskedPLM as ESM2MaskedPLM,
+)
+from keras_hub.src.models.esm.esm_masked_plm import ESMMaskedPLM as ESMMaskedPLM
+from keras_hub.src.models.esm.esm_masked_plm_preprocessor import (
+    ESMMaskedPLMPreprocessor as ESMMaskedPLMPreprocessor,
+)
+from keras_hub.src.models.esm.esm_tokenizer import ESMTokenizer as ESMTokenizer
 from keras_hub.src.models.f_net.f_net_backbone import (
     FNetBackbone as FNetBackbone,
 )
@@ -287,6 +313,15 @@ from keras_hub.src.models.gpt_neo_x.gpt_neo_x_causal_lm_preprocessor import (
 from keras_hub.src.models.gpt_neo_x.gpt_neo_x_tokenizer import (
     GPTNeoXTokenizer as GPTNeoXTokenizer,
 )
+from keras_hub.src.models.hgnetv2.hgnetv2_backbone import (
+    HGNetV2Backbone as HGNetV2Backbone,
+)
+from keras_hub.src.models.hgnetv2.hgnetv2_image_classifier import (
+    HGNetV2ImageClassifier as HGNetV2ImageClassifier,
+)
+from keras_hub.src.models.hgnetv2.hgnetv2_image_classifier_preprocessor import (
+    HGNetV2ImageClassifierPreprocessor as HGNetV2ImageClassifierPreprocessor,
+)
 from keras_hub.src.models.image_classifier import (
     ImageClassifier as ImageClassifier,
 )
@@ -444,6 +479,18 @@ from keras_hub.src.models.qwen.qwen_tokenizer import (
 from keras_hub.src.models.qwen.qwen_tokenizer import (
     QwenTokenizer as QwenTokenizer,
 )
+from keras_hub.src.models.qwen3.qwen3_backbone import (
+    Qwen3Backbone as Qwen3Backbone,
+)
+from keras_hub.src.models.qwen3.qwen3_causal_lm import (
+    Qwen3CausalLM as Qwen3CausalLM,
+)
+from keras_hub.src.models.qwen3.qwen3_causal_lm_preprocessor import (
+    Qwen3CausalLMPreprocessor as Qwen3CausalLMPreprocessor,
+)
+from keras_hub.src.models.qwen3.qwen3_tokenizer import (
+    Qwen3Tokenizer as Qwen3Tokenizer,
+)
 from keras_hub.src.models.qwen_moe.qwen_moe_backbone import (
     QwenMoeBackbone as QwenMoeBackbone,
 )

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/api/tokenizers/__init__.py

@@ -28,6 +28,7 @@ from keras_hub.src.models.distil_bert.distil_bert_tokenizer import (
 from keras_hub.src.models.electra.electra_tokenizer import (
     ElectraTokenizer as ElectraTokenizer,
 )
+from keras_hub.src.models.esm.esm_tokenizer import ESMTokenizer as ESMTokenizer
 from keras_hub.src.models.f_net.f_net_tokenizer import (
     FNetTokenizer as FNetTokenizer,
 )

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/src/layers/modeling/transformer_encoder.py

@@ -16,9 +16,12 @@ class TransformerEncoder(keras.layers.Layer):
     paper [Attention is All You Need](https://arxiv.org/abs/1706.03762). Users
     can instantiate multiple instances of this class to stack up an encoder.
 
-    This layer will correctly compute an attention mask from an implicit
-    Keras padding mask (for example, by passing `mask_zero=True` to a
-    `keras.layers.Embedding` layer). See the Masking and Padding
+    This layer will compute an attention mask, prioritizing explicitly provided
+    masks (a `padding_mask` or a custom `attention_mask`) over an implicit Keras
+    padding mask (for example, by passing `mask_zero=True` to a
+    `keras.layers.Embedding` layer). If both a `padding_mask` and a
+    `attention_mask` are provided, they will be combined to determine the final
+    mask. See the Masking and Padding
     [guide](https://keras.io/guides/understanding_masking_and_padding/)
     for more details.
 

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/src/layers/preprocessing/multi_segment_packer.py

@@ -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)

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/src/layers/preprocessing/start_end_packer.py

@@ -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

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/src/models/backbone.py

@@ -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

{keras_hub-0.21.1 → keras_hub-0.22.0.dev0}/keras_hub/src/models/clip/clip_backbone.py

@@ -1,109 +1,10 @@
-import math
-
 from keras import layers
-from keras import ops
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.backbone import Backbone
-
-
-class CLIPVisionPooler(layers.Layer):
-    """The vision pooler layer of CLIP.
-
-    `CLIPVisionPooler` will extracts the first token (index `0`) from the
-    sequence of the vision embeddings as the pooled outputs.
-
-    Call arguments:
-        vision_embeddings: A tensor of shape
-            `(batch_size, sequence_length, hidden_dim)`.
-    """
-
-    def call(self, vision_embeddings):
-        return vision_embeddings[:, 0, :]
-
-    def compute_output_shape(self, input_shape):
-        return (input_shape[0], input_shape[-1])
-
-
-class CLIPTextPooler(layers.Layer):
-    """The text pooler layer of CLIP.
-
-    `CLIPTextPooler` extracts the text embeddings at the positions of EOS tokens
-    as the pooled outputs.
-
-    Call arguments:
-        text_embeddings: A tensor of shape
-            `(batch_size, sequence_length, hidden_dim)`.
-        token_ids: A tensor of shape `(batch_size, max_tokens)`, used to
-            identify the positions of EOS tokens.
-    """
-
-    def call(self, text_embeddings, token_ids):
-        # `keepdims` is not supported in `keras<=3.1`.
-        eos_index = ops.argmax(token_ids, axis=-1)
-        eos_index = ops.expand_dims(eos_index, axis=-1)
-        eos_index = ops.expand_dims(eos_index, axis=-1)
-        pooled_outputs = ops.take_along_axis(text_embeddings, eos_index, axis=1)
-        return ops.squeeze(pooled_outputs, axis=1)
-
-    def compute_output_shape(self, input_shape):
-        return (input_shape[0], input_shape[-1])
-
-
-class CLIPHead(layers.Layer):
-    """The head layer of CLIP.
-
-    `CLIPHead` takes `vision_embedding` and `text_embedding` as inputs to
-    compute the corresponding logits. Both embeddings are L2 normalized and used
-    to compute pairwise cosine similarity. The resulting logits are then scaled
-    by a learnable `logit_scale` parameter.
-
-    Call arguments:
-        vision_embedding: A tensor of shape `(batch_size, hidden_dim)`.
-        text_embedding: A tensor of shape `(batch_size, hidden_dim)`.
-    """
-
-    def build(self, input_shape):
-        self.logit_scale = self.add_weight(
-            shape=(),
-            initializer=lambda *a, **kw: math.log(1 / 0.07),
-            trainable=True,
-            dtype=self.variable_dtype,
-            name="logit_scale",
-        )
-
-    def call(self, vision_embedding, text_embedding):
-        normalized_vision_embedding = ops.sqrt(
-            ops.sum(ops.power(vision_embedding, 2), axis=-1, keepdims=True)
-        )
-        normalized_text_embedding = ops.sqrt(
-            ops.sum(ops.power(text_embedding, 2), axis=-1, keepdims=True)
-        )
-        vision_embedding = vision_embedding / normalized_vision_embedding
-        text_embedding = text_embedding / normalized_text_embedding
-        logit_scale = ops.exp(self.logit_scale)
-        text_logits = (
-            ops.matmul(
-                text_embedding,
-                ops.transpose(vision_embedding),
-            )
-            * logit_scale
-        )
-        vision_logits = ops.transpose(text_logits)
-        return vision_logits, text_logits
-
-    def compute_output_shape(
-        self, vision_embedding_shape, text_embedding_shape
-    ):
-        vision_logits_shape = (
-            vision_embedding_shape[0],
-            text_embedding_shape[0],
-        )
-        text_logits_shape = (
-            text_embedding_shape[0],
-            vision_embedding_shape[0],
-        )
-        return vision_logits_shape, text_logits_shape
+from keras_hub.src.models.clip.clip_layers import CLIPHead
+from keras_hub.src.models.clip.clip_layers import CLIPTextPooler
+from keras_hub.src.models.clip.clip_layers import CLIPVisionPooler
 
 
 @keras_hub_export("keras_hub.models.CLIPBackbone")