optimum-rbln 0.8.2a4__py3-none-any.whl → 0.9.3rc0__py3-none-any.whl

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

@@ -12,5 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .configuration_gpt2 import RBLNGPT2LMHeadModelConfig
-from .modeling_gpt2 import RBLNGPT2LMHeadModel
+from .configuration_gpt2 import RBLNGPT2LMHeadModelConfig, RBLNGPT2ModelConfig
+from .modeling_gpt2 import RBLNGPT2LMHeadModel, RBLNGPT2Model

optimum/rbln/transformers/models/gpt2/configuration_gpt2.py

@@ -12,11 +12,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ..decoderonly.configuration_decoderonly import RBLNDecoderOnlyModelForCausalLMConfig
+from ..decoderonly.configuration_decoderonly import RBLNDecoderOnlyModelConfig, RBLNDecoderOnlyModelForCausalLMConfig
 
 
 class RBLNGPT2LMHeadModelConfig(RBLNDecoderOnlyModelForCausalLMConfig):
     """
-    Configuration class for GPT-2 causal language model.
-    Inherits from RBLNDecoderOnlyModelForCausalLMConfig with no additional parameters.
+    Configuration class for RBLN GPT2 models.
+
+    This class is an alias of RBLNDecoderOnlyModelForCausalLMConfig.
+    """
+
+
+class RBLNGPT2ModelConfig(RBLNDecoderOnlyModelConfig):
+    """
+    Configuration class for RBLN GPT2 models.
+
+    This class is an alias of RBLNDecoderOnlyModelConfig.
+
+    Example usage:
+    ```python
+    from optimum.rbln import RBLNGPT2Model, RBLNGPT2ModelConfig
+
+    # Create a configuration object
+    config = RBLNGPT2ModelConfig(
+        batch_size=1,
+        max_seq_len=1024,
+        tensor_parallel_size=4
+    )
+
+    # Use the configuration with from_pretrained
+    model = RBLNGPT2Model.from_pretrained(
+        "openai/gpt2",
+        export=True,
+        rbln_config=config
+    )
+    ```
     """

optimum/rbln/transformers/models/gpt2/gpt2_architecture.py

@@ -13,11 +13,10 @@
 # limitations under the License.
 
 import math
-from typing import TYPE_CHECKING, Tuple
+from typing import TYPE_CHECKING, Tuple, Union
 
 import torch
 import torch.nn as nn
-from transformers import PreTrainedModel
 
 from ..decoderonly.decoderonly_architecture import (
     DecoderOnlyAttention,
@@ -28,7 +27,7 @@ from ..decoderonly.decoderonly_architecture import (
 
 
 if TYPE_CHECKING:
-    from transformers import GPT2LMHeadModel
+    from transformers import GPT2LMHeadModel, GPT2Model
 
 
 class GPT2Wrapper(DecoderOnlyWrapper):
@@ -44,11 +43,11 @@ class GPT2Wrapper(DecoderOnlyWrapper):
     def get_attn_layer(self, layer: nn.Module):
         return layer.attn
 
-    def get_model_layer(self, causal_lm: "GPT2LMHeadModel"):
-        return causal_lm.transformer
+    def get_model_layer(self, model: Union["GPT2LMHeadModel", "GPT2Model"]):
+        return model.transformer if self.is_causal_lm else model
 
-    def get_decoder_layers(self, causal_lm: PreTrainedModel):
-        return causal_lm.transformer.h
+    def get_decoder_layers(self, model: Union["GPT2LMHeadModel", "GPT2Model"]):
+        return model.transformer.h if self.is_causal_lm else model.h
 
 
 class GPT2Model(DecoderOnlyModel):
@@ -76,7 +75,10 @@ class GPT2Attention(DecoderOnlyAttention):
         self.o_proj = self._original_mod.c_proj
         self.split_size = self._original_mod.split_size
 
-    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 GPT2Attention")
+
         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/gpt2/modeling_gpt2.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from ....utils import logging
-from ...models.decoderonly import RBLNDecoderOnlyModelForCausalLM
+from ...models.decoderonly import RBLNDecoderOnlyModel, RBLNDecoderOnlyModelForCausalLM
 from .gpt2_architecture import GPT2Wrapper
 
 
@@ -36,3 +36,20 @@ class RBLNGPT2LMHeadModel(RBLNDecoderOnlyModelForCausalLM):
 
     _decoder_wrapper_cls = GPT2Wrapper
     _use_rotary_emb = False
+
+
+class RBLNGPT2Model(RBLNDecoderOnlyModel):
+    """
+    The GPT2 Model transformer without a language modeling head.
+
+    This model inherits from [`RBLNDecoderOnlyModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model.
+
+    A class to convert and run pre-trained transformers based GPT2Model model on RBLN devices.
+    It implements the methods to convert a pre-trained transformers GPT2Model model into a RBLN transformer model by:
+    - transferring the checkpoint weights of the original into an optimized RBLN graph,
+    - compiling the resulting graph using the RBLN compiler.
+    """
+
+    _decoder_wrapper_cls = GPT2Wrapper
+    _use_rotary_emb = False

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

@@ -0,0 +1,10 @@
+from .configuration_grounding_dino import (
+    RBLNGroundingDinoDecoderConfig,
+    RBLNGroundingDinoEncoderConfig,
+    RBLNGroundingDinoForObjectDetectionConfig,
+)
+from .modeling_grounding_dino import (
+    RBLNGroundingDinoDecoder,
+    RBLNGroundingDinoEncoder,
+    RBLNGroundingDinoForObjectDetection,
+)

optimum/rbln/transformers/models/grounding_dino/configuration_grounding_dino.py

@@ -0,0 +1,92 @@
+# 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 Any, List, Optional, Tuple, Union
+
+import torch
+
+from ...configuration_generic import RBLNImageModelConfig, RBLNModelConfig
+
+
+class RBLNGroundingDinoForObjectDetectionConfig(RBLNImageModelConfig):
+    submodules = [
+        "text_backbone",
+        "backbone",
+        "encoder",
+        "decoder",
+    ]
+
+    def __init__(
+        self,
+        batch_size: Optional[int] = None,
+        encoder: Optional["RBLNGroundingDinoEncoderConfig"] = None,
+        decoder: Optional["RBLNGroundingDinoDecoderConfig"] = None,
+        text_backbone: Optional["RBLNModelConfig"] = None,
+        backbone: Optional["RBLNModelConfig"] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        **kwargs: Any,
+    ):
+        """
+        Args:
+            batch_size (Optional[int]): The batch size for image and text processing. Defaults to 1.
+            encoder (Optional["RBLNModelConfig"]): The encoder configuration. Defaults to None.
+            decoder (Optional["RBLNModelConfig"]): The decoder configuration. Defaults to None.
+            text_backbone (Optional["RBLNModelConfig"]): The text backbone configuration. Defaults to None.
+            backbone (Optional["RBLNModelConfig"]): The backbone configuration. Defaults to None.
+            output_attentions (Optional[bool]): Whether to output attentions. Defaults to None.
+            output_hidden_states (Optional[bool]): Whether to output hidden states. Defaults to None.
+            kwargs: Additional arguments passed to the parent RBLNModelConfig.
+
+        Raises:
+            ValueError: If batch_size is not a positive integer.
+        """
+        super().__init__(**kwargs)
+        self.encoder = encoder
+        self.decoder = decoder
+        self.text_backbone = text_backbone
+        self.backbone = backbone
+        self.output_attentions = output_attentions if output_attentions is not None else False
+        self.output_hidden_states = output_hidden_states if output_hidden_states is not None else False
+
+        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 RBLNGroundingDinoComponentConfig(RBLNImageModelConfig):
+    def __init__(
+        self,
+        image_size: Optional[Union[int, Tuple[int, int]]] = None,
+        batch_size: Optional[int] = None,
+        spatial_shapes_list: Optional[List[Tuple[int, int]]] = None,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        **kwargs: Any,
+    ):
+        super().__init__(image_size=image_size, batch_size=batch_size, **kwargs)
+        self.spatial_shapes_list = spatial_shapes_list
+        self.output_attentions = output_attentions
+        self.output_hidden_states = output_hidden_states
+
+    @property
+    def spatial_shapes(self):
+        if self.spatial_shapes_list is None:
+            raise ValueError("Spatial shapes are not defined. Please set them before accessing.")
+        return torch.tensor(self.spatial_shapes_list)
+
+
+class RBLNGroundingDinoEncoderConfig(RBLNGroundingDinoComponentConfig):
+    pass
+
+
+class RBLNGroundingDinoDecoderConfig(RBLNGroundingDinoComponentConfig):
+    pass