optimum-rbln 0.8.1a6__py3-none-any.whl → 0.8.1a7__py3-none-any.whl

optimum/rbln/__version__.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.8.1a6'
-__version_tuple__ = version_tuple = (0, 8, 1, 'a6')
+__version__ = version = '0.8.1a7'
+__version_tuple__ = version_tuple = (0, 8, 1, 'a7')

optimum/rbln/diffusers/configurations/pipelines/configuration_controlnet.py

@@ -20,10 +20,6 @@ from ..models import RBLNAutoencoderKLConfig, RBLNControlNetModelConfig, RBLNUNe
 
 
 class RBLNStableDiffusionControlNetPipelineBaseConfig(RBLNModelConfig):
-    """
-    Base configuration for Stable Diffusion ControlNet pipelines.
-    """
-
     submodules = ["text_encoder", "unet", "vae", "controlnet"]
     _vae_uses_encoder = False
 

optimum/rbln/diffusers/configurations/pipelines/configuration_kandinsky2_2.py

@@ -21,8 +21,6 @@ from ..models.configuration_prior_transformer import RBLNPriorTransformerConfig
 
 
 class RBLNKandinskyV22PipelineBaseConfig(RBLNModelConfig):
-    """Base configuration class for Kandinsky V2.2 decoder pipelines."""
-
     submodules = ["unet", "movq"]
     _movq_uses_encoder = False
 

optimum/rbln/diffusers/configurations/pipelines/configuration_stable_diffusion.py

@@ -20,10 +20,6 @@ from ..models import RBLNAutoencoderKLConfig, RBLNUNet2DConditionModelConfig
 
 
 class RBLNStableDiffusionPipelineBaseConfig(RBLNModelConfig):
-    """
-    Base configuration for Stable Diffusion pipelines.
-    """
-
     submodules = ["text_encoder", "unet", "vae"]
     _vae_uses_encoder = False
 

optimum/rbln/diffusers/configurations/pipelines/configuration_stable_diffusion_3.py

@@ -20,10 +20,6 @@ from ..models import RBLNAutoencoderKLConfig, RBLNSD3Transformer2DModelConfig
 
 
 class RBLNStableDiffusion3PipelineBaseConfig(RBLNModelConfig):
-    """
-    Base configuration for Stable Diffusion 3 pipelines.
-    """
-
     submodules = ["transformer", "text_encoder", "text_encoder_2", "text_encoder_3", "vae"]
     _vae_uses_encoder = False
 

optimum/rbln/diffusers/configurations/pipelines/configuration_stable_diffusion_xl.py

@@ -20,10 +20,6 @@ from ..models import RBLNAutoencoderKLConfig, RBLNUNet2DConditionModelConfig
 
 
 class RBLNStableDiffusionXLPipelineBaseConfig(RBLNModelConfig):
-    """
-    Base configuration for Stable Diffusion XL pipelines.
-    """
-
     submodules = ["text_encoder", "text_encoder_2", "unet", "vae"]
     _vae_uses_encoder = False
 

optimum/rbln/diffusers/modeling_diffusers.py

@@ -412,24 +412,22 @@ class RBLNDiffusionMixin:
         return compiled_image_size
 
     def handle_additional_kwargs(self, **kwargs):
-        """
-        Function to handle additional compile-time parameters during inference.
-
-        If the additional variable is determined by another module, this method should be overrided.
-
-        Example:
-            ```python
-            if hasattr(self, "movq"):
-                compiled_image_size = self.movq.image_size
-                kwargs["height"] = compiled_image_size[0]
-                kwargs["width"] = compiled_image_size[1]
-
-            compiled_num_frames = self.unet.rbln_config.num_frames
-            if compiled_num_frames is not None:
-                kwargs["num_frames"] = compiled_num_frames
-            return kwargs
-            ```
-        """
+        # Function to handle additional compile-time parameters during inference.
+
+        # If the additional variable is determined by another module, this method should be overrided.
+
+        # Example:
+        #     ```python
+        #     if hasattr(self, "movq"):
+        #         compiled_image_size = self.movq.image_size
+        #         kwargs["height"] = compiled_image_size[0]
+        #         kwargs["width"] = compiled_image_size[1]
+
+        #     compiled_num_frames = self.unet.rbln_config.num_frames
+        #     if compiled_num_frames is not None:
+        #         kwargs["num_frames"] = compiled_num_frames
+        #     return kwargs
+        #     ```
         return kwargs
 
     @remove_compile_time_kwargs

optimum/rbln/diffusers/models/autoencoders/autoencoder_kl.py

@@ -80,7 +80,12 @@ class RBLNAutoencoderKL(RBLNModel):
 
             wrapped_model.eval()
 
-            compiled_models[model_name] = cls.compile(wrapped_model, rbln_compile_config=rbln_config.compile_cfgs[i])
+            compiled_models[model_name] = cls.compile(
+                wrapped_model,
+                rbln_compile_config=rbln_config.compile_cfgs[i],
+                create_runtimes=rbln_config.create_runtimes,
+                device=rbln_config.device_map[model_name],
+            )
 
         return compiled_models
 

optimum/rbln/diffusers/models/autoencoders/autoencoder_kl_cosmos.py

@@ -99,11 +99,21 @@ class RBLNAutoencoderKLCosmos(RBLNModel):
             compiled_models = {}
             if rbln_config.uses_encoder:
                 encoder_model, decoder_model = cls.wrap_model_if_needed(model, rbln_config)
-                enc_compiled_model = cls.compile(encoder_model, rbln_compile_config=rbln_config.compile_cfgs[0])
+                enc_compiled_model = cls.compile(
+                    encoder_model,
+                    rbln_compile_config=rbln_config.compile_cfgs[0],
+                    create_runtimes=rbln_config.create_runtimes,
+                    device=rbln_config.device_map["encoder"],
+                )
                 compiled_models["encoder"] = enc_compiled_model
             else:
                 decoder_model = cls.wrap_model_if_needed(model, rbln_config)
-            dec_compiled_model = cls.compile(decoder_model, rbln_compile_config=rbln_config.compile_cfgs[-1])
+            dec_compiled_model = cls.compile(
+                decoder_model,
+                rbln_compile_config=rbln_config.compile_cfgs[-1],
+                create_runtimes=rbln_config.create_runtimes,
+                device=rbln_config.device_map["decoder"],
+            )
             compiled_models["decoder"] = dec_compiled_model
 
         finally:
@@ -115,7 +125,7 @@ class RBLNAutoencoderKLCosmos(RBLNModel):
     def update_rbln_config_using_pipe(
         cls, pipe: "RBLNDiffusionMixin", rbln_config: "RBLNDiffusionMixinConfig", submodule_name: str
     ) -> "RBLNDiffusionMixinConfig":
-        rbln_config.vae.num_channels_latents = pipe.transformer.config.in_channels
+        rbln_config.vae.num_channels_latents = pipe.transformer.config.out_channels
         rbln_config.vae.vae_scale_factor_temporal = pipe.vae_scale_factor_temporal
         rbln_config.vae.vae_scale_factor_spatial = pipe.vae_scale_factor_spatial
         return rbln_config

optimum/rbln/diffusers/models/autoencoders/vq_model.py

@@ -78,7 +78,12 @@ class RBLNVQModel(RBLNModel):
 
             wrapped_model.eval()
 
-            compiled_models[model_name] = cls.compile(wrapped_model, rbln_compile_config=rbln_config.compile_cfgs[i])
+            compiled_models[model_name] = cls.compile(
+                wrapped_model,
+                rbln_compile_config=rbln_config.compile_cfgs[i],
+                create_runtimes=rbln_config.create_runtimes,
+                device=rbln_config.device_map[model_name],
+            )
 
         return compiled_models
 

optimum/rbln/diffusers/pipelines/cosmos/cosmos_guardrail.py

@@ -25,7 +25,7 @@ from huggingface_hub import snapshot_download
 from transformers import AutoTokenizer, SiglipProcessor
 
 from .... import RBLNAutoModelForCausalLM, RBLNSiglipVisionModel
-from ....utils.runtime_utils import RBLNPytorchRuntime
+from ....utils.runtime_utils import RBLNPytorchRuntime, UnavailableRuntime
 from .configuration_cosmos_guardrail import RBLNCosmosSafetyCheckerConfig
 
 
@@ -129,6 +129,8 @@ class RBLNSigLIPEncoder(SigLIPEncoder):
             self.model = RBLNSiglipVisionModel.from_pretrained(
                 self.checkpoint_dir,
                 rbln_device=rbln_config.siglip_encoder.device,
+                rbln_create_runtimes=rbln_config.siglip_encoder.create_runtimes,
+                rbln_activate_profiler=rbln_config.aegis.activate_profiler,
             )
         else:
             super().__init__(model_name, checkpoint_id)
@@ -139,6 +141,8 @@ class RBLNSigLIPEncoder(SigLIPEncoder):
                 rbln_device=rbln_config.siglip_encoder.device,
                 rbln_image_size=rbln_config.siglip_encoder.image_size,
                 rbln_npu=rbln_config.siglip_encoder.npu,
+                rbln_create_runtimes=rbln_config.siglip_encoder.create_runtimes,
+                rbln_activate_profiler=rbln_config.siglip_encoder.activate_profiler,
             )
         self.rbln_config = rbln_config
 
@@ -191,7 +195,29 @@ class RBLNRetinaFaceFilter(RetinaFaceFilter):
             )
 
         self.rbln_config = rbln_config
-        runtime = rebel.Runtime(self.compiled_model, tensor_type="pt", device=self.rbln_config.face_blur_filter.device)
+
+        try:
+            runtime = (
+                rebel.Runtime(
+                    self.compiled_model,
+                    tensor_type="pt",
+                    device=self.rbln_config.face_blur_filter.device,
+                    activate_profiler=rbln_config.face_blur_filter.activate_profiler,
+                )
+                if self.rbln_config.face_blur_filter.create_runtimes
+                else UnavailableRuntime()
+            )
+        except rebel.core.exception.RBLNRuntimeError as e:
+            error_msg = (
+                f"\nFailed to create RBLN runtime: {str(e)}\n\n"
+                f"If you only need to compile the model without loading it to NPU, you can use:\n"
+                f"  from_pretrained(..., rbln_create_runtimes=False) or\n"
+                f"  from_pretrained(..., rbln_config={{..., 'create_runtimes': False}})\n\n"
+                f"To check your NPU status, run the 'rbln-stat' command in your terminal.\n"
+                f"Make sure your NPU is properly installed and operational."
+            )
+            raise rebel.core.exception.RBLNRuntimeError(error_msg) from e
+
         self.net = RBLNPytorchRuntime(runtime)
 
     def save_pretrained(self, checkpoint_id: str):
@@ -245,11 +271,28 @@ class RBLNVideoSafetyModel(VideoSafetyModel):
                 npu=self.rbln_config.video_safety_model.npu,
             )
 
-        runtime = rebel.Runtime(
-            self.compiled_model,
-            tensor_type="pt",
-            device=self.rbln_config.video_safety_model.device,
-        )
+        try:
+            runtime = (
+                rebel.Runtime(
+                    self.compiled_model,
+                    tensor_type="pt",
+                    device=self.rbln_config.video_safety_model.device,
+                    activate_profiler=rbln_config.video_safety_model.activate_profiler,
+                )
+                if self.rbln_config.video_safety_model.create_runtimes
+                else UnavailableRuntime()
+            )
+        except rebel.core.exception.RBLNRuntimeError as e:
+            error_msg = (
+                f"\nFailed to create RBLN runtime: {str(e)}\n\n"
+                f"If you only need to compile the model without loading it to NPU, you can use:\n"
+                f"  from_pretrained(..., rbln_create_runtimes=False) or\n"
+                f"  from_pretrained(..., rbln_config={{..., 'create_runtimes': False}})\n\n"
+                f"To check your NPU status, run the 'rbln-stat' command in your terminal.\n"
+                f"Make sure your NPU is properly installed and operational."
+            )
+            raise rebel.core.exception.RBLNRuntimeError(error_msg) from e
+
         self.network = RBLNPytorchRuntime(runtime)
 
     def save_pretrained(self, checkpoint_id: str):
@@ -291,7 +334,12 @@ class RBLNAegis(Aegis):
             torch.nn.Module.__init__(self)
             cache_dir = pathlib.Path(checkpoint_id) / "aegis"
             self.tokenizer = AutoTokenizer.from_pretrained(cache_dir)
-            self.model = RBLNAutoModelForCausalLM.from_pretrained(cache_dir, rbln_device=rbln_config.aegis.device)
+            self.model = RBLNAutoModelForCausalLM.from_pretrained(
+                cache_dir,
+                rbln_device=rbln_config.aegis.device,
+                rbln_create_runtimes=rbln_config.aegis.create_runtimes,
+                rbln_activate_profiler=rbln_config.aegis.activate_profiler,
+            )
 
         else:
             super().__init__(checkpoint_id, base_model_id, aegis_adapter)
@@ -302,7 +350,9 @@ class RBLNAegis(Aegis):
                 model,
                 rbln_tensor_parallel_size=4,
                 rbln_device=rbln_config.aegis.device,
+                rbln_create_runtimes=rbln_config.aegis.create_runtimes,
                 rbln_npu=rbln_config.aegis.npu,
+                rbln_activate_profiler=rbln_config.aegis.activate_profiler,
             )
 
         self.rbln_config = rbln_config
@@ -335,19 +385,25 @@ class RBLNCosmosSafetyChecker(CosmosSafetyChecker):
 
         if rbln_config is None:
             rbln_config = RBLNCosmosSafetyCheckerConfig()
+        elif isinstance(rbln_config, dict):
+            rbln_config = RBLNCosmosSafetyCheckerConfig(**rbln_config)
 
         self.text_guardrail = GuardrailRunner(
             safety_models=[
                 Blocklist(COSMOS_GUARDRAIL_CHECKPOINT),  # Changed since it cannot be saved
-                RBLNAegis(checkpoint_id, aegis_model_id, aegis_adapter_id, rbln_config=rbln_config),
+                RBLNAegis(
+                    checkpoint_id=checkpoint_id,
+                    base_model_id=aegis_model_id,
+                    aegis_adapter=aegis_adapter_id,
+                    rbln_config=rbln_config,
+                ),
             ]
         )
 
-        with patch("torch.load", partial(torch.load, weights_only=True, map_location=torch.device("cpu"))):
-            self.video_guardrail = GuardrailRunner(
-                safety_models=[RBLNVideoContentSafetyFilter(checkpoint_id, rbln_config=rbln_config)],
-                postprocessors=[RBLNRetinaFaceFilter(checkpoint_id, rbln_config=rbln_config)],
-            )
+        self.video_guardrail = GuardrailRunner(
+            safety_models=[RBLNVideoContentSafetyFilter(checkpoint_id=checkpoint_id, rbln_config=rbln_config)],
+            postprocessors=[RBLNRetinaFaceFilter(checkpoint_id=checkpoint_id, rbln_config=rbln_config)],
+        )
 
         self.rbln_config = rbln_config
 

optimum/rbln/modeling.py

@@ -64,7 +64,12 @@ class RBLNModel(RBLNBaseModel):
     def get_compiled_model(cls, model: "PreTrainedModel", rbln_config: RBLNModelConfig):
         model = cls.wrap_model_if_needed(model, rbln_config)
         rbln_compile_config = rbln_config.compile_cfgs[0]
-        compiled_model = cls.compile(model, rbln_compile_config=rbln_compile_config)
+        compiled_model = cls.compile(
+            model,
+            rbln_compile_config=rbln_compile_config,
+            create_runtimes=rbln_config.create_runtimes,
+            device=rbln_config.device,
+        )
         return compiled_model
 
     @classmethod
@@ -237,7 +242,38 @@ class RBLNModel(RBLNBaseModel):
             for compiled_model in compiled_models
         ]
 
-    def forward(self, *args, return_dict: Optional[bool] = None, **kwargs):
+    def forward(self, *args: Any, return_dict: Optional[bool] = None, **kwargs: Dict[str, Any]) -> Any:
+        """
+        Defines the forward pass of the RBLN model, providing a drop-in replacement for HuggingFace PreTrainedModel.
+
+        This method executes the compiled RBLN model on RBLN NPU devices while maintaining full compatibility
+        with HuggingFace transformers and diffusers APIs. The RBLNModel can be used as a direct substitute
+        for any HuggingFace nn.Module/PreTrainedModel, enabling seamless integration into existing workflows.
+
+        Args:
+            *args: Variable length argument list containing model inputs. The format matches the original
+                HuggingFace model's forward method signature (e.g., input_ids, attention_mask for
+                transformers models, or sample, timestep for diffusers models).
+            return_dict:
+                Whether to return outputs as a dictionary-like object or as a tuple. When `None`:
+                - For transformers models: Uses `self.config.use_return_dict` (typically `True`)
+                - For diffusers models: Defaults to `True`
+            **kwargs: Arbitrary keyword arguments containing additional model inputs and parameters,
+                matching the original HuggingFace model's interface.
+
+        Returns:
+            Model outputs in the same format as the original HuggingFace model.
+
+            - If `return_dict=True`: Returns a dictionary-like object (e.g., BaseModelOutput,
+                CausalLMOutput) with named fields such as `logits`, `hidden_states`, etc.
+            - If `return_dict=False`: Returns a tuple containing the raw model outputs.
+
+        Note:
+            - This method maintains the exact same interface as the original HuggingFace model's forward method
+            - The compiled model runs on RBLN NPU hardware for accelerated inference
+            - All HuggingFace model features (generation, attention patterns, etc.) are preserved
+            - Can be used directly in HuggingFace pipelines, transformers.Trainer, and other workflows
+        """
         if self.hf_library_name == "transformers":
             return_dict = return_dict if return_dict is not None else self.config.use_return_dict
         else:

optimum/rbln/modeling_base.py

@@ -27,7 +27,7 @@ from transformers import AutoConfig, AutoModel, GenerationConfig, PretrainedConf
 from .configuration_utils import RBLNAutoConfig, RBLNCompileConfig, RBLNModelConfig, get_rbln_config_class
 from .utils.hub import PushToHubMixin, pull_compiled_model_from_hub, validate_files
 from .utils.logging import get_logger
-from .utils.runtime_utils import UnavailableRuntime
+from .utils.runtime_utils import UnavailableRuntime, tp_and_devices_are_ok
 from .utils.save_utils import maybe_load_preprocessors
 from .utils.submodule import SubModulesMixin
 
@@ -374,7 +374,23 @@ class RBLNBaseModel(SubModulesMixin, PushToHubMixin, PreTrainedModel):
         return from_pretrained_method(model_id=model_id, **kwargs, rbln_config=rbln_config)
 
     @classmethod
-    def compile(cls, model, rbln_compile_config: Optional[RBLNCompileConfig] = None, **kwargs):
+    def compile(
+        cls,
+        model,
+        rbln_compile_config: RBLNCompileConfig,
+        create_runtimes: bool,
+        device: Union[int, List[int]],
+        **kwargs,
+    ):
+        if create_runtimes:
+            runtime_cannot_be_created = tp_and_devices_are_ok(
+                tensor_parallel_size=rbln_compile_config.tensor_parallel_size,
+                device=device,
+                npu=rbln_compile_config.npu,
+            )
+            if runtime_cannot_be_created:
+                raise ValueError(runtime_cannot_be_created)
+
         compiled_model = rebel.compile_from_torch(
             model,
             input_info=rbln_compile_config.input_info,

optimum/rbln/transformers/modeling_generic.py

@@ -139,7 +139,7 @@ class RBLNTransformerEncoder(RBLNModel):
         return rbln_config
 
 
-class _RBLNImageModel(RBLNModel):
+class RBLNImageModel(RBLNModel):
     auto_model_class = AutoModel
     main_input_name = "pixel_values"
     output_class = BaseModelOutput
@@ -233,11 +233,11 @@ class RBLNTransformerEncoderForFeatureExtraction(RBLNTransformerEncoder):
     rbln_model_input_names = ["input_ids", "attention_mask"]
 
 
-class RBLNModelForImageClassification(_RBLNImageModel):
+class RBLNModelForImageClassification(RBLNImageModel):
     auto_model_class = AutoModelForImageClassification
 
 
-class RBLNModelForDepthEstimation(_RBLNImageModel):
+class RBLNModelForDepthEstimation(RBLNImageModel):
     auto_model_class = AutoModelForDepthEstimation
 
 

optimum/rbln/transformers/models/bart/configuration_bart.py

@@ -17,8 +17,18 @@ from ..seq2seq import RBLNModelForSeq2SeqLMConfig
 
 
 class RBLNBartModelConfig(RBLNTransformerEncoderForFeatureExtractionConfig):
-    pass
+    """
+    Configuration class for RBLNBartModel.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BART models for feature extraction tasks.
+    """
 
 
 class RBLNBartForConditionalGenerationConfig(RBLNModelForSeq2SeqLMConfig):
-    pass
+    """
+    Configuration class for RBLNBartForConditionalGeneration.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BART models for conditional text generation tasks.
+    """

optimum/rbln/transformers/models/bart/modeling_bart.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable
+from typing import Any, Callable
 
 from transformers import BartForConditionalGeneration, PreTrainedModel
 
@@ -27,19 +27,28 @@ from .configuration_bart import RBLNBartForConditionalGenerationConfig
 logger = get_logger()
 
 
-if TYPE_CHECKING:
-    from transformers import PreTrainedModel
-
-
 class RBLNBartModel(RBLNTransformerEncoderForFeatureExtraction):
-    pass
+    """
+    RBLN optimized BART model for feature extraction tasks.
+
+    This class provides hardware-accelerated inference for BART encoder models
+    on RBLN devices, optimized for feature extraction use cases.
+    """
 
 
 class RBLNBartForConditionalGeneration(RBLNModelForSeq2SeqLM):
+    """
+    RBLN optimized BART model for conditional text generation tasks.
+
+    This class provides hardware-accelerated inference for BART models
+    on RBLN devices, supporting sequence-to-sequence generation tasks
+    such as summarization, translation, and text generation.
+    """
+
     support_causal_attn = True
 
     @classmethod
-    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: RBLNBartForConditionalGenerationConfig):
+    def wrap_model_if_needed(self, model: PreTrainedModel, rbln_config: RBLNBartForConditionalGenerationConfig):
         return BartWrapper(
             model, enc_max_seq_len=rbln_config.enc_max_seq_len, use_attention_mask=rbln_config.use_attention_mask
         )

optimum/rbln/transformers/models/bert/configuration_bert.py

@@ -20,12 +20,27 @@ from ...configuration_generic import (
 
 
 class RBLNBertModelConfig(RBLNTransformerEncoderForFeatureExtractionConfig):
-    pass
+    """
+    Configuration class for RBLNBertModel.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BERT models for feature extraction tasks.
+    """
 
 
 class RBLNBertForMaskedLMConfig(RBLNModelForMaskedLMConfig):
-    pass
+    """
+    Configuration class for RBLNBertForMaskedLM.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BERT models for masked language modeling tasks.
+    """
 
 
 class RBLNBertForQuestionAnsweringConfig(RBLNModelForQuestionAnsweringConfig):
-    pass
+    """
+    Configuration class for RBLNBertForQuestionAnswering.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BERT models for question answering tasks.
+    """

optimum/rbln/transformers/models/bert/modeling_bert.py

@@ -24,12 +24,36 @@ logger = get_logger(__name__)
 
 
 class RBLNBertModel(RBLNTransformerEncoderForFeatureExtraction):
+    """
+    RBLN optimized BERT model for feature extraction tasks.
+
+    This class provides hardware-accelerated inference for BERT models
+    on RBLN devices, optimized for extracting contextualized embeddings
+    and features from text sequences.
+    """
+
     rbln_model_input_names = ["input_ids", "attention_mask"]
 
 
 class RBLNBertForMaskedLM(RBLNModelForMaskedLM):
+    """
+    RBLN optimized BERT model for masked language modeling tasks.
+
+    This class provides hardware-accelerated inference for BERT models
+    on RBLN devices, supporting masked language modeling tasks such as
+    token prediction and text completion.
+    """
+
     rbln_model_input_names = ["input_ids", "attention_mask", "token_type_ids"]
 
 
 class RBLNBertForQuestionAnswering(RBLNModelForQuestionAnswering):
+    """
+    RBLN optimized BERT model for question answering tasks.
+
+    This class provides hardware-accelerated inference for BERT models
+    on RBLN devices, supporting extractive question answering tasks where
+    the model predicts start and end positions of answers in text.
+    """
+
     rbln_model_input_names = ["input_ids", "attention_mask", "token_type_ids"]

optimum/rbln/transformers/models/blip_2/configuration_blip_2.py

@@ -18,10 +18,22 @@ from ....configuration_utils import RBLNModelConfig
 
 
 class RBLNBlip2VisionModelConfig(RBLNModelConfig):
-    pass
+    """
+    Configuration class for RBLNBlip2VisionModel.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BLIP-2 vision encoder models for multimodal tasks.
+    """
 
 
 class RBLNBlip2QFormerModelConfig(RBLNModelConfig):
+    """
+    Configuration class for RBLNBlip2QFormerModel.
+
+    This configuration class stores the configuration parameters specific to
+    RBLN-optimized BLIP-2 Q-Former models that bridge vision and language modalities.
+    """
+
     def __init__(
         self,
         num_query_tokens: Optional[int] = None,

optimum/rbln/transformers/models/blip_2/modeling_blip_2.py

@@ -65,6 +65,13 @@ class LoopProjector:
 
 
 class RBLNBlip2VisionModel(RBLNModel):
+    """
+    RBLN optimized BLIP-2 vision encoder model.
+
+    This class provides hardware-accelerated inference for BLIP-2 vision encoders
+    on RBLN devices, supporting image encoding for multimodal vision-language tasks.
+    """
+
     def get_input_embeddings(self):
         return self.embeddings
 
@@ -136,6 +143,14 @@ class RBLNBlip2VisionModel(RBLNModel):
 
 
 class RBLNBlip2QFormerModel(RBLNModel):
+    """
+    RBLN optimized BLIP-2 Q-Former model.
+
+    This class provides hardware-accelerated inference for BLIP-2 Q-Former models
+    on RBLN devices, which bridge vision and language modalities through cross-attention
+    mechanisms for multimodal understanding tasks.
+    """
+
     def get_input_embeddings(self):
         return self.embeddings.word_embeddings
 

optimum/rbln/transformers/models/clip/configuration_clip.py

@@ -34,7 +34,12 @@ class RBLNCLIPTextModelConfig(RBLNModelConfig):
 
 
 class RBLNCLIPTextModelWithProjectionConfig(RBLNCLIPTextModelConfig):
-    pass
+    """
+    Configuration class for RBLNCLIPTextModelWithProjection.
+
+    This configuration inherits from RBLNCLIPTextModelConfig and stores
+    configuration parameters for CLIP text models with projection layers.
+    """
 
 
 class RBLNCLIPVisionModelConfig(RBLNModelConfig):
@@ -76,4 +81,9 @@ class RBLNCLIPVisionModelConfig(RBLNModelConfig):
 
 
 class RBLNCLIPVisionModelWithProjectionConfig(RBLNCLIPVisionModelConfig):
-    pass
+    """
+    Configuration class for RBLNCLIPVisionModelWithProjection.
+
+    This configuration inherits from RBLNCLIPVisionModelConfig and stores
+    configuration parameters for CLIP vision models with projection layers.
+    """