keras-hub-nightly 0.24.0.dev202511090424__py3-none-any.whl → 0.24.0.dev202512090431__py3-none-any.whl

keras_hub/src/models/causal_lm.py

@@ -429,3 +429,25 @@ class CausalLM(Task):
         super()._post_quantize(mode, **kwargs)
         # Reset the compiled generate function.
         self.generate_function = None
+
+    def get_quantization_layer_structure(self, mode):
+        if mode != "gptq":
+            return None
+
+        backbone = self.backbone
+        # Check for standard backbone structure.
+        if not hasattr(backbone, "transformer_layers"):
+            return None
+
+        # Check for embedding.
+        embedding = getattr(backbone, "token_embedding", None)
+        if embedding is None:
+            embedding = getattr(backbone, "embedding", None)
+
+        if embedding is None:
+            return None
+
+        return {
+            "pre_block_layers": [embedding],
+            "sequential_blocks": backbone.transformer_layers,
+        }

keras_hub/src/models/dinov3/dinov3_presets.py

@@ -1,4 +1,93 @@
 """DINOV3 model preset configurations."""
 
 # Metadata for loading pretrained model weights.
-backbone_presets = {}
+backbone_presets = {
+    "dinov3_vit_small_lvd1689m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (small-sized model) trained on LVD-1689M "
+                "using DINOv3."
+            ),
+            "params": 21_600_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_small_lvd1689m/1",
+    },
+    "dinov3_vit_small_plus_lvd1689m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (small-plus-sized model) trained on "
+                "LVD-1689M using DINOv3."
+            ),
+            "params": 29_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_small_plus_lvd1689m/1",
+    },
+    "dinov3_vit_base_lvd1689m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (base-sized model) trained on LVD-1689M "
+                "using DINOv3."
+            ),
+            "params": 86_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_base_lvd1689m/1",
+    },
+    "dinov3_vit_large_lvd1689m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (large-sized model) trained on LVD-1689M "
+                "using DINOv3."
+            ),
+            "params": 300_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_large_lvd1689m/1",
+    },
+    "dinov3_vit_huge_plus_lvd1689m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (huge-plus-sized model) trained on "
+                "LVD-1689M using DINOv3."
+            ),
+            "params": 840_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_huge_plus_lvd1689m/1",
+    },
+    "dinov3_vit_7b_lvd1689m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (7B-sized model) trained on LVD-1689M "
+                "using DINOv3."
+            ),
+            "params": 6_700_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_7b_lvd1689m/1",
+    },
+    "dinov3_vit_large_sat493m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (large-sized model) trained on SAT-493M "
+                "using DINOv3."
+            ),
+            "params": 300_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_large_sat493m/1",
+    },
+    "dinov3_vit_7b_sat493m": {
+        "metadata": {
+            "description": (
+                "Vision Transformer (7B-sized model) trained on SAT-493M "
+                "using DINOv3."
+            ),
+            "params": 6_700_000_000,
+            "path": "dinov3",
+        },
+        "kaggle_handle": "kaggle://keras/dinov3/keras/dinov3_vit_7b_sat493m/1",
+    },
+}

keras_hub/src/models/esm/esm_attention.py

@@ -14,7 +14,8 @@ class ESMRotaryEmbedding(RotaryEmbedding):
         inv_freq = self.scaling_factor / (
             self.max_wavelength ** (ops.arange(0, dim, 2, dtype=x.dtype) / dim)
         )
-        t = ops.arange(x.shape[position], dtype=x.dtype)
+        # Use ops.shape for dynamic shape compatibility with TFLite
+        t = ops.arange(ops.shape(x)[position], dtype=x.dtype)
         freqs = ops.outer(t, inv_freq)
         emb = ops.concatenate((freqs, freqs), axis=-1)
 
@@ -32,11 +33,17 @@ class ESMRotaryEmbedding(RotaryEmbedding):
 
     def rotate_half(self, x):
         x1, x2 = ops.split(x, 2, -1)
-        return ops.concatenate((-x2, x1), axis=-1)
+        # Avoid `ops.concatenate` to prevent XLA compilation issues on JAX
+        # backend. Use stack + reshape approach from base RotaryEmbedding.
+        half_rot_x = ops.stack((-x2, x1), axis=-2)
+        half_rot_x = ops.reshape(half_rot_x, ops.shape(x))
+        return half_rot_x
 
     def apply_rotary_pos_emb(self, x, cos, sin):
-        cos = cos[:, : x.shape[1], :, :]
-        sin = sin[:, : x.shape[1], :, :]
+        # Use ops.shape for dynamic shape compatibility with TFLite
+        seq_len = ops.shape(x)[1]
+        cos = cos[:, :seq_len, :, :]
+        sin = sin[:, :seq_len, :, :]
 
         return (x * cos) + (self.rotate_half(x) * sin)
 

keras_hub/src/models/gemma/gemma_causal_lm.py

@@ -431,3 +431,19 @@ class GemmaCausalLM(CausalLM):
         )
         per_token_loss = per_token_loss_fn(target_ids, logits)
         return per_token_loss
+
+    def get_quantization_layer_structure(self, mode):
+        if mode != "gptq":
+            return None
+
+        # Wrap embedding + scaling
+        backbone = self.backbone
+        inputs = keras.Input(shape=(None,), dtype="int32")
+        x = backbone.token_embedding(inputs)
+        x = x * ops.cast(ops.sqrt(backbone.hidden_dim), x.dtype)
+        pre_processor = keras.Model(inputs=inputs, outputs=x)
+
+        return {
+            "pre_block_layers": [pre_processor],
+            "sequential_blocks": backbone.transformer_layers,
+        }

keras_hub/src/models/gemma3/gemma3_causal_lm_preprocessor.py

@@ -283,9 +283,14 @@ class Gemma3CausalLMPreprocessor(CausalLMPreprocessor):
         # is `None`.
         self.text_only_model = self.image_converter is None
 
-        self.image_placeholder = self.tokenizer.image_placeholder
-        self.start_of_image_token = self.tokenizer.start_of_image_token
-        self.end_of_image_token = self.tokenizer.end_of_image_token
+        if self.text_only_model:
+            self.image_placeholder = None
+            self.start_of_image_token = None
+            self.end_of_image_token = None
+        else:
+            self.image_placeholder = self.tokenizer.image_placeholder
+            self.start_of_image_token = self.tokenizer.start_of_image_token
+            self.end_of_image_token = self.tokenizer.end_of_image_token
 
     def build(self, input_shape):
         # Defer packer creation to `build()` so that we can be sure tokenizer

keras_hub/src/models/gemma3/gemma3_tokenizer.py

@@ -77,20 +77,32 @@ class Gemma3Tokenizer(SentencePieceTokenizer):
 
     backbone_cls = Gemma3Backbone
 
-    def __init__(self, proto, **kwargs):
+    def __init__(self, proto, has_vision_tokens=True, **kwargs):
         # Add special tokens.
 
+        self.has_vision_tokens = has_vision_tokens
         # The usual tokens.
         self._add_special_token("<bos>", "start_token")
         self._add_special_token("<eos>", "end_token")
         self._add_special_token("<pad>", "pad_token")
 
-        # Image placeholder token.
-        self._add_special_token("<img>", "image_placeholder")
-
-        #  Some tokens which are used in the preprocessor. We need to keep them
-        # here so that the preprocessor works with `tf.data`.
-        self._add_special_token("<start_of_image>", "start_of_image_token")
-        self._add_special_token("<end_of_image>", "end_of_image_token")
+        if has_vision_tokens:
+            # Image placeholder token.
+            self._add_special_token("<img>", "image_placeholder")
+            # Some tokens which are used in the preprocessor.
+            # We need to keep them
+            # here so that the preprocessor works with tf.data.
+            self._add_special_token("<start_of_image>", "start_of_image_token")
+            self._add_special_token("<end_of_image>", "end_of_image_token")
+        else:
+            # For text-only, skip assigning token IDs or set to -1
+            self.start_of_image_token_id = -1
+            self.image_placeholder_token_id = -1
+            self.end_of_image_token_id = -1
 
         super().__init__(proto=proto, **kwargs)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"has_vision_tokens": self.has_vision_tokens})
+        return config

keras_hub/src/models/gpt2/gpt2_causal_lm.py

@@ -420,3 +420,20 @@ class GPT2CausalLM(CausalLM):
         )
         per_token_loss = per_token_loss_fn(target_ids, logits)
         return per_token_loss
+
+    def get_quantization_layer_structure(self, mode):
+        if mode != "gptq":
+            return None
+
+        backbone = self.backbone
+        token_ids = keras.Input(shape=(None,), dtype="int32")
+        tokens = backbone.token_embedding(token_ids)
+        positions = backbone.position_embedding(tokens)
+        x = backbone.embeddings_add((tokens, positions))
+        x = backbone.embeddings_dropout(x)
+        pre_processor = keras.Model(inputs=token_ids, outputs=x)
+
+        return {
+            "pre_block_layers": [pre_processor],
+            "sequential_blocks": backbone.transformer_layers,
+        }

keras_hub/src/models/masked_lm.py

@@ -84,3 +84,25 @@ class MaskedLM(Task):
             weighted_metrics=weighted_metrics,
             **kwargs,
         )
+
+    def get_quantization_layer_structure(self, mode):
+        if mode != "gptq":
+            return None
+
+        backbone = self.backbone
+        # Check for standard backbone structure.
+        if not hasattr(backbone, "transformer_layers"):
+            return None
+
+        # Check for embedding.
+        embedding = getattr(backbone, "token_embedding", None)
+        if embedding is None:
+            embedding = getattr(backbone, "embedding", None)
+
+        if embedding is None:
+            return None
+
+        return {
+            "pre_block_layers": [embedding],
+            "sequential_blocks": backbone.transformer_layers,
+        }

keras_hub/src/models/qwen3/qwen3_presets.py

@@ -70,4 +70,40 @@ backbone_presets = {
         },
         "kaggle_handle": "kaggle://keras/qwen-3/keras/qwen3_32b_en/1",
     },
+    "qwen3_embedding_0.6b_en": {
+        "metadata": {
+            "description": (
+                "This text embedding model features a 32k context length and "
+                "offers flexible, user-defined embedding dimensions that can "
+                "range from 32 to 1024."
+            ),
+            "params": 595776512,
+            "path": "qwen3",
+        },
+        "kaggle_handle": "kaggle://keras/qwen-3-embedding/keras/qwen3_embedding_0.6b_en/1",
+    },
+    "qwen3_embedding_4b_en": {
+        "metadata": {
+            "description": (
+                "This text embedding model features a 32k context length and "
+                "offers flexible, user-defined embedding dimensions that can "
+                "range from 32 to 2560."
+            ),
+            "params": 4021774336,
+            "path": "qwen3",
+        },
+        "kaggle_handle": "kaggle://keras/qwen-3-embedding/keras/qwen3_embedding_4b_en/1",
+    },
+    "qwen3_embedding_8b_en": {
+        "metadata": {
+            "description": (
+                "This text embedding model features a 32k context length and "
+                "offers flexible, user-defined embedding dimensions that can "
+                "range from 32 to 4096."
+            ),
+            "params": 8188515328,
+            "path": "qwen3",
+        },
+        "kaggle_handle": "kaggle://keras/qwen-3-embedding/keras/qwen3_embedding_8b_en/1",
+    },
 }

keras_hub/src/models/smollm3/__init__.py

@@ -0,0 +1,5 @@
+from keras_hub.src.models.smollm3.smollm3_backbone import SmolLM3Backbone
+from keras_hub.src.models.smollm3.smollm3_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, SmolLM3Backbone)

keras_hub/src/models/smollm3/smollm3_presets.py

@@ -0,0 +1,16 @@
+"""SmolLM3 model preset configurations."""
+
+backbone_presets = {
+    "smollm3_3b_en": {
+        "metadata": {
+            "description": (
+                "Dense decoder-only model has 3 billion total parameters, "
+                "built on 36 layers and utilizes 16 query and "
+                "4 key/value attention heads."
+            ),
+            "params": 3075100928,
+            "path": "smollm3",
+        },
+        "kaggle_handle": "kaggle://keras/smollm3/keras/smollm3_3b_en/1",
+    },
+}

keras_hub/src/utils/transformers/convert_gemma3.py

@@ -0,0 +1,353 @@
+import numpy as np
+from sentencepiece import SentencePieceProcessor
+
+from keras_hub.src.models.gemma3.gemma3_backbone import Gemma3Backbone
+from keras_hub.src.models.gemma3.gemma3_vision_encoder import (
+    Gemma3VisionEncoder,
+)
+from keras_hub.src.utils.preset_utils import get_file
+from keras_hub.src.utils.preset_utils import load_json
+
+backbone_cls = Gemma3Backbone
+
+
+def load_image_converter_config(preset, transformers_config):
+    if "vision_config" in transformers_config:
+        preprocessor_config = load_json(preset, "preprocessor_config.json")
+        mean = preprocessor_config["image_mean"]
+        std = preprocessor_config["image_std"]
+        rescale_factor = preprocessor_config["rescale_factor"]
+        offset = [(-m / s) for m, s in zip(mean, std)]
+        scale = [(s * rescale_factor) for s in std]
+        image_size = transformers_config["vision_config"].get("image_size", 224)
+        return {
+            "image_size": (image_size, image_size),
+            "scale": scale,
+            "offset": offset,
+        }
+    else:
+        return None
+
+
+def convert_backbone_config(transformers_config):
+    if transformers_config["model_type"] == "gemma3_text":
+        image_size = None
+        vision_encoder = None
+        transformer_config = transformers_config
+    else:
+        vision_config = transformers_config["vision_config"]
+        image_size = vision_config["image_size"]
+        vision_encoder_config = {
+            "image_size": image_size,
+            "patch_size": vision_config["patch_size"],
+            "num_heads": vision_config["num_attention_heads"],
+            "hidden_dim": vision_config["hidden_size"],
+            "num_layers": vision_config["num_hidden_layers"],
+            "intermediate_dim": vision_config["intermediate_size"],
+            "output_dim": 2560,
+            "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"]
+    else:
+        rope_global_config = {}
+    return {
+        "vocabulary_size": transformer_config.get(
+            "vocab_size", 262144 if vision_encoder is None else 262208
+        ),
+        "image_size": image_size,
+        "num_layers": transformer_config["num_hidden_layers"],
+        "num_query_heads": transformer_config.get("num_attention_heads", 8),
+        "num_key_value_heads": transformer_config.get("num_key_value_heads", 4),
+        "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
+        ),
+        "final_logit_softcap": transformer_config.get(
+            "final_logit_softcap", 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
+        ),
+        "layer_norm_epsilon": transformer_config.get("rms_norm_eps", 1e-6),
+        "use_bidirectional_attention": transformer_config.get(
+            "use_bidirectional_attention", False
+        ),
+        "vision_encoder": vision_encoder,
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    if transformers_config["model_type"] == "gemma3_text":
+        prefix = "model"
+    else:
+        prefix = "language_model.model"
+
+    loader.port_weight(
+        keras_variable=backbone.get_layer("token_embedding").embeddings,
+        hf_weight_key=f"{prefix}.embed_tokens.weight",
+    )
+
+    def transpose(x, shape):
+        return np.transpose(x)
+
+    vision_encoder = backbone.vision_encoder
+    if vision_encoder is not None:
+        image_encoder = vision_encoder.get_layer("image_encoder")
+
+        loader.port_weight(
+            keras_variable=image_encoder.vision_embeddings.patch_embedding.kernel,
+            hf_weight_key="vision_tower.vision_model.embeddings.patch_embedding.weight",
+            hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+        )
+        loader.port_weight(
+            keras_variable=image_encoder.vision_embeddings.patch_embedding.bias,
+            hf_weight_key="vision_tower.vision_model.embeddings.patch_embedding.bias",
+        )
+
+        loader.port_weight(
+            keras_variable=image_encoder.vision_embeddings.position_embedding.embeddings,
+            hf_weight_key="vision_tower.vision_model.embeddings.position_embedding.weight",
+        )
+
+        for i in range(image_encoder.num_layers):
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].layer_norm_1.gamma,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.layer_norm1.weight",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].layer_norm_1.beta,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.layer_norm1.bias",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[
+                    i
+                ].attn.query_proj.kernel,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.q_proj.weight",
+                hook_fn=transpose,
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].attn.query_proj.bias,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.q_proj.bias",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].attn.key_proj.kernel,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.k_proj.weight",
+                hook_fn=transpose,
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].attn.key_proj.bias,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.k_proj.bias",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[
+                    i
+                ].attn.value_proj.kernel,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.v_proj.weight",
+                hook_fn=transpose,
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].attn.value_proj.bias,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.v_proj.bias",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].attn.out_proj.kernel,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.out_proj.weight",
+                hook_fn=transpose,
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].attn.out_proj.bias,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.self_attn.out_proj.bias",
+            )
+
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].layer_norm_2.gamma,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.layer_norm2.weight",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].layer_norm_2.beta,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.layer_norm2.bias",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].mlp_dense_1.kernel,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc1.weight",
+                hook_fn=transpose,
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].mlp_dense_1.bias,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc1.bias",
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].mlp_dense_2.kernel,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc2.weight",
+                hook_fn=transpose,
+            )
+            loader.port_weight(
+                keras_variable=image_encoder.resblocks[i].mlp_dense_2.bias,
+                hf_weight_key=f"vision_tower.vision_model.encoder.layers.{i}.mlp.fc2.bias",
+            )
+
+        loader.port_weight(
+            keras_variable=image_encoder.encoder_layer_norm.gamma,
+            hf_weight_key="vision_tower.vision_model.post_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=image_encoder.encoder_layer_norm.beta,
+            hf_weight_key="vision_tower.vision_model.post_layernorm.bias",
+        )
+
+        loader.port_weight(
+            keras_variable=vision_encoder.get_layer(
+                "vision_output_encoder"
+            ).vision_soft_embedding_norm.scale,
+            hf_weight_key="multi_modal_projector.mm_soft_emb_norm.weight",
+        )
+
+        loader.port_weight(
+            keras_variable=vision_encoder.get_layer(
+                "vision_output_encoder"
+            ).vision_input_projection.kernel,
+            hf_weight_key="multi_modal_projector.mm_input_projection_weight",
+        )
+
+    for i in range(backbone.num_layers):
+        decoder_layer = backbone.get_layer(f"decoder_block_{i}")
+
+        loader.port_weight(
+            keras_variable=decoder_layer.pre_attention_norm.scale,
+            hf_weight_key=f"{prefix}.layers.{i}.input_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.post_attention_norm.scale,
+            hf_weight_key=f"{prefix}.layers.{i}.post_attention_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.pre_ffw_norm.scale,
+            hf_weight_key=f"{prefix}.layers.{i}.pre_feedforward_layernorm.weight",
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.post_ffw_norm.scale,
+            hf_weight_key=f"{prefix}.layers.{i}.post_feedforward_layernorm.weight",
+        )
+
+        # Attention layers
+
+        ## Query
+        loader.port_weight(
+            keras_variable=decoder_layer.attention.query_dense.kernel,
+            hf_weight_key=f"{prefix}.layers.{i}.self_attn.q_proj.weight",
+            hook_fn=lambda hf_tensor, keras_shape: np.transpose(
+                np.reshape(
+                    hf_tensor,
+                    (keras_shape[0], keras_shape[2], keras_shape[1]),
+                ),
+                axes=(0, 2, 1),
+            ),
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.attention.query_norm.scale,
+            hf_weight_key=f"{prefix}.layers.{i}.self_attn.q_norm.weight",
+        )
+        ## Key
+        loader.port_weight(
+            keras_variable=decoder_layer.attention.key_dense.kernel,
+            hf_weight_key=f"{prefix}.layers.{i}.self_attn.k_proj.weight",
+            hook_fn=lambda hf_tensor, keras_shape: np.transpose(
+                np.reshape(
+                    hf_tensor,
+                    (keras_shape[0], keras_shape[2], keras_shape[1]),
+                ),
+                axes=(0, 2, 1),
+            ),
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer.attention.key_norm.scale,
+            hf_weight_key=f"{prefix}.layers.{i}.self_attn.k_norm.weight",
+        )
+        ## Value
+        loader.port_weight(
+            keras_variable=decoder_layer.attention.value_dense.kernel,
+            hf_weight_key=f"{prefix}.layers.{i}.self_attn.v_proj.weight",
+            hook_fn=lambda hf_tensor, keras_shape: np.transpose(
+                np.reshape(
+                    hf_tensor,
+                    (keras_shape[0], keras_shape[2], keras_shape[1]),
+                ),
+                axes=(0, 2, 1),
+            ),
+        )
+        ## Output
+        loader.port_weight(
+            keras_variable=decoder_layer.attention.output_dense.kernel,
+            hf_weight_key=f"{prefix}.layers.{i}.self_attn.o_proj.weight",
+            # rearrange_patterns="c (a b) -> a b c",
+            # rearrange_dims={"a": backbone.num_query_heads},
+            hook_fn=lambda hf_tensor, keras_shape: np.transpose(
+                np.reshape(
+                    hf_tensor,
+                    (keras_shape[2], keras_shape[0], keras_shape[1]),
+                ),
+                axes=(1, 2, 0),
+            ),
+        )
+
+        # MLP layers
+        loader.port_weight(
+            keras_variable=decoder_layer.gating_ffw.kernel,
+            hf_weight_key=f"{prefix}.layers.{i}.mlp.gate_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.gating_ffw_2.kernel,
+            hf_weight_key=f"{prefix}.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.ffw_linear.kernel,
+            hf_weight_key=f"{prefix}.layers.{i}.mlp.down_proj.weight",
+            # rearrange_patterns="b a -> a b",
+            hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+        )
+
+    # Final normalization layer
+    loader.port_weight(
+        keras_variable=backbone.get_layer("final_normalization").scale,
+        hf_weight_key=f"{prefix}.norm.weight",
+    )
+
+    return backbone
+
+
+def convert_tokenizer(cls, preset, **kwargs):
+    proto = get_file(preset, "tokenizer.model")
+    sp = SentencePieceProcessor()
+    if isinstance(proto, bytes):
+        sp.LoadFromSerializedProto(proto)
+    else:
+        sp.load(proto)
+
+    has_vision_tokens = (
+        sp.PieceToId("<start_of_image>") != sp.unk_id()
+        and sp.PieceToId("<img>") != sp.unk_id()
+        and sp.PieceToId("<end_of_image>") != sp.unk_id()
+    )
+
+    return cls(proto, has_vision_tokens=has_vision_tokens, **kwargs)

keras_hub/src/utils/transformers/preset_loader.py

@@ -12,6 +12,7 @@ from keras_hub.src.utils.transformers import convert_dinov3
 from keras_hub.src.utils.transformers import convert_distilbert
 from keras_hub.src.utils.transformers import convert_esm
 from keras_hub.src.utils.transformers import convert_gemma
+from keras_hub.src.utils.transformers import convert_gemma3
 from keras_hub.src.utils.transformers import convert_gpt2
 from keras_hub.src.utils.transformers import convert_llama3
 from keras_hub.src.utils.transformers import convert_mistral
@@ -49,6 +50,8 @@ class TransformersPresetLoader(PresetLoader):
             self.converter = convert_esm
         elif model_type in ("gemma", "gemma2"):
             self.converter = convert_gemma
+        elif model_type in ("gemma3", "gemma3_text"):
+            self.converter = convert_gemma3
         elif model_type == "gpt2":
             self.converter = convert_gpt2
         elif model_type == "llama":
@@ -115,5 +118,11 @@ class TransformersPresetLoader(PresetLoader):
         return self.converter.convert_tokenizer(cls, self.preset, **kwargs)
 
     def load_image_converter(self, cls, **kwargs):
+        if hasattr(self.converter, "load_image_converter_config"):
+            config = self.converter.load_image_converter_config(
+                self.preset, self.config
+            )
+            if config is not None:
+                return cls(**{**config, **kwargs})
         # TODO: set image size for pali gemma checkpoints.
         return None

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.24.0.dev202511090424"
+__version__ = "0.24.0.dev202512090431"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.24.0.dev202511090424.dist-info → keras_hub_nightly-0.24.0.dev202512090431.dist-info}/METADATA

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

{keras_hub_nightly-0.24.0.dev202511090424.dist-info → keras_hub_nightly-0.24.0.dev202512090431.dist-info}/RECORD

@@ -5,7 +5,7 @@ keras_hub/models/__init__.py,sha256=XGYkwfBVZiPw5ZjSV5S_n3FnkPf06yYNzxZjXMhiX70,
 keras_hub/samplers/__init__.py,sha256=aFQIkiqbZpi8vjrPp2MVII4QUfE-eQjra5fMeHsoy7k,886
 keras_hub/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/api_export.py,sha256=9pQZK27JObxWZ96QPLBp1OBsjWigh1iuV6RglPGMRk0,1499
-keras_hub/src/version.py,sha256=0oZ2eQ3pK7UNLgYg6OOna2ubpYCdPpH9WrlbvIq-QC0,222
+keras_hub/src/version.py,sha256=RwtmvWeWT3DYRT6L3ZzcKzMVzwl83RHUWlQ1KmiI2nM,222
 keras_hub/src/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/layers/modeling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras_hub/src/layers/modeling/alibi_bias.py,sha256=1XBTHI52L_iJDhN_w5ydu_iMhCuTgQAxEPwcLA6BPuk,4411
@@ -44,7 +44,7 @@ keras_hub/src/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 keras_hub/src/models/audio_to_text.py,sha256=XoOjXtKBX6K1fz-zOXcdVo3FpjuxCMnJZh2LQcYXb_0,2726
 keras_hub/src/models/audio_to_text_preprocessor.py,sha256=GS-WWyJ6aSsPRxi_0bxvxA00h2mT2FEwSdAoQXAUYVI,3249
 keras_hub/src/models/backbone.py,sha256=BdqPsne7lIITIxn6jY6AN4vZ-Rc9VnpqTxvVNR3CS7M,12210
-keras_hub/src/models/causal_lm.py,sha256=x86PTAzoBpAdJyenPRNNBAkazUjcRLr4wb2hMs5SrQ0,18344
+keras_hub/src/models/causal_lm.py,sha256=3WVFo9WAd4ZDu-62X98JMoUw1bqfTlVR0lQPb6vmr1g,18989
 keras_hub/src/models/causal_lm_preprocessor.py,sha256=nxl-sfmCfkfl6JmVRASa878QbaZUgWSA6Jdu48x4-dY,7155
 keras_hub/src/models/depth_estimator.py,sha256=JR7wtunOPrfEoDkLspoZnL2ItWhZFDeAxxw2vue5QLs,8992
 keras_hub/src/models/depth_estimator_preprocessor.py,sha256=2iE8NAUyiD2AvjZwNoXKUaOUogcE1fRzTNXLQ75GZpQ,2822
@@ -55,7 +55,7 @@ keras_hub/src/models/image_segmenter.py,sha256=C1bzIO59pG58iist5GLn_qnlotDpcAVxP
 keras_hub/src/models/image_segmenter_preprocessor.py,sha256=d7I2Hk0SKWyKpjRS6WYccmh_CYQBpWoj0JF5RRrU6rw,3748
 keras_hub/src/models/image_to_image.py,sha256=nblRd-16n5_JxKIH6IJU7bHTFRGxyCpKUilg6VjWuek,16933
 keras_hub/src/models/inpaint.py,sha256=oqdj0Q9dNG54g6sNQ5foto8saPd5Sx8kYZuHCZPBqrY,20995
-keras_hub/src/models/masked_lm.py,sha256=uXO_dE_hILlOC9jNr6oK6IHi9IGUqLyNGvr6nMt8Rk0,3576
+keras_hub/src/models/masked_lm.py,sha256=EPDHfMxyO_pciKuLooR6T5XYRcfvsqgfDXumXkA41No,4221
 keras_hub/src/models/masked_lm_preprocessor.py,sha256=g8vrnyYwqdnSw5xppROM1Gzo_jmMWKYZoQCsKdfrFKk,5656
 keras_hub/src/models/object_detector.py,sha256=oAK42fFBKuN0G_WM-DhygFkgQ0KsEwU_ZiU4umHywqc,3757
 keras_hub/src/models/object_detector_preprocessor.py,sha256=kOSVRNFAg-UjtrCEVBdHXUFyJy7kQtlVuGnZ1aLEfOk,2664
@@ -180,7 +180,7 @@ keras_hub/src/models/dinov3/__init__.py,sha256=AI7vTZJBG6Ygb48o6pXtHzxKk0Rek3p7-
 keras_hub/src/models/dinov3/dinov3_backbone.py,sha256=WDHipJSG10seRzYG_hARifF52wqhj9enkhuZ6mgJmjw,10511
 keras_hub/src/models/dinov3/dinov3_image_converter.py,sha256=_oHDcI2CoxjbSLxLfkK1zEPcf4Goy0S66igmrXt58cQ,342
 keras_hub/src/models/dinov3/dinov3_layers.py,sha256=w5K2btblrgrULqzPQdbvtkyR5Px2UZkqcZQ7jq2K3Uk,37169
-keras_hub/src/models/dinov3/dinov3_presets.py,sha256=AXXdrgrs9WBrsGlac0TgWV0DIPnvKdlxD3kUhbii1sk,114
+keras_hub/src/models/dinov3/dinov3_presets.py,sha256=oAAhMFbBMPmhtoDj3DMZz9zAG1DVSrf-xw0czoPwOEc,3148
 keras_hub/src/models/distil_bert/__init__.py,sha256=3Z0w-Mt3aOR0u9RGzjHQ7B3J3qBF2pGjupDGQ9yyzoc,303
 keras_hub/src/models/distil_bert/distil_bert_backbone.py,sha256=rnAf_GokB3wAeJwVZtgUKQO_bKJIa8RavhL_ykTJpNw,6440
 keras_hub/src/models/distil_bert/distil_bert_masked_lm.py,sha256=axeZd5UcxFr3_Q8H4yG10CINh93wbcyjlPLauqe5N9E,4289
@@ -203,7 +203,7 @@ keras_hub/src/models/electra/electra_backbone.py,sha256=h-QuFxACBvbMktkyGV2pIgn6
 keras_hub/src/models/electra/electra_presets.py,sha256=6f0WAYtDx5To4gvi6btN8I8y7yfc9ANchTHRKgCyIkg,2697
 keras_hub/src/models/electra/electra_tokenizer.py,sha256=Ll_EW-14i-OZr6appQEt5ceMUCeEadF4yPJHMwaRfVs,2729
 keras_hub/src/models/esm/__init__.py,sha256=_IlazeBwHkpetmLIZz3fFzC8CFcSnBRVQvw9nes4TN8,239
-keras_hub/src/models/esm/esm_attention.py,sha256=T21MVs9QDUe_8a53mcW3dJvJfaNZOg5lkMdxGhQdmFQ,3327
+keras_hub/src/models/esm/esm_attention.py,sha256=w74krK1xcsECGLS7v5MfABeW_4n5mexaqhosw6oGPnw,3729
 keras_hub/src/models/esm/esm_backbone.py,sha256=ADIpeiYz16fw1PNvx2tX-51HsZ_AjR2wGLkXZHErWBg,8696
 keras_hub/src/models/esm/esm_classifier.py,sha256=35-_3U725JhzspQAO_4ZkTJ0Tuy0XKMVkSrpmFz2CaE,6049
 keras_hub/src/models/esm/esm_classifier_preprocessor.py,sha256=TXjGH8ttElEsfBLOMLrxP24uPCYVS78iCrnpsGwurII,5532
@@ -238,7 +238,7 @@ keras_hub/src/models/flux/flux_text_to_image_preprocessor.py,sha256=2kI2vSZvTia5
 keras_hub/src/models/gemma/__init__.py,sha256=rVzOJMJ39bgVlT8UdC0t8PlN2c237GKTBmfHIsbPuOQ,251
 keras_hub/src/models/gemma/gemma_attention.py,sha256=wmU5FgQu1Ajg-KHKVXTLHWH7pXqN4_zVJTCp_FXMcAs,10095
 keras_hub/src/models/gemma/gemma_backbone.py,sha256=pAAVaVKB6nlA0PncVnFXvNgJV7SeZy_ko2AxoIs0jF0,13364
-keras_hub/src/models/gemma/gemma_causal_lm.py,sha256=3OXaIXlrKqMIuUnBk-bUz-0SYFL-XkkQTWm8qRY2YII,16770
+keras_hub/src/models/gemma/gemma_causal_lm.py,sha256=5sOXph25bfwlz-o4MYuWU1BN8yTcj5l0R-x6y0sFams,17315
 keras_hub/src/models/gemma/gemma_causal_lm_preprocessor.py,sha256=bpKkEurWIfa6Kp9s4pz84-sBDSA6ZFNHP8nXG1fFQrg,2912
 keras_hub/src/models/gemma/gemma_decoder_block.py,sha256=f5UsRO-VNsKJfm_WHVJWK4UahhzYm3sKprJ8jjr-zm4,7628
 keras_hub/src/models/gemma/gemma_presets.py,sha256=wAH7mjz9tbQqqdwajU2dilGytnWK1qc-aTIVLtjpTWg,8263
@@ -248,17 +248,17 @@ keras_hub/src/models/gemma3/__init__.py,sha256=oPFadkdK5DRLD6sYx83iTetY5daWuSzmJ
 keras_hub/src/models/gemma3/gemma3_attention.py,sha256=u3RNI8dva5lzzqFNTAe9996s87cNJ_GEWc9BIJD337Q,15473
 keras_hub/src/models/gemma3/gemma3_backbone.py,sha256=HdWDRuF9MMwIzNVZEd1j53ILzptskvCxFiO__nfVQYU,16686
 keras_hub/src/models/gemma3/gemma3_causal_lm.py,sha256=U3C9TWlIz8VefAxQ0wJ6bDz18wqHBie8B26Ub_nFZs4,13843
-keras_hub/src/models/gemma3/gemma3_causal_lm_preprocessor.py,sha256=vjt4N-zr0Eb5kvkOR-WUgskDTNe64L_6tYnhyNb6xaE,29601
+keras_hub/src/models/gemma3/gemma3_causal_lm_preprocessor.py,sha256=_gvKPoXqNXpXcsfc8L29wW50MToHIr2D-4Q6MNVfBU0,29790
 keras_hub/src/models/gemma3/gemma3_decoder_block.py,sha256=CYwYazqwakLNfhOLBl_8Q2TVZcMcOxMtiZtuVlk_hoo,11470
 keras_hub/src/models/gemma3/gemma3_image_converter.py,sha256=czi5JrTyKiK0nFzvonviBIX8jjvLHqvGNA9RyheB31k,536
 keras_hub/src/models/gemma3/gemma3_interleave_embeddings.py,sha256=CfYdudk5En9iU6vEnrcrEWIztloD1r8VzF2extqAhAM,4616
 keras_hub/src/models/gemma3/gemma3_presets.py,sha256=1GZSwsGRA19RllhZPR-kFjH5y9A6308V3TYfqHAnXUw,7744
-keras_hub/src/models/gemma3/gemma3_tokenizer.py,sha256=ZaBclFIwzJkSXDuZMBQLHUKV8RWEdZ_dsJMvMcc3qXw,3215
+keras_hub/src/models/gemma3/gemma3_tokenizer.py,sha256=7ZrWgSnXTnxbJVGdHPrz2rSJZhOkii0cxd5zvx4pY-0,3730
 keras_hub/src/models/gemma3/gemma3_vision_encoder.py,sha256=7XI0oBjIfJItV5w90t5bWb3C2KzjhvDnIC7wjIq4Cns,20850
 keras_hub/src/models/gemma3/rms_normalization.py,sha256=fku-JEo2sNy-ytX7ySD1sRzdhRAPmYex_z8oFk1NiG8,833
 keras_hub/src/models/gpt2/__init__.py,sha256=_hqeljpBkW8DLABy4nKBzJxXUh29WIEW27obmDCiH5Q,245
 keras_hub/src/models/gpt2/gpt2_backbone.py,sha256=H1LgDd-bavrWtdCavdI519qlaruE2Jj5H3-SMc-5d14,6961
-keras_hub/src/models/gpt2/gpt2_causal_lm.py,sha256=ynAcvh0-WUmwMN7vgflau4LH4YRFLf986OYRZ3M2Znk,16765
+keras_hub/src/models/gpt2/gpt2_causal_lm.py,sha256=i2veiYijPTsr6RqH5pR93uDw7rU9otQttdFBuVUxA80,17380
 keras_hub/src/models/gpt2/gpt2_causal_lm_preprocessor.py,sha256=3AD1LBFJ-u6bDdrwKa1LbINlEblZkhwB2sMJx-XEUZk,2992
 keras_hub/src/models/gpt2/gpt2_preprocessor.py,sha256=eYMIXw8Oebsr14GhqBh1CEhbLbIK3WnLUxaXj25fFpQ,3179
 keras_hub/src/models/gpt2/gpt2_presets.py,sha256=1mflR1dVuEwFfNe3Fkra6vt7DrjmkAckjyP-LclNLFc,1897
@@ -397,7 +397,7 @@ keras_hub/src/models/qwen3/qwen3_causal_lm.py,sha256=cn_4WFVxhlOArtIGAaqkNzIz9Rx
 keras_hub/src/models/qwen3/qwen3_causal_lm_preprocessor.py,sha256=H4g-bgvuhAUnDwjJovydK16Kes38ZFZWPvflrgHqZis,458
 keras_hub/src/models/qwen3/qwen3_decoder.py,sha256=68s9jQj53zFmXE4-SGXKYHu546fXOyi9LUbnKk-HGYY,11595
 keras_hub/src/models/qwen3/qwen3_layernorm.py,sha256=EJxjf7Pr6ufPQnNeuYQxkExzPjPk4PQxqMsoBeSEkDo,1073
-keras_hub/src/models/qwen3/qwen3_presets.py,sha256=eAqRbjLyRTSXcN-jnGHqoCHejKm2gmt8_zL4EPoE-JA,2518
+keras_hub/src/models/qwen3/qwen3_presets.py,sha256=3ml8rh9dmHCt_TP85xSmkoOxEd5cx5UJ1ts1yB5tTLo,3922
 keras_hub/src/models/qwen3/qwen3_tokenizer.py,sha256=LmPtg0vprMchDvYfTj8m5PraXI2QS3-YgdIIpIm5iAs,1448
 keras_hub/src/models/qwen3_moe/__init__.py,sha256=0jp5BHZ8O8cCrp4g6VWWDUwB5_fSDXvCVCSf6Q0UB6o,273
 keras_hub/src/models/qwen3_moe/qwen3_moe_attention.py,sha256=rZnzWA-cAhuWSuHSJfrNqf5_Cu0PNEe7PKbPNbhJdeM,13355
@@ -476,10 +476,12 @@ keras_hub/src/models/siglip/siglip_presets.py,sha256=jtIQrNcq14othG1QgwBEfozEmoH
 keras_hub/src/models/siglip/siglip_text_encoder.py,sha256=xOVvzyQHLX9ne30y4ussar99gNMXPXHYKlkbCX_On2Y,5380
 keras_hub/src/models/siglip/siglip_tokenizer.py,sha256=j_67JbIHJDRk-CbiemG2dgAO6lp3_0_JdnfroZ90G18,2579
 keras_hub/src/models/siglip/siglip_vision_encoder.py,sha256=CaNaFq5thBC3TUXXOf2qknk5vWsauM20ZoaDPYRnXcs,5927
+keras_hub/src/models/smollm3/__init__.py,sha256=_svUTRF_mnFqe2cPP03CASKbDes6FvI76y_3TEHaxes,263
 keras_hub/src/models/smollm3/smollm3_backbone.py,sha256=9e8ydwy7X0stVEWgIJYt69vt6JYSCiYpM73w6oLxyoQ,7949
 keras_hub/src/models/smollm3/smollm3_causal_lm.py,sha256=PWn2zPu0YS3uRvmjksmXKXpxehl8lvEHAXaO0u7nweM,12641
 keras_hub/src/models/smollm3/smollm3_causal_lm_preprocessor.py,sha256=gbj7IhDbgA30AM80uG6BeI1yZmGd5yQ2VEaPWWyS9M4,3121
 keras_hub/src/models/smollm3/smollm3_layers.py,sha256=lR33IynX-1G42L3hNzOBnnIx-INOzJguSQDAwIPaSIQ,26632
+keras_hub/src/models/smollm3/smollm3_presets.py,sha256=-DRT6uUEa3b7KFpgUmAToh-kXKfyGiNrxAMz-0R8R6E,499
 keras_hub/src/models/smollm3/smollm3_tokenizer.py,sha256=evOVM8pgZUkWLoXAwWiYRSNNFZ7KBv1WtFdLqpHdCQU,1877
 keras_hub/src/models/smollm3/smollm3_utils.py,sha256=zAqtZTv1G--k-Dbjvk886OcmsuIxyYicRiUQXcpyud0,1904
 keras_hub/src/models/stable_diffusion_3/__init__.py,sha256=ZKYQuaRObyhKq8GVAHmoRvlXp6FpU8ChvutVCHyXKuc,343
@@ -607,6 +609,7 @@ keras_hub/src/utils/transformers/convert_dinov3.py,sha256=rZqowTASKSAQQ1HrwlD9_t
 keras_hub/src/utils/transformers/convert_distilbert.py,sha256=SlfIRhSRk5c1ir2HGiDPiXa5XdOId_DbcnZO9lbwyZ8,6498
 keras_hub/src/utils/transformers/convert_esm.py,sha256=rOgGnNY37ZbYnoVC3L-Y-yGGAxTRmYtQV0nJoandH2Y,6214
 keras_hub/src/utils/transformers/convert_gemma.py,sha256=ElCgwBpSN5Q7rV5PJawTsoytPzs5ZjuwoY60YAe8y_A,6533
+keras_hub/src/utils/transformers/convert_gemma3.py,sha256=TKdZh40_xHWXd9vdp7TY2EnDFXMJ8pOWoUsmFwx5EgE,14680
 keras_hub/src/utils/transformers/convert_gpt2.py,sha256=HCeHN_-GiQJRxLCM9OCJJ1watPVpIBF8ujS8pGbBOWc,5703
 keras_hub/src/utils/transformers/convert_llama3.py,sha256=DjVUyQbl4AV-h8VqSIzmxiCd7cYOKIJTYoLM__NtyY0,6413
 keras_hub/src/utils/transformers/convert_mistral.py,sha256=kVhN9h1ZFVhwkNW8p3wnS7eANJUXIsNy1RxWXy20Gqw,4760
@@ -619,13 +622,13 @@ keras_hub/src/utils/transformers/convert_qwen_moe.py,sha256=a7R28aln-PdAcNuKAXdr
 keras_hub/src/utils/transformers/convert_smollm3.py,sha256=V2vWES85YSNXNx39I8OwAcOvSpb9KxUscrDr7ra-LPA,5281
 keras_hub/src/utils/transformers/convert_t5gemma.py,sha256=DPOwd61UhjspKuCsk3_EaNvSADGP_f8KLcZARHYVk5Y,9490
 keras_hub/src/utils/transformers/convert_vit.py,sha256=YAmXh519ecSgEO5B4g-aEQg1Bb_6ifFafLMqDTfLn_c,5259
-keras_hub/src/utils/transformers/preset_loader.py,sha256=alzuIEhDI6gLpEw05wPJVbOJ2LhwmLB_s7JhDqkb4ec,5364
+keras_hub/src/utils/transformers/preset_loader.py,sha256=h9Oaodlyri25Ipb44C5zvMJ15m9IRxrykYjxsFSJWto,5795
 keras_hub/src/utils/transformers/safetensor_utils.py,sha256=CYUHyA4y-B61r7NDnCsFb4t_UmSwZ1k9L-8gzEd6KRg,3339
 keras_hub/src/utils/transformers/export/gemma.py,sha256=xX_vfQwvFZ_-lQX4kgMNOGKL7fL_1yk7QyGYV2Qyly4,4699
 keras_hub/src/utils/transformers/export/hf_exporter.py,sha256=Qk52c6LIA2eMHUNY9Vy4STJSpnhLMdJ_t-3ljqhSr4k,5081
 keras_hub/tokenizers/__init__.py,sha256=XFOxDmM1Mz9TxiE8ICZK_-yTTyRFywUUiVwRIzz2QZ8,4770
 keras_hub/utils/__init__.py,sha256=jXPqVGBpJr_PpYmqD8aDG-fRMlxH-ulqCR2SZMn288Y,646
-keras_hub_nightly-0.24.0.dev202511090424.dist-info/METADATA,sha256=sQwmYQhujdR3LE7rPYvUYCmmx0jOFzEMRXOv3QqnASA,7395
-keras_hub_nightly-0.24.0.dev202511090424.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-keras_hub_nightly-0.24.0.dev202511090424.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
-keras_hub_nightly-0.24.0.dev202511090424.dist-info/RECORD,,
+keras_hub_nightly-0.24.0.dev202512090431.dist-info/METADATA,sha256=qqz7talwW8gweE-PoKMGj24qb4yQhFmC6Yk2ObRdJdw,7395
+keras_hub_nightly-0.24.0.dev202512090431.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+keras_hub_nightly-0.24.0.dev202512090431.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
+keras_hub_nightly-0.24.0.dev202512090431.dist-info/RECORD,,