keras-hub 0.22.1__py3-none-any.whl → 0.23.0.dev0__py3-none-any.whl

keras_hub/src/utils/transformers/convert_smollm3.py

@@ -0,0 +1,139 @@
+import numpy as np
+
+from keras_hub.src.models.smollm3.smollm3_backbone import SmolLM3Backbone
+from keras_hub.src.utils.preset_utils import load_json
+
+backbone_cls = SmolLM3Backbone
+
+
+def convert_backbone_config(transformers_config):
+    return {
+        "vocabulary_size": transformers_config["vocab_size"],
+        "hidden_dim": transformers_config["hidden_size"],
+        "num_layers": transformers_config["num_hidden_layers"],
+        "num_attention_heads": transformers_config["num_attention_heads"],
+        "num_key_value_heads": transformers_config["num_key_value_heads"],
+        "intermediate_dim": transformers_config["intermediate_size"],
+        "layer_norm_epsilon": transformers_config[
+            "rms_norm_eps"
+        ],  # Using rms_norm_eps as layer_norm_epsilon
+        "max_position_embeddings": transformers_config[
+            "max_position_embeddings"
+        ],
+        "rope_theta": transformers_config["rope_theta"],
+        # partial_rotary_factor is not explicitly in config.json
+        # but is inherited from the default value in the
+        # `_compute_default_rope_parameters()` function
+        "partial_rotary_factor": 1.0,
+        "attention_bias": transformers_config["attention_bias"],
+        "attention_dropout": transformers_config["attention_dropout"],
+        # Despite the name, no_rope_layers: 1 = HAS RoPE, 0 = NO RoPE
+        "rope_layer_enabled_list": [
+            bool(x) for x in transformers_config["no_rope_layers"]
+        ],
+        "layer_types": transformers_config["layer_types"],
+        "mlp_bias": transformers_config["mlp_bias"],
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    loader.port_weight(
+        keras_variable=backbone.get_layer("token_embedding").embeddings,
+        hf_weight_key="model.embed_tokens.weight",
+    )
+
+    def transpose_and_reshape(x, shape):
+        return np.reshape(np.transpose(x), shape)
+
+    for i in range(backbone.num_layers):
+        decoder_layer = backbone.get_layer(f"transformer_layer_{i}")
+
+        # Input layernorm
+        loader.port_weight(
+            keras_variable=decoder_layer.input_layernorm.scale,
+            hf_weight_key=f"model.layers.{i}.input_layernorm.weight",
+        )
+
+        # Attention layers
+        ## Query
+        loader.port_weight(
+            keras_variable=decoder_layer.self_attn.q_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.q_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Key
+        loader.port_weight(
+            keras_variable=decoder_layer.self_attn.k_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.k_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Value
+        loader.port_weight(
+            keras_variable=decoder_layer.self_attn.v_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.v_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Output
+        loader.port_weight(
+            keras_variable=decoder_layer.self_attn.o_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.o_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+
+        # MLP layers
+        loader.port_weight(
+            keras_variable=decoder_layer.mlp.up_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.mlp.up_proj.weight",
+            # rearrange_patterns="b a -> a b",
+            hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.mlp.down_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.mlp.down_proj.weight",
+            # rearrange_patterns="b a -> a b",
+            hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.mlp.gate_proj.kernel,
+            hf_weight_key=f"model.layers.{i}.mlp.gate_proj.weight",
+            # rearrange_patterns="b a -> a b",
+            hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+        )
+
+        # Feedforward layernorm
+        loader.port_weight(
+            keras_variable=decoder_layer.post_attention_layernorm.scale,
+            hf_weight_key=f"model.layers.{i}.post_attention_layernorm.weight",
+        )
+
+    # Final normalization layer
+    loader.port_weight(
+        keras_variable=backbone.get_layer("sequence_output_layernorm").scale,
+        hf_weight_key="model.norm.weight",
+    )
+
+    backbone.training = False
+
+    return backbone
+
+
+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]
+
+    # Load all special tokens with the exception of "reserved" ones.
+    special_tokens = set()
+    for token in tokenizer_config["added_tokens"]:
+        if not token["content"].startswith("<|reserved_special_token_"):
+            vocab[token["content"]] = token["id"]
+            special_tokens.add(token["content"])
+
+    kwargs.update(
+        {
+            "unsplittable_tokens": list(special_tokens),
+        }
+    )
+
+    return cls(vocabulary=vocab, merges=merges, **kwargs)

keras_hub/src/utils/transformers/convert_t5gemma.py

@@ -0,0 +1,229 @@
+from keras_hub.src.models.t5gemma.t5gemma_backbone import T5GemmaBackbone
+from keras_hub.src.utils.preset_utils import get_file
+
+backbone_cls = T5GemmaBackbone
+
+
+def convert_backbone_config(transformers_config):
+    """Convert a Hugging Face T5Gemma config to a KerasHub backbone config."""
+    encoder_config = transformers_config["encoder"]
+    decoder_config = transformers_config["decoder"]
+
+    if decoder_config.get("hidden_activation") == "gelu_pytorch_tanh":
+        decoder_config["hidden_activation"] = "gelu_approximate"
+    if encoder_config.get("hidden_activation") == "gelu_pytorch_tanh":
+        encoder_config["hidden_activation"] = "gelu_approximate"
+
+    backbone_config = {
+        "vocabulary_size": decoder_config["vocab_size"],
+        "encoder_hidden_dim": encoder_config["hidden_size"],
+        "encoder_intermediate_dim": encoder_config["intermediate_size"],
+        "encoder_num_layers": encoder_config["num_hidden_layers"],
+        "encoder_num_attention_heads": encoder_config["num_attention_heads"],
+        "encoder_num_key_value_heads": encoder_config["num_key_value_heads"],
+        "encoder_head_dim": encoder_config["head_dim"],
+        "encoder_layer_types": encoder_config["layer_types"],
+        "decoder_hidden_dim": decoder_config["hidden_size"],
+        "decoder_intermediate_dim": decoder_config["intermediate_size"],
+        "decoder_num_layers": decoder_config["num_hidden_layers"],
+        "decoder_num_attention_heads": decoder_config["num_attention_heads"],
+        "decoder_num_key_value_heads": decoder_config["num_key_value_heads"],
+        "decoder_head_dim": decoder_config["head_dim"],
+        "decoder_layer_types": decoder_config["layer_types"],
+        "dropout_rate": decoder_config["dropout_rate"],
+        "rms_norm_eps": decoder_config["rms_norm_eps"],
+        "query_pre_attn_scalar": decoder_config["query_pre_attn_scalar"],
+        "tie_word_embeddings": transformers_config.get(
+            "tie_word_embeddings", True
+        ),
+        "attention_bias": decoder_config["attention_bias"],
+        "hidden_activation": decoder_config["hidden_activation"],
+        "initializer_range": decoder_config["initializer_range"],
+        "attention_dropout": decoder_config["attention_dropout"],
+        "sliding_window": decoder_config["sliding_window"],
+        "cross_attention_hidden_size": encoder_config["hidden_size"],
+        "attn_logit_softcapping": decoder_config["attn_logit_softcapping"],
+        "final_logit_softcapping": decoder_config["final_logit_softcapping"],
+        "rope_max_wavelength": decoder_config["rope_theta"],
+    }
+    return backbone_config
+
+
+def convert_weights(backbone, loader, transformers_config):
+    """Convert T5Gemma from Hugging Face to KerasHub."""
+    # Token embeddings.
+    loader.port_weight(
+        keras_variable=backbone.token_embedding.embeddings,
+        hf_weight_key="encoder.embed_tokens.weight",
+    )
+    loader.port_weight(
+        keras_variable=backbone.decoder_token_embedding.embeddings,
+        hf_weight_key="decoder.embed_tokens.weight",
+    )
+
+    # Encoder.
+    loader.port_weight(
+        keras_variable=backbone.encoder_norm.scale,
+        hf_weight_key="encoder.norm.weight",
+    )
+    for i in range(backbone.encoder_num_layers):
+        layer = backbone.get_layer(f"encoder_layer_{i}")
+        hf_prefix = f"encoder.layers.{i}"
+
+        # Self-attention.
+        loader.port_weight(
+            keras_variable=layer.self_attn.query_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.q_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.self_attn.key_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.k_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.self_attn.value_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.v_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.self_attn.output_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.o_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+
+        # MLP.
+        loader.port_weight(
+            keras_variable=layer.mlp.gate_proj.kernel,
+            hf_weight_key=f"{hf_prefix}.mlp.gate_proj.weight",
+            hook_fn=lambda w, s: w.T,
+        )
+        loader.port_weight(
+            keras_variable=layer.mlp.up_proj.kernel,
+            hf_weight_key=f"{hf_prefix}.mlp.up_proj.weight",
+            hook_fn=lambda w, s: w.T,
+        )
+        loader.port_weight(
+            keras_variable=layer.mlp.down_proj.kernel,
+            hf_weight_key=f"{hf_prefix}.mlp.down_proj.weight",
+            hook_fn=lambda w, s: w.T,
+        )
+
+        # Layer norm.
+        loader.port_weight(
+            keras_variable=layer.pre_self_attn_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.pre_self_attn_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.post_self_attn_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.post_self_attn_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.pre_feedforward_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.pre_feedforward_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.post_feedforward_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.post_feedforward_layernorm.weight",
+        )
+
+    # Decoder.
+    loader.port_weight(
+        keras_variable=backbone.decoder_norm.scale,
+        hf_weight_key="decoder.norm.weight",
+    )
+    for i in range(backbone.decoder_num_layers):
+        layer = backbone.get_layer(f"decoder_layer_{i}")
+        hf_prefix = f"decoder.layers.{i}"
+
+        # Self-attention.
+        loader.port_weight(
+            keras_variable=layer.self_attn.query_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.q_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.self_attn.key_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.k_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.self_attn.value_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.v_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.self_attn.output_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.self_attn.o_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+
+        # Cross-attention.
+        loader.port_weight(
+            keras_variable=layer.cross_attn.query_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.cross_attn.q_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.cross_attn.key_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.cross_attn.k_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.cross_attn.value_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.cross_attn.v_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+        loader.port_weight(
+            keras_variable=layer.cross_attn.output_dense.kernel,
+            hf_weight_key=f"{hf_prefix}.cross_attn.o_proj.weight",
+            hook_fn=lambda w, s: w.T.reshape(s),
+        )
+
+        # MLP.
+        loader.port_weight(
+            keras_variable=layer.mlp.gate_proj.kernel,
+            hf_weight_key=f"{hf_prefix}.mlp.gate_proj.weight",
+            hook_fn=lambda w, s: w.T,
+        )
+        loader.port_weight(
+            keras_variable=layer.mlp.up_proj.kernel,
+            hf_weight_key=f"{hf_prefix}.mlp.up_proj.weight",
+            hook_fn=lambda w, s: w.T,
+        )
+        loader.port_weight(
+            keras_variable=layer.mlp.down_proj.kernel,
+            hf_weight_key=f"{hf_prefix}.mlp.down_proj.weight",
+            hook_fn=lambda w, s: w.T,
+        )
+
+        # Layer norm.
+        loader.port_weight(
+            keras_variable=layer.pre_self_attn_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.pre_self_attn_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.post_self_attn_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.post_self_attn_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.pre_cross_attn_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.pre_cross_attn_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.post_cross_attn_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.post_cross_attn_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.pre_feedforward_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.pre_feedforward_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=layer.post_feedforward_layernorm.scale,
+            hf_weight_key=f"{hf_prefix}.post_feedforward_layernorm.weight",
+        )
+
+
+def convert_tokenizer(cls, preset, **kwargs):
+    """Convert a T5Gemma tokenizer."""
+    return cls(get_file(preset, "tokenizer.model"), **kwargs)

keras_hub/src/utils/transformers/convert_vit.py

@@ -9,7 +9,10 @@ def convert_backbone_config(transformers_config):
     image_size = transformers_config["image_size"]
     return {
         "image_shape": (image_size, image_size, 3),
-        "patch_size": transformers_config["patch_size"],
+        "patch_size": (
+            transformers_config["patch_size"],
+            transformers_config["patch_size"],
+        ),
         "num_layers": transformers_config["num_hidden_layers"],
         "num_heads": transformers_config["num_attention_heads"],
         "hidden_dim": transformers_config["hidden_size"],

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

@@ -2,6 +2,7 @@ import keras.ops as ops
 
 
 def get_gemma_config(backbone):
+    token_embedding_layer = backbone.get_layer("token_embedding")
     hf_config = {
         "vocab_size": backbone.vocabulary_size,
         "num_hidden_layers": backbone.num_layers,
@@ -11,11 +12,16 @@ def get_gemma_config(backbone):
         "intermediate_size": backbone.intermediate_dim // 2,
         "head_dim": backbone.head_dim,
         "max_position_embeddings": 8192,
+        "tie_word_embeddings": token_embedding_layer.tie_weights,
+        "pad_token_id": 0,
+        "bos_token_id": 2,
+        "eos_token_id": 1,
+        "model_type": "gemma",
     }
     return hf_config
 
 
-def get_gemma_weights_map(backbone):
+def get_gemma_weights_map(backbone, include_lm_head=False):
     weights_dict = {}
 
     # Map token embedding
@@ -83,7 +89,46 @@ def get_gemma_weights_map(backbone):
         "final_normalization"
     ).weights[0]
 
-    # Tie weights, but clone to avoid sharing memory issues
-    weights_dict["lm_head.weight"] = ops.copy(token_embedding_layer.weights[0])
-
+    # Map lm_head if embeddings are not tied
+    if include_lm_head and not token_embedding_layer.tie_weights:
+        weights_dict["lm_head.weight"] = ops.transpose(
+            token_embedding_layer.reverse_embeddings
+        )
     return weights_dict
+
+
+def get_gemma_tokenizer_config(tokenizer):
+    tokenizer_config = {
+        "tokenizer_class": "GemmaTokenizer",
+        "clean_up_tokenization_spaces": False,
+        "bos_token": "<bos>",
+        "eos_token": "<eos>",
+        "pad_token": "<pad>",
+        "unk_token": "<unk>",
+        "add_bos_token": True,
+        "add_eos_token": False,
+        "model_max_length": 8192,
+    }
+    # Add added_tokens_decoder
+    added_tokens_decoder = {}
+    special_tokens = [
+        "<pad>",
+        "<bos>",
+        "<eos>",
+        "<unk>",
+        "<start_of_turn>",
+        "<end_of_turn>",
+    ]
+    for token in special_tokens:
+        token_id = tokenizer.token_to_id(token)
+        if token_id is not None:
+            added_tokens_decoder[str(token_id)] = {
+                "content": token,
+                "special": True,
+                "single_word": False,
+                "lstrip": False,
+                "rstrip": False,
+                "normalized": False,
+            }
+    tokenizer_config["added_tokens_decoder"] = added_tokens_decoder
+    return tokenizer_config

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

@@ -6,58 +6,59 @@ import warnings
 import keras
 
 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
 
 MODEL_CONFIGS = {
     "GemmaBackbone": get_gemma_config,
-    # Add future models here, e.g., "LlamaBackbone": get_llama_config,
+    # Add for future models, e.g., "MistralBackbone": get_mistral_config
 }
 
 MODEL_EXPORTERS = {
     "GemmaBackbone": get_gemma_weights_map,
-    # Add future models here, e.g., "LlamaBackbone": get_llama_weights_map,
+    # Add for future models, e.g., "MistralBackbone": get_mistral_weights_map
 }
 
+MODEL_TOKENIZER_CONFIGS = {
+    "GemmaTokenizer": get_gemma_tokenizer_config,
+    # Add for future models, e.g., "MistralTokenizer":
+    # get_mistral_tokenizer_config
+}
 
-def export_to_safetensors(keras_model, path):
-    """Converts a Keras model to Hugging Face safetensor format.
 
-    It does the following:
-    - Extracts and maps weights from the Keras backbone to safetensors.
-    - Saves the configuration as 'config.json'.
-    - Saves weights in 'model.safetensors'.
-    - Saves tokenizer assets.
+def export_backbone(backbone, path, include_lm_head=False):
+    """Export the backbone model to HuggingFace format.
 
     Args:
-        keras_model: The Keras model to convert.
-        path: str. Path of the directory to which the safetensors file,
-          config and tokenizer will be saved.
+        backbone: The Keras backbone model to convert.
+        path: str. Path to save the exported model.
+        include_lm_head: bool. If True, include lm_head weights if applicable.
     """
     backend = keras.config.backend()
-    backbone = keras_model.backbone
     model_type = backbone.__class__.__name__
-
     if model_type not in MODEL_CONFIGS:
-        raise ValueError(f"Config not implemented for {model_type}")
-
+        raise ValueError(
+            f"Export to Transformers format not implemented for {model_type}"
+        )
     if model_type not in MODEL_EXPORTERS:
-        raise ValueError(f"Exporter not implemented for {model_type}")
-
+        raise ValueError(
+            f"Export to Transformers format not implemented for {model_type}"
+        )
+    # Get config
     get_config_fn = MODEL_CONFIGS[model_type]
     hf_config = get_config_fn(backbone)
-
+    # Get weights
     get_weights_fn = MODEL_EXPORTERS[model_type]
-    weights_dict = get_weights_fn(backbone)
-
+    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")
     with open(config_path, "w") as f:
         json.dump(hf_config, f)
-
     # Save weights based on backend
     weights_path = os.path.join(path, "model.safetensors")
     if backend == "torch":
@@ -81,9 +82,28 @@ def export_to_safetensors(keras_model, path):
     else:
         raise ValueError(f"Unsupported backend: {backend}")
 
-    # Save tokenizer assets
-    keras_model.preprocessor.tokenizer.save_assets(path)
 
+def export_tokenizer(tokenizer, path):
+    """Export only the tokenizer to HuggingFace Transformers format.
+
+    Args:
+        tokenizer: The Keras tokenizer to convert.
+        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}"
+        )
+    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")
@@ -96,3 +116,29 @@ def export_to_safetensors(keras_model, path):
             "is correct and that the vocabulary file is present "
             "in the original model."
         )
+
+
+def export_to_safetensors(keras_model, path):
+    """Converts a Keras model to Hugging Face Transformers format.
+
+    It does the following:
+    - Exports the backbone (config and weights).
+    - Exports the tokenizer assets.
+
+    Args:
+        keras_model: The Keras model to convert.
+        path: str. Path of the directory to which the safetensors file,
+          config and tokenizer will be saved.
+    """
+    backbone = keras_model.backbone
+    export_backbone(backbone, path, include_lm_head=True)
+    if (
+        keras_model.preprocessor is not None
+        and keras_model.preprocessor.tokenizer is None
+    ):
+        raise ValueError(
+            "CausalLM preprocessor must have a tokenizer for export "
+            "if attached."
+        )
+    if keras_model.preprocessor is not None:
+        export_tokenizer(keras_model.preprocessor.tokenizer, path)

keras_hub/src/utils/transformers/preset_loader.py

@@ -18,7 +18,10 @@ from keras_hub.src.utils.transformers import convert_mixtral
 from keras_hub.src.utils.transformers import convert_pali_gemma
 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_smollm3
+from keras_hub.src.utils.transformers import convert_t5gemma
 from keras_hub.src.utils.transformers import convert_vit
 from keras_hub.src.utils.transformers.safetensor_utils import SafetensorLoader
 
@@ -60,8 +63,14 @@ class TransformersPresetLoader(PresetLoader):
             self.converter = convert_mixtral
         elif model_type == "qwen2_moe":
             self.converter = convert_qwen_moe
+        elif model_type == "qwen3_moe":
+            self.converter = convert_qwen3_moe
         elif model_type == "qwen3":
             self.converter = convert_qwen3
+        elif model_type == "smollm3":
+            self.converter = convert_smollm3
+        elif model_type == "t5gemma":
+            self.converter = convert_t5gemma
         else:
             raise ValueError(
                 "KerasHub has no converter for huggingface/transformers models "

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.22.1"
+__version__ = "0.23.0.dev0"
 
 
 @keras_hub_export("keras_hub.version")

keras_hub/tokenizers/__init__.py

@@ -66,6 +66,9 @@ from keras_hub.src.models.opt.opt_tokenizer import OPTTokenizer as OPTTokenizer
 from keras_hub.src.models.pali_gemma.pali_gemma_tokenizer import (
     PaliGemmaTokenizer as PaliGemmaTokenizer,
 )
+from keras_hub.src.models.parseq.parseq_tokenizer import (
+    PARSeqTokenizer as PARSeqTokenizer,
+)
 from keras_hub.src.models.phi3.phi3_tokenizer import (
     Phi3Tokenizer as Phi3Tokenizer,
 )
@@ -75,6 +78,9 @@ 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_moe.qwen3_moe_tokenizer import (
+    Qwen3MoeTokenizer as Qwen3MoeTokenizer,
+)
 from keras_hub.src.models.qwen_moe.qwen_moe_tokenizer import (
     QwenMoeTokenizer as QwenMoeTokenizer,
 )
@@ -87,7 +93,16 @@ from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
 from keras_hub.src.models.siglip.siglip_tokenizer import (
     SigLIPTokenizer as SigLIPTokenizer,
 )
+from keras_hub.src.models.smollm3.smollm3_tokenizer import (
+    SmolLM3Tokenizer as SmolLM3Tokenizer,
+)
+from keras_hub.src.models.smollm3.smollm3_tokenizer import (
+    SmolLM3Tokenizer as SmolLMTokenizer,
+)
 from keras_hub.src.models.t5.t5_tokenizer import T5Tokenizer as T5Tokenizer
+from keras_hub.src.models.t5gemma.t5gemma_tokenizer import (
+    T5GemmaTokenizer as T5GemmaTokenizer,
+)
 from keras_hub.src.models.whisper.whisper_tokenizer import (
     WhisperTokenizer as WhisperTokenizer,
 )

{keras_hub-0.22.1.dist-info → keras_hub-0.23.0.dev0.dist-info}/METADATA

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