keras-hub-nightly 0.23.0.dev202510080414__py3-none-any.whl → 0.24.0.dev202511080419__py3-none-any.whl

keras_hub/src/models/smollm3/smollm3_tokenizer.py

@@ -0,0 +1,60 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.smollm3.smollm3_backbone import SmolLM3Backbone
+from keras_hub.src.tokenizers.byte_pair_tokenizer import BytePairTokenizer
+
+
+@keras_hub_export(
+    [
+        "keras_hub.tokenizers.SmolLM3Tokenizer",
+        "keras_hub.tokenizers.SmolLMTokenizer",
+        "keras_hub.models.SmolLM3Tokenizer",
+        "keras_hub.models.SmolLMTokenizer",
+    ]
+)
+class SmolLM3Tokenizer(BytePairTokenizer):
+    """Tokenizer for SmolLM3 models.
+
+    This tokenizer implements byte-pair encoding (BPE) for SmolLM3 models,
+    handling special tokens like BOS (beginning of sequence) and EOS (end of
+    sequence).
+
+    Args:
+        vocabulary: Dictionary mapping tokens to token IDs, or path to
+            vocabulary file.
+        merges: List of BPE merges, or path to merges file.
+        bos_token: Beginning of sequence token. Defaults to None.
+        eos_token: End of sequence token. Defaults to "<|endoftext|>".
+        misc_special_tokens: Set of additional special tokens. Defaults to
+            empty set.
+    """
+
+    backbone_cls = SmolLM3Backbone
+
+    def __init__(
+        self,
+        vocabulary=None,
+        merges=None,
+        **kwargs,
+    ):
+        # Add EOS token
+        eos_token = "<|end_of_text|>"
+        self._add_special_token(eos_token, "end_token")
+
+        bos_token = "<|begin_of_text|>"
+        self._add_special_token(bos_token, "bos_token")
+
+        start_think_token = "<think>"
+        self._add_special_token(start_think_token, "start_think_token")
+
+        end_think_token = "</think>"
+        self._add_special_token(end_think_token, "end_think_token")
+
+        self.start_token_id = None
+        self.start_token = None
+        self.pad_token_id = 0
+
+        super().__init__(
+            vocabulary=vocabulary,
+            merges=merges,
+            **kwargs,
+        )

keras_hub/src/models/smollm3/smollm3_utils.py

@@ -0,0 +1,56 @@
+from keras import ops
+
+
+def rotate_half(x):
+    x1 = x[..., : ops.shape(x)[-1] // 2]
+    x2 = x[..., ops.shape(x)[-1] // 2 :]
+    return ops.concatenate((-x2, x1), axis=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin, expansion_axis=1):
+    cos = ops.expand_dims(cos, expansion_axis)
+    sin = ops.expand_dims(sin, expansion_axis)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+def apply_rotary_pos_single(tensor, cos, sin, expansion_axis=1):
+    cos = ops.expand_dims(cos, expansion_axis)
+    sin = ops.expand_dims(sin, expansion_axis)
+    tensor_embed = (tensor * cos) + (rotate_half(tensor) * sin)
+    return tensor_embed
+
+
+def repeat_kv(hidden_states, n_rep):
+    batch, num_key_value_heads, slen, head_dim = ops.shape(hidden_states)
+    if n_rep == 1:
+        return hidden_states
+    hidden_states = ops.expand_dims(hidden_states, axis=2)
+    target_shape = (batch, num_key_value_heads, n_rep, slen, head_dim)
+    hidden_states = ops.broadcast_to(hidden_states, target_shape)
+    return ops.reshape(
+        hidden_states, [batch, num_key_value_heads * n_rep, slen, head_dim]
+    )
+
+
+def rope_init(rope_theta, partial_rotary_factor, head_dim):
+    """Initialize RoPE (Rotary Position Embedding) parameters.
+
+    Args:
+        rope_theta: float. The theta value for RoPE.
+        partial_rotary_factor: float. The factor for partial rotary embedding.
+        head_dim: int. The dimension of each attention head.
+
+    Returns:
+        A tuple of (inv_freq, attention_scaling) where inv_freq is the inverse
+        frequency tensor and attention_scaling is the scaling factor.
+    """
+    base = rope_theta
+    dim = int(head_dim * partial_rotary_factor)
+
+    inv_freq = 1.0 / (
+        ops.power(base, ops.arange(0, dim, 2, dtype="float32") / dim)
+    )
+    attention_scaling = 1.0
+    return inv_freq, attention_scaling

keras_hub/src/models/stable_diffusion_3/stable_diffusion_3_presets.py

@@ -11,7 +11,7 @@ backbone_presets = {
             "params": 2987080931,
             "path": "stable_diffusion_3",
         },
-        "kaggle_handle": "kaggle://keras/stablediffusion3/keras/stable_diffusion_3_medium/4",
+        "kaggle_handle": "kaggle://keras/stablediffusion3/keras/stable_diffusion_3_medium/5",
     },
     "stable_diffusion_3.5_medium": {
         "metadata": {
@@ -35,7 +35,7 @@ backbone_presets = {
             "params": 9048410595,
             "path": "stable_diffusion_3",
         },
-        "kaggle_handle": "kaggle://keras/stablediffusion-3.5/keras/stable_diffusion_3.5_large/2",
+        "kaggle_handle": "kaggle://keras/stablediffusion-3.5/keras/stable_diffusion_3.5_large/3",
     },
     "stable_diffusion_3.5_large_turbo": {
         "metadata": {
@@ -49,6 +49,6 @@ backbone_presets = {
             "params": 9048410595,
             "path": "stable_diffusion_3",
         },
-        "kaggle_handle": "kaggle://keras/stablediffusion-3.5/keras/stable_diffusion_3.5_large_turbo/2",
+        "kaggle_handle": "kaggle://keras/stablediffusion-3.5/keras/stable_diffusion_3.5_large_turbo/3",
     },
 }

keras_hub/src/models/text_to_image.py

@@ -345,3 +345,8 @@ class TextToImage(Task):
         # Text-to-image.
         outputs = [generate(x) for x in inputs]
         return self._normalize_generate_outputs(outputs, input_is_scalar)
+
+    def _post_quantize(self, mode, **kwargs):
+        super()._post_quantize(mode, **kwargs)
+        # Reset the compiled generate function.
+        self.generate_function = None

keras_hub/src/utils/preset_utils.py

@@ -502,10 +502,17 @@ def jax_memory_cleanup(layer):
     # For jax, delete all previous allocated memory to avoid temporarily
     # duplicating variable allocations. torch and tensorflow have stateful
     # variable types and do not need this fix.
+    # Skip deletion for sharded arrays to avoid breaking references in
+    # distributed setups.
     if keras.config.backend() == "jax":
         for weight in layer.weights:
-            if getattr(weight, "_value", None) is not None:
-                weight._value.delete()
+            if weight._value is not None:
+                # Do not delete sharded arrays, as they may be referenced in
+                # JAX's distributed computation graph and deletion can cause
+                # errors.
+                sharding = getattr(weight._value, "sharding", None)
+                if sharding is None:
+                    weight._value.delete()
 
 
 def set_dtype_in_config(config, dtype=None):

keras_hub/src/utils/tensor_utils.py

@@ -12,9 +12,11 @@ from packaging import version
 
 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
 
 

keras_hub/src/utils/timm/convert_mobilenetv5.py

@@ -0,0 +1,321 @@
+import types
+
+import keras
+import numpy as np
+
+from keras_hub.src.models.mobilenetv5.mobilenetv5_attention import (
+    MobileAttention,
+)
+from keras_hub.src.models.mobilenetv5.mobilenetv5_backbone import (
+    MobileNetV5Backbone,
+)
+from keras_hub.src.models.mobilenetv5.mobilenetv5_blocks import EdgeResidual
+from keras_hub.src.models.mobilenetv5.mobilenetv5_blocks import (
+    UniversalInvertedResidual,
+)
+from keras_hub.src.models.mobilenetv5.mobilenetv5_builder import (
+    convert_arch_def_to_stackwise,
+)
+from keras_hub.src.models.mobilenetv5.mobilenetv5_layers import ConvNormAct
+from keras_hub.src.models.mobilenetv5.mobilenetv5_layers import RmsNorm2d
+
+backbone_cls = MobileNetV5Backbone
+
+MODEL_CONFIGS = {
+    "mobilenetv5_300m": {
+        "backbone": convert_arch_def_to_stackwise(
+            [
+                # Stage 0: 128x128 in
+                [
+                    "er_r1_k3_s2_e4_c128",
+                    "er_r1_k3_s1_e4_c128",
+                    "er_r1_k3_s1_e4_c128",
+                ],
+                # Stage 1: 256x256 in
+                [
+                    "uir_r1_a3_k5_s2_e6_c256",
+                    "uir_r1_a5_k0_s1_e4_c256",
+                    "uir_r1_a3_k0_s1_e4_c256",
+                    "uir_r1_a5_k0_s1_e4_c256",
+                    "uir_r1_a3_k0_s1_e4_c256",
+                ],
+                # Stage 2: 640x640 in
+                [
+                    "uir_r1_a5_k5_s2_e6_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a5_k0_s1_e4_c640",
+                    "uir_r1_a0_k0_s1_e1_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                    "mqa_r1_k3_h12_v2_s1_d64_c640",
+                    "uir_r1_a0_k0_s1_e2_c640",
+                ],
+                # Stage 3: 1280x1280 in
+                [
+                    "uir_r1_a5_k5_s2_e6_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                    "mqa_r1_k3_h16_s1_d96_c1280",
+                    "uir_r1_a0_k0_s1_e2_c1280",
+                ],
+            ]
+        ),
+        "stem_size": 64,
+        "num_features": 2048,
+        "norm_layer": "rms_norm",
+        "act_layer": "gelu",
+        "use_msfa": True,
+        "layer_scale_init_value": 1e-5,
+    },
+}
+
+
+def convert_head(task, loader, timm_config):
+    pass
+
+
+def convert_backbone_config(timm_config):
+    timm_architecture = timm_config["architecture"]
+    if timm_architecture not in MODEL_CONFIGS:
+        raise ValueError(f"Unsupported architecture: {timm_architecture}")
+    config = MODEL_CONFIGS[timm_architecture].copy()
+    backbone_config = config.pop("backbone")
+    backbone_config.update(config)
+    return backbone_config
+
+
+def convert_weights(backbone, loader, timm_config):
+    def key_exists(key):
+        try:
+            loader.get_tensor(key)
+            return True
+        except Exception:
+            return False
+
+    def _port_weights(layer, timm_key, transpose_dims=None):
+        hf_weight_key = f"{timm_key}.weight"
+        if not key_exists(hf_weight_key):
+            return
+        hook_fn = None
+        if transpose_dims:
+
+            def transpose_hook(x, _):
+                return np.transpose(x, transpose_dims)
+
+            hook_fn = transpose_hook
+        loader.port_weight(
+            layer.kernel, hf_weight_key=hf_weight_key, hook_fn=hook_fn
+        )
+        if layer.bias is not None:
+            hf_bias_key = f"{timm_key}.bias"
+            if key_exists(hf_bias_key):
+                loader.port_weight(
+                    layer.bias,
+                    hf_weight_key=hf_bias_key,
+                )
+
+    def _port_bn(layer, timm_prefix):
+        loader.port_weight(layer.gamma, f"{timm_prefix}.weight")
+        loader.port_weight(layer.beta, f"{timm_prefix}.bias")
+        loader.port_weight(layer.moving_mean, f"{timm_prefix}.running_mean")
+        loader.port_weight(layer.moving_variance, f"{timm_prefix}.running_var")
+
+    def _port_rms_norm(layer, timm_prefix):
+        loader.port_weight(layer.gamma, f"{timm_prefix}.weight")
+
+    def _port_cna(cna_layer: ConvNormAct, timm_conv_prefix, timm_norm_prefix):
+        if isinstance(cna_layer.conv, keras.layers.DepthwiseConv2D):
+            _port_weights(
+                cna_layer.conv,
+                timm_conv_prefix,
+                transpose_dims=(2, 3, 0, 1),
+            )
+        else:
+            _port_weights(
+                cna_layer.conv,
+                timm_conv_prefix,
+                transpose_dims=(2, 3, 1, 0),
+            )
+        if key_exists(f"{timm_norm_prefix}.running_mean"):
+            _port_bn(cna_layer.norm, timm_norm_prefix)
+        else:
+            _port_rms_norm(cna_layer.norm, timm_norm_prefix)
+
+    def _port_attn(attn_layer, attn_prefix):
+        _port_weights(
+            attn_layer.query_layers[-1],
+            f"{attn_prefix}.query.proj",
+            (2, 3, 1, 0),
+        )
+        if len(attn_layer.key_layers) > 1:
+            _port_weights(
+                attn_layer.key_layers[0],
+                f"{attn_prefix}.key.down_conv",
+                (2, 3, 0, 1),
+            )
+            key_norm_layer = attn_layer.key_layers[1]
+            if isinstance(key_norm_layer, RmsNorm2d):
+                _port_rms_norm(key_norm_layer, f"{attn_prefix}.key.norm")
+            else:
+                _port_bn(key_norm_layer, f"{attn_prefix}.key.norm")
+        _port_weights(
+            attn_layer.key_layers[-1], f"{attn_prefix}.key.proj", (2, 3, 1, 0)
+        )
+        if len(attn_layer.value_layers) > 1:
+            _port_weights(
+                attn_layer.value_layers[0],
+                f"{attn_prefix}.value.down_conv",
+                (2, 3, 0, 1),
+            )
+            value_norm_layer = attn_layer.value_layers[1]
+            if isinstance(value_norm_layer, RmsNorm2d):
+                _port_rms_norm(value_norm_layer, f"{attn_prefix}.value.norm")
+            else:
+                _port_bn(value_norm_layer, f"{attn_prefix}.value.norm")
+        _port_weights(
+            attn_layer.value_layers[-1],
+            f"{attn_prefix}.value.proj",
+            (2, 3, 1, 0),
+        )
+        _port_weights(
+            attn_layer.output_proj_layers[-2],
+            f"{attn_prefix}.output.proj",
+            (2, 3, 1, 0),
+        )
+
+    stem_layer = backbone.get_layer("conv_stem")
+    _port_cna(stem_layer, "conv_stem.conv", "conv_stem.bn")
+    block_layers = [
+        layer
+        for layer in backbone.layers
+        if isinstance(
+            layer, (EdgeResidual, UniversalInvertedResidual, MobileAttention)
+        )
+    ]
+    block_counter = 0
+    for stack_idx in range(len(backbone.stackwise_num_blocks)):
+        for block_idx_in_stage in range(
+            backbone.stackwise_num_blocks[stack_idx]
+        ):
+            block = block_layers[block_counter]
+            timm_prefix = f"blocks.{stack_idx}.{block_idx_in_stage}"
+            if isinstance(block, EdgeResidual):
+                _port_cna(
+                    block.conv_exp,
+                    f"{timm_prefix}.conv_exp",
+                    f"{timm_prefix}.bn1",
+                )
+                _port_cna(
+                    block.conv_pwl,
+                    f"{timm_prefix}.conv_pwl",
+                    f"{timm_prefix}.bn2",
+                )
+            elif isinstance(block, UniversalInvertedResidual):
+                if hasattr(block, "dw_start") and not isinstance(
+                    block.dw_start, types.FunctionType
+                ):
+                    _port_cna(
+                        block.dw_start,
+                        f"{timm_prefix}.dw_start.conv",
+                        f"{timm_prefix}.dw_start.bn",
+                    )
+                _port_cna(
+                    block.pw_exp,
+                    f"{timm_prefix}.pw_exp.conv",
+                    f"{timm_prefix}.pw_exp.bn",
+                )
+                if hasattr(block, "dw_mid") and not isinstance(
+                    block.dw_mid, types.FunctionType
+                ):
+                    _port_cna(
+                        block.dw_mid,
+                        f"{timm_prefix}.dw_mid.conv",
+                        f"{timm_prefix}.dw_mid.bn",
+                    )
+                _port_cna(
+                    block.pw_proj,
+                    f"{timm_prefix}.pw_proj.conv",
+                    f"{timm_prefix}.pw_proj.bn",
+                )
+                gamma_key = f"{timm_prefix}.layer_scale.gamma"
+                if key_exists(gamma_key):
+                    loader.port_weight(block.layer_scale.gamma, gamma_key)
+            elif isinstance(block, MobileAttention):
+                _port_rms_norm(block.norm, f"{timm_prefix}.norm")
+                gamma_key = f"{timm_prefix}.layer_scale.gamma"
+                if key_exists(gamma_key):
+                    loader.port_weight(block.layer_scale.gamma, gamma_key)
+                attn_prefix = f"{timm_prefix}.attn"
+                _port_attn(block.attn, attn_prefix)
+            block_counter += 1
+    try:
+        msfa_layer = backbone.get_layer("msfa")
+        ffn = msfa_layer.ffn
+        _port_cna(ffn.pw_exp, "msfa.ffn.pw_exp.conv", "msfa.ffn.pw_exp.bn")
+        _port_cna(ffn.pw_proj, "msfa.ffn.pw_proj.conv", "msfa.ffn.pw_proj.bn")
+        _port_rms_norm(msfa_layer.norm, "msfa.norm")
+    except ValueError:
+        pass

keras_hub/src/utils/timm/preset_loader.py

@@ -7,6 +7,7 @@ from keras_hub.src.utils.timm import convert_cspnet
 from keras_hub.src.utils.timm import convert_densenet
 from keras_hub.src.utils.timm import convert_efficientnet
 from keras_hub.src.utils.timm import convert_mobilenet
+from keras_hub.src.utils.timm import convert_mobilenetv5
 from keras_hub.src.utils.timm import convert_resnet
 from keras_hub.src.utils.timm import convert_vgg
 from keras_hub.src.utils.transformers.safetensor_utils import SafetensorLoader
@@ -22,6 +23,8 @@ class TimmPresetLoader(PresetLoader):
             self.converter = convert_cspnet
         elif architecture.startswith("densenet"):
             self.converter = convert_densenet
+        elif architecture.startswith("mobilenetv5"):
+            self.converter = convert_mobilenetv5
         elif architecture.startswith("mobilenet"):
             self.converter = convert_mobilenet
         elif architecture.startswith("vgg"):
@@ -41,7 +44,8 @@ class TimmPresetLoader(PresetLoader):
         keras_config = self.converter.convert_backbone_config(self.config)
         backbone = cls(**{**keras_config, **kwargs})
         if load_weights:
-            jax_memory_cleanup(backbone)
+            if not self.config["architecture"].startswith("mobilenetv5"):
+                jax_memory_cleanup(backbone)
             # Use prefix="" to avoid using `get_prefixed_key`.
             with SafetensorLoader(self.preset, prefix="") as loader:
                 self.converter.convert_weights(backbone, loader, self.config)
@@ -54,9 +58,9 @@ class TimmPresetLoader(PresetLoader):
             )
         # Support loading the classification head for classifier models.
         kwargs["num_classes"] = self.config["num_classes"]
-        if (
-            "num_features" in self.config
-            and "mobilenet" in self.config["architecture"]
+        if "num_features" in self.config and (
+            "mobilenet" in self.config["architecture"]
+            or "mobilenetv5" in self.config["architecture"]
         ):
             kwargs["num_features"] = self.config["num_features"]
 

keras_hub/src/utils/transformers/convert_dinov3.py

@@ -0,0 +1,106 @@
+import numpy as np
+
+from keras_hub.src.models.dinov3.dinov3_backbone import DINOV3Backbone
+
+backbone_cls = DINOV3Backbone
+
+
+def convert_backbone_config(transformers_config):
+    image_size = transformers_config["image_size"]
+    return {
+        "patch_size": transformers_config["patch_size"],
+        "num_layers": transformers_config["num_hidden_layers"],
+        "hidden_dim": transformers_config["hidden_size"],
+        "num_heads": transformers_config["num_attention_heads"],
+        "intermediate_dim": transformers_config["intermediate_size"],
+        "layer_scale_init_value": transformers_config["layerscale_value"],
+        "num_register_tokens": transformers_config["num_register_tokens"],
+        "use_mask_token": True,
+        "hidden_activation": transformers_config["hidden_act"],
+        "use_gated_mlp": transformers_config["use_gated_mlp"],
+        "use_query_bias": transformers_config["query_bias"],
+        "use_key_bias": transformers_config["key_bias"],
+        "use_value_bias": transformers_config["value_bias"],
+        "use_proj_bias": transformers_config["proj_bias"],
+        "use_mlp_bias": transformers_config["mlp_bias"],
+        "attention_dropout": transformers_config["attention_dropout"],
+        "drop_path_rate": transformers_config["drop_path_rate"],
+        "layer_norm_eps": transformers_config["layer_norm_eps"],
+        "image_shape": (image_size, image_size, 3),
+        "rope_theta": transformers_config["rope_theta"],
+        "apply_layernorm": False,
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    if not isinstance(backbone, DINOV3Backbone):
+        raise ValueError(
+            "The provided backbone must be an instance of DINOV3Backbone. "
+            f"Received: {type(backbone)}"
+        )
+
+    def port_ln(keras_variable, weight_key):
+        loader.port_weight(keras_variable.gamma, f"{weight_key}.weight")
+        loader.port_weight(keras_variable.beta, f"{weight_key}.bias")
+
+    def port_dense(keras_variable, weight_key):
+        loader.port_weight(
+            keras_variable.kernel,
+            f"{weight_key}.weight",
+            hook_fn=lambda x, _: x.T,
+        )
+        if keras_variable.bias is not None:
+            loader.port_weight(keras_variable.bias, f"{weight_key}.bias")
+
+    # Embedding.
+    loader.port_weight(
+        keras_variable=backbone.embeddings.cls_token,
+        hf_weight_key="embeddings.cls_token",
+    )
+    if backbone.use_mask_token:
+        loader.port_weight(
+            keras_variable=backbone.embeddings.mask_token,
+            hf_weight_key="embeddings.mask_token",
+        )
+    if backbone.num_register_tokens > 0:
+        loader.port_weight(
+            keras_variable=backbone.embeddings.register_tokens,
+            hf_weight_key="embeddings.register_tokens",
+        )
+    loader.port_weight(
+        keras_variable=backbone.embeddings.patch_embeddings.projection.kernel,
+        hf_weight_key="embeddings.patch_embeddings.weight",
+        hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+    )
+    loader.port_weight(
+        keras_variable=backbone.embeddings.patch_embeddings.projection.bias,
+        hf_weight_key="embeddings.patch_embeddings.bias",
+    )
+
+    # Encoder.
+    for i, layer in enumerate(backbone.encoder.layers):
+        prefix = f"layer.{i}"
+        port_ln(layer.norm1, f"{prefix}.norm1")
+        port_dense(layer.attention.query_dense, f"{prefix}.attention.q_proj")
+        port_dense(layer.attention.key_dense, f"{prefix}.attention.k_proj")
+        port_dense(layer.attention.value_dense, f"{prefix}.attention.v_proj")
+        port_dense(layer.attention.output_dense, f"{prefix}.attention.o_proj")
+
+        loader.port_weight(
+            keras_variable=layer.layer_scale1.lambda1,
+            hf_weight_key=f"{prefix}.layer_scale1.lambda1",
+        )
+        port_ln(layer.norm2, f"{prefix}.norm2")
+        if backbone.use_gated_mlp:
+            port_dense(layer.mlp.gate_proj, f"{prefix}.mlp.gate_proj")
+            port_dense(layer.mlp.up_proj, f"{prefix}.mlp.up_proj")
+            port_dense(layer.mlp.down_proj, f"{prefix}.mlp.down_proj")
+        else:
+            port_dense(layer.mlp.up_proj, f"{prefix}.mlp.up_proj")
+            port_dense(layer.mlp.down_proj, f"{prefix}.mlp.down_proj")
+        loader.port_weight(
+            keras_variable=layer.layer_scale2.lambda1,
+            hf_weight_key=f"{prefix}.layer_scale2.lambda1",
+        )
+
+    port_ln(backbone.layernorm, "norm")