optimum-rbln 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

optimum/rbln/transformers/models/midm/modeling_midm.py

@@ -0,0 +1,426 @@
+# Copyright 2024 Rebellions Inc.
+
+# 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.
+
+# Portions of this software are licensed under the Apache License,
+# Version 2.0. See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.
+
+# All other portions of this software, including proprietary code,
+# are the intellectual property of Rebellions Inc. and may not be
+# copied, modified, or distributed without prior written permission
+# from Rebellions Inc.
+
+import inspect
+import logging
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+
+import rebel
+import torch
+from optimum.exporters import TasksManager
+from transformers import AutoModelForCausalLM, PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutputWithCrossAttentions
+
+from ....modeling_base import RBLNBaseModel
+from ....modeling_config import DEFAULT_COMPILED_MODEL_NAME, RBLNConfig, RBLNRuntimeConfig
+from ....utils.runtime_utils import RBLNPytorchRuntime
+from ....utils.save_utils import maybe_save_preprocessors
+from ...generation.utils import RBLNGenerationMixin
+from .hf_hub_cached.modeling_midm import MidmLMHeadModel
+from .midm_architecture import (
+    MidmLMHeadModelWrapper,
+)
+
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from transformers import (
+        AutoFeatureExtractor,
+        AutoProcessor,
+        AutoTokenizer,
+        PretrainedConfig,
+    )
+
+
+class RBLNRuntimeDecoder(RBLNPytorchRuntime):
+    mandatory_members = ["main_input_name"]
+
+    # RBLN_Runtimemodule
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: torch.LongTensor = None,
+        cache_position: torch.Tensor = None,
+        **kwargs: Dict[str, Any],
+    ):
+        logits = super().forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            cache_position=cache_position,
+        )
+        return logits
+
+
+class RBLNMidmLMHeadModel(RBLNBaseModel, RBLNGenerationMixin):
+    """
+    The Midm Model transformer with a language modeling head on top (linear layer with weights tied to the input
+    embeddings).
+
+    This model inherits from [`RBLNBaseModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model.
+
+    It implements the methods to convert a pre-trained transformers Midm model into a RBLN transformer model by:
+    - transferring the checkpoint weights of the original into an optimized RBLN graph,
+    - compiling the resulting graph using the RBLN compiler.
+
+    """
+
+    model_type = "rbln_model"
+    auto_model_class = AutoModelForCausalLM
+    main_input_name = "input_ids"
+
+    def __init__(
+        self,
+        models: List[Union[PreTrainedModel, rebel.RBLNCompiledModel]],
+        config: PretrainedConfig = None,
+        preprocessors: Optional[List] = None,
+        rbln_config: Optional[RBLNConfig] = None,
+        rbln_device: Optional[List[int]] = None,
+        rbln_device_map: Optional[Dict[str, int]] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            models,
+            config,
+            preprocessors,
+            rbln_config,
+            rbln_device=rbln_device,
+            rbln_device_map=rbln_device_map,
+            **kwargs,
+        )
+        self.batch_size = self.rbln_config.meta["rbln_batch_size"]
+        self.prefill_chunk_size = self.rbln_config.meta["rbln_prefill_chunk_size"]
+        self.max_seq_len = self.rbln_config.meta["rbln_max_seq_len"]
+
+        self.prefill_attention_mask = torch.zeros(
+            self.batch_size, 1, self.prefill_chunk_size, self.max_seq_len, dtype=torch.int64
+        )
+        self.causal_mask = 1 - torch.triu(
+            torch.ones(self.batch_size, 1, self.prefill_chunk_size, self.prefill_chunk_size), diagonal=1
+        )
+
+        self.prefill_decoder = RBLNRuntimeDecoder(runtime=self.runtimes[0], main_input_name="input_ids")
+        self.decoder = RBLNRuntimeDecoder(runtime=self.runtimes[1], main_input_name="input_ids")
+        self.past_cached_length = 0
+
+    def can_generate(self):
+        return True
+
+    def __getattr__(self, __name: str) -> Any:
+        """This is the key method to implement RBLN-Midm.
+
+        Returns:
+            Any: Midm's corresponding method
+        """
+
+        def redirect(func):
+            return lambda *pargs, **kwargs: func(self, *pargs, **kwargs)
+
+        val = getattr(MidmLMHeadModel, __name)
+        if isinstance(val, Callable) and "self" in set(inspect.signature(val).parameters):
+            return redirect(val)
+        return val
+
+    def _reorder_cache(self, past_key_values, beam_idx):
+        # TODO(jongho): implement
+        raise NotImplementedError
+
+    @classmethod
+    def _export(
+        cls,
+        model_id: str,
+        config: "PretrainedConfig",
+        use_auth_token: Optional[Union[bool, str]] = None,
+        revision: Optional[str] = None,
+        force_download: bool = False,
+        cache_dir: Optional[str] = None,
+        subfolder: str = "",
+        local_files_only: bool = False,
+        trust_remote_code: bool = False,
+        model_save_dir: Optional[Union[str, Path, TemporaryDirectory]] = None,
+        **kwargs,
+    ) -> "RBLNMidmLMHeadModel":
+
+        task = kwargs.pop("task", None)
+        if task is None:
+            task = TasksManager.infer_task_from_model(cls.auto_model_class)
+
+        if model_save_dir is None:
+            save_dir = TemporaryDirectory()
+            save_dir_path = Path(save_dir.name)
+        else:
+            save_dir = model_save_dir
+            if isinstance(save_dir, TemporaryDirectory):
+                save_dir_path = Path(model_save_dir.name)
+            else:
+                save_dir_path = Path(model_save_dir)
+                save_dir_path.mkdir(exist_ok=True)
+
+        def update_configs(kwargs):
+            max_seq_len = kwargs.get("rbln_max_seq_len", None)
+            if max_seq_len is not None:
+                kwargs.update({"max_position_embeddings": max_seq_len})
+
+            kwargs.update(
+                {
+                    "torchscript": True,
+                    "return_dict": False,
+                    "use_cache": True,
+                    "torch_dtype": torch.float32,
+                    "_attn_implementation": "eager",
+                }
+            )
+
+            return kwargs
+
+        kwargs = update_configs(kwargs)
+
+        rbln_config_kwargs, rbln_constructor_kwargs = cls.pop_rbln_kwargs_from_kwargs(kwargs)
+
+        model: MidmLMHeadModel = TasksManager.get_model_from_task(
+            task=task,
+            model_name_or_path=model_id,
+            subfolder=subfolder,
+            revision=revision,
+            framework="pt",
+            cache_dir=cache_dir,
+            use_auth_token=use_auth_token,
+            local_files_only=local_files_only,
+            force_download=force_download,
+            trust_remote_code=trust_remote_code,
+            ignore_mismatched_sizes=True,
+            **kwargs,
+        )
+
+        if config is None:
+            config = model.config
+
+        config.save_pretrained(save_dir_path)
+        preprocessors = maybe_save_preprocessors(model_id, save_dir_path, src_subfolder=subfolder)
+
+        # Get compilation arguments
+        if rbln_config_kwargs.get("rbln_config", None) is None:
+            rbln_config = cls.get_rbln_config(
+                preprocessors=preprocessors, model_config=model.config, **rbln_config_kwargs
+            )
+
+        def compile_midm():
+            wrapped_decoder = MidmLMHeadModelWrapper(model).eval()
+            prefill_rbln_runtime_config = rbln_config[DEFAULT_COMPILED_MODEL_NAME][0]
+            dec_rbln_runtime_config = rbln_config[DEFAULT_COMPILED_MODEL_NAME][1]
+
+            prefill_example_inputs = prefill_rbln_runtime_config.get_dummy_inputs(fill=0)
+            dec_example_inputs = dec_rbln_runtime_config.get_dummy_inputs(fill=0)
+
+            prefill_scripted_model = torch.jit.trace(wrapped_decoder, prefill_example_inputs)
+            dec_scripted_model = torch.jit.trace(wrapped_decoder, dec_example_inputs)
+
+            prefill_ir = rebel.torchscript_to_ir(
+                prefill_scripted_model,
+                input_names=[v[0] for v in prefill_rbln_runtime_config.input_info],
+            )
+            dec_ir = rebel.torchscript_to_ir(
+                dec_scripted_model,
+                input_names=[v[0] for v in dec_rbln_runtime_config.input_info],
+            )
+
+            connections = [
+                (prefill_ir.outputs[1 + i], prefill_ir.inputs[3 + i]) for i in range(model.config.n_layer * 2)
+            ]
+
+            compiled_model = rebel.compile(
+                prefill_ir,
+                dec_ir,
+                connections=connections,
+                fusion=prefill_rbln_runtime_config.fusion,
+                npu=prefill_rbln_runtime_config.npu,
+                tensor_parallel_size=prefill_rbln_runtime_config.tensor_parallel_size,
+                use_weight_sharing=True,
+            )
+            compiled_model.save(save_dir_path / f"{DEFAULT_COMPILED_MODEL_NAME}.rbln")
+
+        compile_midm()
+
+        rbln_config.save(save_dir_path)
+
+        return cls._from_pretrained(
+            model_id=save_dir_path,
+            config=config,
+            model_save_dir=save_dir,
+            **rbln_constructor_kwargs,
+            **kwargs,
+        )
+
+    @classmethod
+    def _get_rbln_config(
+        cls,
+        preprocessors: Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"],
+        model_config: "PretrainedConfig",
+        rbln_prefill_chunk_size: Optional[int] = 128,
+        rbln_max_seq_len: Optional[int] = None,
+        rbln_batch_size: Optional[int] = None,
+    ) -> RBLNConfig:
+        meta = {}
+        if rbln_max_seq_len is None:
+            rbln_max_seq_len = getattr(model_config, "max_position_embeddings", None)
+
+        if rbln_max_seq_len is None:
+            for tokenizer in preprocessors:
+                if hasattr(tokenizer, "model_max_length"):
+                    rbln_max_seq_len = tokenizer.model_max_length
+                    break
+            if rbln_max_seq_len is None:
+                raise ValueError("`rbln_max_seq_len` should be specified!")
+
+        if rbln_batch_size is None:
+            rbln_batch_size = 1
+
+        meta["rbln_prefill_chunk_size"] = rbln_prefill_chunk_size
+        meta["rbln_max_seq_len"] = rbln_max_seq_len
+        meta["rbln_batch_size"] = rbln_batch_size if rbln_batch_size is not None else 1
+
+        def get_input_info(query_length):
+            input_info = [
+                ("input_ids", [rbln_batch_size, query_length], "int64"),
+                ("attention_mask", [rbln_batch_size, 1, query_length, rbln_max_seq_len], "int64"),
+                (
+                    "cache_position",
+                    [],
+                    "int32",
+                ),
+            ]
+            input_info.extend(
+                [
+                    (
+                        f"past_key_values_{i}",
+                        [
+                            rbln_batch_size,
+                            model_config.n_head,
+                            rbln_max_seq_len,
+                            model_config.hidden_size // model_config.n_head,
+                        ],
+                        "float32",
+                    )
+                    for i in range(model_config.n_layer * 2)
+                ]
+            )
+            return input_info
+
+        # model input info
+        prefill_input_info = get_input_info(query_length=rbln_prefill_chunk_size)
+        dec_input_info = get_input_info(query_length=1)
+
+        prefill_rbln_runtime_config = RBLNRuntimeConfig(input_info=prefill_input_info)
+        dec_rbln_runtime_config = RBLNRuntimeConfig(input_info=dec_input_info)
+
+        dec_rbln_runtime_config.batch_size = rbln_batch_size
+
+        rbln_config = RBLNConfig.from_rbln_runtime_configs(
+            [prefill_rbln_runtime_config, dec_rbln_runtime_config],
+            _rbln_meta=meta,
+        )
+
+        return rbln_config
+
+    def _create_runtimes(self, rbln_device_map: Dict[str, int]) -> List[rebel.Runtime]:
+        device_val = rbln_device_map[DEFAULT_COMPILED_MODEL_NAME]
+        return [
+            self.compiled_models[0].create_runtime(input_info_index=0, tensor_type="pt", device=device_val),
+            self.compiled_models[0].create_runtime(input_info_index=1, tensor_type="pt", device=device_val),
+        ]
+
+    def prepare_inputs_for_generation(self, input_ids, past_key_values=0, attention_mask=None, **kwargs):
+        batch_size, cur_len = input_ids.shape
+        past_cached_length = past_key_values
+
+        if past_cached_length == 0:
+            mod_len = cur_len % self.prefill_chunk_size
+            self.pad_len = self.prefill_chunk_size - mod_len if mod_len > 0 else 0
+
+            prompt_attn_mask = torch.nn.functional.pad(attention_mask, (self.pad_len, 0), value=0)
+            self.prompt_attn_mask = prompt_attn_mask.reshape(batch_size, 1, 1, -1).contiguous()
+
+            input_ids = torch.nn.functional.pad(input_ids, (self.pad_len, 0), value=0)
+            attention_mask = self.prefill_attention_mask.clone()
+            cache_position = torch.tensor(past_cached_length, dtype=torch.int32)
+
+            query_length = cur_len + self.pad_len
+        else:
+            attention_mask = torch.nn.functional.pad(
+                attention_mask, (self.pad_len, self.max_seq_len - cur_len - self.pad_len)
+            )
+            attention_mask = attention_mask.reshape(batch_size, 1, 1, -1).contiguous()
+            cache_position = torch.tensor(past_cached_length, dtype=torch.int32)
+            input_ids = input_ids[:, -1:].contiguous()
+            query_length = 1
+
+        model_inputs = {
+            "input_ids": input_ids,
+            "past_key_values": past_cached_length,
+            "attention_mask": attention_mask,
+            "cache_position": cache_position,
+            "query_length": query_length,
+        }
+
+        return model_inputs
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        past_key_values: int = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        cache_position: Optional[torch.Tensor] = None,
+        query_length: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[Tuple, CausalLMOutputWithCrossAttentions]:
+        past_cached_length = past_key_values
+
+        if past_cached_length is not None:
+            past_cached_length += query_length
+
+        if cache_position == 0:
+            for step in range(0, query_length, self.prefill_chunk_size):
+                sliced_input_ids = input_ids[:, step : step + self.prefill_chunk_size]
+                attention_mask[:, :, :, :step] = 1
+                attention_mask[:, :, :, step : step + self.prefill_chunk_size] = self.causal_mask
+                attention_mask[:, :, :, :query_length] *= self.prompt_attn_mask
+
+                output = self.prefill_decoder(
+                    input_ids=sliced_input_ids.contiguous(),
+                    attention_mask=attention_mask,
+                    cache_position=cache_position + step,
+                )
+                cache_position += self.prefill_chunk_size
+        else:
+            output = self.decoder(
+                input_ids=input_ids.contiguous(),
+                attention_mask=attention_mask,
+                cache_position=cache_position,
+            )
+        return CausalLMOutputWithCrossAttentions(logits=output, past_key_values=past_cached_length)
+
+    def __repr__(self):
+        return repr(self.runtimes[0]) + "\n" + repr(self.runtimes[1])

{optimum_rbln-0.1.1.dist-info → optimum_rbln-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimum-rbln
-Version: 0.1.1
+Version: 0.1.4
 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.
 Keywords: transformers,diffusers,inference,rbln,atom,rebel
@@ -20,11 +20,12 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Project-URL: Homepage, https://rebellions.ai
 Project-URL: Documentation, https://docs.rbln.ai
 Requires-Python: <3.11,>=3.8
-Requires-Dist: torch>=2.2.1
+Requires-Dist: torch==2.2.1
 Requires-Dist: optimum>=1.17.1
 Requires-Dist: accelerate>=0.28.0
-Requires-Dist: transformers<=4.40.2
-Requires-Dist: rebel-compiler>=0.4.0
+Requires-Dist: transformers==4.40.2
+Requires-Dist: diffusers==0.27.2
+Requires-Dist: einops>=0.8.0
 Requires-Dist: diffusers>=0.27.1; extra == "diffusers"
 Requires-Dist: pytest>=8.1.1; extra == "tests"
 Requires-Dist: psutil>=5.9.8; extra == "tests"

{optimum_rbln-0.1.1.dist-info → optimum_rbln-0.1.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
-optimum/rbln/__init__.py,sha256=1aJPifD6VJCf5FwnA1-dxsVPiEqnHw9ots5T_aUXm3I,4051
-optimum/rbln/__version__.py,sha256=jZ5uWOiyV1Hb9rhNyo3bAgfWmHx8_xkueUWpcUrkz_w,21
+optimum/rbln/__init__.py,sha256=J9OmYkTDCm3a4TmmBbOOScMQA23SJFwZzE4InpwKePg,4111
+optimum/rbln/__version__.py,sha256=K0nJliLE8urvUSONsZC4x-EeWHUpKHvT74DFSIT6PZI,21
 optimum/rbln/diffusers/__init__.py,sha256=JWeu2ihHKiYD0Uzs9jXbaAq-bA1G86UCMPPx_oiJYFU,2606
 optimum/rbln/diffusers/models/__init__.py,sha256=aY6Llq_31dZjdB9HPBDvi7sXVtdQT9r11gokXG5ffxA,1139
 optimum/rbln/diffusers/models/autoencoder_kl.py,sha256=ifgsAoqZE1dOlJv6z7HJv7rp_IJ8KXMEmI_LOg98ITU,12566
@@ -20,14 +20,14 @@ optimum/rbln/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_x
 optimum/rbln/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py,sha256=rGJFKMo6aKbJwwLTS-N3fkFUrRXHr-2hWdatiFzySYk,5516
 optimum/rbln/modeling.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 optimum/rbln/modeling_alias.py,sha256=pyYGME31QaiBaLqnjQq3LwUF1T6dLeb8QLB91gzNsLM,1574
-optimum/rbln/modeling_base.py,sha256=vPkW9yynfa4Ng8XHYw-yKijNpyL3CyiwHnpa6q3KhoY,26545
+optimum/rbln/modeling_base.py,sha256=2A6BJKwrGKMJvlPy4fCFP8OUGJ6-wszak1adIuOR8qE,26552
 optimum/rbln/modeling_config.py,sha256=R0GBd-upavJrpR-2SvfgCCxP7f5Zr0NxIqdKmwBfVCk,6439
 optimum/rbln/modeling_seq2seq.py,sha256=eLPiUnei0XGFK01JbIsfS03-hJ_5EkazpoBONv65JNI,19549
-optimum/rbln/transformers/__init__.py,sha256=RHnckU1ghEE6rEtYrwoElVdKXj3BF2aW0fWRelk65Ng,1860
+optimum/rbln/transformers/__init__.py,sha256=loWV0nNu8woMq4WJbV7IbhYZW8VkbBM9uT5THDkW47M,1920
 optimum/rbln/transformers/generation/__init__.py,sha256=6MmqS9D21ir4dcH6_fq8kRsX1VK3QspSn6Qw83F4ORE,1081
 optimum/rbln/transformers/generation/streamers.py,sha256=X-dEmL1L_0Oy0QSFj2RNdamb_xbDWLXd-Ms8ckx6OZ4,5778
 optimum/rbln/transformers/generation/utils.py,sha256=F8gnVYG79kzg_IvQynD-p409E_5loy5VaIXvfi094u0,19464
-optimum/rbln/transformers/models/__init__.py,sha256=LidItK8nZMZi7IoIOq7fyAn4y1M_K6LOSqohVes-dwg,1238
+optimum/rbln/transformers/models/__init__.py,sha256=ysQWodX3tHE--R54KGerEmoUHh5IFPiCI4EmXtt1ZIE,1276
 optimum/rbln/transformers/models/bart/__init__.py,sha256=SGUcpQ_5iLsVxySxtbwhRpmGt7BgVUTxHAjxAjQStdU,1063
 optimum/rbln/transformers/models/bart/bart_architecture.py,sha256=H8yVoBFa5uMXQv_wYCHKRW6tIIjdD50ho9C0vcMsbSo,14956
 optimum/rbln/transformers/models/clip/__init__.py,sha256=tbco8qW9QhBe3dtWoKgslLZMsXu9dg_KfJ4IgjvK248,1071
@@ -36,8 +36,16 @@ optimum/rbln/transformers/models/gpt2/__init__.py,sha256=jsOKYXUclG9G6cwUTUX4eeK
 optimum/rbln/transformers/models/gpt2/gpt2_architecture.py,sha256=RQ0Y5f7IKQ73onmuIRB-aw379asSR7kfhUPclLHCOkY,10348
 optimum/rbln/transformers/models/gpt2/modeling_gpt2.py,sha256=UbVUmegs-v2jBUQUYwxIQ50EpT2dHDzBiPXshLHtuCQ,15079
 optimum/rbln/transformers/models/llama/__init__.py,sha256=5mX-MuKzVBj6WQeVxyPhtvFTv0jeZXAFfg4RZ2nVUh0,1042
-optimum/rbln/transformers/models/llama/llama_architecture.py,sha256=LFaBX8joIHBw5RU-DJnX7soTG4Nfz24mgXS1VHWkTWs,25843
-optimum/rbln/transformers/models/llama/modeling_llama.py,sha256=x8udEqjHKgZQ2QXoyuGTXaT2clfshmI5vds13Kw3I5k,16628
+optimum/rbln/transformers/models/llama/llama_architecture.py,sha256=VAJqz1rsS2tEk2ECb7VjPCrrQn3VP29LpsStpoHz6Uk,27123
+optimum/rbln/transformers/models/llama/llama_architecture_cb.py,sha256=6Ih0rIBuOLAgV7NmW3aOhafAat6x6AGkWqvkKpRf5yc,32664
+optimum/rbln/transformers/models/llama/modeling_llama.py,sha256=_b_3jE-uxkqE5oAXlRHdDY5m_mTHU3A2AVun3gAo2Bk,21027
+optimum/rbln/transformers/models/midm/__init__.py,sha256=_6kYchy47frGMZ8uoUspZ9IwrmCBQJ-8kVfXM7xOMew,1249
+optimum/rbln/transformers/models/midm/hf_hub_cached/configuration_midm.py,sha256=P5JqTTcx56HOccxKbR14ZjA67BI0RNnJycG738JMaJ4,833
+optimum/rbln/transformers/models/midm/hf_hub_cached/midm_bitext_tokenization.py,sha256=p8U2Owo8KJzOnrI5vAcDkT2DCt3r-05zFDD2m6D4pEg,12835
+optimum/rbln/transformers/models/midm/hf_hub_cached/modeling_midm.py,sha256=v5M_uQsdRUyPaiWEATv_FHp-2Duq2moyQJKSFVY-k1U,61035
+optimum/rbln/transformers/models/midm/hf_hub_cached/rotary_position_embedding.py,sha256=5ywaUVKTvqO8GRsHOSXOOGlbiEn-DbGkpJs59_dFb18,4059
+optimum/rbln/transformers/models/midm/midm_architecture.py,sha256=G3fSKuh9CGZXyjM1UPZ3wQAYDDLJZcRlKmV_NgcyfJE,19138
+optimum/rbln/transformers/models/midm/modeling_midm.py,sha256=y2qFgBrE11_MT9-a3LdFfmAc_3lEcy0b3YRbYLkdtlQ,16174
 optimum/rbln/transformers/models/t5/__init__.py,sha256=dK6F1jbBf001h79WZiVdiNZoXm5kOe2fskzhREhu0EE,1057
 optimum/rbln/transformers/models/t5/t5_architecture.py,sha256=2nFovfOdiJdY9jdAR9BngwPO3d2Oofn9jqVWgZ-YYZ0,18091
 optimum/rbln/transformers/models/wav2vec2/__init__.py,sha256=mz4cXqG9b0tDpTAw3qYn3FaJuolX601VmKBE3gohLSw,1043
@@ -49,7 +57,7 @@ optimum/rbln/utils/__init__.py,sha256=wr7ep1WliFYR0825f7BbHevtT3xhlMSwpDkvAPzShg
 optimum/rbln/utils/import_utils.py,sha256=OL3aBy3XLWj7KDb6VZKBPJWiEcktL4qRxlpQpDBcMRg,1116
 optimum/rbln/utils/runtime_utils.py,sha256=EzEabg2E18nq2WZRDZWsZ_hgrdgQ7u_NElTMAYpSDvM,2545
 optimum/rbln/utils/save_utils.py,sha256=eFIPtmiblCJ3MvtxEPxmAR3iuLEUrzpyzwtVotDauhw,3283
-optimum_rbln-0.1.1.dist-info/METADATA,sha256=Rfid8XwR-tT2s_Suti1amUKuKJBjIOcOItwteCT2vAg,6172
-optimum_rbln-0.1.1.dist-info/WHEEL,sha256=vnE8JVcI2Wz7GRKorsPArnBdnW2SWKWGow5gu5tHlRU,90
-optimum_rbln-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-optimum_rbln-0.1.1.dist-info/RECORD,,
+optimum_rbln-0.1.4.dist-info/METADATA,sha256=dh0AyheyqiCICYYtofJApo2-DDp4W1ymrzay6f2VzVw,6197
+optimum_rbln-0.1.4.dist-info/WHEEL,sha256=SOP-4bEE0jbVaCHQGVvF08uWxk5rcSsfEybvoQVHlD8,90
+optimum_rbln-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+optimum_rbln-0.1.4.dist-info/RECORD,,

{optimum_rbln-0.1.1.dist-info → optimum_rbln-0.1.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.3.0)
+Generator: pdm-backend (2.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any