optimum-rbln 0.7.4a6__py3-none-any.whl → 0.7.4a8__py3-none-any.whl

optimum/rbln/__init__.py

@@ -74,6 +74,10 @@ _import_structure = {
         "RBLNGemmaForCausalLMConfig",
         "RBLNGPT2LMHeadModel",
         "RBLNGPT2LMHeadModelConfig",
+        "RBLNIdefics3VisionTransformer",
+        "RBLNIdefics3ForConditionalGeneration",
+        "RBLNIdefics3ForConditionalGenerationConfig",
+        "RBLNIdefics3VisionTransformerConfig",
         "RBLNLlamaForCausalLM",
         "RBLNLlamaForCausalLMConfig",
         "RBLNLlavaNextForConditionalGeneration",
@@ -281,6 +285,10 @@ if TYPE_CHECKING:
         RBLNGemmaForCausalLMConfig,
         RBLNGPT2LMHeadModel,
         RBLNGPT2LMHeadModelConfig,
+        RBLNIdefics3ForConditionalGeneration,
+        RBLNIdefics3ForConditionalGenerationConfig,
+        RBLNIdefics3VisionTransformer,
+        RBLNIdefics3VisionTransformerConfig,
         RBLNLlamaForCausalLM,
         RBLNLlamaForCausalLMConfig,
         RBLNLlavaNextForConditionalGeneration,

optimum/rbln/__version__.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.7.4a6'
-__version_tuple__ = version_tuple = (0, 7, 4, 'a6')
+__version__ = version = '0.7.4a8'
+__version_tuple__ = version_tuple = (0, 7, 4, 'a8')

optimum/rbln/configuration_utils.py

@@ -174,6 +174,14 @@ class RBLNAutoConfig:
         cls = getattr(importlib.import_module("optimum.rbln"), cls_name)
         return cls(**kwargs)
 
+    @staticmethod
+    def load_from_dict(config_dict: Dict[str, Any]) -> "RBLNModelConfig":
+        cls_name = config_dict.get("cls_name")
+        if cls_name is None:
+            raise ValueError("`cls_name` is required.")
+        cls = getattr(importlib.import_module("optimum.rbln"), cls_name)
+        return cls(**config_dict)
+
     @staticmethod
     def load(
         path: str,
@@ -195,8 +203,9 @@ class RBLNAutoConfig:
         cls, config_file = load_config(path)
 
         rbln_keys = [key for key in kwargs.keys() if key.startswith("rbln_")]
-
         rbln_runtime_kwargs = {key[5:]: kwargs.pop(key) for key in rbln_keys if key[5:] in RUNTIME_KEYWORDS}
+        rbln_submodule_kwargs = {key[5:]: kwargs.pop(key) for key in rbln_keys if key[5:] in cls.submodules}
+
         rbln_kwargs = {
             key[5:]: kwargs.pop(key)
             for key in rbln_keys
@@ -206,6 +215,14 @@ class RBLNAutoConfig:
         if len(rbln_kwargs) > 0:
             raise ValueError(f"Cannot set the following arguments: {list(rbln_kwargs.keys())}")
 
+        # Process submodule's rbln_config
+        for submodule in cls.submodules:
+            if submodule not in config_file:
+                raise ValueError(f"Submodule {submodule} not found in rbln_config.json.")
+            submodule_config = config_file[submodule]
+            submodule_config.update(rbln_submodule_kwargs.pop(submodule, {}))
+            config_file[submodule] = RBLNAutoConfig.load_from_dict(submodule_config)
+
         if passed_rbln_config is not None:
             config_file.update(passed_rbln_config._runtime_options)
             # TODO(jongho): Reject if the passed_rbln_config has different attributes from the config_file

optimum/rbln/diffusers/modeling_diffusers.py

@@ -47,17 +47,11 @@ class RBLNDiffusionMixin:
 
     1. Create a new pipeline class that inherits from both this mixin and the original StableDiffusionPipeline.
     2. Define the required _submodules class variable listing the components to be compiled.
-    3. If needed, implement get_default_rbln_config for custom configuration of submodules.
 
     Example:
         ```python
         class RBLNStableDiffusionPipeline(RBLNDiffusionMixin, StableDiffusionPipeline):
             _submodules = ["text_encoder", "unet", "vae"]
-
-            @classmethod
-            def get_default_rbln_config(cls, model, submodule_name, rbln_config):
-                # Configuration for other submodules...
-                pass
         ```
 
     Class Variables:
@@ -77,14 +71,6 @@ class RBLNDiffusionMixin:
     _prefix = {}
     _rbln_config_class = None
 
-    @classmethod
-    def is_img2img_pipeline(cls):
-        return "Img2Img" in cls.__name__
-
-    @classmethod
-    def is_inpaint_pipeline(cls):
-        return "Inpaint" in cls.__name__
-
     @staticmethod
     def _maybe_apply_and_fuse_lora(
         model: torch.nn.Module,
@@ -151,7 +137,47 @@ class RBLNDiffusionMixin:
         lora_weights_names: Optional[Union[str, List[str]]] = None,
         lora_scales: Optional[Union[float, List[float]]] = None,
         **kwargs,
-    ) -> RBLNModel:
+    ) -> "RBLNDiffusionMixin":
+        """
+        Load a pretrained diffusion pipeline from a model checkpoint, with optional compilation for RBLN NPUs.
+
+        This method has two distinct operating modes:
+        - When `export=True`: Takes a PyTorch-based diffusion model, compiles it for RBLN NPUs, and loads the compiled model
+        - When `export=False`: Loads an already compiled RBLN model from `model_id` without recompilation
+
+        It supports various diffusion pipelines including Stable Diffusion, Kandinsky, ControlNet, and other diffusers-based models.
+
+        Args:
+            model_id (`str`):
+                The model ID or path to the pretrained model to load. Can be either:
+                - A model ID from the HuggingFace Hub
+                - A local path to a saved model directory
+            export (`bool`, *optional*, defaults to `False`):
+                If True, takes a PyTorch model from `model_id` and compiles it for RBLN NPU execution.
+                If False, loads an already compiled RBLN model from `model_id` without recompilation.
+            model_save_dir (`os.PathLike`, *optional*):
+                Directory to save the compiled model artifacts. Only used when `export=True`.
+                If not provided and `export=True`, a temporary directory is used.
+            rbln_config (`Dict[str, Any]`, *optional*, defaults to `{}`):
+                Configuration options for RBLN compilation. Can include settings for specific submodules
+                such as `text_encoder`, `unet`, and `vae`. Configuration can be tailored to the specific
+                pipeline being compiled.
+            lora_ids (`str` or `List[str]`, *optional*):
+                LoRA adapter ID(s) to load and apply before compilation. LoRA weights are fused
+                into the model weights during compilation. Only used when `export=True`.
+            lora_weights_names (`str` or `List[str]`, *optional*):
+                Names of specific LoRA weight files to load, corresponding to lora_ids. Only used when `export=True`.
+            lora_scales (`float` or `List[float]`, *optional*):
+                Scaling factor(s) to apply to the LoRA adapter(s). Only used when `export=True`.
+            **kwargs:
+                Additional arguments to pass to the underlying diffusion pipeline constructor or the
+                RBLN compilation process. These may include parameters specific to individual submodules
+                or the particular diffusion pipeline being used.
+
+        Returns:
+            `RBLNDiffusionMixin`: A compiled or loaded diffusion pipeline that can be used for inference on RBLN NPU.
+            The returned object is an instance of the class that called this method, inheriting from RBLNDiffusionMixin.
+        """
         rbln_config, kwargs = cls.get_rbln_config_class().initialize_from_kwargs(rbln_config, **kwargs)
 
         if export:

optimum/rbln/modeling_base.py

@@ -216,6 +216,7 @@ class RBLNBaseModel(SubModulesMixin, PushToHubMixin, PreTrainedModel):
             if isinstance(rbln_config, dict):
                 rbln_config_as_kwargs = {f"rbln_{key}": value for key, value in rbln_config.items()}
                 kwargs.update(rbln_config_as_kwargs)
+                rbln_config = None
             elif isinstance(rbln_config, RBLNModelConfig) and rbln_config.rbln_model_cls_name != cls.__name__:
                 raise ValueError(
                     f"Cannot use the passed rbln_config. Its model class name ({rbln_config.rbln_model_cls_name}) "
@@ -392,13 +393,13 @@ class RBLNBaseModel(SubModulesMixin, PushToHubMixin, PreTrainedModel):
     @classmethod
     def get_hf_class(cls):
         """
-        Lazily loads and caches the corresponding Hugging Face model class.
+        Lazily loads and caches the corresponding HuggingFace model class.
         Removes 'RBLN' prefix from the class name to get the original class name
         (e.g., RBLNLlamaForCausalLM -> LlamaForCausalLM) and imports it from
         the transformers/diffusers module.
 
         Returns:
-            type: The original Hugging Face model class
+            type: The original HuggingFace model class
         """
         if cls._hf_class is None:
             hf_cls_name = cls.__name__[4:]
@@ -478,7 +479,7 @@ class RBLNBaseModel(SubModulesMixin, PushToHubMixin, PreTrainedModel):
             save_directory (`Union[str, Path]`):
                 Directory where to save the model file.
             push_to_hub (`bool`, *optional*, defaults to `False`):
-                Whether or not to push your model to the Hugging Face model hub after saving it.
+                Whether or not to push your model to the HuggingFace model hub after saving it.
 
         """
         if os.path.isfile(save_directory):

optimum/rbln/transformers/__init__.py

@@ -68,6 +68,10 @@ _import_structure = {
         "RBLNGemmaForCausalLMConfig",
         "RBLNGPT2LMHeadModel",
         "RBLNGPT2LMHeadModelConfig",
+        "RBLNIdefics3VisionTransformer",
+        "RBLNIdefics3ForConditionalGeneration",
+        "RBLNIdefics3ForConditionalGenerationConfig",
+        "RBLNIdefics3VisionTransformerConfig",
         "RBLNLlamaForCausalLM",
         "RBLNLlamaForCausalLMConfig",
         "RBLNLlavaNextForConditionalGeneration",
@@ -169,6 +173,10 @@ if TYPE_CHECKING:
         RBLNGemmaForCausalLMConfig,
         RBLNGPT2LMHeadModel,
         RBLNGPT2LMHeadModelConfig,
+        RBLNIdefics3ForConditionalGeneration,
+        RBLNIdefics3ForConditionalGenerationConfig,
+        RBLNIdefics3VisionTransformer,
+        RBLNIdefics3VisionTransformerConfig,
         RBLNLlamaForCausalLM,
         RBLNLlamaForCausalLMConfig,
         RBLNLlavaNextForConditionalGeneration,

optimum/rbln/transformers/models/__init__.py

@@ -73,6 +73,12 @@ _import_structure = {
     "exaone": ["RBLNExaoneForCausalLM", "RBLNExaoneForCausalLMConfig"],
     "gemma": ["RBLNGemmaForCausalLM", "RBLNGemmaForCausalLMConfig"],
     "gpt2": ["RBLNGPT2LMHeadModel", "RBLNGPT2LMHeadModelConfig"],
+    "idefics3": [
+        "RBLNIdefics3VisionTransformer",
+        "RBLNIdefics3ForConditionalGeneration",
+        "RBLNIdefics3ForConditionalGenerationConfig",
+        "RBLNIdefics3VisionTransformerConfig",
+    ],
     "llama": ["RBLNLlamaForCausalLM", "RBLNLlamaForCausalLMConfig"],
     "llava_next": ["RBLNLlavaNextForConditionalGeneration", "RBLNLlavaNextForConditionalGenerationConfig"],
     "midm": ["RBLNMidmLMHeadModel", "RBLNMidmLMHeadModelConfig"],
@@ -144,6 +150,12 @@ if TYPE_CHECKING:
     from .exaone import RBLNExaoneForCausalLM, RBLNExaoneForCausalLMConfig
     from .gemma import RBLNGemmaForCausalLM, RBLNGemmaForCausalLMConfig
     from .gpt2 import RBLNGPT2LMHeadModel, RBLNGPT2LMHeadModelConfig
+    from .idefics3 import (
+        RBLNIdefics3ForConditionalGeneration,
+        RBLNIdefics3ForConditionalGenerationConfig,
+        RBLNIdefics3VisionTransformer,
+        RBLNIdefics3VisionTransformerConfig,
+    )
     from .llama import RBLNLlamaForCausalLM, RBLNLlamaForCausalLMConfig
     from .llava_next import RBLNLlavaNextForConditionalGeneration, RBLNLlavaNextForConditionalGenerationConfig
     from .midm import RBLNMidmLMHeadModel, RBLNMidmLMHeadModelConfig

optimum/rbln/transformers/models/auto/auto_factory.py

@@ -48,7 +48,7 @@ class _BaseAutoModelClass:
 
         Args:
             pretrained_model_name_or_path (str): Identifier or path to the pretrained model.
-            export (bool): Whether to infer the class based on Hugging Face (HF) architecture.
+            export (bool): Whether to infer the class based on HuggingFace (HF) architecture.
             kwargs: Additional arguments for configuration and loading.
 
         Returns:
@@ -86,14 +86,14 @@ class _BaseAutoModelClass:
         **kwargs,
     ):
         """
-        Infer the Hugging Face model class based on the configuration or model name.
+        Infer the HuggingFace model class based on the configuration or model name.
 
         Args:
             pretrained_model_name_or_path (str): Identifier or path to the pretrained model.
             kwargs: Additional arguments for configuration and loading.
 
         Returns:
-            PretrainedModel: The inferred Hugging Face model class.
+            PretrainedModel: The inferred HuggingFace model class.
         """
 
         # Try to load configuration if provided or retrieve it from the model ID

optimum/rbln/transformers/models/decoderonly/decoderonly_architecture.py

@@ -184,6 +184,7 @@ class DecoderOnlyWrapper(nn.Module):
 
     def convert_to_rbln_causal_lm(self, causal_lm: PreTrainedModel, max_seq_len: int):
         new_layers = []
+
         for layer in causal_lm.model.layers:
             if self.attn_impl == "eager":
                 new_self_attn = DecoderOnlyAttention(
@@ -201,6 +202,7 @@ class DecoderOnlyWrapper(nn.Module):
 
             new_layer = DecoderOnlyLayer(layer, new_self_attn)
             new_layers.append(new_layer)
+
         new_model = DecoderOnlyModel(
             causal_lm.model,
             new_layers,

optimum/rbln/transformers/models/decoderonly/modeling_decoderonly.py

@@ -451,6 +451,12 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
     def get_input_embeddings(self):
         return self.embed_tokens
 
+    def get_attn_impl(self) -> str:
+        return self.rbln_config.attn_impl
+
+    def get_kvcache_num_blocks(self) -> int:
+        return self.rbln_config.kvcache_num_blocks
+
     @classmethod
     def get_quantized_model(
         cls,

optimum/rbln/transformers/models/idefics3/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .configuration_idefics3 import RBLNIdefics3ForConditionalGenerationConfig, RBLNIdefics3VisionTransformerConfig
+from .modeling_idefics3 import RBLNIdefics3ForConditionalGeneration, RBLNIdefics3VisionTransformer

optimum/rbln/transformers/models/idefics3/configuration_idefics3.py

@@ -0,0 +1,51 @@
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+from ....configuration_utils import RBLNModelConfig
+
+
+class RBLNIdefics3VisionTransformerConfig(RBLNModelConfig):
+    pass
+
+
+class RBLNIdefics3ForConditionalGenerationConfig(RBLNModelConfig):
+    submodules = ["vision_model", "text_model"]
+
+    def __init__(
+        self,
+        batch_size: Optional[int] = None,
+        vision_model: Optional[RBLNModelConfig] = None,
+        text_model: Optional[RBLNModelConfig] = None,
+        **kwargs,
+    ):
+        """
+        Args:
+            batch_size (Optional[int]): The batch size for inference. Defaults to 1.
+            vision_model (Optional[RBLNModelConfig]): Configuration for the vision transformer component.
+            text_model (Optional[RBLNModelConfig]): Configuration for the text model component.
+            **kwargs: Additional arguments passed to the parent RBLNModelConfig.
+
+        Raises:
+            ValueError: If batch_size is not a positive integer.
+        """
+
+        super().__init__(**kwargs)
+        self.batch_size = batch_size or 1
+        if not isinstance(self.batch_size, int) or self.batch_size < 0:
+            raise ValueError(f"batch_size must be a positive integer, got {self.batch_size}")
+
+        self.vision_model = vision_model
+        self.text_model = text_model

optimum/rbln/transformers/models/idefics3/modeling_idefics3.py

@@ -0,0 +1,459 @@
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+import inspect
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
+
+import rebel
+import torch
+from transformers import (
+    AutoModelForVision2Seq,
+    Idefics3ForConditionalGeneration,
+    Idefics3VisionConfig,
+    Idefics3VisionTransformer,
+    PretrainedConfig,
+    PreTrainedModel,
+)
+from transformers.modeling_outputs import BaseModelOutput
+from transformers.modeling_utils import no_init_weights
+from transformers.models.idefics3.modeling_idefics3 import Idefics3CausalLMOutputWithPast, Idefics3VisionEmbeddings
+
+from ....configuration_utils import RBLNCompileConfig, RBLNModelConfig
+from ....modeling import RBLNModel
+from ....utils.runtime_utils import RBLNPytorchRuntime
+from ..decoderonly.modeling_decoderonly import (
+    RBLNDecoderOnlyOutput,
+)
+
+
+if TYPE_CHECKING:
+    from transformers import (
+        AutoFeatureExtractor,
+        AutoProcessor,
+        AutoTokenizer,
+    )
+
+
+class RBLNRuntimeVisionModel(RBLNPytorchRuntime):
+    mandatory_members = ["main_input_name"]
+
+    def __init__(
+        self,
+        runtime: rebel.Runtime,
+        config: Idefics3VisionConfig,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(runtime, **kwargs)
+        self.patch_size = config.patch_size
+        self._use_flash_attention_2 = config._attn_implementation == "flash_attention_2"
+
+    def forward(
+        self,
+        pixel_values,
+        patch_attention_mask: Optional[torch.BoolTensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs,
+    ):
+        batch_size = pixel_values.size(0)
+        if patch_attention_mask is None:
+            patch_size = self.patch_size
+            patch_attention_mask = torch.ones(
+                (
+                    batch_size,
+                    pixel_values.size(2) // patch_size,
+                    pixel_values.size(3) // patch_size,
+                )
+            )
+            patch_attention_mask = patch_attention_mask.to(dtype=torch.bool, device=pixel_values.device)
+
+        hidden_states = self.embeddings(pixel_values=pixel_values, patch_attention_mask=patch_attention_mask)
+
+        return super().forward(hidden_states.contiguous())
+
+
+class RBLNIdefics3VisionTransformer(RBLNModel):
+    def __post_init__(self, **kwargs):
+        artifacts = torch.load(self.model_save_dir / self.subfolder / "torch_artifacts.pth", weights_only=False)
+        with no_init_weights():
+            self.embeddings = Idefics3VisionEmbeddings(self.config)
+        self.embeddings.load_state_dict(artifacts["embeddings"])
+        self.model = RBLNRuntimeVisionModel(
+            self.model[0], main_input_name="pixel_values", config=self.config, embeddings=self.embeddings
+        )
+
+    @classmethod
+    def save_torch_artifacts(
+        cls,
+        model: "PreTrainedModel",
+        save_dir_path: Path,
+        subfolder: str,
+        rbln_config: RBLNModelConfig,
+    ):
+        """
+        If you are unavoidably running on a CPU rather than an RBLN device,
+        store the torch tensor, weight, etc. in this function.
+        """
+        save_dict = {}
+        save_dict["embeddings"] = model.get_input_embeddings().state_dict()
+        torch.save(save_dict, save_dir_path / subfolder / "torch_artifacts.pth")
+
+    def get_input_embeddings(self):
+        return self.embeddings
+
+    @classmethod
+    def wrap_model_if_needed(cls, model: torch.nn.Module, rbln_config: RBLNModelConfig) -> torch.nn.Module:
+        class Idefics3VisionTransformerWrapper(torch.nn.Module):
+            def __init__(self, model: "Idefics3VisionTransformer"):
+                super().__init__()
+                self.encoder = model.encoder
+                self.post_layernorm = model.post_layernorm
+
+            def forward(self, hidden_states, patch_attention_mask: Optional[torch.BoolTensor] = None):
+                encoder_outputs = self.encoder(
+                    inputs_embeds=hidden_states,
+                    attention_mask=patch_attention_mask,
+                    output_attentions=None,
+                    output_hidden_states=None,
+                    return_dict=False,
+                )
+                last_hidden_state = encoder_outputs[0]
+                last_hidden_state = self.post_layernorm(last_hidden_state)
+                return last_hidden_state
+
+        return Idefics3VisionTransformerWrapper(model).eval()
+
+    @classmethod
+    def _update_rbln_config(
+        cls,
+        preprocessors: Optional[Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"]],
+        model: Optional["PreTrainedModel"] = None,
+        model_config: Optional["PretrainedConfig"] = None,
+        rbln_config: Optional[RBLNModelConfig] = None,
+    ) -> RBLNModelConfig:
+        input_info = [
+            (
+                "hidden_states",
+                [
+                    # batch_size * num_patches (dependent on image size) -> compile with 1 and use for loop
+                    1,
+                    (model_config.image_size // model_config.patch_size) ** 2,
+                    model_config.hidden_size,
+                ],
+                "float32",
+            ),
+        ]
+
+        rbln_compile_config = RBLNCompileConfig(input_info=input_info)
+        rbln_config.set_compile_cfgs([rbln_compile_config])
+        return rbln_config
+
+    def forward(
+        self,
+        pixel_values,
+        patch_attention_mask: Optional[torch.BoolTensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs,
+    ) -> Union[Tuple, BaseModelOutput]:
+        batch_size = pixel_values.shape[0]
+        last_hidden_state = []
+        for i in range(batch_size):
+            if patch_attention_mask is not None:
+                batch_attention_mask = patch_attention_mask[i : i + 1,]
+            else:
+                batch_attention_mask = None
+
+            batch_hidden_state = self.model(
+                pixel_values[i : i + 1,],
+                batch_attention_mask,
+                return_dict=False,
+            )
+            last_hidden_state.append(batch_hidden_state)
+        last_hidden_state = torch.cat(last_hidden_state, dim=0)
+
+        if not return_dict:
+            return (last_hidden_state,)
+        else:
+            return BaseModelOutput(last_hidden_state=last_hidden_state)
+
+
+class RBLNIdefics3ForConditionalGeneration(RBLNModel):
+    auto_model_class = AutoModelForVision2Seq
+    _rbln_submodules = [{"name": "vision_model"}, {"name": "text_model"}]
+    _rbln_submodule_prefix = "model"
+
+    def __getattr__(self, __name: str) -> Any:
+        def redirect(func):
+            return lambda *pargs, **kwargs: func(self, *pargs, **kwargs)
+
+        val = getattr(Idefics3ForConditionalGeneration, __name)
+
+        if isinstance(val, Callable) and "self" in set(inspect.signature(val).parameters):
+            return redirect(val)
+        return val
+
+    def can_generate(self):
+        return True
+
+    @classmethod
+    def get_pytorch_model(cls, *args, **kwargs):
+        model = super().get_pytorch_model(*args, **kwargs)
+
+        with no_init_weights():
+            model_cls_name = model.model.text_model.__class__.__name__
+            causal_model_cls_name = model_cls_name.replace("Model", "ForCausalLM")
+            causal_model_cls = getattr(importlib.import_module("transformers"), causal_model_cls_name)
+            new_text_model = causal_model_cls(model.model.text_model.config)
+
+        new_text_model.lm_head = model.lm_head
+        new_text_model.model = model.model.text_model
+        model.model.text_model = new_text_model
+        model.lm_head = None
+        del model.lm_head
+        return model
+
+    def __post_init__(self, **kwargs):
+        self.vision_model = self.rbln_submodules[0]
+        self.connector = self.model[0]
+        self.text_model = self.rbln_submodules[1]
+
+    def get_attn_impl(self) -> str:
+        return self.rbln_config.text_model.attn_impl
+
+    def get_kvcache_num_blocks(self) -> int:
+        return self.rbln_config.text_model.kvcache_num_blocks
+
+    def get_input_embeddings(self):
+        return self.text_model.get_input_embeddings()
+
+    @classmethod
+    def wrap_model_if_needed(cls, model, rbln_config):
+        return model.model.connector
+
+    @classmethod
+    def _update_rbln_config(
+        cls,
+        preprocessors: Optional[Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"]],
+        model: Optional["PreTrainedModel"] = None,
+        model_config: Optional["PretrainedConfig"] = None,
+        rbln_config: Optional[RBLNModelConfig] = None,
+    ) -> RBLNModelConfig:
+        input_info = [
+            (
+                "image_hidden_states",
+                [
+                    # batch_size * num_patches (dependent on image size) -> compile with 1 and use for loop
+                    1,
+                    (model_config.vision_config.image_size // model_config.vision_config.patch_size) ** 2,
+                    model_config.vision_config.hidden_size,
+                ],
+                "float32",
+            ),
+        ]
+
+        rbln_compile_config = RBLNCompileConfig(input_info=input_info)
+        rbln_config.set_compile_cfgs([rbln_compile_config])
+
+        return rbln_config
+
+    def prepare_inputs_for_generation(
+        self,
+        input_ids,
+        attention_mask=None,
+        inputs_embeds=None,
+        cache_position=None,
+        pixel_values=None,
+        pixel_attention_mask=None,
+        image_hidden_states=None,
+        generate_idx=None,
+        **kwargs,
+    ):
+        is_prefill_phase = generate_idx is None
+        model_inputs = {}
+
+        if is_prefill_phase:
+            generate_idx = attention_mask.sum(dim=-1, keepdim=True).int()
+            cache_position = None
+            pixel_values = pixel_values
+            pixel_attention_mask = pixel_attention_mask
+        else:
+            if inputs_embeds is not None:
+                raise NotImplementedError("Specifying inputs_embeds in decoder phase is not supported.")
+
+            pixel_values = None
+            pixel_attention_mask = None
+            input_ids = input_ids[:, -1:]
+            cache_position = generate_idx
+            generate_idx = generate_idx + 1
+            model_inputs.update({"input_ids": input_ids})
+
+        if inputs_embeds is not None:
+            if self.rbln_config.use_inputs_embeds:
+                model_inputs.update({"inputs_embeds": inputs_embeds})
+            else:
+                raise ValueError(
+                    "The specifying inputs_embeds is only supported when using a compiled RBLN model with 'rbln_use_inputs_embeds' set to True."
+                )
+        else:
+            model_inputs.update({"input_ids": input_ids})
+
+        model_inputs.update(
+            {
+                "attention_mask": attention_mask,
+                "pixel_values": pixel_values,
+                "pixel_attention_mask": pixel_attention_mask,
+                "image_hidden_states": image_hidden_states,
+                "cache_position": cache_position,
+                "generate_idx": generate_idx,
+            }
+        )
+        return model_inputs
+
+    def _update_model_kwargs_for_generation(self, outputs, model_kwargs, is_encoder_decoder, **kwargs):
+        model_kwargs["generate_idx"] = outputs.generate_idx
+        return model_kwargs
+
+    def inputs_merger(
+        self,
+        input_ids: torch.LongTensor,
+        inputs_embeds: Optional[torch.Tensor],
+        image_hidden_states: Optional[torch.Tensor],
+    ):
+        num_images, _, vision_hidden_size = image_hidden_states.shape
+        special_image_token_mask = input_ids == self.config.image_token_id
+        new_inputs_embeds = inputs_embeds.clone()
+        reshaped_image_hidden_states = image_hidden_states.view(-1, vision_hidden_size)
+        reshaped_image_hidden_states = reshaped_image_hidden_states.to(inputs_embeds.device, inputs_embeds.dtype)
+        new_inputs_embeds[special_image_token_mask] = reshaped_image_hidden_states
+        return new_inputs_embeds
+
+    def _preprocess_prefill(
+        self,
+        input_ids: torch.LongTensor = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        pixel_attention_mask: Optional[torch.BoolTensor] = None,
+        image_hidden_states: Optional[torch.FloatTensor] = None,
+        **kwargs,
+    ):
+        if input_ids is not None:
+            batch_size, _ = input_ids.shape
+        elif inputs_embeds is not None:
+            batch_size, _, _ = inputs_embeds.shape
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        if inputs_embeds is not None and input_ids is None:
+            raise ValueError("When first calling the model, if input_embeds are passed, input_ids should not be None.")
+
+        if inputs_embeds is None:
+            inputs_embeds = self.get_input_embeddings()(input_ids).to(self.device)
+
+        if pixel_values is not None and image_hidden_states is not None:
+            raise ValueError("You cannot specify both pixel_values and image_hidden_states at the same time")
+
+        elif pixel_values is not None:
+            batch_size, num_images, num_channels, height, width = pixel_values.shape
+            pixel_values = pixel_values.to(dtype=self.dtype)
+            pixel_values = pixel_values.view(batch_size * num_images, *pixel_values.shape[2:])
+
+            nb_values_per_image = pixel_values.shape[1:].numel()
+            real_images_inds = (pixel_values == 0.0).sum(dim=(-1, -2, -3)) != nb_values_per_image
+            pixel_values = pixel_values[real_images_inds].contiguous()
+
+            if pixel_attention_mask is None:
+                pixel_attention_mask = torch.ones(
+                    size=(pixel_values.size(0), pixel_values.size(2), pixel_values.size(3)),
+                    dtype=torch.bool,
+                    device=pixel_values.device,
+                )
+            else:
+                pixel_attention_mask = pixel_attention_mask.view(
+                    batch_size * num_images, *pixel_attention_mask.shape[2:]
+                )
+                pixel_attention_mask = pixel_attention_mask[real_images_inds].contiguous()
+
+            patch_size = self.config.vision_config.patch_size
+            patches_subgrid = pixel_attention_mask.unfold(dimension=1, size=patch_size, step=patch_size)
+            patches_subgrid = patches_subgrid.unfold(dimension=2, size=patch_size, step=patch_size)
+            patch_attention_mask = (patches_subgrid.sum(dim=(-1, -2)) > 0).bool()
+
+            image_hidden_states = self.vision_model(
+                pixel_values=pixel_values, patch_attention_mask=patch_attention_mask, return_dict=True
+            ).last_hidden_state
+
+            connector_outputs = []
+            for i in range(image_hidden_states.shape[0]):
+                connector_outputs.append(self.connector(image_hidden_states[i : i + 1,]))
+            image_hidden_states = torch.cat(connector_outputs, dim=0)
+
+        elif image_hidden_states is not None:
+            image_hidden_states = image_hidden_states.to(dtype=self.dtype, device=input_ids.device)
+
+        if inputs_embeds is not None and image_hidden_states is not None:
+            inputs_embeds = self.inputs_merger(
+                input_ids=input_ids,
+                inputs_embeds=inputs_embeds,
+                image_hidden_states=image_hidden_states,
+            )
+
+        return inputs_embeds
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        pixel_attention_mask: Optional[torch.BoolTensor] = None,
+        image_hidden_states: Optional[torch.FloatTensor] = None,
+        cache_position: torch.Tensor = None,
+        generate_idx: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[Tuple, Idefics3CausalLMOutputWithPast]:
+        # Prefill
+        if cache_position is None:
+            inputs_embeds = self._preprocess_prefill(
+                input_ids, inputs_embeds, pixel_values, pixel_attention_mask, image_hidden_states
+            )
+            logits = []
+            inputs = inputs_embeds if inputs_embeds is not None else input_ids
+            batch_size = inputs.shape[0]
+
+            for b_idx in range(batch_size):
+                cache_position = torch.arange(0, generate_idx[b_idx].item(), dtype=torch.int32).unsqueeze(0)
+                logit = self.text_model.prefill_decoder(
+                    input_ids=inputs[b_idx : b_idx + 1] if inputs_embeds is None else None,
+                    inputs_embeds=inputs[b_idx : b_idx + 1] if inputs_embeds is not None else None,
+                    attention_mask=attention_mask[b_idx] if attention_mask is not None else None,
+                    cache_position=cache_position,
+                    batch_idx=b_idx,
+                )
+                logits.append(logit)
+
+            logits = torch.cat(logits, dim=0)
+
+        # Decoder
+        else:
+            logits = self.text_model.decoder(
+                input_ids=input_ids,
+                inputs_embeds=inputs_embeds,
+                cache_position=cache_position,
+            )
+
+        return RBLNDecoderOnlyOutput(
+            logits=logits,
+            generate_idx=generate_idx,
+        )

optimum/rbln/transformers/models/llava_next/modeling_llava_next.py

@@ -157,6 +157,12 @@ class RBLNLlavaNextForConditionalGeneration(RBLNModel):
         self._padding_side = "left"  # set it to left by default, user can use setter to change padding_sides
         return super().__post_init__(**kwargs)
 
+    def get_attn_impl(self) -> str:
+        return self.rbln_config.language_model.attn_impl
+
+    def get_kvcache_num_blocks(self) -> int:
+        return self.rbln_config.language_model.kvcache_num_blocks
+
     def get_input_embeddings(self):
         return self.language_model.get_input_embeddings()
 

optimum/rbln/utils/hub.py

@@ -63,7 +63,7 @@ def pull_compiled_model_from_hub(
     force_download: bool,
     local_files_only: bool,
 ) -> Path:
-    """Pull model files from the Hugging Face Hub."""
+    """Pull model files from the HuggingFace Hub."""
     huggingface_token = _get_huggingface_token(use_auth_token)
     repo_files = list(
         map(
@@ -119,4 +119,4 @@ def _get_huggingface_token(use_auth_token: Union[bool, str]) -> str:
     elif use_auth_token:
         return HfFolder.get_token()
     else:
-        raise ValueError("`use_auth_token` must be provided to interact with the Hugging Face Hub.")
+        raise ValueError("`use_auth_token` must be provided to interact with the HuggingFace Hub.")

optimum/rbln/utils/model_utils.py

@@ -18,10 +18,10 @@ RBLN_PREFIX = "RBLN"
 
 def convert_hf_to_rbln_model_name(hf_model_name: str):
     """
-    Convert Hugging Face model name to RBLN model name.
+    Convert HuggingFace model name to RBLN model name.
 
     Args:
-        hf_model_name (str): The Hugging Face model name.
+        hf_model_name (str): The HuggingFace model name.
 
     Returns:
         str: The corresponding RBLN model name.
@@ -31,13 +31,13 @@ def convert_hf_to_rbln_model_name(hf_model_name: str):
 
 def convert_rbln_to_hf_model_name(rbln_model_name: str):
     """
-    Convert RBLN model name to Hugging Face model name.
+    Convert RBLN model name to HuggingFace model name.
 
     Args:
         rbln_model_name (str): The RBLN model name.
 
     Returns:
-        str: The corresponding Hugging Face model name.
+        str: The corresponding HuggingFace model name.
     """
 
     return rbln_model_name.removeprefix(RBLN_PREFIX)

optimum/rbln/utils/submodule.py

@@ -43,9 +43,16 @@ class SubModulesMixin:
         cls, model: "PreTrainedModel", model_save_dir: str, rbln_config: RBLNModelConfig, **kwargs
     ) -> List["RBLNBaseModel"]:
         rbln_submodules = []
+        submodule_prefix = getattr(cls, "_rbln_submodule_prefix", None)
+
         for submodule in cls._rbln_submodules:
             submodule_name = submodule["name"]
-            torch_submodule: "PreTrainedModel" = getattr(model, submodule["name"])
+            if submodule_prefix is not None:
+                torch_submodule: PreTrainedModel = getattr(model, submodule_prefix)
+                torch_submodule = getattr(torch_submodule, submodule_name)
+            else:
+                torch_submodule: PreTrainedModel = getattr(model, submodule_name)
+
             cls_name = torch_submodule.__class__.__name__
             submodule_cls: Type["RBLNBaseModel"] = getattr(importlib.import_module("optimum.rbln"), f"RBLN{cls_name}")
             submodule_rbln_config = getattr(rbln_config, submodule_name) or {}
@@ -57,6 +64,7 @@ class SubModulesMixin:
 
             rbln_submodule = submodule_cls.from_model(
                 model=torch_submodule,
+                config=torch_submodule.config,
                 subfolder=submodule_name,
                 model_save_dir=model_save_dir,
                 rbln_config=submodule_rbln_config,
@@ -70,6 +78,7 @@ class SubModulesMixin:
     @classmethod
     def _load_submodules_from_compiled_models(cls, model_save_dir: str, rbln_config: RBLNModelConfig, **kwargs):
         rbln_submodules = []
+
         for submodule in cls._rbln_submodules:
             submodule_name = submodule["name"]
 

{optimum_rbln-0.7.4a6.dist-info → optimum_rbln-0.7.4a8.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.7.4a6
-Summary: Optimum RBLN is the interface between the Hugging Face Transformers and Diffusers libraries and RBLN accelerators. It provides a set of tools enabling easy model loading and inference on single and multiple rbln device settings for different downstream tasks.
+Version: 0.7.4a8
+Summary: Optimum RBLN is the interface between the HuggingFace Transformers and Diffusers libraries and RBLN accelerators. It provides a set of tools enabling easy model loading and inference on single and multiple rbln device settings for different downstream tasks.
 Project-URL: Homepage, https://rebellions.ai
 Project-URL: Documentation, https://docs.rbln.ai
 Project-URL: Repository, https://github.com/rebellions-sw/optimum-rbln

{optimum_rbln-0.7.4a6.dist-info → optimum_rbln-0.7.4a8.dist-info}/RECORD

@@ -1,10 +1,10 @@
-optimum/rbln/__init__.py,sha256=gwlRrI10tkLlpXt-N3FbmMeVqEJRVExtfVrxsqdcCpM,12814
-optimum/rbln/__version__.py,sha256=BD2gZveYjqvIGZe_xk184XdKxoYxjbIrrR0xZAj20HQ,519
-optimum/rbln/configuration_utils.py,sha256=1IX8AHmQbnJvhNm3yD6ZJABP7Oi40WvVSNlThty-ASk,29167
+optimum/rbln/__init__.py,sha256=c2whRR6XkelNLlH1MwAKYMoaBEhmGxSQFrhfKS1JC-I,13186
+optimum/rbln/__version__.py,sha256=QL0a_B-kCttMpg_RwbPMs7mYzsY06SEmJHJVDUYponM,519
+optimum/rbln/configuration_utils.py,sha256=S2RGzl-gdE5evUd5ZsO9i8LXgPGCrQEOGZJTa6t1A9Y,30044
 optimum/rbln/modeling.py,sha256=qDXB69Oq0jx9hfONebDiSNe2_DgKYhnAGLTbGAtwYVw,9677
-optimum/rbln/modeling_base.py,sha256=3JQhXDh_Rz1f6bMNxgFk-Xd-lQcAVeh-q1KVO0ijSaA,24141
+optimum/rbln/modeling_base.py,sha256=iQKw2IORu1cN6sOK0xeBVrhatt-ZPeinT_v6l2FnGRw,24173
 optimum/rbln/diffusers/__init__.py,sha256=XL6oKPHbPCV6IVCw3fu0-M9mD2KO_x6unx5kJdAtpVY,6180
-optimum/rbln/diffusers/modeling_diffusers.py,sha256=mOP352aYok7DQIQj1dKq1uTZwIkjmUIm-pmtlu6rIUI,16987
+optimum/rbln/diffusers/modeling_diffusers.py,sha256=DrB-UZbNYXGQYyY5DXOeH88_AfSg35JPEQ3AXnkrCP4,19294
 optimum/rbln/diffusers/configurations/__init__.py,sha256=Sk_sQVTuTl01RVgYViWknQSLmulxKaISS0w-oPdNoBQ,1164
 optimum/rbln/diffusers/configurations/models/__init__.py,sha256=P3vif5I4wYeol50jzHCZ1ttujuEFZSYJPzUdSF6_jsU,407
 optimum/rbln/diffusers/configurations/models/configuration_autoencoder_kl.py,sha256=61QHgb_tVF6lxvy6vBxst2TjnebeKQy3rKHOOOc6e68,2952
@@ -60,15 +60,15 @@ optimum/rbln/ops/attn.py,sha256=x02yFLk7FcONFqfow0ROmVy9fmxo5Pw0SPCiDY3AZNg,9012
 optimum/rbln/ops/flash_attn.py,sha256=NmCqUdMTzgJ4sbYGj8IWXJEsLWvbuCMponR01w5DK6w,4121
 optimum/rbln/ops/kv_cache_update.py,sha256=HjnHBR-oFrJQibsVnkYb0P5_-wEma8jl0mkjkylwakU,1270
 optimum/rbln/ops/linear.py,sha256=1_7Hg-9wXxhu97fqPobotLQx17k7VPeSSL91_9Z7EDg,1018
-optimum/rbln/transformers/__init__.py,sha256=9IzUXwbMZ1cGFNa25wvoBs42UkQrvZNgvlbZ8zjOTOs,7712
+optimum/rbln/transformers/__init__.py,sha256=P89UOclQWiLgNkH90GXdnwWD2492O2tusM-fZApfBNg,8084
 optimum/rbln/transformers/configuration_alias.py,sha256=qFVfg6ohsR7a6b-CBgxjBUPDrk9MyiJwtO8AQah_RTU,1505
 optimum/rbln/transformers/configuration_generic.py,sha256=XIiZ1-5p1CMHhG7Sr2qR4SLYKcYw9aph7eGlga3Opx0,5056
 optimum/rbln/transformers/modeling_alias.py,sha256=yx7FnZQWAnrWzivaO5hI7T6i-fyLzt2tMIXG2oDNbPo,1657
 optimum/rbln/transformers/modeling_generic.py,sha256=nT_lytAILkYtwBVJKxXg0dxmh0UpjGYO6zOdLoMs1uU,12891
 optimum/rbln/transformers/modeling_rope_utils.py,sha256=3zwkhYUyTZhxCJUSmwCc88iiY1TppRWEY9ShwUqNB2k,14293
-optimum/rbln/transformers/models/__init__.py,sha256=9f2fJgdchqM_CJbx5BogQQ_xvCVtgYQ8bgyARt4lFu4,6790
+optimum/rbln/transformers/models/__init__.py,sha256=72eMPN5UYGJ9P5gnJ2yi25cGdX1jV7viTOKmsX2OqBg,7221
 optimum/rbln/transformers/models/auto/__init__.py,sha256=GvGbb3ZpMv-h6euXeZ42jSizoOfrL2O1uvpAnfKxYEo,1034
-optimum/rbln/transformers/models/auto/auto_factory.py,sha256=jS33v5H6AY7yHZMAQPq94MBLer2wpb33IVMYcb1w57A,7047
+optimum/rbln/transformers/models/auto/auto_factory.py,sha256=Uf5rCUoxec2qhIAwbAeZNZN4NIMFaLurSB1EdI79lwA,7044
 optimum/rbln/transformers/models/auto/modeling_auto.py,sha256=Un9qoqdy3dO8JBza_bTJF_6_fRVNM9QisihSgTRFI-o,3933
 optimum/rbln/transformers/models/bart/__init__.py,sha256=fVo-gZEmJ0yxkIxEX6ciuRAGgXNyuvaXE2s88bhbjAE,830
 optimum/rbln/transformers/models/bart/bart_architecture.py,sha256=Oo-Cdne7igKEex8wwP-gztKJHgs5GLHQjK1oc3IZIDE,5801
@@ -82,8 +82,8 @@ optimum/rbln/transformers/models/clip/configuration_clip.py,sha256=wgfZeVvcVdSzr
 optimum/rbln/transformers/models/clip/modeling_clip.py,sha256=UslcDN6otyQ_psou7F_YcdK5vCImEtgIdcbwmexSfOM,7256
 optimum/rbln/transformers/models/decoderonly/__init__.py,sha256=vQYZDDdoddwA7yKc5zzrq2Zs9sax-0p8rNF_aYfF4bk,1006
 optimum/rbln/transformers/models/decoderonly/configuration_decoderonly.py,sha256=b1W7zS0MUmeDd048bLp5AkZMrWd3LIhHaVy8NvlwdCw,4116
-optimum/rbln/transformers/models/decoderonly/decoderonly_architecture.py,sha256=BDATZTGF0J2zfc3u-zHXPKbkvsVHOwkNR10smB9Zuo8,41746
-optimum/rbln/transformers/models/decoderonly/modeling_decoderonly.py,sha256=uzw1nOz_jdi3lrBiLkkHy8QiOn-M5bCwNtyNs01a-d8,42815
+optimum/rbln/transformers/models/decoderonly/decoderonly_architecture.py,sha256=NG2tKC3gT57r34PYKgU0evZHctEHzJGRrk2FOjLyK7Q,41748
+optimum/rbln/transformers/models/decoderonly/modeling_decoderonly.py,sha256=5o2m_xPVjfCovP_jcW8E17sSKkLqcVblr4mFLbv-VDU,42991
 optimum/rbln/transformers/models/dpt/__init__.py,sha256=Nzep9mlzKyL1kV726IBqY8DnLp1DkH9JzFeknWSRhok,714
 optimum/rbln/transformers/models/dpt/configuration_dpt.py,sha256=4fW6bzVhaAxym4wGV3F785rvUOoWPyw_gdEMqB08Leg,755
 optimum/rbln/transformers/models/dpt/modeling_dpt.py,sha256=oKLX7MQZvfk1QB8wOtcdi7AmZH2fOIVbypa9A3RA9MI,733
@@ -99,13 +99,16 @@ optimum/rbln/transformers/models/gpt2/__init__.py,sha256=socBMIBZSiLbrVN12rQ4nL9
 optimum/rbln/transformers/models/gpt2/configuration_gpt2.py,sha256=vKvJD8P9Li4W9wdVoQcqMEr1MwEXojPBnF2NE85VXAo,772
 optimum/rbln/transformers/models/gpt2/gpt2_architecture.py,sha256=1IxqHmB-GlH2Dv2Yk4z0rMxL9CpxMGHhSu_x8_4cxvs,3008
 optimum/rbln/transformers/models/gpt2/modeling_gpt2.py,sha256=qBDanUk_O-HtOIVCA4IE3FYyCsnL9xIDK00vft-0caw,1490
+optimum/rbln/transformers/models/idefics3/__init__.py,sha256=ulxE7HEfXsNJhd25J9Fvi6vggo9aZH9sLKJjWB6LlzQ,814
+optimum/rbln/transformers/models/idefics3/configuration_idefics3.py,sha256=sM0pXsvkxcpDXagoKlqwKdBAcNdayB9KlWdYC9xlyDU,1889
+optimum/rbln/transformers/models/idefics3/modeling_idefics3.py,sha256=Rr9BJDyoOqJFQ8dJV78QU4Tjjhhj3aqRk05JcDqFv6Y,17904
 optimum/rbln/transformers/models/llama/__init__.py,sha256=knxvRkPx8x6-WOxqSq_PlaKYD-9F9Q8dh7r095Esey0,708
 optimum/rbln/transformers/models/llama/configuration_llama.py,sha256=B9gr4pTn9yiv3-8DIk0P7_AQdIHEc7SuLaH9gZAmP8E,773
 optimum/rbln/transformers/models/llama/llama_architecture.py,sha256=S7MCPfyjG5eUqgaS-QNBB0ApUD6wnb5fR0RHq7k7-pA,728
 optimum/rbln/transformers/models/llama/modeling_llama.py,sha256=Z3iony7icoFhRQ11MAuFx9UF03uJCsvJQZ6bxHXlrgk,1530
 optimum/rbln/transformers/models/llava_next/__init__.py,sha256=kDXKr7wMkp1XqE__DER2B8kQF_NYMxhzsQS5ytGg56I,752
 optimum/rbln/transformers/models/llava_next/configuration_llava_next.py,sha256=QPreWZyohwRL23GOyvoAfKtk5UNg7IJ_Y_pNfUDe7cU,1838
-optimum/rbln/transformers/models/llava_next/modeling_llava_next.py,sha256=-NvLf9ixzEbVqUKlkyZW94n0tmnsIQ7CvP1Y7U1JEPU,25773
+optimum/rbln/transformers/models/llava_next/modeling_llava_next.py,sha256=xOXc1XUIK4oLSFvAq7Q0lxiOLlDFMbFdOcg5JvLnVkI,25979
 optimum/rbln/transformers/models/midm/__init__.py,sha256=IC3FETwgYinbp3wDj7tp4zIHJhbqM-c6GfTRdYcMNj8,913
 optimum/rbln/transformers/models/midm/configuration_midm.py,sha256=Kv5g5dIsBrhGcZ2_pFUOPNB80np4Xiw0wPH1IZm1PHI,772
 optimum/rbln/transformers/models/midm/midm_architecture.py,sha256=357iviqQkzI0s_lU_teH1sVOChNRDUABe3GA0HuhZZY,5444
@@ -153,14 +156,14 @@ optimum/rbln/transformers/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 optimum/rbln/transformers/utils/rbln_quantization.py,sha256=gwBVHf97sQgPNmGa0wq87E8mPyrtXYhMnO4X4sKp3c8,7639
 optimum/rbln/utils/__init__.py,sha256=ieDBT2VFTt2E0M4v_POLBpuGW9LxSydpb_DuPd6PQqc,712
 optimum/rbln/utils/decorator_utils.py,sha256=xu-TrsNi33SRC2a7DBsyoo6-pEQxWKZPZSmM9QlDe2Y,3745
-optimum/rbln/utils/hub.py,sha256=bNmOJGEO9Jfux4Cg8Xli-898I4mxk20KuwQOhP0Zs1U,4198
+optimum/rbln/utils/hub.py,sha256=Z_R9Ic9VAew8bUmlaAlxZf5JGMDBivHvvFRI557pILY,4196
 optimum/rbln/utils/import_utils.py,sha256=uMldLJmDVMj5uHvxBfb96uV29bfGEDvlksLY26GOHAs,4389
 optimum/rbln/utils/logging.py,sha256=VKKBmlQSdg6iZCGmAXaWYiW67K84jyp1QJhLQSSjPPE,3453
-optimum/rbln/utils/model_utils.py,sha256=DfD_Z2qvZHqcddXqnzTM1AN8khanj3-DXK2lJvVxDvs,1278
+optimum/rbln/utils/model_utils.py,sha256=V2kFpUe2aqVzLwbpztD8JOVFQqRHncvIWwJbgnUPr4E,1274
 optimum/rbln/utils/runtime_utils.py,sha256=LoKNK3AQNV_BSScstIZWjICkJf265MnUgy360BOocVI,5454
 optimum/rbln/utils/save_utils.py,sha256=hG5uOtYmecSXZuGTvCXsTM-SiyZpr5q3InUGCCq_jzQ,3619
-optimum/rbln/utils/submodule.py,sha256=_qX15LE2nHzOFVUp5U5DqdJx11RzPBR848PR0nsjQBc,4293
-optimum_rbln-0.7.4a6.dist-info/METADATA,sha256=m4NMptBdyrOQ746DO16TCGBCSHeidkLBpXQQC8_EEhY,5300
-optimum_rbln-0.7.4a6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-optimum_rbln-0.7.4a6.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-optimum_rbln-0.7.4a6.dist-info/RECORD,,
+optimum/rbln/utils/submodule.py,sha256=TtcH3OLctFd2Dosc-zNMGZ8xOXKKUfE91dLQ1v09E8Q,4636
+optimum_rbln-0.7.4a8.dist-info/METADATA,sha256=jkrw5KRSdUkdaY3ZJYv0A4HHNhUDdOB59D_tNSMa7Ss,5299
+optimum_rbln-0.7.4a8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+optimum_rbln-0.7.4a8.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+optimum_rbln-0.7.4a8.dist-info/RECORD,,