keras-hub-nightly 0.20.0.dev202503310403__py3-none-any.whl → 0.20.0.dev202504020401__py3-none-any.whl

keras_hub/api/models/__init__.py

@@ -323,6 +323,24 @@ from keras_hub.src.models.roberta.roberta_text_classifier_preprocessor import (
     RobertaTextClassifierPreprocessor as RobertaPreprocessor,
 )
 from keras_hub.src.models.roberta.roberta_tokenizer import RobertaTokenizer
+from keras_hub.src.models.roformer_v2.roformer_v2_backbone import (
+    RoformerV2Backbone as RorformerV2Backbone,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_masked_lm import (
+    RoformerV2MaskedLM,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_masked_lm_preprocessor import (
+    RoformerV2MaskedLMPreprocessor,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_text_classifier import (
+    RorformerV2TextClassifier,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_text_classifier_preprocessor import (
+    RoformerV2TextClassifierPreprocessor,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
+    RoformerV2Tokenizer,
+)
 from keras_hub.src.models.sam.sam_backbone import SAMBackbone
 from keras_hub.src.models.sam.sam_image_segmenter import SAMImageSegmenter
 from keras_hub.src.models.sam.sam_image_segmenter_preprocessor import (
@@ -369,6 +387,9 @@ from keras_hub.src.models.text_classifier_preprocessor import (
     TextClassifierPreprocessor,
 )
 from keras_hub.src.models.text_to_image import TextToImage
+from keras_hub.src.models.text_to_image_preprocessor import (
+    TextToImagePreprocessor,
+)
 from keras_hub.src.models.vgg.vgg_backbone import VGGBackbone
 from keras_hub.src.models.vgg.vgg_image_classifier import VGGImageClassifier
 from keras_hub.src.models.vgg.vgg_image_classifier_preprocessor import (

keras_hub/api/tokenizers/__init__.py

@@ -35,6 +35,9 @@ from keras_hub.src.models.qwen.qwen_tokenizer import (
     QwenTokenizer as Qwen2Tokenizer,
 )
 from keras_hub.src.models.roberta.roberta_tokenizer import RobertaTokenizer
+from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
+    RoformerV2Tokenizer,
+)
 from keras_hub.src.models.siglip.siglip_tokenizer import SigLIPTokenizer
 from keras_hub.src.models.t5.t5_tokenizer import T5Tokenizer
 from keras_hub.src.models.whisper.whisper_tokenizer import WhisperTokenizer

keras_hub/src/models/gemma/gemma_attention.py

@@ -133,6 +133,13 @@ class CachedGemmaAttention(keras.layers.Layer):
             query_normalization = 1 / np.sqrt(
                 self.hidden_dim // self.num_query_heads
             )
+
+        if self.use_sliding_window_attention and attention_mask is not None:
+            attention_mask = self._mask_sliding_window(
+                attention_mask,
+                cache_update_index=cache_update_index,
+            )
+
         if self._can_use_flash_attention():
             if attention_mask is not None:
                 attention_mask = ops.expand_dims(attention_mask, axis=1)
@@ -172,13 +179,8 @@ class CachedGemmaAttention(keras.layers.Layer):
                 ops.tanh(attention_logits), self.logit_soft_cap
             )
 
-        if self.use_sliding_window_attention:
-            attention_mask = self._mask_sliding_window(
-                attention_mask,
-                cache_update_index=cache_update_index,
-            )
-
-        attention_mask = attention_mask[:, None, None, :, :]
+        if attention_mask is not None:
+            attention_mask = attention_mask[:, None, None, :, :]
         orig_dtype = attention_logits.dtype
         attention_softmax = self.softmax(attention_logits, mask=attention_mask)
         attention_softmax = ops.cast(attention_softmax, orig_dtype)

keras_hub/src/models/roformer_v2/roformer_v2_attention.py

@@ -0,0 +1,212 @@
+import keras
+from keras import initializers
+from keras import ops
+
+
+class RoformerNorm(keras.layers.Layer):
+    """A normalization layer for Roformer that implements RMS normalization."""
+
+    def __init__(self, epsilon=1e-6, **kwargs):
+        super().__init__(**kwargs)
+        self.epsilon = epsilon
+
+    def build(self, input_shape):
+        dim = input_shape[-1]
+        self.scale = self.add_weight(
+            name="scale",
+            trainable=True,
+            shape=(dim,),
+            initializer="ones",
+            dtype=self.variable_dtype,
+        )
+        self.built = True
+
+    def call(self, x):
+        x = ops.cast(x, "float32")
+        var = ops.mean(ops.power(x, 2), axis=-1, keepdims=True)
+        x = x * ops.rsqrt(var + self.epsilon)
+        return ops.cast(x * self.scale, self.compute_dtype)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"epsilon": self.epsilon})
+        return config
+
+
+class RoformrPositionalEmbedding(keras.layers.Layer):
+    """Native rotary implement by jianlin su
+    from native implement
+    https://github.com/bojone/bert4keras
+
+    """
+
+    def __init__(self, output_dim, max_wavelength=10000, **kwargs):
+        super().__init__(**kwargs)
+        self.max_wavelength = max_wavelength
+        self.output_dim = output_dim
+
+    def call(self, tensors):
+        input_shape = ops.shape(tensors[0])
+        seq_len = input_shape[1]
+        position_ids = ops.arange(0, seq_len, dtype=tensors[0].dtype)[None]
+        embeddings = self.sinusoidal_embeddings(
+            position_ids, self.output_dim, self.max_wavelength
+        )
+        embeddings = ops.cast(embeddings, self.compute_dtype)
+
+        ndim = ops.ndim(tensors[0])
+        sinusoidal = self.align(embeddings, [0, 1, -1], ndim)
+        cos_pos = ops.repeat(sinusoidal[..., 1::2], 2, -1)
+        sin_pos = ops.repeat(sinusoidal[..., ::2], 2, -1)
+        outputs = []
+        for tensor in tensors:
+            tensor2 = ops.stack([-tensor[..., 1::2], tensor[..., ::2]], ndim)
+            tensor2 = ops.reshape(tensor2, ops.shape(tensor))
+            outputs.append(tensor * cos_pos + tensor2 * sin_pos)
+        return outputs[0] if len(outputs) == 1 else outputs
+
+    def align(self, tensor, axes, ndim=None):
+        ndim = ndim or max(axes) + 1
+        indices = [None] * ndim
+        for i in axes:
+            indices[i] = slice(None)
+        if keras.config.backend() == "jax":
+            return tensor[tuple(indices)]
+        return tensor[indices]
+
+    def sinusoidal_embeddings(self, pos, dim, base=10000):
+        if dim % 2 != 0:
+            raise ("Dimension must be even")
+
+        indices = ops.arange(0, dim // 2, dtype="float32")
+        indices = ops.power(ops.cast(base, dtype="float32"), -2 * indices / dim)
+        embeddings = ops.einsum("...,d->...d", pos, indices)
+        embeddings = ops.stack(
+            [ops.sin(embeddings), ops.cos(embeddings)], axis=-1
+        )
+        shape = list(ops.shape(embeddings))
+        embeddings = ops.reshape(embeddings, shape[:-2] + [-1])
+        return embeddings
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "out_dim": self.out_dim,
+                "max_wavelength": self.max_wavelength,
+            }
+        )
+        return config
+
+
+@keras.saving.register_keras_serializable(package="keras_hub")
+class RoformerAttention(keras.layers.Layer):
+    """MultiHeadAttention by roformerV2
+
+    modifity from native implement
+    https://github.com/bojone/bert4keras
+    """
+
+    def __init__(
+        self,
+        heads,
+        head_size,
+        out_dim=None,
+        use_bias=False,
+        max_wavelength=10000,
+        kernel_initializer="glorot_uniform",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.heads = heads
+        self.head_size = head_size
+        self.out_dim = out_dim or heads * head_size
+        self.use_bias = use_bias
+        self.kernel_initializer = initializers.get(kernel_initializer)
+        self.max_wavelength = max_wavelength
+
+    def build(self, input_shape):
+        super().build(input_shape)
+        self.q_dense = keras.layers.Dense(
+            units=self.head_size * self.heads,
+            use_bias=self.use_bias,
+            kernel_initializer=self.kernel_initializer,
+            name="q_dense_layer",
+            dtype=self.dtype_policy,
+        )
+        self.q_dense.build(input_shape)
+
+        self.k_dense = keras.layers.Dense(
+            units=self.head_size * self.heads,
+            use_bias=self.use_bias,
+            kernel_initializer=self.kernel_initializer,
+            name="k_dense_layer",
+            dtype=self.dtype_policy,
+        )
+        self.k_dense.build(input_shape)
+
+        self.v_dense = keras.layers.Dense(
+            units=self.head_size * self.heads,
+            use_bias=self.use_bias,
+            kernel_initializer=self.kernel_initializer,
+            name="v_dense_layer",
+            dtype=self.dtype_policy,
+        )
+        self.v_dense.build(input_shape)
+
+        self.o_dense = keras.layers.Dense(
+            units=self.out_dim,
+            use_bias=self.use_bias,
+            kernel_initializer=self.kernel_initializer,
+            name="o_dense_layer",
+            dtype=self.dtype_policy,
+        )
+        self.o_dense.build([None, None, self.head_size * self.heads])
+
+        self.rotary_embedding_layer = RoformrPositionalEmbedding(
+            self.head_size, self.max_wavelength, dtype=self.dtype_policy
+        )
+        self.rotary_embedding_layer.build([])
+
+    def call(self, x, attention_mask=None):
+        qw = self.q_dense(x)
+        kw = self.k_dense(x)
+        vw = self.v_dense(x)
+
+        b, s = ops.shape(qw)[:2]
+        qw = ops.reshape(qw, (b, s, self.heads, self.head_size))
+        kw = ops.reshape(kw, (b, s, self.heads, self.head_size))
+        vw = ops.reshape(vw, (b, s, self.heads, self.head_size))
+
+        qw, kw = self.rotary_embedding_layer([qw, kw])
+        if keras.__version__ < "3.6":
+            raise ("Please make sure your Keras version is >=3.6.")
+        flash_attention = keras.config.is_flash_attention_enabled()
+        attention_mask = ops.reshape(attention_mask, [b, 1, s, 1])
+        if keras.config.backend() == "torch":
+            attention_mask = ops.repeat(attention_mask, s, -1)
+            attention_mask = ops.transpose(attention_mask, [0, 1, 3, 2])
+        o = ops.dot_product_attention(
+            qw, kw, vw, mask=attention_mask, flash_attention=flash_attention
+        )
+
+        return self.o_dense(ops.reshape(o, [b, s, -1]))
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "heads": self.heads,
+                "head_size": self.head_size,
+                "out_dim": self.out_dim,
+                "use_bias": self.use_bias,
+                "max_wavelength": self.max_wavelength,
+                "kernel_initializer": initializers.serialize(
+                    self.kernel_initializer
+                ),
+            }
+        )
+        return config

keras_hub/src/models/roformer_v2/roformer_v2_backbone.py

@@ -0,0 +1,198 @@
+import keras
+from keras import activations
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.layers.modeling.reversible_embedding import (
+    ReversibleEmbedding,
+)
+from keras_hub.src.models.backbone import Backbone
+from keras_hub.src.models.roformer_v2.roformer_v2_attention import RoformerNorm
+from keras_hub.src.models.roformer_v2.roformer_v2_encoder import (
+    RoformerV2Encoder,
+)
+
+
+def roformer_kernel_initializer(stddev=0.02):
+    return keras.initializers.TruncatedNormal(stddev=stddev)
+
+
+@keras_hub_export("keras_hub.models.RorformerV2Backbone")
+class RoformerV2Backbone(Backbone):
+    """A RoformerV2 encoder network.
+
+    This class implements a bi-directional Transformer-based encoder as
+    described in ["Roformer"](https://github.com/ZhuiyiTechnology/roformer).
+    It includes the
+    embedding lookups and transformer layers, but not the masked language model
+    or next sentence prediction heads.
+
+    The default constructor gives a fully customizable, randomly initialized
+    RoformerV2 encoder with any number of layers, heads, and embed dim.To
+    load preset architectures and weights, use the `from_preset()` constructor.
+
+    Disclaimer: Pre-trained models are provided on an "as is" basis, without
+    warranties or conditions of any kind.
+
+    Args:
+        vocabulary_size: int. The size of the token vocabulary.
+        num_layers: int. The number of transformer layers.
+        num_heads: int. The number of attention heads for each transformer.
+            The hidden size must be divisible by the number of attention heads.
+        hidden_dim: int. The size of the transformer encoding and pooler layers.
+        intermediate_dim: int. The output dimension of the first Dense layer in
+            a two-layer feedforward network for each transformer.
+        dropout: float. Dropout probability for the Transformer encoder.
+        num_segments: int. The number of types that the 'segment_ids' input can
+            take.
+        dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
+            for model computations and weights. Note that some computations,
+            such as softmax and layer normalization, will always be done at
+            float32 precision regardless of dtype.
+
+    Examples:
+    ```python
+    input_data = {
+        "token_ids": np.ones(shape=(1, 12), dtype="int32"),
+        "segment_ids": np.array([[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0]]),
+        "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]]),
+    }
+
+    # Pretrained RoformerV2 encoder.
+    model = keras_hub.models.RoformerV2Backbone.from_preset("roformer_v2_base")
+    model(input_data)
+
+    # Randomly initialized RoformerV2 encoder with a custom config.
+    model = keras_hub.models.RoformerV2Backbone(
+        vocabulary_size=30552,
+        num_layers=4,
+        num_heads=4,
+        hidden_dim=256,
+        intermediate_dim=512,
+        head_size = 64,
+    )
+    model(input_data)
+    ```
+    """
+
+    def __init__(
+        self,
+        vocabulary_size,
+        num_layers,
+        num_heads,
+        hidden_dim,
+        intermediate_dim,
+        head_size,
+        use_bias=False,
+        activation="relu",
+        dropout=0.1,
+        num_segments=2,
+        dtype=None,
+        max_wavelength=10000,
+        **kwargs,
+    ):
+        # === Layers ===
+        self.token_embedding = ReversibleEmbedding(
+            input_dim=vocabulary_size,
+            output_dim=hidden_dim,
+            embeddings_initializer=roformer_kernel_initializer(),
+            dtype=dtype,
+            name="token_embedding",
+        )
+        self.segment_embedding = keras.layers.Embedding(
+            input_dim=num_segments,
+            output_dim=hidden_dim,
+            embeddings_initializer=roformer_kernel_initializer(),
+            dtype=dtype,
+            name="segment_embedding",
+        )
+        self.embeddings_add = keras.layers.Add(
+            dtype=dtype,
+            name="embeddings_add",
+        )
+        self.embeddings_layer_norm = RoformerNorm(
+            epsilon=keras.backend.epsilon(),
+            dtype=dtype,
+            name="embeddings_layer_norm",
+        )
+        self.embeddings_dropout = keras.layers.Dropout(
+            dropout,
+            dtype=dtype,
+            name="embeddings_dropout",
+        )
+        self.transformer_layers = []
+        for i in range(num_layers):
+            layer = RoformerV2Encoder(
+                heads=num_heads,
+                head_size=head_size,
+                intermediate_size=intermediate_dim,
+                use_bias=use_bias,
+                max_wavelength=max_wavelength,
+                dropout=dropout,
+                activation=activation,
+                kernel_initializer=roformer_kernel_initializer(),
+                dtype=dtype,
+                name=f"transformer_layer_{i}",
+            )
+            self.transformer_layers.append(layer)
+
+        # === Functional Model ===
+        token_id_input = keras.Input(
+            shape=(None,), dtype="int32", name="token_ids"
+        )
+        segment_id_input = keras.Input(
+            shape=(None,), dtype="int32", name="segment_ids"
+        )
+        attention_mask = keras.ops.not_equal(token_id_input, 0)
+        # Embed tokens, positions, and segment ids.
+        tokens = self.token_embedding(token_id_input)
+        segments = self.segment_embedding(segment_id_input)
+        # Sum, normalize and apply dropout to embeddings.
+        x = self.embeddings_add((tokens, segments))
+        x = self.embeddings_layer_norm(x)
+        x = self.embeddings_dropout(x)
+        for transformer_layer in self.transformer_layers:
+            x = transformer_layer(x, attention_mask=attention_mask)
+
+        super().__init__(
+            inputs={
+                "token_ids": token_id_input,
+                "segment_ids": segment_id_input,
+            },
+            outputs=x,
+            dtype=dtype,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.vocabulary_size = vocabulary_size
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.hidden_dim = hidden_dim
+        self.intermediate_dim = intermediate_dim
+        self.dropout = dropout
+        self.num_segments = num_segments
+        self.max_wavelength = max_wavelength
+        self.head_size = head_size
+        self.dropout = dropout
+        self.activation = activations.get(activation)
+        self.use_bias = use_bias
+        self.start_token_index = 0
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "vocabulary_size": self.vocabulary_size,
+                "num_layers": self.num_layers,
+                "num_heads": self.num_heads,
+                "hidden_dim": self.hidden_dim,
+                "intermediate_dim": self.intermediate_dim,
+                "dropout": self.dropout,
+                "num_segments": self.num_segments,
+                "max_wavelength": self.max_wavelength,
+                "head_size": self.head_size,
+                "use_bias": self.use_bias,
+                "activation": activations.serialize(self.activation),
+            }
+        )
+        return config

keras_hub/src/models/roformer_v2/roformer_v2_encoder.py

@@ -0,0 +1,128 @@
+import keras
+from keras import activations
+from keras import initializers
+
+from keras_hub.src.models.roformer_v2.roformer_v2_attention import (
+    RoformerAttention,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_attention import RoformerNorm
+
+
+@keras.saving.register_keras_serializable(package="keras_hub")
+class RoformerV2Encoder(keras.layers.Layer):
+    """A Transformer Encoder layer for the Roformer backbone."""
+
+    def __init__(
+        self,
+        heads,
+        head_size,
+        intermediate_size=None,
+        max_wavelength=10000,
+        dropout=0,
+        activation="relu",
+        use_bias=False,
+        kernel_initializer="glorot_uniform",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.heads = heads
+        self.head_size = head_size
+        self.intermediate_size = intermediate_size
+        self.use_bias = use_bias
+        self.kernel_initializer = initializers.get(kernel_initializer)
+        self.max_wavelength = max_wavelength
+        self.dropout = dropout
+        self.activation = activations.get(activation)
+
+    def build(self, input_shape):
+        super().build(input_shape)
+        self.attention_layer = RoformerAttention(
+            heads=self.heads,
+            head_size=self.head_size,
+            use_bias=self.use_bias,
+            max_wavelength=self.max_wavelength,
+            kernel_initializer=self.kernel_initializer,
+            dtype=self.dtype_policy,
+            name="attention_layer",
+        )
+        self.attention_layer.build(input_shape)
+
+        self.dropout_layer = keras.layers.Dropout(
+            rate=self.dropout,
+            dtype=self.dtype_policy,
+            name="self_attention_dropout",
+        )
+        self.dropout_layer.build([])
+
+        # Feedforward layers.
+        self.feedforward_intermediate_dense = keras.layers.Dense(
+            self.intermediate_size,
+            kernel_initializer=self.kernel_initializer,
+            use_bias=self.use_bias,
+            dtype=self.dtype_policy,
+            activation=self.activation,
+            name="feedforward_intermediate_dense",
+        )
+        self.feedforward_intermediate_dense.build(input_shape)
+
+        self.feedforward_output_dense = keras.layers.Dense(
+            input_shape[-1],
+            kernel_initializer=self.kernel_initializer,
+            use_bias=self.use_bias,
+            dtype=self.dtype_policy,
+            name="feedforward_output_dense",
+        )
+
+        self.feedforward_output_dense.build(
+            [None, None, self.intermediate_size]
+        )
+
+        self.attention_norm = RoformerNorm(
+            epsilon=keras.backend.epsilon(),
+            name="attention_norm",
+            dtype=self.dtype_policy,
+        )
+        self.attention_norm.build(input_shape)
+
+        self.feedforward_norm = RoformerNorm(
+            epsilon=keras.backend.epsilon(),
+            name="feedforward_norm",
+            dtype=self.dtype_policy,
+        )
+        self.feedforward_norm.build(input_shape)
+
+    def call(self, x, attention_mask=None):
+        attention_output = self.attention_layer(
+            x,
+            attention_mask=attention_mask,
+        )
+
+        residual = x + self.dropout_layer(attention_output)
+        x = self.attention_norm(residual)
+
+        intermediate_output = self.feedforward_intermediate_dense(x)
+        feedroward_output = self.feedforward_output_dense(intermediate_output)
+
+        residual = x + self.dropout_layer(feedroward_output)
+        return self.feedforward_norm(residual)
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "heads": self.heads,
+                "head_size": self.head_size,
+                "intermediate_size": self.intermediate_size,
+                "max_wavelength": self.max_wavelength,
+                "use_bias": self.use_bias,
+                "activation": activations.serialize(self.activation),
+                "dropout": self.dropout,
+                "kernel_initializer": initializers.serialize(
+                    self.kernel_initializer
+                ),
+            }
+        )
+        return config