optimum-rbln 0.9.3.post1__py3-none-any.whl

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

@@ -0,0 +1,93 @@
+# 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.
+
+import math
+from typing import TYPE_CHECKING, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from ..decoderonly.decoderonly_architecture import (
+    DecoderOnlyAttention,
+    DecoderOnlyLayer,
+    DecoderOnlyModel,
+    DecoderOnlyWrapper,
+)
+
+
+if TYPE_CHECKING:
+    from transformers import GPT2LMHeadModel, GPT2Model
+
+
+class GPT2Wrapper(DecoderOnlyWrapper):
+    def get_rbln_attn_class(self):
+        return GPT2Attention
+
+    def get_rbln_layer_class(self):
+        return GPT2Layer
+
+    def get_rbln_model_class(self):
+        return GPT2Model
+
+    def get_attn_layer(self, layer: nn.Module):
+        return layer.attn
+
+    def get_model_layer(self, model: Union["GPT2LMHeadModel", "GPT2Model"]):
+        return model.transformer if self.is_causal_lm else model
+
+    def get_decoder_layers(self, model: Union["GPT2LMHeadModel", "GPT2Model"]):
+        return model.transformer.h if self.is_causal_lm else model.h
+
+
+class GPT2Model(DecoderOnlyModel):
+    def get_last_layernorm(self) -> nn.LayerNorm:
+        return self._original_mod.ln_f
+
+    def get_embedding(self) -> nn.Embedding:
+        return self._original_mod.wte
+
+    def get_pos_embedding(self) -> nn.Embedding:
+        return self._original_mod.wpe
+
+
+class GPT2Layer(DecoderOnlyLayer):
+    def get_pre_attention_layernorm(self) -> nn.LayerNorm:
+        return self._original_mod.ln_1
+
+    def get_post_attention_layernorm(self) -> nn.LayerNorm:
+        return self._original_mod.ln_2
+
+
+class GPT2Attention(DecoderOnlyAttention):
+    def __post_init__(self):
+        self.c_attn = self._original_mod.c_attn
+        self.o_proj = self._original_mod.c_proj
+        self.split_size = self._original_mod.split_size
+
+    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
+
+    def get_attn_scale(self):
+        scale = 1.0
+        if self._original_mod.scale_attn_weights:
+            scale /= math.sqrt(self.head_dim)
+
+        if self._original_mod.scale_attn_by_inverse_layer_idx:
+            scale /= 1 + self.layer_idx
+
+        return scale

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

@@ -0,0 +1,55 @@
+# 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 ....utils import logging
+from ...models.decoderonly import RBLNDecoderOnlyModel, RBLNDecoderOnlyModelForCausalLM
+from .gpt2_architecture import GPT2Wrapper
+
+
+logger = logging.get_logger(__name__)
+
+
+class RBLNGPT2LMHeadModel(RBLNDecoderOnlyModelForCausalLM):
+    """
+    The GPT2 Model transformer with a language modeling head on top (linear layer with weights tied to the input
+    embeddings).
+
+    This model inherits from [`RBLNDecoderOnlyModelForCausalLM`]. Check the superclass documentation for the generic methods the
+    library implements for all its model.
+
+    It implements the methods to convert a pre-trained transformers GPT2 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
+
+
+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