diff --git a/build/torch210-cxx11-cu126-x86_64-linux/__init__.py b/build/torch210-cxx11-cu126-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu126-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch210-cxx11-cu126-x86_64-linux/_ops.py b/build/torch210-cxx11-cu126-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu126-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch210-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch210-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 74344bcac64f3c3161824a2c589c92042ccdbdfb..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:51027ec42e88d98547fac8145714f9ef08cde6c28d8723d2bbc4d4a653ed6643 -size 8200552 diff --git a/build/torch210-cxx11-cu126-x86_64-linux/metadata.json b/build/torch210-cxx11-cu126-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu126-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch210-cxx11-cu126-x86_64-linux/rotary/__init__.py b/build/torch210-cxx11-cu126-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu126-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu128-x86_64-linux/__init__.py b/build/torch210-cxx11-cu128-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu128-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch210-cxx11-cu128-x86_64-linux/_ops.py b/build/torch210-cxx11-cu128-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu128-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch210-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch210-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 793b06dce27c4ec8184befeec7ae7c8f5f235cf3..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:39cc33889c406562d97b3a4db53d9464c88acc2410d8a6980f0afe0bc9c29e5a -size 11905888 diff --git a/build/torch210-cxx11-cu128-x86_64-linux/metadata.json b/build/torch210-cxx11-cu128-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu128-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch210-cxx11-cu128-x86_64-linux/rotary/__init__.py b/build/torch210-cxx11-cu128-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu128-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu130-x86_64-linux/__init__.py b/build/torch210-cxx11-cu130-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu130-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch210-cxx11-cu130-x86_64-linux/_ops.py b/build/torch210-cxx11-cu130-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu130-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch210-cxx11-cu130-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch210-cxx11-cu130-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index adba1aa5b05854d9b7e56e99f6f7c5aa02f22f31..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu130-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:3c4468ae96a6f8677482061f25d20d4dc5f06bd8110fabf27d1d07c72cc13b3e -size 10310736 diff --git a/build/torch210-cxx11-cu130-x86_64-linux/metadata.json b/build/torch210-cxx11-cu130-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu130-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch210-cxx11-cu130-x86_64-linux/rotary/__init__.py b/build/torch210-cxx11-cu130-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-cu130-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-xpu20253-x86_64-linux/__init__.py b/build/torch210-cxx11-xpu20253-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-xpu20253-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch210-cxx11-xpu20253-x86_64-linux/_ops.py b/build/torch210-cxx11-xpu20253-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-xpu20253-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch210-cxx11-xpu20253-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch210-cxx11-xpu20253-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index e2aa633cceeb345d2db5406c93826eae3d99ed1c..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-xpu20253-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:a7bc816c9085ff4756d87484127679dd39968bfc943ecc49eea40947caf2a310 -size 2301488 diff --git a/build/torch210-cxx11-xpu20253-x86_64-linux/metadata.json b/build/torch210-cxx11-xpu20253-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-xpu20253-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch210-cxx11-xpu20253-x86_64-linux/rotary/__init__.py b/build/torch210-cxx11-xpu20253-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch210-cxx11-xpu20253-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-cu126-x86_64-linux/__init__.py b/build/torch28-cxx11-cu126-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu126-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch28-cxx11-cu126-x86_64-linux/_ops.py b/build/torch28-cxx11-cu126-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu126-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch28-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 7304b81b09ceee3855568e584ebab39de1fc27e0..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:a040bbb8748df983d6c6e07c94bdd24477116ce9792ed785485d073038010d66 -size 8190648 diff --git a/build/torch28-cxx11-cu126-x86_64-linux/metadata.json b/build/torch28-cxx11-cu126-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu126-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch28-cxx11-cu126-x86_64-linux/rotary/__init__.py b/build/torch28-cxx11-cu126-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu126-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-cu128-x86_64-linux/__init__.py b/build/torch28-cxx11-cu128-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu128-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch28-cxx11-cu128-x86_64-linux/_ops.py b/build/torch28-cxx11-cu128-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu128-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch28-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 98d5ee908ac72265e27cf7d79398100bc2d6c227..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:98c0ac8bc3419520fc5cd00658273b71611e2fe0bef3d63e5cd9c256b28540ac -size 11895768 diff --git a/build/torch28-cxx11-cu128-x86_64-linux/metadata.json b/build/torch28-cxx11-cu128-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu128-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch28-cxx11-cu128-x86_64-linux/rotary/__init__.py b/build/torch28-cxx11-cu128-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu128-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-cu129-x86_64-linux/__init__.py b/build/torch28-cxx11-cu129-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu129-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch28-cxx11-cu129-x86_64-linux/_ops.py b/build/torch28-cxx11-cu129-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu129-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-cu129-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch28-cxx11-cu129-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 44bb51eb8b1e0c888028ed47e6882b71403dc27c..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu129-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:8e5aeb4ea26bf0cc26423ed103edbbbaa7a0329086a723c259daaa2e458b0a5f -size 11964056 diff --git a/build/torch28-cxx11-cu129-x86_64-linux/metadata.json b/build/torch28-cxx11-cu129-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu129-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch28-cxx11-cu129-x86_64-linux/rotary/__init__.py b/build/torch28-cxx11-cu129-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-cu129-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-xpu20251-x86_64-linux/__init__.py b/build/torch28-cxx11-xpu20251-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-xpu20251-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch28-cxx11-xpu20251-x86_64-linux/_ops.py b/build/torch28-cxx11-xpu20251-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-xpu20251-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-xpu20251-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch28-cxx11-xpu20251-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 40c5eef7d51c9c427079939962d0e62094d4ea37..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-xpu20251-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:bbdc8e24aa6917d5c44abdd37f7b0dfd6e42420d66999a71fffca4db2feeab73 -size 2338640 diff --git a/build/torch28-cxx11-xpu20251-x86_64-linux/metadata.json b/build/torch28-cxx11-xpu20251-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-xpu20251-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch28-cxx11-xpu20251-x86_64-linux/rotary/__init__.py b/build/torch28-cxx11-xpu20251-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch28-cxx11-xpu20251-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu126-x86_64-linux/__init__.py b/build/torch29-cxx11-cu126-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu126-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch29-cxx11-cu126-x86_64-linux/_ops.py b/build/torch29-cxx11-cu126-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu126-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch29-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch29-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 94a97806f791177e5843877ec7f199a54d14af7b..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu126-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:dd3327462b2c2aa0ee26f7a8e39655e9453cf2544c809c2fb2b25dae13256296 -size 8190536 diff --git a/build/torch29-cxx11-cu126-x86_64-linux/metadata.json b/build/torch29-cxx11-cu126-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu126-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch29-cxx11-cu126-x86_64-linux/rotary/__init__.py b/build/torch29-cxx11-cu126-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu126-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu128-x86_64-linux/__init__.py b/build/torch29-cxx11-cu128-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu128-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch29-cxx11-cu128-x86_64-linux/_ops.py b/build/torch29-cxx11-cu128-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu128-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch29-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch29-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 2597ddb43ece909b444abc9c96cad1f85d39c398..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu128-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:8f434031167709f70d404eb67234655fdb3ec9a5a1a65976e98607230deb07f3 -size 11899968 diff --git a/build/torch29-cxx11-cu128-x86_64-linux/metadata.json b/build/torch29-cxx11-cu128-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu128-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch29-cxx11-cu128-x86_64-linux/rotary/__init__.py b/build/torch29-cxx11-cu128-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu128-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu130-x86_64-linux/__init__.py b/build/torch29-cxx11-cu130-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu130-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch29-cxx11-cu130-x86_64-linux/_ops.py b/build/torch29-cxx11-cu130-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu130-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch29-cxx11-cu130-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch29-cxx11-cu130-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index d11448a6d90db7e38ba3cb7c06ca56ab214f39d5..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu130-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:8ad1dd83b4c79b96e9fe20789511fe93df48cd4d66daff676ba6ea52a089936b -size 10304816 diff --git a/build/torch29-cxx11-cu130-x86_64-linux/metadata.json b/build/torch29-cxx11-cu130-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu130-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch29-cxx11-cu130-x86_64-linux/rotary/__init__.py b/build/torch29-cxx11-cu130-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-cu130-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-xpu20252-x86_64-linux/__init__.py b/build/torch29-cxx11-xpu20252-x86_64-linux/__init__.py deleted file mode 100644 index 1538f7189d1d92adeb45b3931e6e6efef3f2279c..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-xpu20252-x86_64-linux/__init__.py +++ /dev/null @@ -1,53 +0,0 @@ -from typing import Optional, Tuple -import torch - -from ._ops import ops - - -def apply_rotary( - x1: torch.Tensor, - x2: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - out1: torch.Tensor, - out2: torch.Tensor, - conj: bool, -) -> None: - ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj) - - -def apply_rotary_transformers( - q: torch.Tensor, - k: torch.Tensor, - cos: torch.Tensor, - sin: torch.Tensor, - position_ids: Optional[torch.Tensor] = None, - unsqueeze_dim: int = 1, -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Rotary kernel implementation wrapper - Adapts rotary kernels implementation to match transformers apply_rotary_pos_emb signature - """ - cos = cos.unsqueeze(unsqueeze_dim) - sin = sin.unsqueeze(unsqueeze_dim) - - q_rotated = q.clone() - k_rotated = k.clone() - - # Get half dimension for rotation - half_dim = q.shape[-1] // 2 - q1 = q_rotated[..., :half_dim] - q2 = q_rotated[..., half_dim:] - k1 = k_rotated[..., :half_dim] - k2 = k_rotated[..., half_dim:] - if cos.shape[-1] != half_dim: - # Trim cos/sin to match half_dim - cos = cos[..., :half_dim] - sin = sin[..., :half_dim] - - apply_rotary(q1, q2, cos, sin, q1, q2, False) - apply_rotary(k1, k2, cos, sin, k1, k2, False) - return q_rotated, k_rotated - - -__all__ = ["apply_rotary", "apply_rotary_transformers"] diff --git a/build/torch29-cxx11-xpu20252-x86_64-linux/_ops.py b/build/torch29-cxx11-xpu20252-x86_64-linux/_ops.py deleted file mode 100644 index be1d7b62cdbeaab7c5b1cb52669a4e3a63ac7f45..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-xpu20252-x86_64-linux/_ops.py +++ /dev/null @@ -1,9 +0,0 @@ -import torch -from . import _rotary_90e4f0f -ops = torch.ops._rotary_90e4f0f - -def add_op_namespace_prefix(op_name: str): - """ - Prefix op by namespace. - """ - return f"_rotary_90e4f0f::{op_name}" \ No newline at end of file diff --git a/build/torch29-cxx11-xpu20252-x86_64-linux/_rotary_90e4f0f.abi3.so b/build/torch29-cxx11-xpu20252-x86_64-linux/_rotary_90e4f0f.abi3.so deleted file mode 100644 index 3710b6e1281d7417c23e989f02e8c488b0b02521..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-xpu20252-x86_64-linux/_rotary_90e4f0f.abi3.so +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:b386b58b002e882d84e10db3be283b201ed735d1384f8aecec3d17aafaa38f38 -size 2287128 diff --git a/build/torch29-cxx11-xpu20252-x86_64-linux/metadata.json b/build/torch29-cxx11-xpu20252-x86_64-linux/metadata.json deleted file mode 100644 index 76bafa5f33b6818aa6bb4cab04be811b87519b44..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-xpu20252-x86_64-linux/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"python-depends":[]} \ No newline at end of file diff --git a/build/torch29-cxx11-xpu20252-x86_64-linux/rotary/__init__.py b/build/torch29-cxx11-xpu20252-x86_64-linux/rotary/__init__.py deleted file mode 100644 index 03dbc1afe1cf156661a2b1b22003cd5f599a0309..0000000000000000000000000000000000000000 --- a/build/torch29-cxx11-xpu20252-x86_64-linux/rotary/__init__.py +++ /dev/null @@ -1,26 +0,0 @@ -import ctypes -import sys - -import importlib -from pathlib import Path -from types import ModuleType - -def _import_from_path(file_path: Path) -> ModuleType: - # We cannot use the module name as-is, after adding it to `sys.modules`, - # it would also be used for other imports. So, we make a module name that - # depends on the path for it to be unique using the hex-encoded hash of - # the path. - path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) - module_name = path_hash - spec = importlib.util.spec_from_file_location(module_name, file_path) - if spec is None: - raise ImportError(f"Cannot load spec for {module_name} from {file_path}") - module = importlib.util.module_from_spec(spec) - if module is None: - raise ImportError(f"Cannot load module {module_name} from spec") - sys.modules[module_name] = module - spec.loader.exec_module(module) # type: ignore - return module - - -globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))