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

keras_hub/src/utils/transformers/export/hf_exporter.py

@@ -5,26 +5,45 @@ import warnings
 
 import keras
 
+# --- Gemma Utils ---
 from keras_hub.src.utils.transformers.export.gemma import get_gemma_config
 from keras_hub.src.utils.transformers.export.gemma import (
     get_gemma_tokenizer_config,
 )
 from keras_hub.src.utils.transformers.export.gemma import get_gemma_weights_map
 
+# --- Gemma 3 Utils ---
+from keras_hub.src.utils.transformers.export.gemma3 import get_gemma3_config
+from keras_hub.src.utils.transformers.export.gemma3 import (
+    get_gemma3_tokenizer_config,
+)
+from keras_hub.src.utils.transformers.export.gemma3 import (
+    get_gemma3_weights_map,
+)
+
+# --- Qwen Utils ---
+from keras_hub.src.utils.transformers.export.qwen import get_qwen_config
+from keras_hub.src.utils.transformers.export.qwen import (
+    get_qwen_tokenizer_config,
+)
+from keras_hub.src.utils.transformers.export.qwen import get_qwen_weights_map
+
 MODEL_CONFIGS = {
     "GemmaBackbone": get_gemma_config,
-    # Add for future models, e.g., "MistralBackbone": get_mistral_config
+    "Gemma3Backbone": get_gemma3_config,
+    "QwenBackbone": get_qwen_config,
 }
 
 MODEL_EXPORTERS = {
     "GemmaBackbone": get_gemma_weights_map,
-    # Add for future models, e.g., "MistralBackbone": get_mistral_weights_map
+    "Gemma3Backbone": get_gemma3_weights_map,
+    "QwenBackbone": get_qwen_weights_map,
 }
 
 MODEL_TOKENIZER_CONFIGS = {
     "GemmaTokenizer": get_gemma_tokenizer_config,
-    # Add for future models, e.g., "MistralTokenizer":
-    # get_mistral_tokenizer_config
+    "Gemma3Tokenizer": get_gemma3_tokenizer_config,
+    "QwenTokenizer": get_qwen_tokenizer_config,
 }
 
 
@@ -54,23 +73,55 @@ def export_backbone(backbone, path, include_lm_head=False):
     weights_dict = get_weights_fn(backbone, include_lm_head=include_lm_head)
     if not weights_dict:
         raise ValueError("No weights to save.")
+
     # Save config
     os.makedirs(path, exist_ok=True)
     config_path = os.path.join(path, "config.json")
+
+    config_to_save = hf_config
+    if hasattr(hf_config, "to_dict"):
+        config_to_save = hf_config.to_dict()
+
     with open(config_path, "w") as f:
-        json.dump(hf_config, f)
+        json.dump(config_to_save, f, indent=2)
+
     # Save weights based on backend
     weights_path = os.path.join(path, "model.safetensors")
     if backend == "torch":
+        # Lazy import to prevent crash on TF-only environments
+        import torch
         from safetensors.torch import save_file
 
-        weights_dict_contiguous = {
-            k: v.value.contiguous() if hasattr(v, "value") else v.contiguous()
-            for k, v in weights_dict.items()
-        }
-        save_file(
-            weights_dict_contiguous, weights_path, metadata={"format": "pt"}
-        )
+        weights_dict_torch = {}
+        for k, v in weights_dict.items():
+            tensor = v.value if hasattr(v, "value") else v
+
+            if isinstance(tensor, torch.Tensor):
+                t = tensor.detach().to("cpu")
+            elif hasattr(tensor, "numpy"):
+                t = torch.tensor(tensor.numpy())
+            elif hasattr(tensor, "__array__"):
+                t = torch.tensor(tensor)
+            else:
+                t = tensor
+
+            if hasattr(t, "contiguous"):
+                t = t.contiguous()
+
+            weights_dict_torch[k] = t
+
+        # Handle Tied Weights
+        if (
+            "lm_head.weight" in weights_dict_torch
+            and "model.embed_tokens.weight" in weights_dict_torch
+        ):
+            wte = weights_dict_torch["model.embed_tokens.weight"]
+            lm = weights_dict_torch["lm_head.weight"]
+            if wte.data_ptr() == lm.data_ptr():
+                weights_dict_torch["lm_head.weight"] = lm.clone().contiguous()
+
+        save_file(weights_dict_torch, weights_path, metadata={"format": "pt"})
+
     elif backend == "tensorflow":
         from safetensors.tensorflow import save_file
 
@@ -91,31 +142,41 @@ def export_tokenizer(tokenizer, path):
         path: str. Path to save the exported tokenizer.
     """
     os.makedirs(path, exist_ok=True)
+
     # Save tokenizer assets
     tokenizer.save_assets(path)
+
     # Export tokenizer config
     tokenizer_type = tokenizer.__class__.__name__
     if tokenizer_type not in MODEL_TOKENIZER_CONFIGS:
         raise ValueError(
-            "Export to Transformers format not implemented for {tokenizer_type}"
+            f"Export to Transformer format not implemented for {tokenizer_type}"
         )
     get_tokenizer_config_fn = MODEL_TOKENIZER_CONFIGS[tokenizer_type]
     tokenizer_config = get_tokenizer_config_fn(tokenizer)
     tokenizer_config_path = os.path.join(path, "tokenizer_config.json")
     with open(tokenizer_config_path, "w") as f:
         json.dump(tokenizer_config, f, indent=4)
-    # Rename vocabulary file
-    vocab_spm_path = os.path.join(path, "vocabulary.spm")
-    tokenizer_model_path = os.path.join(path, "tokenizer.model")
-    if os.path.exists(vocab_spm_path):
-        shutil.move(vocab_spm_path, tokenizer_model_path)
-    else:
-        warnings.warn(
-            f"{vocab_spm_path} not found. Tokenizer may not load "
-            "correctly. Ensure that the tokenizer configuration "
-            "is correct and that the vocabulary file is present "
-            "in the original model."
-        )
+
+    # Rename files to match Hugging Face expectations
+
+    # 1. SentencePiece Models (Gemma / Gemma 3)
+    if tokenizer_type in ["GemmaTokenizer", "Gemma3Tokenizer"]:
+        vocab_spm_path = os.path.join(path, "vocabulary.spm")
+        tokenizer_model_path = os.path.join(path, "tokenizer.model")
+        if os.path.exists(vocab_spm_path):
+            shutil.move(vocab_spm_path, tokenizer_model_path)
+        else:
+            warnings.warn(f"{vocab_spm_path} not found.")
+
+    # 2. BPE Models (Qwen)
+    elif tokenizer_type == "QwenTokenizer":
+        vocab_json_path = os.path.join(path, "vocabulary.json")
+        vocab_hf_path = os.path.join(path, "vocab.json")
+        if os.path.exists(vocab_json_path):
+            shutil.move(vocab_json_path, vocab_hf_path)
+        else:
+            warnings.warn(f"{vocab_json_path} not found.")
 
 
 def export_to_safetensors(keras_model, path):

keras_hub/src/utils/transformers/export/qwen.py

@@ -0,0 +1,136 @@
+import keras.ops as ops
+
+
+def get_qwen_config(backbone):
+    """Convert Keras Qwen config to Hugging Face Qwen2Config."""
+    return {
+        # Core architectural dimensions
+        "vocab_size": backbone.vocabulary_size,
+        "hidden_size": backbone.hidden_dim,
+        "num_hidden_layers": backbone.num_layers,
+        "num_attention_heads": backbone.num_query_heads,
+        "num_key_value_heads": backbone.num_key_value_heads,
+        "intermediate_size": backbone.intermediate_dim,
+        # Activation and regularization
+        "hidden_act": "silu",
+        "attention_dropout": backbone.dropout,
+        # Numerical stability and initialization
+        "rms_norm_eps": backbone.layer_norm_epsilon,
+        "initializer_range": 0.02,
+        # RoPE settings
+        "rope_theta": backbone.rope_max_wavelength,
+        # Model behavior
+        "use_cache": True,
+        "tie_word_embeddings": backbone.tie_word_embeddings,
+        "model_type": "qwen2",
+    }
+
+
+def get_qwen_weights_map(backbone, include_lm_head=False):
+    """Create a weights map for a given Qwen model."""
+    weights_map = {}
+
+    # 1. Embeddings
+    weights_map["model.embed_tokens.weight"] = backbone.get_layer(
+        "token_embedding"
+    ).embeddings
+
+    for i in range(backbone.num_layers):
+        # Access the decoder layer
+        decoder_layer = backbone.get_layer(f"transformer_layer_{i}")
+
+        # --- Normalization ---
+        # Input Norm (Pre-Attention)
+        weights_map[f"model.layers.{i}.input_layernorm.weight"] = (
+            decoder_layer._self_attention_layernorm.scale
+        )
+
+        # Post Attention Norm (Pre-MLP)
+        weights_map[f"model.layers.{i}.post_attention_layernorm.weight"] = (
+            decoder_layer._feedforward_layernorm.scale
+        )
+
+        # --- Attention ---
+        attn_layer = decoder_layer._self_attention_layer
+
+        # Query
+        q_kernel = attn_layer._query_dense.kernel
+        q_kernel = ops.reshape(q_kernel, (backbone.hidden_dim, -1))
+        weights_map[f"model.layers.{i}.self_attn.q_proj.weight"] = (
+            ops.transpose(q_kernel)
+        )
+        weights_map[f"model.layers.{i}.self_attn.q_proj.bias"] = ops.reshape(
+            attn_layer._query_dense.bias, (-1,)
+        )
+
+        # Key
+        k_kernel = attn_layer._key_dense.kernel
+        k_kernel = ops.reshape(k_kernel, (backbone.hidden_dim, -1))
+        weights_map[f"model.layers.{i}.self_attn.k_proj.weight"] = (
+            ops.transpose(k_kernel)
+        )
+        weights_map[f"model.layers.{i}.self_attn.k_proj.bias"] = ops.reshape(
+            attn_layer._key_dense.bias, (-1,)
+        )
+
+        # Value
+        v_kernel = attn_layer._value_dense.kernel
+        v_kernel = ops.reshape(v_kernel, (backbone.hidden_dim, -1))
+        weights_map[f"model.layers.{i}.self_attn.v_proj.weight"] = (
+            ops.transpose(v_kernel)
+        )
+        weights_map[f"model.layers.{i}.self_attn.v_proj.bias"] = ops.reshape(
+            attn_layer._value_dense.bias, (-1,)
+        )
+
+        # Output
+        o_kernel = attn_layer._output_dense.kernel
+        o_kernel = ops.reshape(o_kernel, (-1, backbone.hidden_dim))
+        weights_map[f"model.layers.{i}.self_attn.o_proj.weight"] = (
+            ops.transpose(o_kernel)
+        )
+
+        # --- MLP (SwiGLU) ---
+        gate_kernel = decoder_layer._feedforward_gate_dense.kernel
+        weights_map[f"model.layers.{i}.mlp.gate_proj.weight"] = ops.transpose(
+            gate_kernel
+        )
+
+        up_kernel = decoder_layer._feedforward_intermediate_dense.kernel
+        weights_map[f"model.layers.{i}.mlp.up_proj.weight"] = ops.transpose(
+            up_kernel
+        )
+
+        down_kernel = decoder_layer._feedforward_output_dense.kernel
+        weights_map[f"model.layers.{i}.mlp.down_proj.weight"] = ops.transpose(
+            down_kernel
+        )
+
+    # Final Norm
+    weights_map["model.norm.weight"] = backbone.get_layer(
+        "sequence_output_layernorm"
+    ).scale
+
+    # LM Head
+    if include_lm_head:
+        if backbone.tie_word_embeddings:
+            weights_map["lm_head.weight"] = weights_map[
+                "model.embed_tokens.weight"
+            ]
+        else:
+            lm_head_w = backbone.get_layer("token_embedding").reverse_embeddings
+            weights_map["lm_head.weight"] = ops.transpose(lm_head_w)
+
+    return weights_map
+
+
+def get_qwen_tokenizer_config(tokenizer):
+    """Convert Keras Qwen tokenizer config to Hugging Face."""
+    return {
+        "tokenizer_class": "Qwen2Tokenizer",
+        "bos_token": None,
+        "eos_token": "<|endoftext|>",
+        "pad_token": "<|endoftext|>",
+        "unk_token": None,
+        "model_max_length": 32768,
+    }

keras_hub/src/utils/transformers/preset_loader.py

@@ -1,5 +1,7 @@
 """Convert huggingface models to KerasHub."""
 
+import inspect
+
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.utils.preset_utils import PresetLoader
 from keras_hub.src.utils.preset_utils import jax_memory_cleanup
@@ -23,6 +25,7 @@ from keras_hub.src.utils.transformers import convert_qwen
 from keras_hub.src.utils.transformers import convert_qwen3
 from keras_hub.src.utils.transformers import convert_qwen3_moe
 from keras_hub.src.utils.transformers import convert_qwen_moe
+from keras_hub.src.utils.transformers import convert_sam3
 from keras_hub.src.utils.transformers import convert_smollm3
 from keras_hub.src.utils.transformers import convert_t5gemma
 from keras_hub.src.utils.transformers import convert_vit
@@ -76,6 +79,8 @@ class TransformersPresetLoader(PresetLoader):
             self.converter = convert_qwen3_moe
         elif model_type == "qwen3":
             self.converter = convert_qwen3
+        elif model_type == "sam3_video":
+            self.converter = convert_sam3
         elif model_type == "smollm3":
             self.converter = convert_smollm3
         elif model_type == "t5gemma":
@@ -90,7 +95,16 @@ class TransformersPresetLoader(PresetLoader):
         return self.converter.backbone_cls
 
     def load_backbone(self, cls, load_weights, **kwargs):
-        keras_config = self.converter.convert_backbone_config(self.config)
+        convert_backbone_config_param_len = len(
+            inspect.signature(self.converter.convert_backbone_config).parameters
+        )
+        if convert_backbone_config_param_len != 1:
+            backbone_kwargs, kwargs = self.get_backbone_kwargs(**kwargs)
+            keras_config = self.converter.convert_backbone_config(
+                self.config, cls, **backbone_kwargs
+            )
+        else:
+            keras_config = self.converter.convert_backbone_config(self.config)
         backbone = cls(**{**keras_config, **kwargs})
         if load_weights:
             jax_memory_cleanup(backbone)

keras_hub/src/version.py

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

keras_hub/tokenizers/__init__.py

@@ -93,6 +93,12 @@ from keras_hub.src.models.roberta.roberta_tokenizer import (
 from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
     RoformerV2Tokenizer as RoformerV2Tokenizer,
 )
+from keras_hub.src.models.rwkv7.rwkv7_tokenizer import (
+    RWKVTokenizer as RWKVTokenizer,
+)
+from keras_hub.src.models.sam3.sam3_tokenizer import (
+    SAM3Tokenizer as SAM3Tokenizer,
+)
 from keras_hub.src.models.siglip.siglip_tokenizer import (
     SigLIPTokenizer as SigLIPTokenizer,
 )

{keras_hub-0.25.1.dist-info → keras_hub-0.26.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-hub
-Version: 0.25.1
+Version: 0.26.0.dev0
 Summary: Pretrained models for Keras.
 Author-email: Keras team <keras-users@googlegroups.com>
 License-Expression: Apache-2.0
@@ -8,7 +8,6 @@ Project-URL: Home, https://keras.io/keras_hub/
 Project-URL: Repository, https://github.com/keras-team/keras/keras_hub
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -18,9 +17,9 @@ Classifier: Operating System :: MacOS
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: keras>=3.8
+Requires-Dist: keras>=3.13
 Requires-Dist: absl-py
 Requires-Dist: numpy
 Requires-Dist: packaging
@@ -31,7 +30,8 @@ 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.10.0+-success.svg)
+![Python](https://img.shields.io/badge/python-v3.11.0+-success.svg)
+[![Kaggle Models](https://img.shields.io/badge/Kaggle-Models-brightgreen?colorA=0099ff)](https://www.kaggle.com/organizations/keras/models)
 [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/keras-team/keras-hub/issues)
 
 > [!IMPORTANT]
@@ -41,7 +41,7 @@ Requires-Dist: tensorflow-text; platform_system != "Windows"
 **KerasHub** is a pretrained modeling library that aims to be simple, flexible,
 and fast. The library provides [Keras 3](https://keras.io/keras_3/)
 implementations of popular model architectures, paired with a collection of
-pretrained checkpoints available on [Kaggle Models](https://kaggle.com/models/).
+pretrained checkpoints available on [Kaggle Models](https://www.kaggle.com/organizations/keras/models).
 Models can be used with text, image, and audio data for generation, classification,
 and many other built in tasks.
 
@@ -133,13 +133,6 @@ To install the latest KerasHub release with Keras 3, simply run:
 pip install --upgrade keras-hub
 ```
 
-Our text tokenizers are based on TensorFlow Text. Hence, if you are using any
-model which has language as a modality, you will have to run:
-
-```
-pip install --upgrade keras-hub[nlp]
-```
-
 To install the latest nightly changes for both KerasHub and Keras, you can use
 our nightly package.