optimum-rbln 0.7.4a9__py3-none-any.whl → 0.7.5a0__py3-none-any.whl

optimum/rbln/__init__.py

@@ -337,6 +337,7 @@ else:
         globals()["__file__"],
         _import_structure,
         module_spec=__spec__,
+        extra_objects={"__version__": __version__},
     )
 
 

optimum/rbln/__version__.py

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

optimum/rbln/configuration_utils.py

@@ -19,7 +19,6 @@ from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
-import rebel
 import torch
 
 from .__version__ import __version__
@@ -533,7 +532,7 @@ class RBLNModelConfig:
 
         Args:
             cls_name (Optional[str]): The class name of the configuration. Defaults to the current class name.
-            create_runtimes (Optional[bool]): Whether to create RBLN runtimes. Defaults to True if an NPU is available.
+            create_runtimes (Optional[bool]): Whether to create RBLN runtimes. Defaults to True.
             optimize_host_memory (Optional[bool]): Whether to optimize host memory usage. Defaults to True.
             device (Optional[Union[int, List[int]]]): The device(s) to load the model onto. Can be a single device ID or a list.
             device_map (Optional[Dict[str, Union[int, List[int]]]]): Mapping from compiled model names to device IDs.
@@ -756,7 +755,7 @@ class RBLNModelConfig:
         if context is not None:
             return context
         elif self._runtime_options["create_runtimes"] is None:
-            return rebel.npu_is_available()
+            return True
         return self._runtime_options["create_runtimes"]
 
     @create_runtimes.setter

optimum/rbln/diffusers/models/controlnet.py

@@ -222,7 +222,7 @@ class RBLNControlNetModel(RBLNModel):
                 f"Mismatch between ControlNet's runtime batch size ({sample_batch_size}) and compiled batch size ({compiled_batch_size}). "
                 "This may be caused by the 'guidance_scale' parameter, which doubles the runtime batch size of ControlNet in Stable Diffusion. "
                 "Adjust the batch size of ControlNet during compilation to match the runtime batch size.\n\n"
-                "For details, see: https://docs.rbln.ai/software/optimum/model_api.html#stable-diffusion"
+                "For details, see: https://docs.rbln.ai/software/optimum/model_api/diffusers/pipelines/controlnet.html#important-batch-size-configuration-for-guidance-scale"
             )
 
         added_cond_kwargs = {} if added_cond_kwargs is None else added_cond_kwargs

optimum/rbln/diffusers/models/transformers/transformer_sd3.py

@@ -161,7 +161,7 @@ class RBLNSD3Transformer2DModel(RBLNModel):
                 f"Mismatch between transformer's runtime batch size ({sample_batch_size}) and compiled batch size ({compiled_batch_size}). "
                 "This may be caused by the 'guidance scale' parameter, which doubles the runtime batch size in Stable Diffusion. "
                 "Adjust the batch size of transformer during compilation.\n\n"
-                "For details, see: https://docs.rbln.ai/software/optimum/model_api.html#stable-diffusion"
+                "For details, see: https://docs.rbln.ai/software/optimum/model_api/diffusers/pipelines/stable_diffusion_3.html#important-batch-size-configuration-for-guidance-scale"
             )
 
         return super().forward(

optimum/rbln/diffusers/models/unets/unet_2d_condition.py

@@ -346,7 +346,7 @@ class RBLNUNet2DConditionModel(RBLNModel):
                 f"Mismatch between UNet's runtime batch size ({sample_batch_size}) and compiled batch size ({compiled_batch_size}). "
                 "This may be caused by the 'guidance scale' parameter, which doubles the runtime batch size of UNet in Stable Diffusion. "
                 "Adjust the batch size of UNet during compilation to match the runtime batch size.\n\n"
-                "For details, see: https://docs.rbln.ai/software/optimum/model_api.html#stable-diffusion"
+                "For details, see: https://docs.rbln.ai/software/optimum/model_api/diffusers/pipelines/stable_diffusion.html#important-batch-size-configuration-for-guidance-scale"
             )
 
         added_cond_kwargs = {} if added_cond_kwargs is None else added_cond_kwargs

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

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 import rebel
 
@@ -37,6 +37,7 @@ class RBLNDecoderOnlyModelForCausalLMConfig(RBLNModelConfig):
         quantization: Optional[Dict[str, Any]] = None,
         prefill_chunk_size: Optional[int] = None,
         kvcache_num_blocks: Optional[int] = None,
+        decoder_batch_sizes: Optional[List[int]] = None,
         **kwargs,
     ):
         """
@@ -53,6 +54,13 @@ class RBLNDecoderOnlyModelForCausalLMConfig(RBLNModelConfig):
             prefill_chunk_size (Optional[int]): The chunk size for prefilling the KV cache. Defaults to 128,
                 and must be a positive integer divisible by 64.
             kvcache_num_blocks (Optional[int]): The number of blocks in the KV cache.
+            decoder_batch_sizes (Optional[List[int]]): A list of batch sizes for which separate decoder models will be compiled.
+                This allows the model to handle varying batch sizes efficiently during generation. If not specified,
+                defaults to a list containing only the model's main batch size. When specifying multiple batch sizes:
+                1) All values must be less than or equal to the main batch size.
+                2) The list will be sorted in descending order (larger batch sizes first).
+                3) If using multiple decoders, at least one batch size should match the main batch size.
+
             **kwargs: Additional arguments passed to the parent RBLNModelConfig.
 
         Raises:
@@ -88,3 +96,25 @@ class RBLNDecoderOnlyModelForCausalLMConfig(RBLNModelConfig):
             raise ValueError("`prefill_chunk_size` must be a positive integer divisible by 64.")
 
         self.kvcache_num_blocks = kvcache_num_blocks
+        self.decoder_batch_sizes = decoder_batch_sizes
+        if self.decoder_batch_sizes is None:
+            self.decoder_batch_sizes = [self.batch_size]
+
+        if self.use_multiple_decoder:
+            if max(self.decoder_batch_sizes) > self.batch_size:
+                raise ValueError(
+                    f"Decoder batch size ({max(self.decoder_batch_sizes)}) must be less than or equal to the runtime batch size ({self.batch_size})."
+                )
+            if max(self.decoder_batch_sizes) < self.batch_size:
+                logger.warning(
+                    f"Maximum decoder batch size ({max(self.decoder_batch_sizes)}) is less than the model's batch size ({self.batch_size}). "
+                    "Appending the model's batch size to the decoder batch size."
+                )
+                self.decoder_batch_sizes.append(self.batch_size)
+
+            # Larger batch size should be at the beginning of the list.
+            self.decoder_batch_sizes.sort(reverse=True)
+
+    @property
+    def use_multiple_decoder(self):
+        return isinstance(self.decoder_batch_sizes, list) and len(self.decoder_batch_sizes) > 1

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

@@ -229,6 +229,12 @@ class RBLNRuntimeModel(RBLNPytorchRuntime):
 
             attention_mask = self.dec_attn_mask
 
+        if self.batch_size < block_tables.shape[0]:
+            block_tables = block_tables[: self.batch_size]
+
+        if self.batch_size < attention_mask.shape[0]:
+            attention_mask = attention_mask[: self.batch_size]
+
         logits = super().forward(
             inputs,
             cache_position,
@@ -417,19 +423,24 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
             use_attention_mask=self.rbln_config.use_attention_mask,
             attn_impl=self.rbln_config.attn_impl,
         )
-        self.decoder = RBLNRuntimeModel(
-            runtime=self.model[1],
-            main_input_name=main_input_name,
-            embed_tokens=self.embed_tokens,
-            phase="decode",
-            batch_size=self.rbln_config.batch_size,
-            dec_attn_mask=dec_attn_mask,
-            block_tables=block_tables,
-            free_block_pool=free_block_pool,
-            kvcache_block_size=self.rbln_config.kvcache_block_size,
-            use_attention_mask=self.rbln_config.use_attention_mask,
-            attn_impl=self.rbln_config.attn_impl,
-        )
+        self.decoders = {}
+        for i, batch_size in enumerate(self.rbln_config.decoder_batch_sizes):
+            self.decoders[batch_size] = RBLNRuntimeModel(
+                runtime=self.model[i + 1],
+                main_input_name=main_input_name,
+                embed_tokens=self.embed_tokens,
+                phase="decode",
+                batch_size=batch_size,
+                dec_attn_mask=dec_attn_mask,
+                block_tables=block_tables,
+                free_block_pool=free_block_pool,
+                kvcache_block_size=self.rbln_config.kvcache_block_size,
+                use_attention_mask=self.rbln_config.use_attention_mask,
+                attn_impl=self.rbln_config.attn_impl,
+            )
+
+        # NOTE(eunji): Use a decoder whose batch size matches the model's main batch size for compatibility.
+        self.decoder = self.decoders[self.rbln_config.batch_size]
 
     @classmethod
     def save_torch_artifacts(
@@ -547,7 +558,6 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
 
         rbln_compile_configs = rbln_config.compile_cfgs
         prefill_compile_config = rbln_compile_configs[0]
-        dec_compile_config = rbln_compile_configs[1]
 
         context = CompileContext(use_weight_sharing=True)
 
@@ -562,33 +572,42 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
                 static_tensors[name] = tensor
                 context.mark_static_address(tensor)
 
-        dec_example_inputs = dec_compile_config.get_dummy_inputs(fill=0, static_tensors=static_tensors)
-
         @QuantizationManager.with_quantization_env
-        def compile_model(*args, **kwargs):
+        def compile_model(wrapped_model, compile_config, example_inputs, compile_context, **kwargs):
             try:
                 original_linear = torch.nn.functional.linear
                 torch.nn.functional.linear = torch.ops.rbln_custom_ops.linear
-                wrapped_model.phase = "prefill"
-                compiled_prefill = RBLNModel.compile(
+                compiled_model = RBLNModel.compile(
                     wrapped_model,
-                    prefill_compile_config,
-                    example_inputs=prefill_example_inputs,
-                    compile_context=context,
+                    compile_config,
+                    example_inputs=example_inputs,
+                    compile_context=compile_context,
                 )
-
-                wrapped_model.phase = "decode"
-                compiled_decoder = RBLNModel.compile(
-                    wrapped_model,
-                    dec_compile_config,
-                    example_inputs=dec_example_inputs,
-                    compile_context=context,
-                )
-                return {"prefill": compiled_prefill, "decoder": compiled_decoder}
+                return compiled_model
             finally:
                 torch.nn.functional.linear = original_linear
 
-        compiled_models = compile_model(quantize_config=rbln_config.quantization)
+        wrapped_model.phase = "prefill"
+        compiled_prefill = compile_model(
+            wrapped_model,
+            prefill_compile_config,
+            prefill_example_inputs,
+            context,
+            quantize_config=rbln_config.quantization,
+        )
+
+        wrapped_model.phase = "decode"
+        compiled_models = {"prefill": compiled_prefill}
+        for batch_size, dec_compile_config in zip(rbln_config.decoder_batch_sizes, rbln_compile_configs[1:]):
+            dec_example_inputs = dec_compile_config.get_dummy_inputs(fill=0, static_tensors=static_tensors)
+            compiled_decoder = compile_model(
+                wrapped_model,
+                dec_compile_config,
+                dec_example_inputs,
+                context,
+                quantize_config=rbln_config.quantization,
+            )
+            compiled_models[f"decoder_batch_{batch_size}"] = compiled_decoder
 
         # check if the memory is enough to have additional blocks
         required_num_blocks = (rbln_config.max_seq_len // rbln_config.kvcache_block_size) * rbln_config.batch_size
@@ -613,8 +632,11 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
         alloc_memory_by_key: Dict[str, int] = {
             key: sum(memory_per_node) for key, memory_per_node in alloc_memory_per_node_by_key.items()
         }
-        for key, memory_per_node in compiled_models["decoder"].get_alloc_per_node_by_key().items():
-            alloc_memory_by_key[key] += sum(memory_per_node)
+        for batch_size in rbln_config.decoder_batch_sizes:
+            for key, memory_per_node in (
+                compiled_models[f"decoder_batch_{batch_size}"].get_alloc_per_node_by_key().items()
+            ):
+                alloc_memory_by_key[key] += sum(memory_per_node)
         alloc_memory_by_key.pop("PortRecur")  # kv-cache
         kernel_size = alloc_memory_by_key.pop("Kernel")  # model weight
 
@@ -650,6 +672,7 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
         n_model_params: Optional[int] = None,
         kernel_size: Optional[int] = None,
         buffer: Optional[int] = None,
+        num_runtimes: int = 2,
     ) -> int:
         """
         We are finding max_n_blocks(x) that satisfies the following equation:
@@ -721,7 +744,8 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
 
         if buffer is None:
             # TODO: Accurate buffer estimation
-            buffer_per_core = 2**29  # 500MB per npu
+            buffer_per_runtime_per_core = 2**28  # 256MB per runtime
+            buffer_per_core = buffer_per_runtime_per_core * num_runtimes  # 1 for prefill, 1 for decoder
             buffer = buffer_per_core * tensor_parallel_size
         available_dram -= buffer
 
@@ -839,6 +863,7 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
                 kvcache_block_size=rbln_config.kvcache_block_size,
                 nbits_per_param=16 if not rbln_config.quantization else 4,  # TODO(jongho): FIX Ad-hoc
                 n_model_params=sum(p.numel() for p in model.parameters()),
+                num_runtimes=1 + len(rbln_config.decoder_batch_sizes),
             )
 
             max_num_blocks = min(max_num_blocks, estimated_max_num_blocks)
@@ -881,24 +906,28 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
             hidden_size=hidden_size,
             head_dim=head_dim,
         )
-        dec_input_info = cls.get_input_info(
-            batch_size=rbln_config.batch_size,
-            query_length=1,
-            use_inputs_embeds=rbln_config.use_inputs_embeds,
-            use_attention_mask=rbln_config.use_attention_mask,
-            max_seq_len=rbln_config.max_seq_len,
-            kvcache_block_size=rbln_config.kvcache_block_size,
-            kvcache_num_blocks=rbln_config.kvcache_num_blocks,
-            num_key_value_heads=num_key_value_heads,
-            num_hidden_layers=num_hidden_layers,
-            hidden_size=hidden_size,
-            head_dim=head_dim,
-        )
 
         prefill_compile_config = RBLNCompileConfig(compiled_model_name="prefill", input_info=prefill_input_info)
-        dec_compile_config = RBLNCompileConfig(compiled_model_name="decoder", input_info=dec_input_info)
 
-        rbln_config.set_compile_cfgs([prefill_compile_config, dec_compile_config])
+        dec_compile_configs = []
+        for batch_size in rbln_config.decoder_batch_sizes:
+            dec_input_info = cls.get_input_info(
+                batch_size=batch_size,
+                query_length=1,
+                use_inputs_embeds=rbln_config.use_inputs_embeds,
+                use_attention_mask=rbln_config.use_attention_mask,
+                max_seq_len=rbln_config.max_seq_len,
+                kvcache_block_size=rbln_config.kvcache_block_size,
+                kvcache_num_blocks=rbln_config.kvcache_num_blocks,
+                num_key_value_heads=num_key_value_heads,
+                num_hidden_layers=num_hidden_layers,
+                hidden_size=hidden_size,
+                head_dim=head_dim,
+            )
+            dec_compile_configs.append(
+                RBLNCompileConfig(compiled_model_name=f"decoder_batch_{batch_size}", input_info=dec_input_info)
+            )
+        rbln_config.set_compile_cfgs([prefill_compile_config, *dec_compile_configs])
 
         return rbln_config
 
@@ -908,8 +937,12 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
         compiled_models: List[rebel.RBLNCompiledModel],
         rbln_config: RBLNDecoderOnlyModelForCausalLMConfig,
     ) -> List[rebel.Runtime]:
-        if any(model_name not in rbln_config.device_map for model_name in ["prefill", "decoder"]):
-            cls._raise_missing_compiled_file_error(["prefill", "decoder"])
+        expected_model_names = [
+            "prefill",
+            *[f"decoder_batch_{batch_size}" for batch_size in rbln_config.decoder_batch_sizes],
+        ]
+        if any(model_name not in rbln_config.device_map for model_name in expected_model_names):
+            cls._raise_missing_compiled_file_error(expected_model_names)
 
         return [
             rebel.Runtime(
@@ -918,12 +951,15 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
                 device=rbln_config.device_map["prefill"],
                 activate_profiler=rbln_config.activate_profiler,
             ),
-            rebel.Runtime(
-                compiled_models[1],
-                tensor_type="pt",
-                device=rbln_config.device_map["decoder"],
-                activate_profiler=rbln_config.activate_profiler,
-            ),
+            *[
+                rebel.Runtime(
+                    compiled_models[i + 1],
+                    tensor_type="pt",
+                    device=rbln_config.device_map[f"decoder_batch_{batch_size}"],
+                    activate_profiler=rbln_config.activate_profiler,
+                )
+                for i, batch_size in enumerate(rbln_config.decoder_batch_sizes)
+            ],
         ]
 
     def get_decoder(self):
@@ -1024,7 +1060,15 @@ class RBLNDecoderOnlyModelForCausalLM(RBLNModel):
             logits = torch.cat(logits, dim=0)
         # Decoder
         else:
-            logits = self.decoder(
+            inputs = inputs_embeds if inputs_embeds is not None else input_ids
+            batch_size = inputs.shape[0]
+            if batch_size not in self.decoders:
+                raise ValueError(
+                    f"No decoder runtime available for batch size {batch_size}. "
+                    f"Available batch sizes are: {list(self.decoders.keys())}. "
+                    f"Please run your model with one of these batch sizes or add support for batch size {batch_size}."
+                )
+            logits = self.decoders[batch_size](
                 input_ids=input_ids,
                 inputs_embeds=inputs_embeds,
                 cache_position=cache_position,

optimum/rbln/utils/import_utils.py

@@ -144,10 +144,27 @@ def check_version_compats() -> None:
         except importlib.metadata.PackageNotFoundError:
             warnings.warn(f"optimum-rbln requires {compat.package_name} to be installed.", ImportWarning)
             continue
+        # For versions 0.7.2 and above, don't show warning for rebel-compiler if base versions match
 
-        if not Version(compat.min_version) <= Version(dep_version) < Version(compat.max_version):
-            warnings.warn(
-                f"optimum-rbln v{my_version} is compatible to {compat.package_name} v{compat.min_version} to v{compat.max_version}. (you are currently using v{dep_version})\n"
-                "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
-                ImportWarning,
-            )
+        if compat.package_name == "rebel-compiler":
+            # For optimum-rbln versions 0.7.2 and above, suppress the warning if the base versions of
+            # optimum-rbln and rebel-compiler match (e.g., 0.7.x with 0.7.y).
+            if (
+                Version(my_version) >= Version("0.7.2")
+                and Version(my_version).base_version == Version(dep_version).base_version
+            ):
+                continue
+            else:
+                warnings.warn(
+                    f"Version mismatch detected: optimum-rbln v{my_version} and {compat.package_name} v{dep_version} have different base versions. "
+                    f"For optimal performance and compatibility, please ensure both packages share the same major and minor version numbers. "
+                    "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
+                    ImportWarning,
+                )
+        else:
+            if not Version(compat.min_version) <= Version(dep_version) < Version(compat.max_version):
+                warnings.warn(
+                    f"optimum-rbln v{my_version} is compatible to {compat.package_name} v{compat.min_version} to v{compat.max_version}. (you are currently using v{dep_version})\n"
+                    "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
+                    ImportWarning,
+                )

{optimum_rbln-0.7.4a9.dist-info → optimum_rbln-0.7.5a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.7.4a9
+Version: 0.7.5a0
 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.7.4a9.dist-info → optimum_rbln-0.7.5a0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-optimum/rbln/__init__.py,sha256=c2whRR6XkelNLlH1MwAKYMoaBEhmGxSQFrhfKS1JC-I,13186
-optimum/rbln/__version__.py,sha256=GuANUTgAHXrhQ4V27YBqp-zK5jY_U9soaBj4Ef2cU3A,519
-optimum/rbln/configuration_utils.py,sha256=rOXG9_ptYwzLlDIebd-CoiT3i6xaZl5IVPplLIrUyoE,31106
+optimum/rbln/__init__.py,sha256=89QJBCQbW1u83pFzFif2gwnJ09eAWYEUEuiVF_mDHBI,13238
+optimum/rbln/__version__.py,sha256=bJpxWEb0lqqNtDNdD8kjIjXRVQ1JbWhjYWAaVwJIkmU,519
+optimum/rbln/configuration_utils.py,sha256=Bz4mDuKQAbIvd1F1E5hssLenqUIwGWYZIRAe0UCaHbU,31050
 optimum/rbln/modeling.py,sha256=qDXB69Oq0jx9hfONebDiSNe2_DgKYhnAGLTbGAtwYVw,9677
 optimum/rbln/modeling_base.py,sha256=iQKw2IORu1cN6sOK0xeBVrhatt-ZPeinT_v6l2FnGRw,24173
 optimum/rbln/diffusers/__init__.py,sha256=XL6oKPHbPCV6IVCw3fu0-M9mD2KO_x6unx5kJdAtpVY,6180
@@ -20,16 +20,16 @@ optimum/rbln/diffusers/configurations/pipelines/configuration_stable_diffusion.p
 optimum/rbln/diffusers/configurations/pipelines/configuration_stable_diffusion_3.py,sha256=54NTvVur7RADGgjGwO33s76dgKQ4zVNvmFl68rQFapw,6370
 optimum/rbln/diffusers/configurations/pipelines/configuration_stable_diffusion_xl.py,sha256=H0hqsqpAfqb9gBIK5KsfUf9gX9cTnggK9Nt2aqfzeIM,5528
 optimum/rbln/diffusers/models/__init__.py,sha256=mkCvJyH1KcwrsUvYSq_bVC79oOfyqtBSFDyPS1_48wA,1478
-optimum/rbln/diffusers/models/controlnet.py,sha256=m2hHKrom1ladsDO4bTSZ7o_bIRrLRpzv7XBI2BlesxY,10224
+optimum/rbln/diffusers/models/controlnet.py,sha256=kzDbUckGlioor8t0kKBvwi-hzNaG15XluEzTa7xZs1Q,10292
 optimum/rbln/diffusers/models/autoencoders/__init__.py,sha256=dg17ZTUsiqTcbIaEE4fqew9uRbao0diQ21PXvRKIqKg,679
 optimum/rbln/diffusers/models/autoencoders/autoencoder_kl.py,sha256=qjReFNmuQEjnHjoI8f7ClAp_rRTA1vIk-3dwxJi6s7U,7905
 optimum/rbln/diffusers/models/autoencoders/vae.py,sha256=_fyFco2697uT1zo_P_fGML-_zqZw2sUQp3tRRjA5pg4,4172
 optimum/rbln/diffusers/models/autoencoders/vq_model.py,sha256=DC8Nee8_BabGhagJgpCUDhA-oaTpZMg-lCVzXJ6dNEw,6134
 optimum/rbln/diffusers/models/transformers/__init__.py,sha256=V8rSR7WzHs-i8Cwb_MNxhY2NFbwPgxu24vGtkwl-6tk,706
 optimum/rbln/diffusers/models/transformers/prior_transformer.py,sha256=d7CYmm88lozepqXjmrFr4qsQ-lRE_10wQRwnenMSflU,4989
-optimum/rbln/diffusers/models/transformers/transformer_sd3.py,sha256=qBdk8fBxOnlRywUDKMab1G4YpFDVnMOkTyhKW9LPops,6503
+optimum/rbln/diffusers/models/transformers/transformer_sd3.py,sha256=ywWiRAYQ0wfKMMZBrJ9C34GBwIu92F5QXSG8qi7Cr6s,6579
 optimum/rbln/diffusers/models/unets/__init__.py,sha256=MaICuK9CWjgzejXy8y2NDrphuEq1rkzanF8u45k6O5I,655
-optimum/rbln/diffusers/models/unets/unet_2d_condition.py,sha256=bFFidMPZ2JgZf5tQVi2WNrDtT_yRDyqzNlkZ-wvQm7M,15481
+optimum/rbln/diffusers/models/unets/unet_2d_condition.py,sha256=dyrez3vS0_YSxTVwcjlSijDJhe6XchdsLsCFv74HiFQ,15555
 optimum/rbln/diffusers/pipelines/__init__.py,sha256=5KLZ5LrpMzBya2e_3_PvEoPwG24U8JMexfw_ygZREKc,3140
 optimum/rbln/diffusers/pipelines/controlnet/__init__.py,sha256=n1Ef22TSeax-kENi_d8K6wGGHSNEo9QkUeygELHgcao,983
 optimum/rbln/diffusers/pipelines/controlnet/multicontrolnet.py,sha256=Cv__E0Boc6TSOIv8TdXVE821zIiPG4MVI_lnaGSqquk,4102
@@ -81,9 +81,9 @@ optimum/rbln/transformers/models/clip/__init__.py,sha256=TLeXDqcFK6M6v9x7Xr64kBb
 optimum/rbln/transformers/models/clip/configuration_clip.py,sha256=wgfZeVvcVdSzrN9tcnt7DKJQ0NLR0REvW7MyUXyv2Bg,2976
 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/configuration_decoderonly.py,sha256=tIBzKmts1Ea-CZWXC7RtJqeE9bd5wjmkugZg269wmVg,5962
 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/decoderonly/modeling_decoderonly.py,sha256=n5Kh5hE49m8Rl94DDwe2aDD3Y-dCPwRcENn-x9qkpzM,45245
 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
@@ -157,13 +157,13 @@ optimum/rbln/transformers/utils/rbln_quantization.py,sha256=gwBVHf97sQgPNmGa0wq8
 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=Z_R9Ic9VAew8bUmlaAlxZf5JGMDBivHvvFRI557pILY,4196
-optimum/rbln/utils/import_utils.py,sha256=uMldLJmDVMj5uHvxBfb96uV29bfGEDvlksLY26GOHAs,4389
+optimum/rbln/utils/import_utils.py,sha256=fpOERIIxXm-cDYGn1NN6c7aWDPQYVitPQW2MiyZ9NEY,5471
 optimum/rbln/utils/logging.py,sha256=VKKBmlQSdg6iZCGmAXaWYiW67K84jyp1QJhLQSSjPPE,3453
 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=TtcH3OLctFd2Dosc-zNMGZ8xOXKKUfE91dLQ1v09E8Q,4636
-optimum_rbln-0.7.4a9.dist-info/METADATA,sha256=s2GSC8Y7NFqtsFxZFbkYzQdMRBuyzA6zjKeON7ov8G0,5299
-optimum_rbln-0.7.4a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-optimum_rbln-0.7.4a9.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-optimum_rbln-0.7.4a9.dist-info/RECORD,,
+optimum_rbln-0.7.5a0.dist-info/METADATA,sha256=4whxRZ9ifF1V_E6GUaWfwDfEW8oM0ahTpV_KttLvsrE,5299
+optimum_rbln-0.7.5a0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+optimum_rbln-0.7.5a0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+optimum_rbln-0.7.5a0.dist-info/RECORD,,