optimum-rbln 0.8.3a3__tar.gz → 0.8.3a4__tar.gz

optimum_rbln-0.8.3a4/.github/version.yaml

@@ -0,0 +1 @@
+rebel_compiler_version: 0.8.3.dev154+gd92397cc

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/.github/workflows/rbln_check_compiler.yaml

@@ -8,9 +8,9 @@ on:
         required: true
         type: string
     outputs:
-      is_deploy_version:
+      compiler_version_check:
         description: "Whether the compiler is a deploy version"
-        value: ${{ jobs.check-rebel-compiler-version.outputs.is_deploy_version }}
+        value: ${{ jobs.check-rebel-compiler-version.outputs.compiler_version_check }}
       compiler_version:
         description: "The compiler version used"
         value: ${{ jobs.check-rebel-compiler-version.outputs.compiler_version }}
@@ -19,7 +19,7 @@ jobs:
   check-rebel-compiler-version:
     runs-on: rebel-k8s-runner
     outputs:
-      is_deploy_version: ${{ steps.check_prod.outputs.IS_PROD }}
+      compiler_version_check: ${{ steps.final_check.outputs.COMPILER_VERSION_CHECK }}
       compiler_version: ${{ steps.install_compiler.outputs.COMPILER_VERSION }}
     steps:
       - name: Set up Python
@@ -51,11 +51,35 @@ jobs:
         id: check_prod
         run: |
           if [ "$ENV_VALUE" = "PROD" ]; then
-            echo "IS_PROD=true" >> $GITHUB_OUTPUT
+            echo "IS_PROD=true" >> $GITHUB_ENV
             echo "version check pass(✅)!!"
           else
-            echo "IS_PROD=false" >> $GITHUB_OUTPUT
+            echo "IS_PROD=false" >> $GITHUB_ENV
             echo "version check fail(❌)!!" 
             echo "rebel-compiler must be prod version"
+          fi 
+
+      - name: Check pyarmor
+        id: check_pyarmor
+        run: |
+          if pip3 show -f rebel-compiler | grep -Ei 'pytransform|pyarmor_runtime|__pyarmor__|license\.lic'; then
+            echo "PYARMOR_ENC=true" >> $GITHUB_ENV
+            echo "pyarmor check pass(✅)!!"
+          else
+            echo "PYARMOR_ENC=false" >> $GITHUB_ENV
+            echo "pyarmor check fail(❌)!!"
+          fi
+
+      - name: Final verification
+        id: final_check
+        run: |
+          echo "IS_PROD=$IS_PROD"
+          echo "PYARMOR_ENC=$PYARMOR_ENC"
+          if [ "$IS_PROD" = "true" ] && [ "$PYARMOR_ENC" = "true" ]; then
+            echo "COMPILER_VERSION_CHECK=true" >> $GITHUB_OUTPUT
+            echo "Final check pass(✅)!!"
+          else
+            echo "COMPILER_VERSION_CHECK=false" >> $GITHUB_OUTPUT
+            echo "Final check fail(❌)!! Both IS_PROD and PYARMOR_ENC must be true."
             exit 1
-          fi 
+          fi

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/.github/workflows/rbln_scheduled_test.yaml

@@ -41,7 +41,7 @@ jobs:
 
   optimum-rbln-pytest:
     needs: [load-version, check-compiler]
-    if: ${{ needs.check-compiler.outputs.is_deploy_version == 'true' }}
+    if: ${{ needs.check-compiler.outputs.compiler_version_check == 'true' }}
     uses: ./.github/workflows/rbln_optimum_pytest.yaml
     with:
       ref: main
@@ -53,7 +53,7 @@ jobs:
 
   optimum-rbln-inference-test:
     needs: check-compiler
-    if: ${{ needs.check-compiler.outputs.is_deploy_version == 'true' }}
+    if: ${{ needs.check-compiler.outputs.compiler_version_check == 'true' }}
     uses: ./.github/workflows/rbln_optimum_inference_test.yaml
     with:
       ref: main

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/.github/workflows/rbln_trigger_on_pr.yaml

@@ -61,7 +61,7 @@ jobs:
   check-team-member:
     runs-on: rebel-k8s-runner
     needs: [check-skip-ci, check-code-quality, test-docstrings, check-compiler]
-    if: ${{ needs.check-skip-ci.outputs.should_skip != 'true' && needs.check-compiler.outputs.is_deploy_version == 'true' }}
+    if: ${{ needs.check-skip-ci.outputs.should_skip != 'true' && needs.check-compiler.outputs.compiler_version_check == 'true' }}
     outputs:
       is_team_member: ${{ steps.check_member.outputs.IS_TEAM_MEMBER }}
     steps:

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optimum-rbln
-Version: 0.8.3a3
+Version: 0.8.3a4
 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

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/src/optimum/rbln/__init__.py

@@ -149,6 +149,8 @@ _import_structure = {
         "RBLNRobertaForSequenceClassificationConfig",
         "RBLNSiglipVisionModel",
         "RBLNSiglipVisionModelConfig",
+        "RBLNSwinBackbone",
+        "RBLNSwinBackboneConfig",
         "RBLNT5EncoderModel",
         "RBLNT5EncoderModelConfig",
         "RBLNT5ForConditionalGeneration",
@@ -426,6 +428,8 @@ if TYPE_CHECKING:
         RBLNRobertaForSequenceClassificationConfig,
         RBLNSiglipVisionModel,
         RBLNSiglipVisionModelConfig,
+        RBLNSwinBackbone,
+        RBLNSwinBackboneConfig,
         RBLNT5EncoderModel,
         RBLNT5EncoderModelConfig,
         RBLNT5ForConditionalGeneration,

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/src/optimum/rbln/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.8.3a3'
-__version_tuple__ = version_tuple = (0, 8, 3, 'a3')
+__version__ = version = '0.8.3a4'
+__version_tuple__ = version_tuple = (0, 8, 3, 'a4')
 
 __commit_id__ = commit_id = None

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/src/optimum/rbln/configuration_utils.py

@@ -21,6 +21,7 @@ from typing import Any, Dict, List, Optional, Protocol, Tuple, Type, Union, runt
 
 import numpy as np
 import torch
+from packaging.version import Version
 
 from .__version__ import __version__
 from .utils.depreacate_utils import warn_deprecated_npu
@@ -621,6 +622,21 @@ class RBLNModelConfig(RBLNSerializableConfigProtocol):
             self.set_compile_cfgs([RBLNCompileConfig(**cfg) for cfg in self._compile_cfgs])
 
         if len(kwargs) > 0:
+            if optimum_rbln_version is not None:  # loaded from file
+                if Version(__version__) < Version(optimum_rbln_version):
+                    diff = "newer"
+                elif Version(__version__) > Version(optimum_rbln_version):
+                    diff = "older"
+                else:
+                    diff = None
+                if diff is not None:
+                    raise ValueError(
+                        f"Unexpected arguments: {kwargs.keys()}\n"
+                        f"Maybe you are trying to load a model compiled with {diff} version of optimum-rbln. "
+                        "It is recommended to use the same version to compile and load the model.\n"
+                        f"Current version: {__version__}, Loaded version: {optimum_rbln_version}"
+                    )
+
             raise ValueError(f"Unexpected arguments: {kwargs.keys()}")
 
     @property

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/src/optimum/rbln/diffusers/pipelines/auto_pipeline.py

@@ -48,7 +48,7 @@ class RBLNAutoPipelineBase:
             rbln_class_name = convert_hf_to_rbln_model_name(hf_model_class.__name__)
         else:
             rbln_class_name = cls.get_rbln_model_cls_name(pretrained_model_name_or_path, **kwargs)
-            if convert_rbln_to_hf_model_name(rbln_class_name) not in cls._model_mapping_names:
+            if convert_rbln_to_hf_model_name(rbln_class_name) not in cls._model_mapping_names.values():
                 raise ValueError(
                     f"The architecture '{rbln_class_name}' is not supported by the `{cls.__name__}.from_pretrained()` method. "
                     "Please use the `from_pretrained()` method of the appropriate class to load this model, "

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/src/optimum/rbln/transformers/__init__.py

@@ -139,6 +139,8 @@ _import_structure = {
         "RBLNRobertaForSequenceClassificationConfig",
         "RBLNSiglipVisionModel",
         "RBLNSiglipVisionModelConfig",
+        "RBLNSwinBackbone",
+        "RBLNSwinBackboneConfig",
         "RBLNT5EncoderModel",
         "RBLNT5EncoderModelConfig",
         "RBLNT5ForConditionalGeneration",
@@ -278,6 +280,8 @@ if TYPE_CHECKING:
         RBLNRobertaForSequenceClassificationConfig,
         RBLNSiglipVisionModel,
         RBLNSiglipVisionModelConfig,
+        RBLNSwinBackbone,
+        RBLNSwinBackboneConfig,
         RBLNT5EncoderModel,
         RBLNT5EncoderModelConfig,
         RBLNT5ForConditionalGeneration,

{optimum_rbln-0.8.3a3 → optimum_rbln-0.8.3a4}/src/optimum/rbln/transformers/models/__init__.py

@@ -142,6 +142,10 @@ _import_structure = {
         "RBLNSiglipVisionModel",
         "RBLNSiglipVisionModelConfig",
     ],
+    "swin": [
+        "RBLNSwinBackbone",
+        "RBLNSwinBackboneConfig",
+    ],
     "time_series_transformer": [
         "RBLNTimeSeriesTransformerForPrediction",
         "RBLNTimeSeriesTransformerForPredictionConfig",
@@ -268,6 +272,7 @@ if TYPE_CHECKING:
         RBLNRobertaForSequenceClassificationConfig,
     )
     from .siglip import RBLNSiglipVisionModel, RBLNSiglipVisionModelConfig
+    from .swin import RBLNSwinBackbone, RBLNSwinBackboneConfig
     from .t5 import (
         RBLNT5EncoderModel,
         RBLNT5EncoderModelConfig,

optimum_rbln-0.8.3a4/src/optimum/rbln/transformers/models/swin/__init__.py

@@ -0,0 +1,16 @@
+# 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_swin import RBLNSwinBackboneConfig
+from .modeling_swin import RBLNSwinBackbone

optimum_rbln-0.8.3a4/src/optimum/rbln/transformers/models/swin/configuration_swin.py

@@ -0,0 +1,42 @@
+# 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, Optional, Tuple, Union
+
+from ...configuration_generic import RBLNModelForImageClassificationConfig
+
+
+class RBLNSwinBackboneConfig(RBLNModelForImageClassificationConfig):
+    def __init__(
+        self,
+        image_size: Optional[Union[int, Tuple[int, int]]] = None,
+        batch_size: Optional[int] = None,
+        output_hidden_states: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        **kwargs: Any,
+    ):
+        """
+        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}")
+
+        self.image_size = image_size
+        self.output_hidden_states = output_hidden_states
+        self.output_attentions = output_attentions

optimum_rbln-0.8.3a4/src/optimum/rbln/transformers/models/swin/modeling_swin.py

@@ -0,0 +1,316 @@
+# 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 types
+from typing import TYPE_CHECKING, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from transformers import SwinConfig
+from transformers.models.swin.modeling_swin import BackboneOutput
+
+from ....configuration_utils import RBLNCompileConfig
+from ....modeling import RBLNModel
+from ....utils.logging import get_logger
+from .configuration_swin import RBLNSwinBackboneConfig
+
+
+logger = get_logger(__name__)
+
+if TYPE_CHECKING:
+    from transformers import (
+        AutoFeatureExtractor,
+        AutoProcessor,
+        AutoTokenizer,
+        PreTrainedModel,
+        SwinBackbone,
+        SwinEncoder,
+    )
+
+
+def window_partition(input_feature, window_size):
+    """
+    Partitions the given input into windows.
+    """
+    batch_size, height, width, num_channels = input_feature.shape
+    input_feature = input_feature.view(
+        batch_size, height // window_size, window_size, width // window_size, window_size, num_channels
+    )
+    windows = input_feature.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, num_channels)
+    return windows
+
+
+def get_attn_mask(self, height, width, dtype, device):
+    if self.shift_size > 0:
+        # calculate attention mask for SW-MSA
+        img_mask = torch.zeros((1, height, width, 1), dtype=dtype, device=device)
+        height_slices = (
+            slice(0, -self.window_size),
+            slice(-self.window_size, -self.shift_size),
+            slice(-self.shift_size, None),
+        )
+        width_slices = (
+            slice(0, -self.window_size),
+            slice(-self.window_size, -self.shift_size),
+            slice(-self.shift_size, None),
+        )
+        count = torch.zeros(1)
+        for height_slice in height_slices:
+            for width_slice in width_slices:
+                img_mask[:, height_slice, width_slice, :] = count
+                count += 1
+
+        mask_windows = window_partition(img_mask, self.window_size)
+        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+    else:
+        attn_mask = None
+    return attn_mask
+
+
+class _SwinEncoder(torch.nn.Module):
+    def __init__(self, model: "SwinEncoder"):
+        super().__init__()
+        self.layers = model.layers
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        input_dimensions: Tuple[int, int],
+        head_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        output_hidden_states_before_downsampling: Optional[bool] = False,
+        always_partition: Optional[bool] = False,
+        return_dict: Optional[bool] = True,
+    ):
+        all_hidden_states = () if output_hidden_states else None
+        all_reshaped_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+
+        if output_hidden_states:
+            batch_size, _, hidden_size = hidden_states.shape
+            # rearrange b (h w) c -> b c h w
+            reshaped_hidden_state = hidden_states.view(batch_size, *input_dimensions, hidden_size)
+            reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
+            all_hidden_states += (hidden_states,)
+            all_reshaped_hidden_states += (reshaped_hidden_state,)
+
+        for i, layer_module in enumerate(self.layers):
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+
+            layer_outputs = layer_module(
+                hidden_states, input_dimensions, layer_head_mask, output_attentions, always_partition
+            )
+
+            hidden_states = layer_outputs[0]
+            hidden_states_before_downsampling = layer_outputs[1]
+            output_dimensions = layer_outputs[2]
+
+            input_dimensions = (output_dimensions[-2], output_dimensions[-1])
+
+            if output_hidden_states and output_hidden_states_before_downsampling:
+                batch_size, _, hidden_size = hidden_states_before_downsampling.shape
+                # rearrange b (h w) c -> b c h w
+                # here we use the original (not downsampled) height and width
+                reshaped_hidden_state = hidden_states_before_downsampling.view(
+                    batch_size, *(output_dimensions[0], output_dimensions[1]), hidden_size
+                )
+                reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
+                all_hidden_states += (hidden_states_before_downsampling,)
+                all_reshaped_hidden_states += (reshaped_hidden_state,)
+            elif output_hidden_states and not output_hidden_states_before_downsampling:
+                batch_size, _, hidden_size = hidden_states.shape
+                # rearrange b (h w) c -> b c h w
+                reshaped_hidden_state = hidden_states.view(batch_size, *input_dimensions, hidden_size)
+                reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
+                all_hidden_states += (hidden_states,)
+                all_reshaped_hidden_states += (reshaped_hidden_state,)
+
+            if output_attentions:
+                all_self_attentions += layer_outputs[3:]
+
+        return tuple(
+            v
+            for v in [hidden_states, all_hidden_states, all_self_attentions, all_reshaped_hidden_states]
+            if v is not None
+        )
+
+
+class _SwinBackbone(torch.nn.Module):
+    def __init__(self, model: "SwinBackbone", output_hidden_states: bool, output_attentions: bool):
+        super().__init__()
+        self.model = model
+        self.embeddings = model.embeddings
+        self.encoder = model.encoder
+        self.stage_names = model.stage_names
+        self.out_features = model.out_features
+        self.hidden_states_norms = model.hidden_states_norms
+        self.output_hidden_states = output_hidden_states
+        self.output_attentions = output_attentions
+
+    def forward(
+        self,
+        pixel_values: torch.Tensor,
+    ):
+        embedding_output, input_dimensions = self.embeddings(pixel_values)
+        outputs = _SwinEncoder(self.encoder)(
+            embedding_output,
+            input_dimensions,
+            head_mask=None,
+            output_attentions=self.output_attentions,
+            output_hidden_states=True,
+            output_hidden_states_before_downsampling=True,
+            always_partition=True,
+            return_dict=False,
+        )
+
+        hidden_states = outputs[-1]
+
+        feature_maps = ()
+        for stage, hidden_state in zip(self.stage_names, hidden_states):
+            if stage in self.out_features:
+                batch_size, num_channels, height, width = hidden_state.shape
+                hidden_state = hidden_state.permute(0, 2, 3, 1).contiguous()
+                hidden_state = hidden_state.view(batch_size, height * width, num_channels)
+                hidden_state = self.hidden_states_norms[stage](hidden_state)
+                hidden_state = hidden_state.view(batch_size, height, width, num_channels)
+                hidden_state = hidden_state.permute(0, 3, 1, 2).contiguous()
+                feature_maps += (hidden_state,)
+
+        output = (feature_maps,)
+
+        if self.output_hidden_states:
+            output += (outputs[1],)
+
+        if self.output_attentions:
+            output += (outputs[2],)
+
+        return output
+
+
+class RBLNSwinBackbone(RBLNModel):
+    @classmethod
+    def wrap_model_if_needed(cls, model: torch.nn.Module, rbln_config: RBLNSwinBackboneConfig) -> torch.nn.Module:
+        for layer in model.encoder.layers:
+            for block in layer.blocks:
+                block.get_attn_mask = types.MethodType(get_attn_mask, block)
+
+        wrapper_cfg = {
+            "output_hidden_states": rbln_config.output_hidden_states,
+            "output_attentions": rbln_config.output_attentions,
+        }
+        return _SwinBackbone(model, **wrapper_cfg).eval()
+
+    @classmethod
+    def _update_rbln_config(
+        cls,
+        preprocessors: Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"],
+        model: Optional["PreTrainedModel"] = None,
+        model_config: "SwinConfig" = None,
+        rbln_config: Optional[RBLNSwinBackboneConfig] = None,
+    ) -> RBLNSwinBackboneConfig:
+        if rbln_config.image_size is None:
+            for processor in preprocessors:
+                if hasattr(processor, "size"):
+                    if all(required_key in processor.size.keys() for required_key in ["height", "width"]):
+                        rbln_config.image_size = (processor.size["height"], processor.size["width"])
+                    break
+
+        input_info = [
+            (
+                "pixel_values",
+                [
+                    rbln_config.batch_size,
+                    3,
+                    rbln_config.image_size[0],
+                    rbln_config.image_size[1],
+                ],
+                "float32",
+            ),
+        ]
+
+        rbln_config.set_compile_cfgs([RBLNCompileConfig(input_info=input_info)])
+        return rbln_config
+
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        return_dict: bool = True,
+        output_attentions: bool = None,
+        output_hidden_states: bool = None,
+        **kwargs,
+    ) -> Union[Tuple, BackboneOutput]:
+        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
+        )
+
+        if output_attentions != self.rbln_config.output_attentions:
+            raise ValueError(
+                f"Variable output_attentions {output_attentions} is not equal to rbln_config.output_attentions {self.rbln_config.output_attentions} "
+                f"Please compile again with the correct argument."
+            )
+
+        if output_hidden_states != self.rbln_config.output_hidden_states:
+            raise ValueError(
+                f"Variable output_hidden_states {output_hidden_states} is not equal to rbln_config.output_hidden_states {self.rbln_config.output_hidden_states} "
+                f"Please compile again with the correct argument."
+            )
+
+        _, _, original_h, original_w = pixel_values.shape
+        if original_h > self.rbln_config.image_size[0] or original_w > self.rbln_config.image_size[1]:
+            raise ValueError(
+                f"Input image size ({original_h}x{original_w}) exceeds the configured maximum size"
+                f" ({self.rbln_config.image_size[0]}x{self.rbln_config.image_size[1]})."
+            )
+
+        pad_h = self.rbln_config.image_size[0] - original_h
+        pad_w = self.rbln_config.image_size[1] - original_w
+        padded_pixel_values = F.pad(pixel_values, (0, pad_w, 0, pad_h))
+
+        output = self.model[0](padded_pixel_values)
+
+        feature_maps = ()
+        for i in range(len(self.config.out_features)):
+            feature_maps += (output.pop(0),)
+
+        if self.rbln_config.output_hidden_states:
+            hidden_states = ()
+            for i in range(len(self.config.stage_names)):
+                hidden_states += (output.pop(0),)
+        else:
+            hidden_states = None
+
+        if self.rbln_config.output_attentions:
+            attentions = ()
+            for i in range(len(self.config.depths)):
+                attentions += (output.pop(0),)
+        else:
+            attentions = None
+
+        if not return_dict:
+            return tuple(item for item in (feature_maps, hidden_states, attentions) if item is not None)
+        else:
+            return BackboneOutput(
+                feature_maps=feature_maps,
+                hidden_states=hidden_states,
+                attentions=attentions,
+            )

optimum_rbln-0.8.3a3/.github/version.yaml

@@ -1 +0,0 @@
-rebel_compiler_version: 0.8.2.dev187+g9f5b6c9b