Kernels:

kernels-community
/

activation

Trusted publisher

Kernel card Files Files and versions

xet

Community

danieldk HF Staff commited on 15 days ago

Commit

c554bb5

1 Parent(s): d9e5445

Remove builds incompatible with kernels >= 0.14

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

build/torch210-cu128-x86_64-windows/activation/__init__.py +0 -75
build/torch210-cu128-x86_64-windows/activation/_activation_e1b4b08.pyd +0 -3
build/torch210-cu128-x86_64-windows/activation/_ops.py +0 -9
build/torch210-cu128-x86_64-windows/activation/layers.py +0 -201
build/torch210-cu128-x86_64-windows/metadata.json +0 -4
build/torch211-cu128-x86_64-windows/__init__.py +0 -75
build/torch211-cu128-x86_64-windows/_activation_cuda_47eab20.pyd +0 -3
build/torch211-cu128-x86_64-windows/_ops.py +0 -9
build/torch211-cu128-x86_64-windows/activation/__init__.py +0 -26
build/torch211-cu128-x86_64-windows/layers.py +0 -201
build/torch211-cu128-x86_64-windows/metadata.json +0 -21
build/torch27-cxx11-cu118-x86_64-linux/activation/__init__.py +0 -75
build/torch27-cxx11-cu118-x86_64-linux/activation/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu118-x86_64-linux/activation/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu118-x86_64-linux/activation/__pycache__/layers.cpython-313.pyc +0 -0
build/torch27-cxx11-cu118-x86_64-linux/activation/_activation_beeaae6.abi3.so +0 -3
build/torch27-cxx11-cu118-x86_64-linux/activation/_ops.py +0 -9
build/torch27-cxx11-cu118-x86_64-linux/activation/layers.py +0 -179
build/torch27-cxx11-cu126-x86_64-linux/activation/__init__.py +0 -75
build/torch27-cxx11-cu126-x86_64-linux/activation/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu126-x86_64-linux/activation/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu126-x86_64-linux/activation/__pycache__/layers.cpython-313.pyc +0 -0
build/torch27-cxx11-cu126-x86_64-linux/activation/_activation_beeaae6.abi3.so +0 -3
build/torch27-cxx11-cu126-x86_64-linux/activation/_ops.py +0 -9
build/torch27-cxx11-cu126-x86_64-linux/activation/layers.py +0 -179
build/torch27-cxx11-cu128-aarch64-linux/activation/__init__.py +0 -75
build/torch27-cxx11-cu128-aarch64-linux/activation/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-aarch64-linux/activation/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-aarch64-linux/activation/__pycache__/layers.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-aarch64-linux/activation/_activation_320b408.abi3.so +0 -3
build/torch27-cxx11-cu128-aarch64-linux/activation/_ops.py +0 -9
build/torch27-cxx11-cu128-aarch64-linux/activation/layers.py +0 -179
build/torch27-cxx11-cu128-x86_64-linux/activation/__init__.py +0 -75
build/torch27-cxx11-cu128-x86_64-linux/activation/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-x86_64-linux/activation/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-x86_64-linux/activation/__pycache__/layers.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-x86_64-linux/activation/_activation_beeaae6.abi3.so +0 -3
build/torch27-cxx11-cu128-x86_64-linux/activation/_ops.py +0 -9
build/torch27-cxx11-cu128-x86_64-linux/activation/layers.py +0 -179
build/torch28-cxx11-cu126-aarch64-linux/activation/__init__.py +0 -57
build/torch28-cxx11-cu126-aarch64-linux/activation/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch28-cxx11-cu126-aarch64-linux/activation/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch28-cxx11-cu126-aarch64-linux/activation/__pycache__/layers.cpython-313.pyc +0 -0
build/torch28-cxx11-cu126-aarch64-linux/activation/_activation_0c3eb4e_dirty.abi3.so +0 -3
build/torch28-cxx11-cu126-aarch64-linux/activation/_ops.py +0 -9
build/torch28-cxx11-cu126-aarch64-linux/activation/layers.py +0 -128
build/torch28-cxx11-cu126-x86_64-linux/__init__.py +0 -75
build/torch28-cxx11-cu126-x86_64-linux/_activation_f8d6759.abi3.so +0 -3
build/torch28-cxx11-cu126-x86_64-linux/_ops.py +0 -9
build/torch28-cxx11-cu126-x86_64-linux/activation/__init__.py +0 -26

build/torch210-cu128-x86_64-windows/activation/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch210-cu128-x86_64-windows/activation/_activation_e1b4b08.pyd DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d741006dd4fe8a85ed461fa3727d4d9f1b438083d2f1075ae54650bbdd2dc179
-size 2463744

build/torch210-cu128-x86_64-windows/activation/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_e1b4b08
-ops = torch.ops._activation_e1b4b08
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_e1b4b08::{op_name}"

build/torch210-cu128-x86_64-windows/activation/layers.py DELETED Viewed

@@ -1,201 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class Silu(nn.Module):
-    """An activation function for SiLU.
-    The function computes x -> silu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.silu(out, x)
-        return out
-class Gelu(nn.Module):
-    """An activation function for GELU.
-    The function computes x -> gelu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu(out, x)
-        return out
-class GeluTanh(nn.Module):
-    """An activation function for GELU with `tanh` approximation.
-    The function computes x -> gelu_tanh(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_tanh(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch210-cu128-x86_64-windows/metadata.json DELETED Viewed

@@ -1,4 +0,0 @@
-{
-  "version": 1,
-  "python-depends": []
-}

build/torch211-cu128-x86_64-windows/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch211-cu128-x86_64-windows/_activation_cuda_47eab20.pyd DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:93643f052fbcac3db67fed466c5a0a080ff9d3ad7fffa463793fa2f35a275785
-size 2464256

build/torch211-cu128-x86_64-windows/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_cuda_47eab20
-ops = torch.ops._activation_cuda_47eab20
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_cuda_47eab20::{op_name}"

build/torch211-cu128-x86_64-windows/activation/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-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")))

build/torch211-cu128-x86_64-windows/layers.py DELETED Viewed

@@ -1,201 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class Silu(nn.Module):
-    """An activation function for SiLU.
-    The function computes x -> silu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.silu(out, x)
-        return out
-class Gelu(nn.Module):
-    """An activation function for GELU.
-    The function computes x -> gelu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu(out, x)
-        return out
-class GeluTanh(nn.Module):
-    """An activation function for GELU with `tanh` approximation.
-    The function computes x -> gelu_tanh(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_tanh(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        if not x.is_contiguous():
-            x = x.contiguous()
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not x.is_contiguous():
-            x = x.contiguous()
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch211-cu128-x86_64-windows/metadata.json DELETED Viewed

@@ -1,21 +0,0 @@
-{
-  "version": 1,
-  "license": "Apache-2.0",
-  "python-depends": [],
-  "backend": {
-    "type": "cuda",
-    "archs": [
-      "10.0",
-      "10.1",
-      "12.0+PTX",
-      "7.0",
-      "7.2",
-      "7.5",
-      "8.0",
-      "8.6",
-      "8.7",
-      "8.9",
-      "9.0"
-    ]
-  }
-}

build/torch27-cxx11-cu118-x86_64-linux/activation/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch27-cxx11-cu118-x86_64-linux/activation/__pycache__/__init__.cpython-313.pyc DELETED Viewed

Binary file (3.25 kB)

build/torch27-cxx11-cu118-x86_64-linux/activation/__pycache__/_ops.cpython-313.pyc DELETED Viewed

Binary file (526 Bytes)

build/torch27-cxx11-cu118-x86_64-linux/activation/__pycache__/layers.cpython-313.pyc DELETED Viewed

Binary file (8.92 kB)

build/torch27-cxx11-cu118-x86_64-linux/activation/_activation_beeaae6.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ce06ec284ecd4ac5423d3822a60cd9eeb686d0054b38d66567de73e1137b0567
-size 2773632

build/torch27-cxx11-cu118-x86_64-linux/activation/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_beeaae6
-ops = torch.ops._activation_beeaae6
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_beeaae6::{op_name}"

build/torch27-cxx11-cu118-x86_64-linux/activation/layers.py DELETED Viewed

@@ -1,179 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class Silu(nn.Module):
-    """An activation function for SiLU.
-    The function computes x -> silu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.silu(out, x)
-        return out
-class Gelu(nn.Module):
-    """An activation function for GELU.
-    The function computes x -> gelu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu(out, x)
-        return out
-class GeluTanh(nn.Module):
-    """An activation function for GELU with `tanh` approximation.
-    The function computes x -> gelu_tanh(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu_tanh(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch27-cxx11-cu126-x86_64-linux/activation/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch27-cxx11-cu126-x86_64-linux/activation/__pycache__/__init__.cpython-313.pyc DELETED Viewed

Binary file (3.25 kB)

build/torch27-cxx11-cu126-x86_64-linux/activation/__pycache__/_ops.cpython-313.pyc DELETED Viewed

Binary file (526 Bytes)

build/torch27-cxx11-cu126-x86_64-linux/activation/__pycache__/layers.cpython-313.pyc DELETED Viewed

Binary file (8.92 kB)

build/torch27-cxx11-cu126-x86_64-linux/activation/_activation_beeaae6.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a529bd105aca5081398d63329e829b6b159570424cd654d3a9f275ca9a720e82
-size 2852200

build/torch27-cxx11-cu126-x86_64-linux/activation/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_beeaae6
-ops = torch.ops._activation_beeaae6
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_beeaae6::{op_name}"

build/torch27-cxx11-cu126-x86_64-linux/activation/layers.py DELETED Viewed

@@ -1,179 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class Silu(nn.Module):
-    """An activation function for SiLU.
-    The function computes x -> silu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.silu(out, x)
-        return out
-class Gelu(nn.Module):
-    """An activation function for GELU.
-    The function computes x -> gelu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu(out, x)
-        return out
-class GeluTanh(nn.Module):
-    """An activation function for GELU with `tanh` approximation.
-    The function computes x -> gelu_tanh(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu_tanh(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch27-cxx11-cu128-aarch64-linux/activation/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch27-cxx11-cu128-aarch64-linux/activation/__pycache__/__init__.cpython-313.pyc DELETED Viewed

Binary file (3.25 kB)

build/torch27-cxx11-cu128-aarch64-linux/activation/__pycache__/_ops.cpython-313.pyc DELETED Viewed

Binary file (527 Bytes)

build/torch27-cxx11-cu128-aarch64-linux/activation/__pycache__/layers.cpython-313.pyc DELETED Viewed

Binary file (8.92 kB)

build/torch27-cxx11-cu128-aarch64-linux/activation/_activation_320b408.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:34bdeb9ab72686850aef0a16b225b1b956162edb2cf46cba65c5e5b92ae267ae
-size 4207000

build/torch27-cxx11-cu128-aarch64-linux/activation/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_320b408
-ops = torch.ops._activation_320b408
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_320b408::{op_name}"

build/torch27-cxx11-cu128-aarch64-linux/activation/layers.py DELETED Viewed

@@ -1,179 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class Silu(nn.Module):
-    """An activation function for SiLU.
-    The function computes x -> silu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.silu(out, x)
-        return out
-class Gelu(nn.Module):
-    """An activation function for GELU.
-    The function computes x -> gelu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu(out, x)
-        return out
-class GeluTanh(nn.Module):
-    """An activation function for GELU with `tanh` approximation.
-    The function computes x -> gelu_tanh(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu_tanh(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch27-cxx11-cu128-x86_64-linux/activation/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch27-cxx11-cu128-x86_64-linux/activation/__pycache__/__init__.cpython-313.pyc DELETED Viewed

Binary file (3.25 kB)

build/torch27-cxx11-cu128-x86_64-linux/activation/__pycache__/_ops.cpython-313.pyc DELETED Viewed

Binary file (526 Bytes)

build/torch27-cxx11-cu128-x86_64-linux/activation/__pycache__/layers.cpython-313.pyc DELETED Viewed

Binary file (8.92 kB)

build/torch27-cxx11-cu128-x86_64-linux/activation/_activation_beeaae6.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0f2cffcb6b5b9a49f03a2df46fc2ad36765676edecb468c233e78e1f5e21e206
-size 4127872

build/torch27-cxx11-cu128-x86_64-linux/activation/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_beeaae6
-ops = torch.ops._activation_beeaae6
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_beeaae6::{op_name}"

build/torch27-cxx11-cu128-x86_64-linux/activation/layers.py DELETED Viewed

@@ -1,179 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class Silu(nn.Module):
-    """An activation function for SiLU.
-    The function computes x -> silu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.silu(out, x)
-        return out
-class Gelu(nn.Module):
-    """An activation function for GELU.
-    The function computes x -> gelu(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu(out, x)
-        return out
-class GeluTanh(nn.Module):
-    """An activation function for GELU with `tanh` approximation.
-    The function computes x -> gelu_tanh(x).
-    Shapes:
-        x: (num_tokens, d) or (batch_size, seq_len, d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        out = torch.empty_like(x)
-        ops.gelu_tanh(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch28-cxx11-cu126-aarch64-linux/activation/__init__.py DELETED Viewed

@@ -1,57 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "layers",
-]

build/torch28-cxx11-cu126-aarch64-linux/activation/__pycache__/__init__.cpython-313.pyc DELETED Viewed

Binary file (2.5 kB)

build/torch28-cxx11-cu126-aarch64-linux/activation/__pycache__/_ops.cpython-313.pyc DELETED Viewed

Binary file (539 Bytes)

build/torch28-cxx11-cu126-aarch64-linux/activation/__pycache__/layers.cpython-313.pyc DELETED Viewed

Binary file (6.92 kB)

build/torch28-cxx11-cu126-aarch64-linux/activation/_activation_0c3eb4e_dirty.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:02b62f5d045f370c3fb7c0e7ef458165feb987fba186b8cb9aee55c735a82e93
-size 2699928

build/torch28-cxx11-cu126-aarch64-linux/activation/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_0c3eb4e_dirty
-ops = torch.ops._activation_0c3eb4e_dirty
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_0c3eb4e_dirty::{op_name}"

build/torch28-cxx11-cu126-aarch64-linux/activation/layers.py DELETED Viewed

@@ -1,128 +0,0 @@
-import torch
-import torch.nn as nn
-from ._ops import ops
-class SiluAndMul(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> silu(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.silu_and_mul(out, x)
-        return out
-class MulAndSilu(nn.Module):
-    """An activation function for SwiGLU.
-    The function computes x -> x[:d] * silu(x[d:]) where d = x.shape[-1] // 2.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.mul_and_silu(out, x)
-        return out
-class GeluAndMul(nn.Module):
-    """An activation function for GeGLU.
-    The function computes x -> GELU(x[:d]) * x[d:] where d = x.shape[-1] // 2.
-    Shapes:
-        x: (batch_size, seq_len, 2 * d) or (num_tokens, 2 * d)
-        return: (batch_size, seq_len, d) or (num_tokens, d)
-    """
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_and_mul(out, x)
-        return out
-class GeluTanhAndMul(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.gelu_tanh_and_mul(out, x)
-        return out
-class FatreluAndMul(nn.Module):
-    """An activation function for FATReLU.
-    The function computes x -> FATReLU(x[:d]) * x[d:] where
-    d = x.shape[-1] // 2.
-    This is used in openbmb/MiniCPM-S-1B-sft.
-    Shapes:
-        x: (num_tokens, 2 * d) or (batch_size, seq_len, 2 * d)
-        return: (num_tokens, d) or (batch_size, seq_len, d)
-    """
-    can_torch_compile: bool = True
-    def __init__(self, threshold: float = 0.0):
-        super().__init__()
-        self.threshold = threshold
-    def forward(self, x: torch.Tensor):
-        d = x.shape[-1] // 2
-        output_shape = x.shape[:-1] + (d,)
-        out = torch.empty(output_shape, dtype=x.dtype, device=x.device)
-        ops.fatrelu_and_mul(out, x, self.threshold)
-        return out
-class FastGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_fast(out, x)
-        return out
-class NewGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_new(out, x)
-        return out
-class QuickGELU(nn.Module):
-    can_torch_compile: bool = True
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = torch.empty_like(x)
-        ops.gelu_quick(out, x)
-        return out

build/torch28-cxx11-cu126-x86_64-linux/__init__.py DELETED Viewed

@@ -1,75 +0,0 @@
-import torch
-from ._ops import ops
-from . import layers
-def silu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu_and_mul(out, x)
-    return out
-def mul_and_silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.mul_and_silu(out, x)
-    return out
-def gelu_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_and_mul(out, x)
-    return out
-def gelu_tanh_and_mul(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh_and_mul(out, x)
-    return out
-def fatrelu_and_mul(out: torch.Tensor, x: torch.Tensor, threshold: float = 0.0) -> None:
-    ops.fatrelu_and_mul(out, x, threshold)
-    return out
-def gelu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu(out, x)
-    return out
-def silu(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.silu(out, x)
-    return out
-def gelu_tanh(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_tanh(out, x)
-    return out
-def gelu_fast(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_fast(out, x)
-    return out
-def gelu_new(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_new(out, x)
-    return out
-def gelu_quick(out: torch.Tensor, x: torch.Tensor) -> None:
-    ops.gelu_quick(out, x)
-    return out
-__all__ = [
-    "silu_and_mul",
-    "mul_and_silu",
-    "gelu_and_mul",
-    "gelu_tanh_and_mul",
-    "fatrelu_and_mul",
-    "gelu_fast",
-    "gelu_new",
-    "gelu_quick",
-    "gelu_tanh",
-    "silu",
-    "gelu",
-    "layers",
-]

build/torch28-cxx11-cu126-x86_64-linux/_activation_f8d6759.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cf76431ff46ef5bc002ce8813eeed3ae9618a15094d98ef4b164f7a10a54f0bc
-size 3121056

build/torch28-cxx11-cu126-x86_64-linux/_ops.py DELETED Viewed

@@ -1,9 +0,0 @@
-import torch
-from . import _activation_f8d6759
-ops = torch.ops._activation_f8d6759
-def add_op_namespace_prefix(op_name: str):
-    """
-    Prefix op by namespace.
-    """
-    return f"_activation_f8d6759::{op_name}"

build/torch28-cxx11-cu126-x86_64-linux/activation/__init__.py DELETED Viewed

@@ -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")))