keras-hub 0.25.1__py3-none-any.whl → 0.26.0.dev0__py3-none-any.whl

keras_hub/src/tokenizers/word_piece_tokenizer.py

@@ -3,6 +3,7 @@ import re
 from typing import Iterable
 
 import keras
+from keras.src.saving import serialization_lib
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.tokenizers import tokenizer
@@ -13,9 +14,11 @@ from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 try:
     import tensorflow as tf
-    import tensorflow_text as tf_text
 except ImportError:
     tf = None
+try:
+    import tensorflow_text as tf_text
+except ImportError:
     tf_text = None
 
 VOCAB_FILENAME = "vocabulary.txt"
@@ -374,6 +377,17 @@ class WordPieceTokenizer(tokenizer.Tokenizer):
             return
 
         if isinstance(vocabulary, str):
+            if serialization_lib.in_safe_mode():
+                raise ValueError(
+                    "Requested the loading of a vocabulary file outside of the "
+                    "model archive. This carries a potential risk of loading "
+                    "arbitrary and sensitive files and thus it is disallowed "
+                    "by default. If you trust the source of the artifact, you "
+                    "can override this error by passing `safe_mode=False` to "
+                    "the loading function, or calling "
+                    "`keras.config.enable_unsafe_deserialization()`. "
+                    f"Vocabulary file: '{vocabulary}'"
+                )
             with open(vocabulary, "r", encoding="utf-8") as file:
                 self.vocabulary = [line.rstrip() for line in file]
         elif isinstance(vocabulary, Iterable):

keras_hub/src/utils/preset_utils.py

@@ -285,7 +285,7 @@ def tf_copy_gfile_to_cache(preset, path):
             # Work around this bug.
             os.remove(local_path)
             if isinstance(
-                e, tf.errors.PermissionDeniedError, tf.errors.NotFoundError
+                e, (tf.errors.PermissionDeniedError, tf.errors.NotFoundError)
             ):
                 raise FileNotFoundError(
                     f"`{path}` doesn't exist in preset directory `{preset}`.",

keras_hub/src/utils/tensor_utils.py

@@ -231,6 +231,7 @@ def tensor_to_list(inputs):
     Args:
         inputs: Input tensor, or dict/list/tuple of input tensors.
     """
+    assert_tf_installed("tensor_to_list")
     if not isinstance(inputs, (tf.RaggedTensor, tf.Tensor)):
         inputs = tf.convert_to_tensor(inputs)
     if isinstance(inputs, tf.RaggedTensor):
@@ -246,6 +247,7 @@ def tensor_to_list(inputs):
 
 def convert_to_ragged_batch(inputs):
     """Ensure a tf.Tensor is a ragged rank 2 tensor."""
+    assert_tf_installed("convert_to_ragged_batch")
     if not isinstance(inputs, (tf.RaggedTensor, tf.Tensor)):
         inputs = tf.convert_to_tensor(inputs)
     unbatched = inputs.shape.rank == 1
@@ -259,6 +261,7 @@ def convert_to_ragged_batch(inputs):
 
 def truncate_at_token(inputs, token, mask):
     """Truncate at first instance of `token`, ignoring `mask`."""
+    assert_tf_installed("truncate_at_token")
     matches = (inputs == token) & (~mask)
     end_indices = tf.cast(tf.math.argmax(matches, -1), "int32")
     end_indices = tf.where(end_indices == 0, tf.shape(inputs)[-1], end_indices)
@@ -267,12 +270,21 @@ def truncate_at_token(inputs, token, mask):
 
 def strip_to_ragged(token_ids, mask, ids_to_strip):
     """Remove masked and special tokens from a sequence before detokenizing."""
+    assert_tf_installed("strip_to_ragged")
     mask = tf.cast(mask, "bool")
     for id in ids_to_strip:
         mask = mask & (token_ids != id)
     return tf.ragged.boolean_mask(token_ids, mask)
 
 
+def assert_tf_installed(symbol_name):
+    if tf is None:
+        raise ImportError(
+            f"{symbol_name} requires `tensorflow`. "
+            "Run `pip install tensorflow` to install it."
+        )
+
+
 def assert_tf_libs_installed(symbol_name):
     if tf_text is None or tf is None:
         raise ImportError(

keras_hub/src/utils/transformers/convert_gemma3.py

@@ -37,6 +37,7 @@ def convert_backbone_config(transformers_config):
     else:
         vision_config = transformers_config["vision_config"]
         image_size = vision_config["image_size"]
+        transformer_config = transformers_config["text_config"]
         vision_encoder_config = {
             "image_size": image_size,
             "patch_size": vision_config["patch_size"],
@@ -44,21 +45,44 @@ def convert_backbone_config(transformers_config):
             "hidden_dim": vision_config["hidden_size"],
             "num_layers": vision_config["num_hidden_layers"],
             "intermediate_dim": vision_config["intermediate_size"],
-            "output_dim": 2560,
+            "output_dim": transformer_config["hidden_size"],
             "pool_size": 4,
             "layer_norm_epsilon": vision_config.get("layer_norm_eps", 1e-6),
         }
         vision_encoder = Gemma3VisionEncoder(**vision_encoder_config)
-        transformer_config = transformers_config["text_config"]
 
-    if "rope_parameters" in transformer_config:
-        rope_global_config = transformer_config.get("rope_parameters", {}).get(
-            "full_attention"
-        )
-    elif "rope_scaling" in transformer_config:
-        rope_global_config = transformer_config["rope_scaling"]
+    # Extract rope parameters. HuggingFace uses `rope_scaling` for the
+    # global rotary embedding. `rope_parameters` is optional and not used
+    # by HF for global scaling when `rope_scaling` is None.
+    rope_scaling = transformer_config.get("rope_scaling", None)
+    rope_params = transformer_config.get("rope_parameters") or {}
+
+    if rope_scaling is not None:
+        rope_global_config = rope_scaling or {}
     else:
-        rope_global_config = {}
+        rope_global_config = rope_params.get("full_attention", {})
+
+    rope_local_config = rope_params.get("sliding_attention", {})
+
+    # Determine sliding window attention usage from layer_types or config
+    sliding_window = transformer_config.get("sliding_window", None)
+    layer_types = transformer_config.get("layer_types", [])
+
+    use_sliding_window_attention = sliding_window not in (None, 0) or any(
+        lt == "sliding_attention" for lt in layer_types
+    )
+
+    # Determine query_head_dim_normalize
+    # If query_pre_attn_scalar equals head_dim, then normalize by head_dim
+    query_pre_attn_scalar = transformer_config.get(
+        "query_pre_attn_scalar", None
+    )
+    head_dim = transformer_config.get("head_dim")
+    if query_pre_attn_scalar is not None and head_dim is not None:
+        query_head_dim_normalize = query_pre_attn_scalar == head_dim
+    else:
+        query_head_dim_normalize = True
+
     return {
         "vocabulary_size": transformer_config.get(
             "vocab_size", 262144 if vision_encoder is None else 262208
@@ -70,25 +94,35 @@ def convert_backbone_config(transformers_config):
         "hidden_dim": transformer_config["hidden_size"],
         "intermediate_dim": transformer_config["intermediate_size"],
         "head_dim": transformer_config["head_dim"],
-        "use_post_ffw_norm": True,
-        "use_post_attention_norm": True,
-        "attention_logit_softcap": transformer_config.get(
-            "attn_logit_softcap", None
+        # Gemma3 models use post-norm and post-attention norm by default
+        "use_post_ffw_norm": transformer_config.get("use_post_ffw_norm", True),
+        "use_post_attention_norm": transformer_config.get(
+            "use_post_attention_norm", True
         ),
-        "final_logit_softcap": transformer_config.get(
-            "final_logit_softcap", None
+        # Handle soft-capping parameters (may be null)
+        "attention_logit_soft_cap": transformer_config.get(
+            "attn_logit_softcapping", None
         ),
-        "use_sliding_window_attention": True,
-        "query_head_dim_normalize": True,
-        "sliding_window_size": transformer_config["sliding_window"],
-        "local_rope_scaling_factor": 1.0,
-        "global_rope_scaling_factor": (
-            rope_global_config.get("factor", 1.0) if rope_global_config else 1.0
+        "final_logit_soft_cap": transformer_config.get(
+            "final_logit_softcapping", None
         ),
+        # Use sliding window attention if configured
+        "use_sliding_window_attention": use_sliding_window_attention,
+        # Normalize query by head_dim if query_pre_attn_scalar == head_dim
+        "query_head_dim_normalize": query_head_dim_normalize,
+        # Sliding window size (default to 1024 for full attention layers)
+        "sliding_window_size": sliding_window or 4096,
+        # Rope scaling factors for local (sliding) and global (full) attention
+        "local_rope_scaling_factor": rope_local_config.get("factor", 1.0),
+        "global_rope_scaling_factor": rope_global_config.get("factor", 1.0),
         "layer_norm_epsilon": transformer_config.get("rms_norm_eps", 1e-6),
         "use_bidirectional_attention": transformer_config.get(
             "use_bidirectional_attention", False
         ),
+        # Gemma3 uses query/key normalization by default
+        "use_query_key_norm": transformer_config.get(
+            "use_query_key_norm", True
+        ),
         "vision_encoder": vision_encoder,
     }
 
@@ -97,7 +131,7 @@ def convert_weights(backbone, loader, transformers_config):
     if transformers_config["model_type"] == "gemma3_text":
         prefix = "model"
     else:
-        prefix = "language_model.model"
+        prefix = _resolve_multimodal_prefix(loader)
 
     loader.port_weight(
         keras_variable=backbone.get_layer("token_embedding").embeddings,
@@ -336,6 +370,18 @@ def convert_weights(backbone, loader, transformers_config):
     return backbone
 
 
+def _resolve_multimodal_prefix(loader):
+    candidates = ["model.language_model", "language_model.model"]
+    for candidate in candidates:
+        key = f"{candidate}.embed_tokens.weight"
+        try:
+            loader.get_tensor(key)
+            return candidate
+        except Exception:
+            continue
+    return candidates[0]
+
+
 def convert_tokenizer(cls, preset, **kwargs):
     proto = get_file(preset, "tokenizer.model")
     sp = SentencePieceProcessor()

keras_hub/src/utils/transformers/convert_qwen3_moe.py

@@ -198,7 +198,10 @@ def convert_tokenizer(cls, preset, **kwargs):
     tokenizer_config = load_json(preset, "tokenizer.json")
     vocab = tokenizer_config["model"]["vocab"]
     merges = tokenizer_config["model"]["merges"]
-    merges = [" ".join(item) for item in merges]
+    # Check if merges are already strings or lists
+    # If they are lists, join them into strings.
+    if merges and isinstance(merges[0], list):
+        merges = [" ".join(item) for item in merges]
 
     # Load all special tokens with the exception of "reserved" ones.
     special_tokens = set()