optimum-rbln 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

optimum/rbln/transformers/models/midm/hf_hub_cached/rotary_position_embedding.py

@@ -1,98 +0,0 @@
-# coding=utf-8
-# Copyright (c) 2022, NVIDIA CORPORATION.  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 torch
-from einops import rearrange
-from torch import einsum, nn
-
-
-__all__ = ["RotaryEmbedding", "apply_rotary_pos_emb"]
-
-
-class RotaryEmbedding(nn.Module):
-    """
-    Implements Rotary Position Embedding from https://arxiv.org/abs/2104.09864.
-    """
-
-    def __init__(
-        self, dim: int, seq_len_interpolation_factor: int = None, pretrained_max_position_embeddings: int = None
-    ):
-        """
-        Args:
-
-            dim (int): rotary embedding dimension
-            seq_len_interpolation_factor (int): if not None, discrete positions will be interpolated
-            by this factor via the trick in https://arxiv.org/abs/2306.15595.
-            pretrained_max_position_embeddings (int): pre-trained max_position_embeddings before position interpolation.
-        """
-        super().__init__()
-        self.seq_len_interpolation_factor = seq_len_interpolation_factor
-        inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2).float() / dim))
-        self.register_buffer("inv_freq", inv_freq)
-        self.pretrained_max_position_embeddings = pretrained_max_position_embeddings
-
-    def forward(self, max_seq_len, offset=0):
-        seq = torch.arange(max_seq_len, device=self.inv_freq.device) + offset
-        seq = seq.type_as(self.inv_freq)
-
-        if self.pretrained_max_position_embeddings is not None and self.seq_len_interpolation_factor is not None:
-            if max_seq_len > self.pretrained_max_position_embeddings * self.seq_len_interpolation_factor:
-                # dynamic linear scaling (length > position we have learned)
-                seq *= 1 / (max_seq_len / self.pretrained_max_position_embeddings)
-            else:
-                # fixed linear scaling
-                seq *= 1 / self.seq_len_interpolation_factor
-
-        freqs = einsum("i , j -> i j", seq, self.inv_freq)
-        # first part even vector components, second part odd vector components,
-        #  2 * dim in dimension size
-        emb = torch.cat((freqs, freqs), dim=-1)
-        # emb [seq_length, .., dim]
-        return rearrange(emb, "n d -> n 1 1 d")
-
-
-def _rotate_half(x):
-    """
-    change sign so the last dimension
-    [A, B, C, D] -> [-C, -D, A, B]
-    """
-    x = rearrange(x, "... (j d) -> ... j d", j=2)
-    x1, x2 = x.unbind(dim=-2)
-    return torch.cat((-x2, x1), dim=-1)
-
-
-def apply_rotary_pos_emb(t, freqs):
-    """
-    input tensor t is of shape [seq_length, ..., dim]
-    rotary positional embeding tensor freqs is of shape [seq_length, ..., dim]
-    check https://kexue.fm/archives/8265 for detailed formulas
-    """
-    # Changes from the original RoPE implementation
-    # 1. The original NeMo implementation assumes the input tensor of shape
-    # [seq_length, ..., dim], but the HF layout is [..., seq_length, dim].
-    # Thus freqs needs to be viewed as [..., seq_length, dim].
-    freqs = freqs.permute(1, 2, 0, 3)
-    # 2. Support for queries which past tokens are truncated
-    assert freqs.shape[-2] >= t.shape[-2]
-    if freqs.shape[-2] != t.shape[-2]:
-        freqs = freqs[:, :, -t.shape[-2] :, :]
-
-    rot_dim = freqs.shape[-1]
-    # ideally t_pass is empty so rotary pos embedding is applied to all tensor t
-    t, t_pass = t[..., :rot_dim], t[..., rot_dim:]
-    # first part is cosine component
-    # second part is sine component, need to change signs with _rotate_half method
-    t = (t * freqs.cos()) + (_rotate_half(t) * freqs.sin())
-    return torch.cat((t, t_pass), dim=-1)

optimum/rbln/utils/context.py

@@ -1,58 +0,0 @@
-# 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 contextlib import contextmanager
-from pathlib import Path
-from typing import Union
-
-from optimum.exporters import TasksManager
-from transformers import AutoConfig, AutoModel
-
-
-@contextmanager
-def override_auto_classes(config_func=None, model_func=None, skip_taskmanager=True):
-    """Temporarily override Auto classes with original model classes"""
-    original_config = AutoConfig.from_pretrained
-    original_model = AutoModel.from_pretrained
-    original_get_model_from_task = TasksManager.get_model_from_task
-
-    def get_model_from_task(
-        task: str,
-        model_name_or_path: Union[str, Path],
-        **kwargs,
-    ):
-        return model_func(model_name_or_path, **kwargs)
-
-    def none_func(*args, **kwargs):
-        return None
-
-    try:
-        AutoConfig.from_pretrained = config_func or none_func
-        AutoModel.from_pretrained = model_func or none_func
-        if skip_taskmanager:
-            TasksManager.get_model_from_task = none_func if model_func is None else get_model_from_task
-        yield
-    finally:
-        AutoConfig.from_pretrained = original_config
-        AutoModel.from_pretrained = original_model
-        TasksManager.get_model_from_task = original_get_model_from_task

optimum_rbln-0.1.13.dist-info/METADATA

@@ -1,120 +0,0 @@
-Metadata-Version: 2.1
-Name: optimum-rbln
-Version: 0.1.13
-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
-Author-Email: "Rebellions Inc." <support@rebellions.ai>
-License: Apache
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Science/Research
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Project-URL: Homepage, https://rebellions.ai
-Project-URL: Documentation, https://docs.rbln.ai
-Requires-Python: <3.13,>=3.9
-Requires-Dist: torch<=2.5.1
-Requires-Dist: torchvision<=0.20.1
-Requires-Dist: torchaudio<=2.5.1
-Requires-Dist: optimum==1.23.1
-Requires-Dist: accelerate>=0.28.0
-Requires-Dist: transformers==4.45.2
-Requires-Dist: diffusers<=0.31.0
-Requires-Dist: einops>=0.8.0
-Requires-Dist: packaging>=24.1
-Requires-Dist: halo
-Provides-Extra: tests
-Requires-Dist: pytest>=8.1.1; extra == "tests"
-Requires-Dist: psutil>=5.9.8; extra == "tests"
-Requires-Dist: parameterized>=0.9.0; extra == "tests"
-Requires-Dist: GitPython>=3.1.42; extra == "tests"
-Requires-Dist: sentencepiece>=0.2.0; extra == "tests"
-Requires-Dist: datasets>=2.18.0; extra == "tests"
-Requires-Dist: sacremoses>=0.1.1; extra == "tests"
-Requires-Dist: safetensors>=0.4.2; extra == "tests"
-Provides-Extra: quality
-Requires-Dist: ruff>=0.3.3; extra == "quality"
-Requires-Dist: isort>=5.13.2; extra == "quality"
-Requires-Dist: hf-doc-builder>=0.5.0; extra == "quality"
-Description-Content-Type: text/markdown
-
-<!---
-Copyright 2023 The HuggingFace Team. 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.
--->
-
-# Optimum RBLN
-
-🤗 Optimum RBLN is the interface between the 🤗 Transformers library and RBLN Accelerators including [ATOM](https://atom_link) and [REBEL](https://rebel_link).
-It provides a set of tools enabling easy model loading and inference on single- and multi-Accelerator settings for different downstream tasks.
-The list of officially validated models and tasks is available [here](https://docs.rbln.ai/software/optimum/optimum_rbln.html). Users can try other models and tasks with only few changes.
-
-## Install from PyPI
-
-To install the latest release of this package:
-
-- Export environment variables to access to RBLN private PyPI.
-  ```bash
-  export REBEL_PYPI_USERNAME=<username>
-  export REBEL_PYPI_PASSWORD=<password>
-  ```
-
-- Install optimum-rbln package:
-  ```bash
-  pip install --index-url https://pypi.rebellions.in/simple optimum-rbln
-  ```
-
-## Install from source
-
-### Prerequisites
-
-- Install [PDM](https://pdm-project.org/latest/) (refer [this link](https://pdm-project.org/latest/#installation) for detailed commands)
-
-The below command installs optimum-rbln along with its dependencies.
-
-```bash
-git clone https://github.com/rebellions-sw/optimum-rbln.git
-cd optimum-rbln
-pdm install
-```
-
-To install optional dependencies from all groups, specify `-G:all` option.
-
-```bash
-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
-
-🤗 Optimum RBLN was designed with one goal in mind: **to make inference straightforward for any 🤗 Transformers user while leveraging the complete power of RBLN Accelerators**.
-
-### Documentation
-
-Check out [the documentation of Optimum RBLN](https://docs.rbln.ai/software/optimum/optimum_rbln.html) for more advanced usage.

optimum_rbln-0.1.13.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-
-[gui_scripts]
-