optimum-rbln 0.7.4a4__py3-none-any.whl → 0.7.4a5__py3-none-any.whl

optimum/rbln/transformers/models/__init__.py

@@ -32,29 +32,60 @@ _import_structure = {
         "RBLNAutoModelForSpeechSeq2Seq",
         "RBLNAutoModelForVision2Seq",
     ],
-    "bart": ["RBLNBartForConditionalGeneration", "RBLNBartModel"],
-    "bert": ["RBLNBertModel", "RBLNBertForQuestionAnswering", "RBLNBertForMaskedLM"],
+    "bart": [
+        "RBLNBartForConditionalGeneration",
+        "RBLNBartModel",
+        "RBLNBartForConditionalGenerationConfig",
+        "RBLNBartModelConfig",
+    ],
+    "bert": [
+        "RBLNBertModel",
+        "RBLNBertModelConfig",
+        "RBLNBertForQuestionAnswering",
+        "RBLNBertForQuestionAnsweringConfig",
+        "RBLNBertForMaskedLM",
+        "RBLNBertForMaskedLMConfig",
+    ],
     "clip": [
         "RBLNCLIPTextModel",
+        "RBLNCLIPTextModelConfig",
         "RBLNCLIPTextModelWithProjection",
+        "RBLNCLIPTextModelWithProjectionConfig",
         "RBLNCLIPVisionModel",
+        "RBLNCLIPVisionModelConfig",
         "RBLNCLIPVisionModelWithProjection",
+        "RBLNCLIPVisionModelWithProjectionConfig",
+    ],
+    "decoderonly": [
+        "RBLNDecoderOnlyModelForCausalLM",
+        "RBLNDecoderOnlyModelForCausalLMConfig",
+    ],
+    "dpt": [
+        "RBLNDPTForDepthEstimation",
+        "RBLNDPTForDepthEstimationConfig",
+    ],
+    "exaone": ["RBLNExaoneForCausalLM", "RBLNExaoneForCausalLMConfig"],
+    "gemma": ["RBLNGemmaForCausalLM", "RBLNGemmaForCausalLMConfig"],
+    "gpt2": ["RBLNGPT2LMHeadModel", "RBLNGPT2LMHeadModelConfig"],
+    "llama": ["RBLNLlamaForCausalLM", "RBLNLlamaForCausalLMConfig"],
+    "llava_next": ["RBLNLlavaNextForConditionalGeneration", "RBLNLlavaNextForConditionalGenerationConfig"],
+    "midm": ["RBLNMidmLMHeadModel", "RBLNMidmLMHeadModelConfig"],
+    "mistral": ["RBLNMistralForCausalLM", "RBLNMistralForCausalLMConfig"],
+    "phi": ["RBLNPhiForCausalLM", "RBLNPhiForCausalLMConfig"],
+    "qwen2": ["RBLNQwen2ForCausalLM", "RBLNQwen2ForCausalLMConfig"],
+    "time_series_transformers": [
+        "RBLNTimeSeriesTransformerForPrediction",
+        "RBLNTimeSeriesTransformerForPredictionConfig",
+    ],
+    "t5": [
+        "RBLNT5EncoderModel",
+        "RBLNT5ForConditionalGeneration",
+        "RBLNT5EncoderModelConfig",
+        "RBLNT5ForConditionalGenerationConfig",
     ],
-    "dpt": ["RBLNDPTForDepthEstimation"],
-    "exaone": ["RBLNExaoneForCausalLM"],
-    "gemma": ["RBLNGemmaForCausalLM"],
-    "gpt2": ["RBLNGPT2LMHeadModel"],
-    "llama": ["RBLNLlamaForCausalLM"],
-    "llava_next": ["RBLNLlavaNextForConditionalGeneration"],
-    "midm": ["RBLNMidmLMHeadModel"],
-    "mistral": ["RBLNMistralForCausalLM"],
-    "phi": ["RBLNPhiForCausalLM"],
-    "qwen2": ["RBLNQwen2ForCausalLM"],
-    "time_series_transformers": ["RBLNTimeSeriesTransformerForPrediction"],
-    "t5": ["RBLNT5EncoderModel", "RBLNT5ForConditionalGeneration"],
-    "wav2vec2": ["RBLNWav2Vec2ForCTC"],
-    "whisper": ["RBLNWhisperForConditionalGeneration"],
-    "xlm_roberta": ["RBLNXLMRobertaModel"],
+    "wav2vec2": ["RBLNWav2Vec2ForCTC", "RBLNWav2Vec2ForCTCConfig"],
+    "whisper": ["RBLNWhisperForConditionalGeneration", "RBLNWhisperForConditionalGenerationConfig"],
+    "xlm_roberta": ["RBLNXLMRobertaModel", "RBLNXLMRobertaModelConfig"],
 }
 
 if TYPE_CHECKING:
@@ -72,29 +103,60 @@ if TYPE_CHECKING:
         RBLNAutoModelForSpeechSeq2Seq,
         RBLNAutoModelForVision2Seq,
     )
-    from .bart import RBLNBartForConditionalGeneration, RBLNBartModel
-    from .bert import RBLNBertForMaskedLM, RBLNBertForQuestionAnswering, RBLNBertModel
+    from .bart import (
+        RBLNBartForConditionalGeneration,
+        RBLNBartForConditionalGenerationConfig,
+        RBLNBartModel,
+        RBLNBartModelConfig,
+    )
+    from .bert import (
+        RBLNBertForMaskedLM,
+        RBLNBertForMaskedLMConfig,
+        RBLNBertForQuestionAnswering,
+        RBLNBertForQuestionAnsweringConfig,
+        RBLNBertModel,
+        RBLNBertModelConfig,
+    )
     from .clip import (
         RBLNCLIPTextModel,
+        RBLNCLIPTextModelConfig,
         RBLNCLIPTextModelWithProjection,
+        RBLNCLIPTextModelWithProjectionConfig,
         RBLNCLIPVisionModel,
+        RBLNCLIPVisionModelConfig,
         RBLNCLIPVisionModelWithProjection,
+        RBLNCLIPVisionModelWithProjectionConfig,
+    )
+    from .decoderonly import (
+        RBLNDecoderOnlyModelForCausalLM,
+        RBLNDecoderOnlyModelForCausalLMConfig,
+    )
+    from .dpt import (
+        RBLNDPTForDepthEstimation,
+        RBLNDPTForDepthEstimationConfig,
+    )
+    from .exaone import RBLNExaoneForCausalLM, RBLNExaoneForCausalLMConfig
+    from .gemma import RBLNGemmaForCausalLM, RBLNGemmaForCausalLMConfig
+    from .gpt2 import RBLNGPT2LMHeadModel, RBLNGPT2LMHeadModelConfig
+    from .llama import RBLNLlamaForCausalLM, RBLNLlamaForCausalLMConfig
+    from .llava_next import RBLNLlavaNextForConditionalGeneration, RBLNLlavaNextForConditionalGenerationConfig
+    from .midm import RBLNMidmLMHeadModel, RBLNMidmLMHeadModelConfig
+    from .mistral import RBLNMistralForCausalLM, RBLNMistralForCausalLMConfig
+    from .phi import RBLNPhiForCausalLM, RBLNPhiForCausalLMConfig
+    from .qwen2 import RBLNQwen2ForCausalLM, RBLNQwen2ForCausalLMConfig
+    from .t5 import (
+        RBLNT5EncoderModel,
+        RBLNT5EncoderModelConfig,
+        RBLNT5ForConditionalGeneration,
+        RBLNT5ForConditionalGenerationConfig,
+    )
+    from .time_series_transformers import (
+        RBLNTimeSeriesTransformerForPrediction,
+        RBLNTimeSeriesTransformerForPredictionConfig,
     )
-    from .dpt import RBLNDPTForDepthEstimation
-    from .exaone import RBLNExaoneForCausalLM
-    from .gemma import RBLNGemmaForCausalLM
-    from .gpt2 import RBLNGPT2LMHeadModel
-    from .llama import RBLNLlamaForCausalLM
-    from .llava_next import RBLNLlavaNextForConditionalGeneration
-    from .midm import RBLNMidmLMHeadModel
-    from .mistral import RBLNMistralForCausalLM
-    from .phi import RBLNPhiForCausalLM
-    from .qwen2 import RBLNQwen2ForCausalLM
-    from .t5 import RBLNT5EncoderModel, RBLNT5ForConditionalGeneration
-    from .time_series_transformers import RBLNTimeSeriesTransformerForPrediction
-    from .wav2vec2 import RBLNWav2Vec2ForCTC
-    from .whisper import RBLNWhisperForConditionalGeneration
-    from .xlm_roberta import RBLNXLMRobertaModel
+    from .wav2vec2 import RBLNWav2Vec2ForCTC, RBLNWav2Vec2ForCTCConfig
+    from .whisper import RBLNWhisperForConditionalGeneration, RBLNWhisperForConditionalGenerationConfig
+    from .xlm_roberta import RBLNXLMRobertaModel, RBLNXLMRobertaModelConfig
 
 else:
     import sys

optimum/rbln/transformers/models/auto/auto_factory.py

@@ -20,8 +20,8 @@ from transformers import AutoConfig, PretrainedConfig
 from transformers.dynamic_module_utils import get_class_from_dynamic_module
 from transformers.models.auto.auto_factory import _get_model_class
 
+from optimum.rbln.configuration_utils import RBLNAutoConfig
 from optimum.rbln.modeling_base import RBLNBaseModel
-from optimum.rbln.modeling_config import RBLNConfig
 from optimum.rbln.utils.model_utils import convert_hf_to_rbln_model_name, convert_rbln_to_hf_model_name
 
 
@@ -154,9 +154,9 @@ class _BaseAutoModelClass:
         model_path_subfolder = RBLNBaseModel._load_compiled_model_dir(
             model_id=pretrained_model_name_or_path, **filtered_kwargs
         )
-        rbln_config = RBLNConfig.load(model_path_subfolder)
+        rbln_config = RBLNAutoConfig.load(model_path_subfolder)
 
-        return rbln_config.meta["cls"]
+        return rbln_config.rbln_model_cls_name
 
     @classmethod
     def from_pretrained(

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

@@ -13,4 +13,5 @@
 # limitations under the License.
 
 from ....ops import paged_attn_decode, paged_causal_attn_decode
+from .configuration_bart import RBLNBartForConditionalGenerationConfig, RBLNBartModelConfig
 from .modeling_bart import RBLNBartForConditionalGeneration, RBLNBartModel

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

@@ -0,0 +1,24 @@
+# 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 ...configuration_generic import RBLNTransformerEncoderForFeatureExtractionConfig
+from ..seq2seq import RBLNModelForSeq2SeqLMConfig
+
+
+class RBLNBartModelConfig(RBLNTransformerEncoderForFeatureExtractionConfig):
+    pass
+
+
+class RBLNBartForConditionalGenerationConfig(RBLNModelForSeq2SeqLMConfig):
+    pass

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

@@ -13,110 +13,36 @@
 # limitations under the License.
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable
 
-from transformers import BartForConditionalGeneration, PretrainedConfig, PreTrainedModel
+from transformers import BartForConditionalGeneration, PreTrainedModel
 
-from ....modeling import RBLNModel
-from ....modeling_config import RBLNCompileConfig, RBLNConfig
 from ....utils.logging import get_logger
+from ...modeling_generic import RBLNTransformerEncoderForFeatureExtraction
 from ...models.seq2seq import RBLNModelForSeq2SeqLM
 from .bart_architecture import BartWrapper
+from .configuration_bart import RBLNBartForConditionalGenerationConfig
 
 
 logger = get_logger()
 
 
 if TYPE_CHECKING:
-    from transformers import AutoFeatureExtractor, AutoProcessor, AutoTokenizer, PreTrainedModel
+    from transformers import PreTrainedModel
 
 
-class RBLNBartModel(RBLNModel):
-    @classmethod
-    def _get_rbln_config(
-        cls,
-        preprocessors: Optional[Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"]],
-        model_config: Optional["PretrainedConfig"] = None,
-        rbln_kwargs: Dict[str, Any] = {},
-    ) -> RBLNConfig:
-        rbln_max_seq_len = rbln_kwargs.get("max_seq_len", None)
-        rbln_batch_size = rbln_kwargs.get("batch_size", None)
-        rbln_model_input_names = rbln_kwargs.get("model_input_names", None)
-
-        max_position_embeddings = getattr(model_config, "max_position_embeddings", None)
-
-        if rbln_max_seq_len is None:
-            rbln_max_seq_len = max_position_embeddings
-            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 max_position_embeddings is not None and rbln_max_seq_len > max_position_embeddings:
-            raise ValueError("`rbln_max_seq_len` should be less or equal than max_position_embeddings!")
-
-        signature_params = inspect.signature(cls.get_hf_class().forward).parameters.keys()
-
-        if rbln_model_input_names is None:
-            for tokenizer in preprocessors:
-                if hasattr(tokenizer, "model_input_names"):
-                    rbln_model_input_names = [name for name in signature_params if name in tokenizer.model_input_names]
-                    # BartModel's forward() does not take token_type_ids as input.
-                    # (Added because some of the tokenizers includes 'token_type_ids')
-                    if "token_type_ids" in rbln_model_input_names:
-                        rbln_model_input_names.remove("token_type_ids")
-
-                    invalid_params = set(rbln_model_input_names) - set(signature_params)
-                    if invalid_params:
-                        raise ValueError(f"Invalid model input names: {invalid_params}")
-                    break
-            if rbln_model_input_names is None and hasattr(cls, "rbln_model_input_names"):
-                rbln_model_input_names = cls.rbln_model_input_names
-            elif rbln_model_input_names is None and hasattr(cls, "rbln_model_input_names") is False:
-                raise ValueError(
-                    "Specify the model input names obtained by the tokenizer via `rbln_model_input_names`, "
-                    f"and be sure to make the order of the inputs same as BartModel forward() arguments like ({list(signature_params)})"
-                )
-        else:
-            invalid_params = set(rbln_model_input_names) - set(signature_params)
-            if invalid_params:
-                raise ValueError(f"Invalid model input names: {invalid_params}")
-            rbln_model_input_names = [name for name in signature_params if name in rbln_model_input_names]
-
-        if rbln_batch_size is None:
-            rbln_batch_size = 1
-
-        input_info = [
-            (model_input_name, [rbln_batch_size, rbln_max_seq_len], "int64")
-            for model_input_name in rbln_model_input_names
-        ]
-
-        rbln_compile_config = RBLNCompileConfig(input_info=input_info)
-
-        rbln_config = RBLNConfig(
-            rbln_cls=cls.__name__,
-            compile_cfgs=[rbln_compile_config],
-            rbln_kwargs=rbln_kwargs,
-        )
-
-        rbln_config.model_cfg.update({"max_seq_len": rbln_max_seq_len})
-        return rbln_config
+class RBLNBartModel(RBLNTransformerEncoderForFeatureExtraction):
+    pass
 
 
 class RBLNBartForConditionalGeneration(RBLNModelForSeq2SeqLM):
     support_causal_attn = True
 
     @classmethod
-    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: "RBLNConfig"):
-        enc_max_seq_len = (
-            rbln_config.model_cfg["enc_max_seq_len"] if "enc_max_seq_len" in rbln_config.model_cfg else 1024
+    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
         )
-        use_attention_mask = rbln_config.model_cfg.get("use_attention_mask", False)
-
-        return BartWrapper(model, enc_max_seq_len=enc_max_seq_len, use_attention_mask=use_attention_mask)
 
     def __getattr__(self, __name: str) -> Any:
         def redirect(func):

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

@@ -12,4 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .configuration_bert import RBLNBertForMaskedLMConfig, RBLNBertForQuestionAnsweringConfig, RBLNBertModelConfig
 from .modeling_bert import RBLNBertForMaskedLM, RBLNBertForQuestionAnswering, RBLNBertModel

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

@@ -0,0 +1,31 @@
+# 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 ...configuration_generic import (
+    RBLNModelForMaskedLMConfig,
+    RBLNModelForQuestionAnsweringConfig,
+    RBLNTransformerEncoderForFeatureExtractionConfig,
+)
+
+
+class RBLNBertModelConfig(RBLNTransformerEncoderForFeatureExtractionConfig):
+    pass
+
+
+class RBLNBertForMaskedLMConfig(RBLNModelForMaskedLMConfig):
+    pass
+
+
+class RBLNBertForQuestionAnsweringConfig(RBLNModelForQuestionAnsweringConfig):
+    pass

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

@@ -12,92 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import inspect
-from typing import TYPE_CHECKING, Any, Dict, Optional, Union
-
-from transformers import PretrainedConfig
-
-from ....modeling import RBLNModel
-from ....modeling_config import RBLNCompileConfig, RBLNConfig
 from ....utils.logging import get_logger
-from ...modeling_generic import RBLNModelForMaskedLM, RBLNModelForQuestionAnswering
+from ...modeling_generic import (
+    RBLNModelForMaskedLM,
+    RBLNModelForQuestionAnswering,
+    RBLNTransformerEncoderForFeatureExtraction,
+)
 
 
 logger = get_logger(__name__)
 
-if TYPE_CHECKING:
-    from transformers import AutoFeatureExtractor, AutoProcessor, AutoTokenizer
-
-
-class RBLNBertModel(RBLNModel):
-    @classmethod
-    def _get_rbln_config(
-        cls,
-        preprocessors: Optional[Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"]],
-        model_config: Optional["PretrainedConfig"] = None,
-        rbln_kwargs: Dict[str, Any] = {},
-    ) -> RBLNConfig:
-        rbln_max_seq_len = rbln_kwargs.get("max_seq_len", None)
-        rbln_batch_size = rbln_kwargs.get("batch_size", None)
-        rbln_model_input_names = rbln_kwargs.get("model_input_names", None)
-
-        max_position_embeddings = getattr(model_config, "max_position_embeddings", None)
-
-        if rbln_max_seq_len is None:
-            rbln_max_seq_len = max_position_embeddings
-            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 max_position_embeddings is not None and rbln_max_seq_len > max_position_embeddings:
-            raise ValueError("`rbln_max_seq_len` should be less or equal than max_position_embeddings!")
-
-        signature_params = inspect.signature(cls.get_hf_class().forward).parameters.keys()
-
-        if rbln_model_input_names is None:
-            for tokenizer in preprocessors:
-                if hasattr(tokenizer, "model_input_names"):
-                    rbln_model_input_names = [name for name in signature_params if name in tokenizer.model_input_names]
-
-                    invalid_params = set(rbln_model_input_names) - set(signature_params)
-                    if invalid_params:
-                        raise ValueError(f"Invalid model input names: {invalid_params}")
-                    break
-            if rbln_model_input_names is None and hasattr(cls, "rbln_model_input_names"):
-                rbln_model_input_names = cls.rbln_model_input_names
-            elif rbln_model_input_names is None and hasattr(cls, "rbln_model_input_names") is False:
-                raise ValueError(
-                    "Specify the model input names obtained by the tokenizer via `rbln_model_input_names`, "
-                    f"and be sure to make the order of the inputs same as BertModel forward() arguments like ({list(signature_params)})"
-                )
-        else:
-            invalid_params = set(rbln_model_input_names) - set(signature_params)
-            if invalid_params:
-                raise ValueError(f"Invalid model input names: {invalid_params}")
-            rbln_model_input_names = [name for name in signature_params if name in rbln_model_input_names]
-
-        if rbln_batch_size is None:
-            rbln_batch_size = 1
-
-        input_info = [
-            (model_input_name, [rbln_batch_size, rbln_max_seq_len], "int64")
-            for model_input_name in rbln_model_input_names
-        ]
-
-        rbln_compile_config = RBLNCompileConfig(input_info=input_info)
-
-        rbln_config = RBLNConfig(
-            rbln_cls=cls.__name__,
-            compile_cfgs=[rbln_compile_config],
-            rbln_kwargs=rbln_kwargs,
-        )
 
-        rbln_config.model_cfg.update({"max_seq_len": rbln_max_seq_len})
-        return rbln_config
+class RBLNBertModel(RBLNTransformerEncoderForFeatureExtraction):
+    rbln_model_input_names = ["input_ids", "attention_mask"]
 
 
 class RBLNBertForMaskedLM(RBLNModelForMaskedLM):

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

@@ -12,6 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .configuration_clip import (
+    RBLNCLIPTextModelConfig,
+    RBLNCLIPTextModelWithProjectionConfig,
+    RBLNCLIPVisionModelConfig,
+    RBLNCLIPVisionModelWithProjectionConfig,
+)
 from .modeling_clip import (
     RBLNCLIPTextModel,
     RBLNCLIPTextModelWithProjection,

optimum/rbln/transformers/models/clip/configuration_clip.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 typing import Optional
+
+from ....configuration_utils import RBLNModelConfig
+
+
+class RBLNCLIPTextModelConfig(RBLNModelConfig):
+    def __init__(self, batch_size: Optional[int] = None, **kwargs):
+        """
+        Args:
+            batch_size (Optional[int]): The batch size for text processing. Defaults to 1.
+            **kwargs: Additional arguments passed to the parent RBLNModelConfig.
+
+        Raises:
+            ValueError: If batch_size is not a positive integer.
+        """
+        super().__init__(**kwargs)
+        self.batch_size = batch_size or 1
+        if not isinstance(self.batch_size, int) or self.batch_size < 0:
+            raise ValueError(f"batch_size must be a positive integer, got {self.batch_size}")
+
+
+class RBLNCLIPTextModelWithProjectionConfig(RBLNCLIPTextModelConfig):
+    pass
+
+
+class RBLNCLIPVisionModelConfig(RBLNModelConfig):
+    def __init__(self, batch_size: Optional[int] = None, image_size: Optional[int] = None, **kwargs):
+        """
+        Args:
+            batch_size (Optional[int]): The batch size for image processing. Defaults to 1.
+            image_size (Optional[int]): The size of input images. Can be an integer for square images,
+                a tuple/list (height, width), or a dictionary with 'height' and 'width' keys.
+            **kwargs: Additional arguments passed to the parent RBLNModelConfig.
+
+        Raises:
+            ValueError: If batch_size is not a positive integer.
+        """
+        super().__init__(**kwargs)
+        self.batch_size = batch_size or 1
+        if not isinstance(self.batch_size, int) or self.batch_size < 0:
+            raise ValueError(f"batch_size must be a positive integer, got {self.batch_size}")
+
+        self.image_size = image_size
+
+    @property
+    def image_width(self):
+        if isinstance(self.image_size, int):
+            return self.image_size
+        elif isinstance(self.image_size, (list, tuple)):
+            return self.image_size[1]
+        else:
+            return self.image_size["width"]
+
+    @property
+    def image_height(self):
+        if isinstance(self.image_size, int):
+            return self.image_size
+        elif isinstance(self.image_size, (list, tuple)):
+            return self.image_size[0]
+        else:
+            return self.image_size["height"]
+
+
+class RBLNCLIPVisionModelWithProjectionConfig(RBLNCLIPVisionModelConfig):
+    pass