optimum-rbln 0.8.2a5__py3-none-any.whl → 0.8.2a7__py3-none-any.whl

optimum/rbln/transformers/models/pixtral/modeling_pixtral.py

@@ -0,0 +1,318 @@
+# 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 pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional, Tuple, Union
+
+import rebel
+import torch
+import torch.nn as nn
+from transformers import PixtralVisionConfig, PixtralVisionModel
+from transformers.modeling_outputs import BaseModelOutput
+from transformers.modeling_utils import no_init_weights
+from transformers.models.pixtral.modeling_pixtral import (
+    PixtralRMSNorm,
+    PixtralRotaryEmbedding,
+)
+
+from ....configuration_utils import RBLNCompileConfig, RBLNModelConfig
+from ....modeling import RBLNModel
+from ....utils.logging import get_logger
+from ....utils.runtime_utils import RBLNPytorchRuntime
+from .configuration_pixtral import RBLNPixtralVisionModelConfig
+from .pixtral_architecture import PixtralAttention
+
+
+logger = get_logger(__name__)
+
+if TYPE_CHECKING:
+    from transformers import AutoFeatureExtractor, AutoProcessor, AutoTokenizer, PreTrainedModel
+
+    from ....diffusers.modeling_diffusers import RBLNDiffusionMixin, RBLNDiffusionMixinConfig
+
+
+class RBLNRuntimePixtralVisionModel(RBLNPytorchRuntime):
+    mandatory_members = ["main_input_name"]
+
+    def __init__(
+        self,
+        runtime: rebel.Runtime,
+        config: PixtralVisionConfig,
+        rbln_config: RBLNPixtralVisionModelConfig,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(runtime, **kwargs)
+        self.patch_positional_embedding = PixtralRotaryEmbedding(config)
+        self.patch_size = config.patch_size
+        self.image_size = config.image_size
+        self.hidden_size = config.hidden_size
+        self.max_image_size = rbln_config.max_image_size
+
+    def forward(
+        self,
+        pixel_values: torch.Tensor,
+        image_sizes: torch.Tensor,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs,
+    ):
+        if pixel_values.shape[2] > self.max_image_size[0] or pixel_values.shape[3] > self.max_image_size[1]:
+            raise ValueError("The height() and width of pixel_values can't be larger than max_image_size.")
+
+        if pixel_values.shape[2] != self.max_image_size[0] or pixel_values.shape[3] != self.max_image_size[1]:
+            padded_pixel_values = [
+                torch.nn.functional.pad(
+                    image,
+                    pad=(
+                        0,
+                        self.max_image_size[1] - pixel_values.shape[3],
+                        0,
+                        self.max_image_size[0] - pixel_values.shape[2],
+                    ),
+                )
+                for image in pixel_values
+            ]
+            pixel_values = torch.stack(padded_pixel_values)
+
+        batch_size, _, H_max, W_max = pixel_values.shape
+        H_max_p = H_max // self.patch_size
+        W_max_p = W_max // self.patch_size
+
+        final_hidden_states = None
+
+        last_hidden_state_list = []
+        if output_hidden_states:
+            batch_hidden_states_list = []
+
+        for i in range(batch_size):
+            h_patched_original = image_sizes[i, 0] // self.patch_size
+            w_patched_original = image_sizes[i, 1] // self.patch_size
+
+            single_pixel_values = pixel_values[i : i + 1]
+            patch_embed = self.patch_conv(single_pixel_values)
+            patch_embed_seq = patch_embed[:, :, :h_patched_original, :w_patched_original].flatten(2).transpose(1, 2)
+            patch_embed_seq = self.ln_pre(patch_embed_seq)
+            patch_embed_seq = nn.functional.pad(
+                patch_embed_seq, (0, 0, 0, H_max_p * W_max_p - patch_embed_seq.shape[1]), "constant", value=0
+            )
+
+            max_w_from_config = self.image_size // self.patch_size
+            mesh = torch.meshgrid(torch.arange(h_patched_original), torch.arange(w_patched_original), indexing="ij")
+            h_grid, v_grid = torch.stack(mesh, dim=-1).reshape(-1, 2).chunk(2, -1)
+            ids = h_grid * max_w_from_config + v_grid
+            position_ids = ids[:, 0]
+
+            position_embeddings = self.patch_positional_embedding(patch_embed_seq, position_ids)
+            cos = nn.functional.pad(
+                position_embeddings[0],
+                (0, 0, 0, H_max_p * W_max_p - position_embeddings[0].shape[0]),
+                "constant",
+                value=0,
+            )
+            sin = nn.functional.pad(
+                position_embeddings[1],
+                (0, 0, 0, H_max_p * W_max_p - position_embeddings[1].shape[0]),
+                "constant",
+                value=0,
+            )
+
+            attention_mask = torch.full(
+                (1, patch_embed_seq.shape[-2]), fill_value=torch.finfo(patch_embed_seq.dtype).min
+            )
+            attention_mask[:, : h_patched_original * w_patched_original] = 0
+
+            transformer_output = super().forward(patch_embed_seq, attention_mask, cos, sin)
+
+            last_hidden_state_list.append(transformer_output[0][:, : h_patched_original * w_patched_original, :])
+            hidden_states = transformer_output[1:]
+
+            if output_hidden_states:
+                batch_hidden_states_list.append(
+                    [hidden_state[:, : h_patched_original * w_patched_original, :] for hidden_state in hidden_states]
+                )
+
+        final_last_hidden_state = torch.cat(last_hidden_state_list, dim=1)
+
+        if output_hidden_states:
+            hidden_states = [
+                torch.cat(
+                    [batch_hidden_states[layer_idx] for batch_hidden_states in batch_hidden_states_list],
+                    dim=1,
+                )
+                for layer_idx in range(len(batch_hidden_states_list[0]))
+            ]
+
+            final_hidden_states = tuple(hidden_states)
+
+        if not return_dict:
+            return tuple(v for v in (final_last_hidden_state, final_hidden_states) if v is not None)
+
+        # TODO: output_attentions
+        return BaseModelOutput(
+            last_hidden_state=final_last_hidden_state,
+            hidden_states=final_hidden_states,
+        )
+
+
+class _PixtralVisionModel(torch.nn.Module):
+    def __init__(self, model: PixtralVisionModel, output_hidden_states: bool):
+        super().__init__()
+        self.transformer = self.convert_to_rbln_pixtral_vision_model(model)
+        self.output_hidden_states = output_hidden_states
+
+    def convert_to_rbln_pixtral_vision_model(self, model: nn.Module):
+        for layer in model.transformer.layers:
+            layer.attention = PixtralAttention(layer.attention)
+        return model.transformer
+
+    def forward(self, patch_embeds, attention_mask, position_embeddings_1, position_embeddings_2):
+        output = self.transformer(
+            inputs_embeds=patch_embeds,
+            attention_mask=attention_mask,
+            position_embeddings=(position_embeddings_1, position_embeddings_2),
+            output_hidden_states=self.output_hidden_states,
+            return_dict=False,
+        )
+        return output
+
+
+class RBLNPixtralVisionModel(RBLNModel):
+    """
+    RBLN optimized Pixtral vision encoder model.
+
+    This class provides hardware-accelerated inference for Pixtral vision encoders
+    on RBLN devices, supporting image encoding for multimodal tasks.
+    """
+
+    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.patch_conv = nn.Conv2d(
+                in_channels=self.config.num_channels,
+                out_channels=self.config.hidden_size,
+                kernel_size=self.config.patch_size,
+                stride=self.config.patch_size,
+                bias=False,
+            )
+            self.ln_pre = PixtralRMSNorm(self.config.hidden_size, eps=1e-5)
+        self.patch_conv.load_state_dict(artifacts["patch_conv"])
+        self.ln_pre.load_state_dict(artifacts["ln_pre"])
+        self.model = RBLNRuntimePixtralVisionModel(
+            self.model[0],
+            main_input_name="pixel_values",
+            config=self.config,
+            rbln_config=self.rbln_config,
+            patch_conv=self.patch_conv,
+            ln_pre=self.ln_pre,
+        )
+
+    @classmethod
+    def save_torch_artifacts(
+        cls,
+        model: "PreTrainedModel",
+        save_dir_path: Path,
+        subfolder: str,
+        rbln_config: RBLNModelConfig,
+    ):
+        save_dict = {}
+        save_dict["patch_conv"] = model.get_input_embeddings().state_dict()
+        save_dict["ln_pre"] = model.ln_pre.state_dict()
+        torch.save(save_dict, save_dir_path / subfolder / "torch_artifacts.pth")
+
+    @classmethod
+    def wrap_model_if_needed(
+        cls, model: torch.nn.Module, rbln_config: RBLNPixtralVisionModelConfig
+    ) -> torch.nn.Module:
+        wrapper_cfg = {
+            "output_hidden_states": rbln_config.output_hidden_states,
+        }
+        return _PixtralVisionModel(model, **wrapper_cfg).eval()
+
+    @classmethod
+    def update_rbln_config_using_pipe(
+        cls, pipe: "RBLNDiffusionMixin", rbln_config: "RBLNDiffusionMixinConfig", submodule_name: str
+    ) -> "RBLNDiffusionMixinConfig":
+        return rbln_config
+
+    @classmethod
+    def _update_rbln_config(
+        cls,
+        preprocessors: Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"],
+        model: Optional["PreTrainedModel"] = None,
+        model_config: "PixtralVisionConfig" = None,
+        rbln_config: Optional[RBLNPixtralVisionModelConfig] = None,
+    ) -> RBLNPixtralVisionModelConfig:
+        if rbln_config.max_image_size is None:
+            rbln_config.max_image_size = (model_config.image_size, model_config.image_size)
+
+        if rbln_config.output_hidden_states is None:
+            rbln_config.output_hidden_states = getattr(model_config, "output_hidden_states", False)
+
+        num_total_patches = (rbln_config.max_image_size[0] // model_config.patch_size) * (
+            rbln_config.max_image_size[1] // model_config.patch_size
+        )
+
+        rbln_compile_config = RBLNCompileConfig(
+            input_info=[
+                (
+                    "patch_embeds",
+                    [1, num_total_patches, model_config.hidden_size],
+                    "float32",
+                ),
+                ("attention_mask", [1, num_total_patches], "float32"),
+                (
+                    "position_embeddings_1",
+                    [
+                        num_total_patches,
+                        model_config.head_dim,
+                    ],
+                    "float32",
+                ),
+                (
+                    "position_embeddings_2",
+                    [
+                        num_total_patches,
+                        model_config.head_dim,
+                    ],
+                    "float32",
+                ),
+            ]
+        )
+
+        rbln_config.set_compile_cfgs([rbln_compile_config])
+        return rbln_config
+
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        image_sizes: Optional[torch.FloatTensor] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: bool = True,
+        **kwargs,
+    ) -> Union[Tuple, BaseModelOutput]:
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.rbln_config.output_hidden_states
+        )
+
+        if output_hidden_states != self.rbln_config.output_hidden_states:
+            raise ValueError(
+                f"Variable output_hidden_states {output_hidden_states} is not equal to rbln_config.output_hidden_states {self.rbln_config.output_hidden_states} "
+                f"Please compile again with the correct argument."
+            )
+
+        output = self.model(
+            pixel_values, image_sizes, output_hidden_states=output_hidden_states, return_dict=return_dict
+        )
+
+        return output

optimum/rbln/transformers/models/pixtral/pixtral_architecture.py

@@ -0,0 +1,73 @@
+# 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, Tuple
+
+import torch
+import torch.nn as nn
+
+from ..decoderonly.decoderonly_architecture import apply_rotary_pos_emb
+
+
+class PixtralAttention(nn.Module):
+    def __init__(self, self_attention):
+        super().__init__()
+        self.original_model = self_attention
+        self.num_heads = getattr(self.original_model, "num_heads", None) or getattr(
+            self.original_model.config, "num_attention_heads"
+        )
+        self.head_dim = self.original_model.head_dim
+        self.scaling = self.head_dim**-0.5
+
+        self.__post_init__()
+
+    def __post_init__(self):
+        self.q_proj = self.original_model.q_proj
+        self.k_proj = self.original_model.k_proj
+        self.v_proj = self.original_model.v_proj
+        self.o_proj = self.original_model.o_proj
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+        output_attentions: Optional[bool] = False,
+    ):
+        batch_size, patches, _ = hidden_states.size()
+
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
+
+        # TODO: return output attention
+        query_states = query_states.view(batch_size, patches, 1, self.num_heads, self.head_dim).transpose(1, 3)
+        key_states = key_states.view(batch_size, patches, 1, self.num_heads, self.head_dim).transpose(1, 3)
+        value_states = value_states.view(batch_size, patches, 1, self.num_heads, self.head_dim).transpose(1, 3)
+
+        cos, sin = position_embeddings
+        cos = cos[None, None, None, :, :]
+        sin = sin[None, None, None, :, :]
+        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+        attn_weights = torch.matmul(query_states, key_states.transpose(3, 4)) * self.scaling
+        attn_weights = attn_weights + attention_mask
+        attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32)
+        attn_output = torch.matmul(attn_weights, value_states)
+        attn_output = attn_output.transpose(1, 3)
+
+        attn_output = attn_output.reshape(batch_size, patches, -1)
+        attn_output = self.o_proj(attn_output)
+
+        return attn_output, _

{optimum_rbln-0.8.2a5.dist-info → optimum_rbln-0.8.2a7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.8.2a5
+Version: 0.8.2a7
 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

{optimum_rbln-0.8.2a5.dist-info → optimum_rbln-0.8.2a7.dist-info}/RECORD

@@ -1,5 +1,5 @@
-optimum/rbln/__init__.py,sha256=4yfoQoNMGSDI1nSH-4bkO_FOOTDCEyyr5ksRdOl9MdI,16652
-optimum/rbln/__version__.py,sha256=C96t3cbMGfE0WqD1B1heigdNUtbxH0j6cpJ80oY3DiM,519
+optimum/rbln/__init__.py,sha256=10giCZmQrRZpbO_gOC5HCTyLxZmezwtM3KpjEk8vYg8,16984
+optimum/rbln/__version__.py,sha256=5wNjDf6ebAXNOKXq2q2velYFX1bRX9PJq61LJdDliJw,519
 optimum/rbln/configuration_utils.py,sha256=FluYXTBB3C93-_35Z_XSdVnN6ScIj4AuKt-4QFt0m8g,33116
 optimum/rbln/modeling.py,sha256=gww-H-q16_mGw2qGnFwOjEj3J9yMjBKnRTKlnCkVlx8,14315
 optimum/rbln/modeling_base.py,sha256=AShxAt3KIOcCqfyF4U83dIrKwoj4p2Kxtc1ns_9-ltU,24154
@@ -71,12 +71,12 @@ optimum/rbln/ops/flash_attn.py,sha256=z39DJZSk94630ueoOCkiybxR5gzvNR-SRADHs0F6pz
 optimum/rbln/ops/kv_cache_update.py,sha256=aIvK2Sp7M3EfJzJgNvIvAJv4emoN6QOhmgaWj-VboLs,1440
 optimum/rbln/ops/linear.py,sha256=5K3pcrrUHu_p8LrMIU-jX2TnafksveFjjZSCsYSp_yw,1328
 optimum/rbln/ops/sliding_window_attn.py,sha256=EQrV_yRGc5z6kvwEsAcLP028bJWkQg2UPI3xubt9skU,3487
-optimum/rbln/transformers/__init__.py,sha256=II1nG2O38GUtG7cTek_zeV2vO7Yzi7fsjLQFJlcrFf4,10581
+optimum/rbln/transformers/__init__.py,sha256=nKbPwORGP9uWd9p4uPfVinai8TxjV301_QgANbQtbpc,10913
 optimum/rbln/transformers/configuration_generic.py,sha256=kNhPWtzF0IovUnrsXfxXdXITqgpfCAAedjfB6jSAhEg,5131
 optimum/rbln/transformers/modeling_attention_utils.py,sha256=aLyOaq4me1m-JMmnKbuyNQageDxNU2jjEhGE_ew2P5o,11465
 optimum/rbln/transformers/modeling_generic.py,sha256=SXsZghRDsPolNnG5FFPRtXzIEmPQDnz0iRy6PIZvFVI,12225
 optimum/rbln/transformers/modeling_rope_utils.py,sha256=6Zg3r-TeUk4WQAlr95pqfhuoAD_RQ4njT1rbO9uPL0Q,14379
-optimum/rbln/transformers/models/__init__.py,sha256=-3nM-k9_VHTstiPCIMrCJ7lEc2GIbIEE8SvGMwQMhVQ,11447
+optimum/rbln/transformers/models/__init__.py,sha256=1uy61IYS99gex9Y0nz3G40IXhYDfONncwMXELd4KHs4,11793
 optimum/rbln/transformers/models/audio_spectrogram_transformer/__init__.py,sha256=I2vL4lrzbT5p4eJcH-EKHzEfcPkj_XVsie7jb9q6yic,775
 optimum/rbln/transformers/models/audio_spectrogram_transformer/configuration_audio_spectrogram_transformer.py,sha256=z7LJiVJPmnlCM3mcyhPJP8AufSrxO_dsPeJ51onq-Nc,833
 optimum/rbln/transformers/models/audio_spectrogram_transformer/modeling_audio_spectrogram_transformer.py,sha256=FIKEVWpIt6-JQX9B_rAfCrAPqdUHtR2i8D_X2k7639E,1498
@@ -101,9 +101,9 @@ optimum/rbln/transformers/models/colpali/colpali_architecture.py,sha256=bWG7TehW
 optimum/rbln/transformers/models/colpali/configuration_colpali.py,sha256=ieY-tuyDPObFUIJ5sfpcfuCsJ_HTAizN7ZGqirqeFRU,2636
 optimum/rbln/transformers/models/colpali/modeling_colpali.py,sha256=jzvJCBrrCXSpjfmJ3O-VvPNFGWGaNbpOV09JwLPAZWs,15757
 optimum/rbln/transformers/models/decoderonly/__init__.py,sha256=w3VZOIBYaHXVdnuhK4y0zWAj0IAv7_5LGTJYaz9oYmI,1056
-optimum/rbln/transformers/models/decoderonly/configuration_decoderonly.py,sha256=IDOtbCfvo_WV1ZA4hHnSuFkDpqZQqnDWuLSqPE1Enrc,23429
-optimum/rbln/transformers/models/decoderonly/decoderonly_architecture.py,sha256=3D0shcG1I4Vj04nt9GuIz1oCbm-pzwiUlhQhlr_fok4,42042
-optimum/rbln/transformers/models/decoderonly/modeling_decoderonly.py,sha256=5Kh3M9tUjnVLzaUf89kqfQyNJCG-Dgc4URrFoIzu024,62251
+optimum/rbln/transformers/models/decoderonly/configuration_decoderonly.py,sha256=tZNT0kz90V4xVDJ9I_9WjPZjLHwhFZpKshija64vcMA,23868
+optimum/rbln/transformers/models/decoderonly/decoderonly_architecture.py,sha256=uR6I_OtYHauNlnUEtg2CUb_am9EUrBtiitMU4r25rPE,42206
+optimum/rbln/transformers/models/decoderonly/modeling_decoderonly.py,sha256=ZuOLXbFWGtghJgEu_VPYbtR36ndhy_f6q_EDY2MWemU,62426
 optimum/rbln/transformers/models/distilbert/__init__.py,sha256=zXL78SOEORTnUN_wrdoaDaYpntG8lcFHvPobM6jC0CI,841
 optimum/rbln/transformers/models/distilbert/configuration_distilbert.py,sha256=O3BW9JjyYk9PLyiofvOKEgTdMZ_jpIuPfot281pSsyg,984
 optimum/rbln/transformers/models/distilbert/modeling_distilbert.py,sha256=LUh6zYGa8AR3Yxaj3gtyJRc-czBN3qnHTc-JTAhuqY0,1099
@@ -119,9 +119,9 @@ optimum/rbln/transformers/models/gemma/configuration_gemma.py,sha256=H1nVp8HBJxx
 optimum/rbln/transformers/models/gemma/gemma_architecture.py,sha256=2Ivay8NTSHmQAqXFh9JvG6Ja5rMThcRAjYPzyipcRI8,956
 optimum/rbln/transformers/models/gemma/modeling_gemma.py,sha256=p9mxRkxu8xAa3g-v62-A0mbcfiQrLIepw2R3BpZP3Cg,3659
 optimum/rbln/transformers/models/gemma3/__init__.py,sha256=6rugk3615SEt4lh7gduo_J9VyGiSReuEIvL0Uno0eaI,790
-optimum/rbln/transformers/models/gemma3/configuration_gemma3.py,sha256=xxa-ypePlz8nJA7aJcKq-DgLV3-LKE6KdN4sEUinaNY,2847
+optimum/rbln/transformers/models/gemma3/configuration_gemma3.py,sha256=QkDfE_TpjekwSUC0kUAZ_IX484qTsksALmNdoKTeej4,3052
 optimum/rbln/transformers/models/gemma3/gemma3_architecture.py,sha256=fpLDAXCe5paWVsfc0tL59JkRQMRF-WNgIzOIb_QpSLU,6191
-optimum/rbln/transformers/models/gemma3/modeling_gemma3.py,sha256=uJBWExPLX3FDm1vQLV1qNxG5tAxF58OOqWiIUNv-SgQ,31978
+optimum/rbln/transformers/models/gemma3/modeling_gemma3.py,sha256=PPGb1wgEfqSnoSgI6diNvQ2qQ5kOH-1NaG8Uf89tW8E,32793
 optimum/rbln/transformers/models/gpt2/__init__.py,sha256=SsawHMStE3wYRtqkH5EvdTFkCdX0LLmp-QSKFhEBrHo,740
 optimum/rbln/transformers/models/gpt2/configuration_gpt2.py,sha256=iGdHfzG7plekZcIz-Z5U8lRE4SB8gbJJNcFQJ9l8Myg,1533
 optimum/rbln/transformers/models/gpt2/gpt2_architecture.py,sha256=MyAWReXmyuHnDpW5HI_TI7psyJZxLujZ9KT5XnNm7nA,2802
@@ -133,6 +133,9 @@ optimum/rbln/transformers/models/llama/__init__.py,sha256=6tgx9-qlM5r9ouoeZEouVR
 optimum/rbln/transformers/models/llama/configuration_llama.py,sha256=_uxfH5kaGbeJTMJfESYn0Vg3OEkINS2ShGtVQTeOcs4,1578
 optimum/rbln/transformers/models/llama/llama_architecture.py,sha256=S7MCPfyjG5eUqgaS-QNBB0ApUD6wnb5fR0RHq7k7-pA,728
 optimum/rbln/transformers/models/llama/modeling_llama.py,sha256=1rk1kZhzsMumaRVPgTSMAYQfan1w-UaePDIhi0a2V1o,3705
+optimum/rbln/transformers/models/llava/__init__.py,sha256=FaVLgBIqKGjT_nvwYO9k9BVqrzH_Ym3DfjGRCSUhG2s,734
+optimum/rbln/transformers/models/llava/configuration_llava.py,sha256=pMA9Tepq89hIZCeOCW25DofB9ediYj-3G46_ufeEup4,2163
+optimum/rbln/transformers/models/llava/modeling_llava.py,sha256=FIOarysPdSD81L6qQ-Rv8DxqjOBNYffZozQuV6UI2jo,15070
 optimum/rbln/transformers/models/llava_next/__init__.py,sha256=kDXKr7wMkp1XqE__DER2B8kQF_NYMxhzsQS5ytGg56I,752
 optimum/rbln/transformers/models/llava_next/configuration_llava_next.py,sha256=U6_DQoaXugN2Bc4ntUb7WkelbNmw1L4VbgqsMRVuuE4,2776
 optimum/rbln/transformers/models/llava_next/modeling_llava_next.py,sha256=i8MuaVWH6sqZXEgx2-zcpVYbcL4-on5DuLBtHGDoS7I,27465
@@ -156,6 +159,10 @@ optimum/rbln/transformers/models/phi/__init__.py,sha256=M5Sh4AtIhJYegl-yAKPggAU3
 optimum/rbln/transformers/models/phi/configuration_phi.py,sha256=CXHIG3xlBdr628oDu_u4OGsu_QZLx5EUSqu3zfmfEnk,1553
 optimum/rbln/transformers/models/phi/modeling_phi.py,sha256=r7B0NlqwIGjm-MmE-h5_xeRJPzs4O2OotgbjI-FYA2o,3403
 optimum/rbln/transformers/models/phi/phi_architecture.py,sha256=ygJIJvn20bnxE9nHKo4CBW9_1FJsz7MEVolB5asTmI0,3684
+optimum/rbln/transformers/models/pixtral/__init__.py,sha256=fhclVAWnIDsfMfC-TW6mYrJXxgyehlLaadK64LOShH4,716
+optimum/rbln/transformers/models/pixtral/configuration_pixtral.py,sha256=b7i1cIJESj7CtNy3w_Sqfr2d0zVfM9jChv-uOJfLsVU,1696
+optimum/rbln/transformers/models/pixtral/modeling_pixtral.py,sha256=_4ooUqy_AAczAo9DiTNa2ZjvfdrtRL0cjVDmUVLlP5Q,12374
+optimum/rbln/transformers/models/pixtral/pixtral_architecture.py,sha256=s-6C9DtHmSZEGJXo5b95RwZE2A5aR6ELMHlj7aK6CIg,2950
 optimum/rbln/transformers/models/qwen2/__init__.py,sha256=h9dWJ3HX4xspMLt44g7r3UGU8QL03Ynmz_Mi3Vlu6UA,746
 optimum/rbln/transformers/models/qwen2/configuration_qwen2.py,sha256=tTWcPOk_ycZvdSPlal9S5elTmWZAX2BbpZP5Ok2ySwI,1567
 optimum/rbln/transformers/models/qwen2/modeling_qwen2.py,sha256=VOboPJF1rvvSVWkHCnw3D5COWbfBwXJJ6JV0tCOgl5g,4938
@@ -215,7 +222,7 @@ optimum/rbln/utils/model_utils.py,sha256=4k5879Kh75m3x_vS4-qOGfqsOiAvc2kdNFFfvsF
 optimum/rbln/utils/runtime_utils.py,sha256=nIJioiN16nAyAzoArKjsy5ocLUsrr0UEy4f3LNT82SA,7961
 optimum/rbln/utils/save_utils.py,sha256=hG5uOtYmecSXZuGTvCXsTM-SiyZpr5q3InUGCCq_jzQ,3619
 optimum/rbln/utils/submodule.py,sha256=w5mgPgncI740gVKMu3S-69DGNdUSI0bTZxegQGcZ98Y,5011
-optimum_rbln-0.8.2a5.dist-info/METADATA,sha256=3pVIoi6dzEn3YuCeD6FueJjA0h4Xm1KvqjytWBdB8Xg,5299
-optimum_rbln-0.8.2a5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-optimum_rbln-0.8.2a5.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-optimum_rbln-0.8.2a5.dist-info/RECORD,,
+optimum_rbln-0.8.2a7.dist-info/METADATA,sha256=65rKMblcQerbNfifD8lIAJ0RZZ3WAcCzBPdzhxef1FE,5299
+optimum_rbln-0.8.2a7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+optimum_rbln-0.8.2a7.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+optimum_rbln-0.8.2a7.dist-info/RECORD,,