optimum-rbln 0.9.1__py3-none-any.whl → 0.9.2__py3-none-any.whl

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

@@ -123,7 +123,10 @@ class MidmAttention(DecoderOnlyAttention):
         self.split_size = self._original_mod.split_size
         self.num_key_value_heads = self._original_mod.num_heads
 
-    def projection(self, hidden_states) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    def projection(self, hidden_states, lora_int_id) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        if lora_int_id is not None:
+            raise NotImplementedError("LoRA is not supported for MidmAttention")
+
         query_states, key_states, value_states = self.c_attn(hidden_states).split(self.split_size, dim=2)
         return query_states, key_states, value_states
 

optimum/rbln/transformers/models/phi/phi_architecture.py

@@ -56,7 +56,10 @@ class PhiAttention(DecoderOnlyAttention):
         self.qk_layernorm = self._original_mod.qk_layernorm
         self.rotary_ndims = self._original_mod.rotary_ndims
 
-    def projection(self, hidden_states) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    def projection(self, hidden_states, lora_int_id) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        if lora_int_id is not None:
+            raise NotImplementedError("LoRA is not supported for PhiAttention")
+
         query_states = self.q_proj(hidden_states)
         key_states = self.k_proj(hidden_states)
         value_states = self.v_proj(hidden_states)
@@ -84,6 +87,7 @@ class PhiLayer(DecoderOnlyLayer):
         cos: Optional[torch.Tensor] = None,
         sin: Optional[torch.Tensor] = None,
         block_tables: Optional[torch.Tensor] = None,
+        lora_int_id: Optional[torch.Tensor] = None,
     ):
         residual = hidden_states
 

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

@@ -36,8 +36,6 @@ 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"]
@@ -128,8 +126,11 @@ class RBLNRuntimePixtralVisionModel(RBLNPytorchRuntime):
                 (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)
+            if "out" in kwargs:
+                super().forward(patch_embed_seq, attention_mask, cos, sin, **kwargs)
+                transformer_output = kwargs["out"]
+            else:
+                transformer_output = super().forward(patch_embed_seq, attention_mask, cos, sin, **kwargs)
 
             last_hidden_state_list.append(transformer_output[0][:, : h_patched_original * w_patched_original, :])
             hidden_states = transformer_output[1:]
@@ -236,12 +237,6 @@ class RBLNPixtralVisionModel(RBLNModel):
         }
         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,
@@ -309,7 +304,7 @@ class RBLNPixtralVisionModel(RBLNModel):
             )
 
         output = self.model(
-            pixel_values, image_sizes, output_hidden_states=output_hidden_states, return_dict=return_dict
+            pixel_values, image_sizes, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs
         )
 
         return output

optimum/rbln/transformers/models/qwen2_5_vl/modeling_qwen2_5_vl.py

@@ -23,6 +23,7 @@ from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import (
     Qwen2_5_VisionPatchEmbed,
     Qwen2_5_VisionRotaryEmbedding,
     Qwen2_5_VisionTransformerPretrainedModel,
+    Qwen2_5_VLModel,
     Qwen2_5_VLRotaryEmbedding,
 )
 
@@ -392,13 +393,12 @@ class RBLNQwen2_5_VLForConditionalGeneration(RBLNDecoderOnlyModelForCausalLM):
         return True
 
     @classmethod
-    def update_kwargs(cls, kwargs):
-        kwargs.update(
-            {
-                "_attn_implementation": "eager",
-            }
-        )
-        return super().update_kwargs(kwargs)
+    def get_pytorch_model(cls, *args, **kwargs):
+        model = super().get_pytorch_model(*args, **kwargs)
+        model.model.lm_head = model.lm_head
+        model.lm_head = None
+        del model.lm_head
+        return model
 
     @classmethod
     def get_input_info(
@@ -532,7 +532,8 @@ class RBLNQwen2_5_VLForConditionalGeneration(RBLNDecoderOnlyModelForCausalLM):
             vision_tokens = input_id[0][vision_start_indices + 1]
             image_nums = (vision_tokens == image_token_id).sum()
             video_nums = (vision_tokens == video_token_id).sum()
-            position_ids, rope_deltas = self.get_rope_index(
+            position_ids, rope_deltas = Qwen2_5_VLModel.get_rope_index(
+                self,
                 input_id,
                 image_grid_thw[image_idx : image_idx + image_nums] if image_grid_thw is not None else None,
                 video_grid_thw[video_idx : video_idx + video_nums] if video_grid_thw is not None else None,

optimum/rbln/transformers/models/qwen2_5_vl/qwen2_5_vl_architecture.py

@@ -3,6 +3,7 @@ from typing import Tuple
 
 import torch
 import torch.nn as nn
+from transformers import PreTrainedModel
 
 from ..decoderonly.decoderonly_architecture import DecoderOnlyWrapper, apply_rotary_pos_emb
 
@@ -164,6 +165,7 @@ class Qwen2_5_VL_LanguageModelWrapper(DecoderOnlyWrapper):
         position_embeds = args.pop(0)
         query_position = args.pop(0) if self.phase == "prefill" else None
         position_ids = None
+        lora_int_id = None
         attention_mask = args.pop(0) if self.rbln_config.use_attention_mask else None
         past_key_values = args
 
@@ -191,6 +193,28 @@ class Qwen2_5_VL_LanguageModelWrapper(DecoderOnlyWrapper):
             query_position,
             attention_mask,
             position_ids,
+            lora_int_id,
             past_key_values,
             position_embeds,
         )
+
+    def convert_to_rbln_class(self, model: PreTrainedModel, max_seq_len: int):
+        new_layers = []
+
+        for layer_idx, layer in enumerate(model.model.language_model.layers):
+            is_sliding = layer_idx in self.rbln_config.sliding_window_layers
+            new_self_attn = self.get_rbln_attn_class()(
+                self.get_attn_layer(layer), self.rbln_config, is_sliding=is_sliding
+            )
+            new_layer = self.get_rbln_layer_class()(layer, new_self_attn)
+            new_layers.append(new_layer)
+
+        new_model = self.get_rbln_model_class()(
+            model.model.language_model,
+            new_layers,
+            self.rbln_config,
+            use_learned_pos_emb=self.__class__._use_learned_pos_emb,
+        )
+
+        new_model = self.get_rbln_causal_lm_class()(model.model, new_model)
+        return new_model

optimum/rbln/transformers/models/qwen2_vl/modeling_qwen2_vl.py

@@ -27,6 +27,7 @@ from transformers.modeling_utils import no_init_weights
 from transformers.models.qwen2_vl.modeling_qwen2_vl import (
     PatchEmbed,
     Qwen2VisionTransformerPretrainedModel,
+    Qwen2VLModel,
     Qwen2VLRotaryEmbedding,
     VisionRotaryEmbedding,
 )
@@ -280,6 +281,14 @@ class RBLNQwen2VLForConditionalGeneration(RBLNDecoderOnlyModelForCausalLM):
     def can_generate(self):
         return True
 
+    @classmethod
+    def get_pytorch_model(cls, *args, **kwargs):
+        model = super().get_pytorch_model(*args, **kwargs)
+        model.model.lm_head = model.lm_head
+        model.lm_head = None
+        del model.lm_head
+        return model
+
     @classmethod
     def get_input_info(
         cls,
@@ -402,7 +411,8 @@ class RBLNQwen2VLForConditionalGeneration(RBLNDecoderOnlyModelForCausalLM):
             vision_tokens = input_id[0][vision_start_indices + 1]
             image_nums = (vision_tokens == image_token_id).sum()
             video_nums = (vision_tokens == video_token_id).sum()
-            position_ids, rope_deltas = self.get_rope_index(
+            position_ids, rope_deltas = Qwen2VLModel.get_rope_index(
+                self,
                 input_id,
                 image_grid_thw[image_idx : image_idx + image_nums] if image_grid_thw is not None else None,
                 video_grid_thw[video_idx : video_idx + video_nums] if video_grid_thw is not None else None,

optimum/rbln/transformers/models/qwen2_vl/qwen2_vl_architecture.py

@@ -3,6 +3,7 @@ from typing import Tuple
 
 import torch
 import torch.nn as nn
+from transformers import PreTrainedModel
 
 from ..decoderonly.decoderonly_architecture import (
     DecoderOnlyWrapper,
@@ -110,6 +111,7 @@ class Qwen2VL_LanguageModelWrapper(DecoderOnlyWrapper):
         query_position = args.pop(0) if self.phase == "prefill" else None
         position_ids = None
         attention_mask = args.pop(0) if self.rbln_config.use_attention_mask else None
+        lora_int_id = args.pop(0) if self.rbln_config.lora_config else None
         past_key_values = args
 
         if len(past_key_values) != 2 * self.num_hidden_layers:
@@ -136,6 +138,28 @@ class Qwen2VL_LanguageModelWrapper(DecoderOnlyWrapper):
             query_position,
             attention_mask,
             position_ids,
+            lora_int_id,
             past_key_values,
             position_embeds,
         )
+
+    def convert_to_rbln_class(self, model: PreTrainedModel, max_seq_len: int):
+        new_layers = []
+
+        for layer_idx, layer in enumerate(model.model.language_model.layers):
+            is_sliding = layer_idx in self.rbln_config.sliding_window_layers
+            new_self_attn = self.get_rbln_attn_class()(
+                self.get_attn_layer(layer), self.rbln_config, is_sliding=is_sliding
+            )
+            new_layer = self.get_rbln_layer_class()(layer, new_self_attn)
+            new_layers.append(new_layer)
+
+        new_model = self.get_rbln_model_class()(
+            model.model.language_model,
+            new_layers,
+            self.rbln_config,
+            use_learned_pos_emb=self.__class__._use_learned_pos_emb,
+        )
+
+        new_model = self.get_rbln_causal_lm_class()(model.model, new_model)
+        return new_model

optimum/rbln/transformers/models/seq2seq/modeling_seq2seq.py

@@ -20,6 +20,7 @@ import rebel
 import torch
 from rebel.compile_context import CompileContext
 from transformers import AutoModelForSeq2SeqLM, PretrainedConfig, PreTrainedModel
+from transformers.generation.utils import GenerationMixin
 from transformers.modeling_outputs import BaseModelOutput, Seq2SeqLMOutput
 
 from ....configuration_utils import RBLNCompileConfig
@@ -101,7 +102,7 @@ class RBLNRuntimeDecoder(RBLNPytorchRuntime):
         return Seq2SeqLMOutput(logits=lm_logits)
 
 
-class RBLNModelForSeq2SeqLM(RBLNModel, ABC):
+class RBLNModelForSeq2SeqLM(RBLNModel, GenerationMixin, ABC):
     """
     This is a generic model class that will be instantiated as one of the model classes of the library (with a sequence-to-sequence language modeling head) when created with the from_pretrained() class method.
     This model inherits from [`RBLNModel`]. Check the superclass documentation for the generic methods the library implements for all its models.
@@ -117,6 +118,7 @@ class RBLNModelForSeq2SeqLM(RBLNModel, ABC):
     main_input_name = "input_ids"
     auto_model_class = AutoModelForSeq2SeqLM
     support_causal_attn = None
+    _is_stateful = False
 
     def __post_init__(self, **kwargs):
         batch_size = self.rbln_config.batch_size

optimum/rbln/transformers/models/siglip/modeling_siglip.py

@@ -29,8 +29,6 @@ logger = get_logger(__name__)
 if TYPE_CHECKING:
     from transformers import AutoFeatureExtractor, AutoProcessor, AutoTokenizer, PreTrainedModel
 
-    from ....diffusers.modeling_diffusers import RBLNDiffusionMixin, RBLNDiffusionMixinConfig
-
 
 class _SiglipVisionModel(torch.nn.Module):
     def __init__(
@@ -65,6 +63,8 @@ class RBLNSiglipVisionModel(RBLNModel):
     on RBLN devices, supporting image encoding for multimodal vision-language tasks.
     """
 
+    _tp_support = False
+
     @classmethod
     def wrap_model_if_needed(cls, model: torch.nn.Module, rbln_config: RBLNSiglipVisionModelConfig) -> torch.nn.Module:
         wrapper_cfg = {
@@ -74,12 +74,6 @@ class RBLNSiglipVisionModel(RBLNModel):
         }
         return _SiglipVisionModel(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,
@@ -128,11 +122,6 @@ class RBLNSiglipVisionModel(RBLNModel):
         interpolate_pos_encoding: bool = False,
         **kwargs: Any,
     ) -> Union[Tuple, BaseModelOutputWithPooling]:
-        if len(kwargs) > 0 and any(value is not None for value in kwargs.values()):
-            logger.warning(
-                f"Currently, optimum-rbln does not support kwargs {kwargs.keys()} for {self.__class__.__name__}."
-            )
-
         output_attentions = output_attentions if output_attentions is not None else self.rbln_config.output_attentions
         output_hidden_states = (
             output_hidden_states if output_hidden_states is not None else self.rbln_config.output_hidden_states
@@ -156,7 +145,7 @@ class RBLNSiglipVisionModel(RBLNModel):
                 f"Please compile again with the correct argument."
             )
 
-        output = super().forward(pixel_values, return_dict=return_dict)
+        output = super().forward(pixel_values, return_dict=return_dict, **kwargs)
         return output
 
     def _prepare_output(self, output, return_dict):

optimum/rbln/transformers/models/whisper/generation_whisper.py

@@ -39,14 +39,31 @@ from transformers.models.whisper.generation_whisper import WhisperGenerationMixi
 
 
 class RBLNWhisperGenerationMixin(WhisperGenerationMixin, GenerationMixin):
-    """
-    This class is based on transformers version 4.44.2.
-    It uses the same generate() method, so it's crucial to maintain the inheritance order.
-    Ensure WhisperGenerationMixin is listed before GenerationMixin.
-    """
+    def generate(self, *args, generation_config=None, **kwargs):
+        num_beams = kwargs.get(
+            "num_beams",
+            generation_config.num_beams
+            if hasattr(generation_config, "num_beams") and generation_config.num_beams is not None
+            else 1,
+        )
+        if num_beams > 1:
+            raise ValueError(
+                f"Beam search is not supported in RBLNWhisperGenerationMixin. "
+                f"Received num_beams={num_beams}, but only num_beams=1 is allowed. "
+                f"Please set num_beams=1 for greedy search or adjust your configuration."
+            )
+
+        return super().generate(*args, **kwargs)
 
     def _postprocess_outputs(
-        self, seek_outputs, decoder_input_ids, return_token_timestamps, generation_config, *args, **kwargs
+        self,
+        seek_outputs,
+        decoder_input_ids,
+        return_token_timestamps,
+        generation_config,
+        is_shortform,
+        seek,
+        batch_idx_map,
     ):
         # remove all previously passed decoder input ids
         # should happen only if it is the first generated segment
@@ -64,6 +81,11 @@ class RBLNWhisperGenerationMixin(WhisperGenerationMixin, GenerationMixin):
 
         if return_token_timestamps and hasattr(generation_config, "alignment_heads"):
             num_frames = getattr(generation_config, "num_frames", None)
+
+            if num_frames is not None:
+                num_frames = num_frames - seek
+                num_frames = num_frames[batch_idx_map]
+
             if version.parse(transformers.__version__) >= version.parse("4.46.0"):
                 seek_outputs["token_timestamps"] = self._extract_token_timestamps(
                     seek_outputs,

optimum/rbln/transformers/models/whisper/modeling_whisper.py

@@ -150,7 +150,8 @@ class RBLNWhisperForConditionalGeneration(RBLNModel, RBLNWhisperGenerationMixin)
     """
 
     auto_model_class = AutoModelForSpeechSeq2Seq
-    main_input_name = "input_ids"
+    main_input_name = "input_features"
+    _is_stateful = False
 
     def __post_init__(self, **kwargs):
         super().__post_init__(**kwargs)

optimum/rbln/transformers/utils/rbln_runtime_wrapper.py

@@ -0,0 +1,79 @@
+# 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 abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Union
+
+from torch.nn import Module
+
+from ...modeling import RBLNModel
+
+
+if TYPE_CHECKING:
+    import rebel
+
+
+class LoopProcessor(Module, ABC):
+    def __init__(self, model: Union[RBLNModel, "rebel.Runtime"]):
+        super().__init__()
+        self.model = model
+
+    def __repr__(self) -> str:
+        return repr(self.model)
+
+    def _is_batch_implemented(self) -> bool:
+        return self._forward_batch.__func__ is not LoopProcessor._forward_batch
+
+    def forward(self, *args, force_loop: bool = False, **kwargs) -> Any:
+        if not force_loop and self._is_batch_implemented():
+            return self._forward_batch(*args, **kwargs)
+        else:
+            return self._forward_loop(*args, **kwargs)
+
+    def _forward_loop(self, *args, **kwargs) -> Any:
+        batch_size = self._get_batch_size(*args, **kwargs)
+
+        if not isinstance(batch_size, int) or batch_size == 0:
+            return self._process_outputs([])
+
+        common_inputs = self._prepare_inputs_before_loop(*args, **kwargs)
+
+        outputs = []
+        for i in range(batch_size):
+            item_args, item_kwargs = self._prepare_inputs_for_iteration(i, common_inputs, *args, **kwargs)
+            item_output = self.model(*item_args, **item_kwargs)
+            outputs.append(item_output)
+
+        return self._process_outputs(outputs, **kwargs)
+
+    def _forward_batch(self, *args, **kwargs) -> Any:
+        raise NotImplementedError("The batch processing logic (_forward_batch) is not implemented in this class.")
+
+    @abstractmethod
+    def _get_batch_size(self, *args, **kwargs) -> int:
+        pass
+
+    @abstractmethod
+    def _prepare_inputs_for_iteration(
+        self, index: int, common_inputs: Dict[str, Any], *args, **kwargs
+    ) -> Tuple[List[Any], Dict[str, Any]]:
+        pass
+
+    def _prepare_inputs_before_loop(self, *args, **kwargs) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def _process_outputs(self, outputs: List[Any], **kwargs) -> Any:
+        pass

optimum/rbln/utils/runtime_utils.py

@@ -167,33 +167,44 @@ class ContextRblnConfig:
         device=None,
         device_map=None,
         create_runtimes=None,
-        optimize_host_mem=None,
         activate_profiler=None,
         timeout=None,
     ):
         self.device = device
         self.device_map = device_map
         self.create_runtimes = create_runtimes
-        self.optimize_host_mem = optimize_host_mem
         self.activate_profiler = activate_profiler
         self.timeout = timeout
+        self._previous_context = None
 
     def __enter__(self):
-        self._local.device = self.device
-        self._local.device_map = self.device_map
-        self._local.create_runtimes = self.create_runtimes
-        self._local.optimize_host_memory = self.optimize_host_mem
-        self._local.activate_profiler = self.activate_profiler
-        self._local.timeout = self.timeout
+        self._previous_context = {
+            "device": getattr(self._local, "device", None),
+            "device_map": getattr(self._local, "device_map", None),
+            "create_runtimes": getattr(self._local, "create_runtimes", None),
+            "activate_profiler": getattr(self._local, "activate_profiler", None),
+            "timeout": getattr(self._local, "timeout", None),
+        }
+
+        if self.device is not None:
+            self._local.device = self.device
+        if self.device_map is not None:
+            self._local.device_map = self.device_map
+        if self.create_runtimes is not None:
+            self._local.create_runtimes = self.create_runtimes
+        if self.activate_profiler is not None:
+            self._local.activate_profiler = self.activate_profiler
+        if self.timeout is not None:
+            self._local.timeout = self.timeout
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self._local.device = None
-        self._local.device_map = None
-        self._local.create_runtimes = None
-        self._local.optimize_host_memory = None
-        self._local.activate_profiler = None
-        self._local.timeout = None
+        if self._previous_context is not None:
+            self._local.device = self._previous_context["device"]
+            self._local.device_map = self._previous_context["device_map"]
+            self._local.create_runtimes = self._previous_context["create_runtimes"]
+            self._local.activate_profiler = self._previous_context["activate_profiler"]
+            self._local.timeout = self._previous_context["timeout"]
 
     @classmethod
     def get_current_context(cls):
@@ -201,7 +212,6 @@ class ContextRblnConfig:
             "device": getattr(cls._local, "device", None),
             "device_map": getattr(cls._local, "device_map", None),
             "create_runtimes": getattr(cls._local, "create_runtimes", None),
-            "optimize_host_memory": getattr(cls._local, "optimize_host_memory", None),
             "activate_profiler": getattr(cls._local, "activate_profiler", None),
             "timeout": getattr(cls._local, "timeout", None),
         }

optimum/rbln/utils/submodule.py

@@ -17,7 +17,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 from transformers import PretrainedConfig
 
-from ..configuration_utils import RBLNModelConfig
+from ..configuration_utils import RBLNModelConfig, get_rbln_config_class
 from ..utils.model_utils import get_rbln_model_cls
 
 
@@ -41,6 +41,15 @@ class SubModulesMixin:
         for submodule_meta, submodule in zip(self._rbln_submodules, rbln_submodules):
             setattr(self, submodule_meta["name"], submodule)
 
+    @classmethod
+    def _get_submodule_config_class(
+        cls, cls_name: str, submodule_rbln_config: Dict[str, Any]
+    ) -> Type[RBLNModelConfig]:
+        if isinstance(submodule_rbln_config, dict) and "cls_name" in submodule_rbln_config:
+            config_cls_name = submodule_rbln_config["cls_name"]
+            return get_rbln_config_class(config_cls_name)
+        return get_rbln_config_class(f"RBLN{cls_name}Config")
+
     @classmethod
     def _update_submodule_config(
         cls,
@@ -69,12 +78,19 @@ class SubModulesMixin:
             cls_name = torch_submodule.__class__.__name__
             submodule_cls: Type["RBLNModel"] = get_rbln_model_cls(f"RBLN{cls_name}")
             submodule_rbln_config = getattr(rbln_config, submodule_name) or {}
+            submodule_config_cls = cls._get_submodule_config_class(cls_name, submodule_rbln_config)
 
             if isinstance(submodule_rbln_config, dict):
-                submodule_rbln_config_class = submodule_cls.get_rbln_config_class()
-                submodule_rbln_config = submodule_rbln_config_class(**submodule_rbln_config)
-                setattr(rbln_config, submodule_name, submodule_rbln_config)
-
+                filtered_kwargs = rbln_config.filter_parameters(submodule_config_cls, submodule_rbln_config)
+                filtered_kwargs["cls_name"] = submodule_config_cls.__name__
+                submodule_rbln_config = submodule_config_cls(**filtered_kwargs)
+            elif not isinstance(submodule_rbln_config, submodule_config_cls):
+                config_dict = {k: v for k, v in submodule_rbln_config.__dict__.items() if not k.startswith("_")}
+                filtered_kwargs = rbln_config.filter_parameters(submodule_config_cls, config_dict)
+                filtered_kwargs["cls_name"] = submodule_config_cls.__name__
+                submodule_rbln_config = submodule_config_cls(**filtered_kwargs)
+
+            setattr(rbln_config, submodule_name, submodule_rbln_config)
             submodule_rbln_config = submodule_cls._update_submodule_config(model, submodule_rbln_config, preprocessors)
 
             rbln_submodule = submodule_cls.from_model(

{optimum_rbln-0.9.1.dist-info → optimum_rbln-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.9.1
+Version: 0.9.2
 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
@@ -26,10 +26,10 @@ Requires-Python: <3.14,>=3.9
 Requires-Dist: accelerate>=1.0.1
 Requires-Dist: diffusers==0.35.1
 Requires-Dist: packaging>=24.1
-Requires-Dist: torch==2.7.0
-Requires-Dist: torchaudio<=2.7.0
-Requires-Dist: torchvision<=0.22.0
-Requires-Dist: transformers==4.51.3
+Requires-Dist: torch==2.8.0
+Requires-Dist: torchaudio<=2.8.0
+Requires-Dist: torchvision<=0.23.0
+Requires-Dist: transformers==4.57.1
 Description-Content-Type: text/markdown