optimum-rbln 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

optimum/rbln/transformers/models/gemma/modeling_gemma.py

@@ -23,14 +23,19 @@
 
 import inspect
 import logging
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
-from transformers import GemmaForCausalLM, PreTrainedModel
+from transformers import GemmaForCausalLM
 
 from ...models.decoderonly import RBLNDecoderOnlyModelForCausalLM
 from .gemma_architecture import GemmaWrapper
 
 
+if TYPE_CHECKING:
+    from transformers import PreTrainedModel
+
+    from ....modeling_config import RBLNConfig
+
 logger = logging.getLogger(__name__)
 
 
@@ -46,7 +51,8 @@ class RBLNGemmaForCausalLM(RBLNDecoderOnlyModelForCausalLM):
     """
 
     @classmethod
-    def wrapping_torch_model(self, model: "PreTrainedModel", rbln_max_seq_len: int):
+    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: "RBLNConfig"):
+        rbln_max_seq_len = rbln_config.meta["rbln_max_seq_len"]
         return GemmaWrapper(model, rbln_max_seq_len).eval()
 
     def __getattr__(self, __name: str) -> Any:

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

@@ -23,23 +23,18 @@
 
 import inspect
 import logging
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable
 
-from transformers import GPT2LMHeadModel, PretrainedConfig, PreTrainedModel
+from transformers import GPT2LMHeadModel
 
-from ....modeling_config import RBLNConfig, RBLNRuntimeConfig
+from ....modeling_config import RBLNConfig
 from ...models.decoderonly import RBLNDecoderOnlyModelForCausalLM
 from .gpt2_architecture import GPT2LMHeadModelWrapper
 
 
 logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
-    from transformers import (
-        AutoFeatureExtractor,
-        AutoProcessor,
-        AutoTokenizer,
-        PretrainedConfig,
-    )
+    from transformers import PreTrainedModel
 
 
 class RBLNGPT2LMHeadModel(RBLNDecoderOnlyModelForCausalLM):
@@ -57,7 +52,8 @@ class RBLNGPT2LMHeadModel(RBLNDecoderOnlyModelForCausalLM):
     """
 
     @classmethod
-    def wrapping_torch_model(self, model: "PreTrainedModel", rbln_max_seq_len: int):
+    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: "RBLNConfig"):
+        rbln_max_seq_len = rbln_config.meta["rbln_max_seq_len"]
         return GPT2LMHeadModelWrapper(model, rbln_max_seq_len).eval()
 
     def __getattr__(self, __name: str) -> Any:
@@ -74,82 +70,3 @@ class RBLNGPT2LMHeadModel(RBLNDecoderOnlyModelForCausalLM):
         if isinstance(val, Callable) and "self" in set(inspect.signature(val).parameters):
             return redirect(val)
         return val
-
-    @classmethod
-    def _get_rbln_config(
-        cls,
-        preprocessors: Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"],
-        model_config: "PretrainedConfig",
-        rbln_max_seq_len: Optional[int] = None,
-        rbln_batch_size: Optional[int] = None,
-        **kwargs,
-    ) -> RBLNConfig:
-        meta = {}
-
-        prefill_chunk_size = 128
-        if rbln_max_seq_len is None:  # differenct from llama
-            rbln_max_seq_len = getattr(model_config, "n_positions", None)
-        rbln_batch_size = 1 if rbln_batch_size is None else rbln_batch_size
-
-        meta["rbln_max_seq_len"] = rbln_max_seq_len
-        meta["rbln_batch_size"] = rbln_batch_size
-        meta["rbln_prefill_chunk_size"] = prefill_chunk_size
-
-        def get_input_info(
-            batch_size,
-            query_length,
-        ):
-            head_dim = (
-                model_config.head_dim
-                if hasattr(model_config, "head_dim")
-                else model_config.hidden_size // model_config.n_head
-            )
-            input_info = [
-                ("input_ids", [batch_size, query_length], "int64"),
-                ("attention_mask", [batch_size, 1, query_length, rbln_max_seq_len], "int64"),
-                (
-                    "cache_position",
-                    [batch_size, query_length],
-                    "int32",
-                ),
-                ("batch_position", [], "int16"),
-            ]
-
-            input_info.extend(
-                [
-                    (
-                        f"past_key_values_{i}",
-                        [
-                            rbln_batch_size,
-                            model_config.n_head,  # differenct from llama
-                            rbln_max_seq_len,
-                            head_dim,
-                        ],
-                        "float32",
-                    )
-                    for i in range(model_config.n_layer * 2)  # differenct from llama
-                ]
-            )
-
-            return input_info
-
-        prefill_input_info = get_input_info(
-            batch_size=1,
-            query_length=prefill_chunk_size,
-        )
-        dec_input_info = get_input_info(
-            batch_size=rbln_batch_size,
-            query_length=1,
-        )
-
-        prefill_rbln_runtime_config = RBLNRuntimeConfig(input_info=prefill_input_info)
-        dec_rbln_runtime_config = RBLNRuntimeConfig(input_info=dec_input_info)
-
-        dec_rbln_runtime_config.batch_size = rbln_batch_size
-
-        rbln_config = RBLNConfig.from_rbln_runtime_configs(
-            [prefill_rbln_runtime_config, dec_rbln_runtime_config],
-            _rbln_meta=meta,
-        )
-
-        return rbln_config

optimum/rbln/transformers/models/llama/modeling_llama.py

@@ -23,14 +23,19 @@
 
 import inspect
 import logging
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
-from transformers import LlamaForCausalLM, PreTrainedModel
+from transformers import LlamaForCausalLM
 
 from ...models.decoderonly import RBLNDecoderOnlyModelForCausalLM
 from .llama_architecture import LlamaWrapper
 
 
+if TYPE_CHECKING:
+    from transformers import PreTrainedModel
+
+    from ....modeling_config import RBLNConfig
+
 logger = logging.getLogger(__name__)
 
 
@@ -46,7 +51,8 @@ class RBLNLlamaForCausalLM(RBLNDecoderOnlyModelForCausalLM):
     """
 
     @classmethod
-    def wrapping_torch_model(self, model: "PreTrainedModel", rbln_max_seq_len: int):
+    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: "RBLNConfig"):
+        rbln_max_seq_len = rbln_config.meta["rbln_max_seq_len"]
         return LlamaWrapper(model, rbln_max_seq_len).eval()
 
     def __getattr__(self, __name: str) -> Any:

optimum/rbln/transformers/models/midm/modeling_midm.py

@@ -23,11 +23,9 @@
 
 import inspect
 import logging
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable
 
-from transformers import PretrainedConfig, PreTrainedModel
-
-from ....modeling_config import RBLNConfig, RBLNRuntimeConfig
+from ....modeling_config import RBLNConfig
 from ...models.decoderonly import RBLNDecoderOnlyModelForCausalLM
 from .hf_hub_cached.modeling_midm import MidmLMHeadModel
 from .midm_architecture import (
@@ -38,10 +36,7 @@ from .midm_architecture import (
 logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from transformers import (
-        AutoFeatureExtractor,
-        AutoProcessor,
-        AutoTokenizer,
-        PretrainedConfig,
+        PreTrainedModel,
     )
 
 
@@ -60,7 +55,8 @@ class RBLNMidmLMHeadModel(RBLNDecoderOnlyModelForCausalLM):
     """
 
     @classmethod
-    def wrapping_torch_model(self, model: "PreTrainedModel", rbln_max_seq_len: int):
+    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: "RBLNConfig"):
+        rbln_max_seq_len = rbln_config.meta["rbln_max_seq_len"]
         return MidmLMHeadModelWrapper(model, rbln_max_seq_len).eval()
 
     def __getattr__(self, __name: str) -> Any:
@@ -77,82 +73,3 @@ class RBLNMidmLMHeadModel(RBLNDecoderOnlyModelForCausalLM):
         if isinstance(val, Callable) and "self" in set(inspect.signature(val).parameters):
             return redirect(val)
         return val
-
-    @classmethod
-    def _get_rbln_config(
-        cls,
-        preprocessors: Union["AutoFeatureExtractor", "AutoProcessor", "AutoTokenizer"],
-        model_config: "PretrainedConfig",
-        rbln_max_seq_len: Optional[int] = None,
-        rbln_batch_size: Optional[int] = None,
-        **kwargs,
-    ) -> RBLNConfig:
-        meta = {}
-
-        prefill_chunk_size = 128
-        if rbln_max_seq_len is None:
-            rbln_max_seq_len = getattr(model_config, "n_positions", None)
-        rbln_batch_size = 1 if rbln_batch_size is None else rbln_batch_size
-
-        meta["rbln_max_seq_len"] = rbln_max_seq_len
-        meta["rbln_batch_size"] = rbln_batch_size
-        meta["rbln_prefill_chunk_size"] = prefill_chunk_size
-
-        def get_input_info(
-            batch_size,
-            query_length,
-        ):
-            head_dim = (
-                model_config.head_dim
-                if hasattr(model_config, "head_dim")
-                else model_config.hidden_size // model_config.n_head
-            )
-            input_info = [
-                ("input_ids", [batch_size, query_length], "int64"),
-                ("attention_mask", [batch_size, 1, query_length, rbln_max_seq_len], "int64"),
-                (
-                    "cache_position",
-                    [batch_size, query_length],
-                    "int32",
-                ),
-                ("batch_position", [], "int16"),
-            ]
-
-            input_info.extend(
-                [
-                    (
-                        f"past_key_values_{i}",
-                        [
-                            rbln_batch_size,
-                            model_config.n_head,
-                            rbln_max_seq_len,
-                            head_dim,
-                        ],
-                        "float32",
-                    )
-                    for i in range(model_config.n_layer * 2)
-                ]
-            )
-
-            return input_info
-
-        prefill_input_info = get_input_info(
-            batch_size=1,
-            query_length=prefill_chunk_size,
-        )
-        dec_input_info = get_input_info(
-            batch_size=rbln_batch_size,
-            query_length=1,
-        )
-
-        prefill_rbln_runtime_config = RBLNRuntimeConfig(input_info=prefill_input_info)
-        dec_rbln_runtime_config = RBLNRuntimeConfig(input_info=dec_input_info)
-
-        dec_rbln_runtime_config.batch_size = rbln_batch_size
-
-        rbln_config = RBLNConfig.from_rbln_runtime_configs(
-            [prefill_rbln_runtime_config, dec_rbln_runtime_config],
-            _rbln_meta=meta,
-        )
-
-        return rbln_config

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

@@ -0,0 +1,24 @@
+# Copyright 2024 Rebellions Inc.
+
+# 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.
+
+# Portions of this software are licensed under the Apache License,
+# Version 2.0. See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.
+
+# All other portions of this software, including proprietary code,
+# are the intellectual property of Rebellions Inc. and may not be
+# copied, modified, or distributed without prior written permission
+# from Rebellions Inc.
+
+from .modeling_mistral import RBLNMistralForCausalLM

optimum/rbln/transformers/models/mistral/mistral_architecture.py

@@ -0,0 +1,29 @@
+# Copyright 2024 Rebellions Inc.
+
+# 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.
+
+# Portions of this software are licensed under the Apache License,
+# Version 2.0. See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.
+
+# All other portions of this software, including proprietary code,
+# are the intellectual property of Rebellions Inc. and may not be
+# copied, modified, or distributed without prior written permission
+# from Rebellions Inc.
+
+
+from ..decoderonly.decoderonly_architecture import DecoderOnlyWrapper
+
+
+class MistralForCausalLMWrapper(DecoderOnlyWrapper):
+    pass

optimum/rbln/transformers/models/mistral/modeling_mistral.py

@@ -0,0 +1,68 @@
+# Copyright 2024 Rebellions Inc.
+
+# 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.
+
+# Portions of this software are licensed under the Apache License,
+# Version 2.0. See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.
+
+# All other portions of this software, including proprietary code,
+# are the intellectual property of Rebellions Inc. and may not be
+# copied, modified, or distributed without prior written permission
+# from Rebellions Inc.
+
+import inspect
+import logging
+from typing import TYPE_CHECKING, Any, Callable
+
+from transformers import MistralForCausalLM
+
+from ...models.decoderonly import RBLNDecoderOnlyModelForCausalLM
+from .mistral_architecture import MistralForCausalLMWrapper
+
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedModel
+
+    from ....modeling_config import RBLNConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+class RBLNMistralForCausalLM(RBLNDecoderOnlyModelForCausalLM):
+    """
+    The Llama Model transformer with a language modeling head (linear layer) on top.
+    This model inherits from [`RBLNMultiModel`]. Check the superclass documentation for the generic methods the library implements for all its models.
+
+    A class to convert and run pre-trained transformers based LlamaForCausalLM model on RBLN devices.
+    It implements the methods to convert a pre-trained transformers LlamaForCausalLM 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.
+    """
+
+    @classmethod
+    def wrap_model_if_needed(self, model: "PreTrainedModel", rbln_config: "RBLNConfig"):
+        rbln_max_seq_len = rbln_config.meta["rbln_max_seq_len"]
+        return MistralForCausalLMWrapper(model, rbln_max_seq_len).eval()
+
+    def __getattr__(self, __name: str) -> Any:
+        def redirect(func):
+            return lambda *pargs, **kwargs: func(self, *pargs, **kwargs)
+
+        val = getattr(MistralForCausalLM, __name)
+
+        if isinstance(val, Callable) and "self" in set(inspect.signature(val).parameters):
+            return redirect(val)
+
+        return val

optimum/rbln/transformers/models/wav2vec2/modeling_wav2vec2.py

@@ -70,7 +70,7 @@ class RBLNWav2Vec2ForCTC(RBLNModel):
     auto_model_class = AutoModelForMaskedLM
 
     @classmethod
-    def wrap_model_if_needed(cls, model: torch.nn.Module) -> torch.nn.Module:
+    def wrap_model_if_needed(cls, model: torch.nn.Module, rbln_config: RBLNConfig) -> torch.nn.Module:
         return _Wav2Vec2(model).eval()
 
     @classmethod

optimum/rbln/transformers/models/xlm_roberta/modeling_xlm_roberta.py

@@ -36,6 +36,7 @@ logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from transformers import AutoFeatureExtractor, AutoProcessor, AutoTokenizer
 
+
 class RBLNXLMRobertaModel(RBLNModel):
     auto_model_class = AutoModel  # feature extraction
     original_model_class = XLMRobertaModel
@@ -81,7 +82,6 @@ class RBLNXLMRobertaModel(RBLNModel):
         rbln_model_input_names: Optional[List[str]] = None,
         rbln_batch_size: Optional[int] = None,
     ) -> RBLNConfig:
-
         max_position_embeddings = getattr(model_config, "n_positions", None) or getattr(
             model_config, "max_position_embeddings", None
         )
@@ -118,7 +118,13 @@ class RBLNXLMRobertaModel(RBLNModel):
 
         return RBLNConfig.from_rbln_runtime_configs([rbln_runtime_config], _rbln_meta=meta)
 
-    def forward(self, input_ids: "torch.Tensor", attention_mask: "torch.Tensor", token_type_ids: "torch.Tensor" = None, **kwargs):
+    def forward(
+        self,
+        input_ids: "torch.Tensor",
+        attention_mask: "torch.Tensor",
+        token_type_ids: "torch.Tensor" = None,
+        **kwargs,
+    ):
         if token_type_ids is None:
             token_type_ids = torch.zeros_like(input=input_ids, dtype=torch.int64)
         output = super().forward(input_ids, attention_mask, token_type_ids)

optimum/rbln/transformers/utils/rbln_quantization.py

@@ -0,0 +1,109 @@
+# Copyright 2024 Rebellions Inc.
+
+# 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.
+
+# Portions of this software are licensed under the Apache License,
+# Version 2.0. See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.
+
+# All other portions of this software, including proprietary code,
+# are the intellectual property of Rebellions Inc. and may not be
+# copied, modified, or distributed without prior written permission
+# from Rebellions Inc.
+
+
+from typing import Any, List
+
+import torch
+from torch.nn import Linear, Parameter
+from torch.nn import functional as F
+
+
+QUANTIZED_WEIGHTS = [
+    "q_proj",
+    "k_proj",
+    "v_proj",
+    "o_proj",
+    "gate_proj",
+    "up_proj",
+    "down_proj",
+]
+
+
+def replace_quantized_linear_layers(
+    module: torch.nn.Module,
+) -> None:
+    """Replace target(quantized) linear layer's forward to qlinear forward
+
+    Args:
+        module (torch.nn.Module): The module containing the linear layers to be replaced.
+                                  For example, this could be an instance of a model like
+                                  LlamaForCausalLM().
+    """
+    processed_names: List[str] = []
+
+    for name, layer in module.named_modules():
+        is_replace_linear = name.split(".")[-1] in QUANTIZED_WEIGHTS
+        if isinstance(layer, torch.nn.Linear) and is_replace_linear:
+            *parent_address, child_name = name.split(".")
+            parent = access_attribute(module, parent_address)
+            setattr(parent, child_name, get_qlinear(layer))
+            processed_names.append(name)
+    names_repr = ", ".join(processed_names)
+    print(f"Replace the following linear layers as qlinear layer:\n {{{names_repr}}}")
+
+
+def access_attribute(obj: Any, tokens: List[str]) -> Any:
+    """Get attribute of given object.
+
+    Args:
+        obj: object
+
+        tokens (List[str]): attribute names to access, must be in correct order
+
+    Returns:
+        Any: accessed attribute
+
+    Raises:
+        AttributeError: If attribute doesn't exists
+    """
+    if len(tokens) == 0:
+        return obj
+    return access_attribute(getattr(obj, tokens[0]), tokens[1:])
+
+
+def get_qlinear(layer: Linear):
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        """Perform weight-only quantized linear layer.
+
+        Forward workflow:
+          - cast weight to high precision
+          - multiply scale factor to weight
+          - call torch.nn.functional linear
+        Note:
+          - Please don't modify following workflow
+          - if the workflow must be changed please contact Rebellions
+        """
+        if inputs.dtype != self.scales.dtype:
+            raise TypeError(f"Expected tensor of dtype {self.scales.dtype} but got {inputs.dtype}")
+        w_fp = self.weight.type(inputs.dtype)
+        w_fp *= self.scales.view(-1, 1)
+        return F.linear(inputs, w_fp, self.bias)
+
+    keep = layer.weight.to(torch.int8)
+    layer.weight = None
+    del layer.weight
+    layer.weight = Parameter(keep, requires_grad=False)
+    layer.scales = Parameter(torch.ones(layer.out_features, dtype=torch.float32), requires_grad=False)
+    layer.forward = lambda *args, **kwargs: forward(layer, *args, **kwargs)
+    return layer

optimum/rbln/utils/import_utils.py

@@ -53,8 +53,7 @@ def is_rbln_available() -> bool:
 
 
 def check_version_compats() -> None:
-    warnings.filterwarnings(action="always", category=ImportWarning)
-
+    warnings.filterwarnings(action="always", category=ImportWarning, module="optimum.rbln")
     my_version = importlib.metadata.version("optimum-rbln")
     target_version = list(filter(lambda v: Version(my_version) > Version(v), RBLN_VERSION_COMPATS.keys()))[0]
     for compat in RBLN_VERSION_COMPATS[target_version]:
@@ -70,5 +69,3 @@ def check_version_compats() -> None:
                 "Please refer to our SDK release notes at https://docs.rbln.ai/about_atom/release_note.html",
                 ImportWarning,
             )
-
-    warnings.resetwarnings()

optimum/rbln/utils/runtime_utils.py

@@ -42,8 +42,9 @@ class RBLNPytorchRuntime:
         return self.forward(*args, **kwds)
 
     def forward(self, *args: List["torch.Tensor"], **kwargs: Dict[str, "torch.Tensor"]):
+        # filtering uselss args or kwarg such as None.
         args = list(filter(lambda arg: isinstance(arg, torch.Tensor), args))
-        kwargs = dict(filter(lambda kwarg: isinstance(kwarg[1], torch.Tensor), kwargs.items()))
+        kwargs = dict(filter(lambda kwarg: isinstance(kwarg[1], torch.Tensor) or kwarg[0] == "out", kwargs.items()))
         output = self.runtime(*args, **kwargs)
         return output
 

{optimum_rbln-0.1.8.dist-info → optimum_rbln-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimum-rbln
-Version: 0.1.8
+Version: 0.1.9
 Summary: Optimum RBLN is the interface between the Hugging Face 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.
 Keywords: transformers,diffusers,inference,rbln,atom,rebel
@@ -21,10 +21,12 @@ Project-URL: Homepage, https://rebellions.ai
 Project-URL: Documentation, https://docs.rbln.ai
 Requires-Python: <3.11,>=3.8
 Requires-Dist: torch<=2.2.1
+Requires-Dist: torchvision<=0.17.1
+Requires-Dist: torchaudio<=2.2.1
 Requires-Dist: optimum<=1.20.0
 Requires-Dist: accelerate>=0.28.0
-Requires-Dist: transformers<=4.40.2
-Requires-Dist: diffusers<=0.29.2
+Requires-Dist: transformers<=4.40.2,>=4.38.0
+Requires-Dist: diffusers<=0.30.1
 Requires-Dist: einops>=0.8.0
 Requires-Dist: packaging>=24.1
 Requires-Dist: pytest>=8.1.1; extra == "tests"
@@ -99,6 +101,11 @@ To install optional dependencies from all groups, specify `-G:all` option.
 pdm install -G:all
 ```
 
+If you want to install optimum-rbln as [editable mode](https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs) in existing venv,
+```bash
+(venv) pip install -e .
+```
+
 ## How to use it?
 
 ### Quick Start