Kernels:

kernels-community
/

rwkv

Trusted publisher

danieldk HF Staff commited on Jun 18

Commit

f155cfc

1 Parent(s): 6a86c8e

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/__init__.py +0 -170
build/torch210-cu128-x86_64-windows/_ops.py +0 -9
build/torch210-cu128-x86_64-windows/_rwkv_cuda_38ccc47.pyd +0 -3
build/torch210-cu128-x86_64-windows/metadata.json +0 -15
build/torch210-cu128-x86_64-windows/rwkv/__init__.py +0 -26
build/torch211-cu128-x86_64-windows/__init__.py +0 -170
build/torch211-cu128-x86_64-windows/_ops.py +0 -9
build/torch211-cu128-x86_64-windows/_rwkv_cuda_34ead3e.pyd +0 -3
build/torch211-cu128-x86_64-windows/metadata.json +0 -15
build/torch211-cu128-x86_64-windows/rwkv/__init__.py +0 -26
build/torch27-cxx11-cu118-x86_64-linux/rwkv/__init__.py +0 -170
build/torch27-cxx11-cu118-x86_64-linux/rwkv/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu118-x86_64-linux/rwkv/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu118-x86_64-linux/rwkv/_ops.py +0 -9
build/torch27-cxx11-cu118-x86_64-linux/rwkv/_rwkv_0aa7cb0.abi3.so +0 -3
build/torch27-cxx11-cu126-x86_64-linux/rwkv/__init__.py +0 -170
build/torch27-cxx11-cu126-x86_64-linux/rwkv/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu126-x86_64-linux/rwkv/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu126-x86_64-linux/rwkv/_ops.py +0 -9
build/torch27-cxx11-cu126-x86_64-linux/rwkv/_rwkv_0aa7cb0.abi3.so +0 -3
build/torch27-cxx11-cu128-x86_64-linux/rwkv/__init__.py +0 -170
build/torch27-cxx11-cu128-x86_64-linux/rwkv/__pycache__/__init__.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-x86_64-linux/rwkv/__pycache__/_ops.cpython-313.pyc +0 -0
build/torch27-cxx11-cu128-x86_64-linux/rwkv/_ops.py +0 -9
build/torch27-cxx11-cu128-x86_64-linux/rwkv/_rwkv_0aa7cb0.abi3.so +0 -3
build/torch28-cxx11-cu126-x86_64-linux/__init__.py +0 -170
build/torch28-cxx11-cu126-x86_64-linux/_ops.py +0 -9
build/torch28-cxx11-cu126-x86_64-linux/_rwkv_44f2fa4.abi3.so +0 -3
build/torch28-cxx11-cu126-x86_64-linux/metadata.json +0 -4
build/torch28-cxx11-cu126-x86_64-linux/rwkv/__init__.py +0 -26
build/torch28-cxx11-cu128-x86_64-linux/__init__.py +0 -170
build/torch28-cxx11-cu128-x86_64-linux/_ops.py +0 -9
build/torch28-cxx11-cu128-x86_64-linux/_rwkv_44f2fa4.abi3.so +0 -3
build/torch28-cxx11-cu128-x86_64-linux/metadata.json +0 -4
build/torch28-cxx11-cu128-x86_64-linux/rwkv/__init__.py +0 -26
build/torch28-cxx11-cu129-x86_64-linux/__init__.py +0 -170
build/torch28-cxx11-cu129-x86_64-linux/_ops.py +0 -9
build/torch28-cxx11-cu129-x86_64-linux/_rwkv_44f2fa4.abi3.so +0 -3
build/torch28-cxx11-cu129-x86_64-linux/metadata.json +0 -4
build/torch28-cxx11-cu129-x86_64-linux/rwkv/__init__.py +0 -26
build/torch29-cxx11-cu126-aarch64-linux/__init__.py +0 -170
build/torch29-cxx11-cu126-aarch64-linux/_ops.py +0 -9
build/torch29-cxx11-cu126-aarch64-linux/_rwkv_cuda_efd954c.abi3.so +0 -3
build/torch29-cxx11-cu126-aarch64-linux/metadata.json +0 -13
build/torch29-cxx11-cu126-aarch64-linux/rwkv/__init__.py +0 -26
build/torch29-cxx11-cu126-x86_64-linux/__init__.py +0 -170
build/torch29-cxx11-cu126-x86_64-linux/_ops.py +0 -9
build/torch29-cxx11-cu126-x86_64-linux/_rwkv_44f2fa4.abi3.so +0 -3
build/torch29-cxx11-cu126-x86_64-linux/metadata.json +0 -4
build/torch29-cxx11-cu126-x86_64-linux/rwkv/__init__.py +0 -26

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

build/torch210-cu128-x86_64-windows/_rwkv_cuda_38ccc47.pyd DELETED Viewed

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

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

@@ -1,15 +0,0 @@
-{
-  "version": 1,
-  "license": "Apache-2.0",
-  "python-depends": [],
-  "backend": {
-    "type": "cuda",
-    "archs": [
-      "10.0",
-      "12.0",
-      "8.0",
-      "8.9",
-      "9.0"
-    ]
-  }
-}

build/torch210-cu128-x86_64-windows/rwkv/__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")))

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

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

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

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

@@ -1,15 +0,0 @@
-{
-  "version": 1,
-  "license": "Apache-2.0",
-  "python-depends": [],
-  "backend": {
-    "type": "cuda",
-    "archs": [
-      "10.0",
-      "12.0",
-      "8.0",
-      "8.9",
-      "9.0"
-    ]
-  }
-}

build/torch211-cu128-x86_64-windows/rwkv/__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/torch27-cxx11-cu118-x86_64-linux/rwkv/__init__.py DELETED Viewed

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

Binary file (7.21 kB)

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

Binary file (508 Bytes)

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

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

build/torch27-cxx11-cu118-x86_64-linux/rwkv/_rwkv_0aa7cb0.abi3.so DELETED Viewed

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

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

Binary file (7.21 kB)

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

Binary file (508 Bytes)

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

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

build/torch27-cxx11-cu126-x86_64-linux/rwkv/_rwkv_0aa7cb0.abi3.so DELETED Viewed

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

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

Binary file (7.21 kB)

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

Binary file (508 Bytes)

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

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

build/torch27-cxx11-cu128-x86_64-linux/rwkv/_rwkv_0aa7cb0.abi3.so DELETED Viewed

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

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

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

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

build/torch28-cxx11-cu126-x86_64-linux/metadata.json DELETED Viewed

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

build/torch28-cxx11-cu126-x86_64-linux/rwkv/__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")))

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

build/torch28-cxx11-cu128-x86_64-linux/_rwkv_44f2fa4.abi3.so DELETED Viewed

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

build/torch28-cxx11-cu128-x86_64-linux/metadata.json DELETED Viewed

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

build/torch28-cxx11-cu128-x86_64-linux/rwkv/__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")))

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

build/torch28-cxx11-cu129-x86_64-linux/_rwkv_44f2fa4.abi3.so DELETED Viewed

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

build/torch28-cxx11-cu129-x86_64-linux/metadata.json DELETED Viewed

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

build/torch28-cxx11-cu129-x86_64-linux/rwkv/__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")))

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

build/torch29-cxx11-cu126-aarch64-linux/_rwkv_cuda_efd954c.abi3.so DELETED Viewed

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

build/torch29-cxx11-cu126-aarch64-linux/metadata.json DELETED Viewed

@@ -1,13 +0,0 @@
-{
-  "version": 1,
-  "license": "Apache-2.0",
-  "python-depends": [],
-  "backend": {
-    "type": "cuda",
-    "archs": [
-      "8.0",
-      "8.9",
-      "9.0"
-    ]
-  }
-}

build/torch29-cxx11-cu126-aarch64-linux/rwkv/__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")))

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

@@ -1,170 +0,0 @@
-from ._ops import ops
-from typing import Tuple, Any
-# Use a broad Tensor alias to avoid importing torch at import time.
-from torch import Tensor
-def forward(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (float32).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward(w, u, k, v, y)
-def forward_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor) -> None:
-    """RWKV WKV forward pass (bfloat16 inputs/outputs, float32 ``w``).
-    Runs the CUDA kernel and writes the result into ``y`` in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y))
-    ops.forward_bf16(w, u, k, v, y)
-def forward_with_state(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (float32).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.float32``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state(w, u, k, v, y, s)
-def forward_with_state_bf16(w: Tensor, u: Tensor, k: Tensor, v: Tensor, y: Tensor, s: Tensor) -> None:
-    """RWKV WKV forward pass with persistent state (bfloat16 inputs/outputs, float32 ``w`` and ``s``).
-    Runs the CUDA kernel using and updating state ``s`` and writes the result into ``y``.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u: Input tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        k: Key tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        v: Value tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        y: Output tensor, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-        s: Stateful tensor, shape ``[B, C]``, dtype ``torch.float32`` (updated in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B`` and ``C``; ``y`` shares ``[B, T, C]`` with inputs.
-    """
-    _validate_device_match((w, u, k, v, y, s))
-    ops.forward_with_state_bf16(w, u, k, v, y, s)
-def backward(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (float32).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.float32``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.float32`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.float32`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward(w, u, k, v, y, gy, gw, gu, gk, gv)
-def backward_bf16(
-    w: Tensor,
-    u: Tensor,
-    k: Tensor,
-    v: Tensor,
-    y: Tensor,
-    gy: Tensor,
-    gw: Tensor,
-    gu: Tensor,
-    gk: Tensor,
-    gv: Tensor,
-) -> None:
-    """RWKV WKV backward pass (bfloat16 inputs/outputs/gradients, float32 ``w``).
-    Writes gradients into the provided tensors in-place.
-    Args:
-        w: Decay weights, shape ``[C]``, dtype ``torch.float32``.
-        u, k, v, y: Forward-pass tensors, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gy: Gradient of ``y``, shape ``[B, T, C]``, dtype ``torch.bfloat16``.
-        gw: Gradient for ``w``, shape ``[C]``, dtype ``torch.bfloat16`` (written in-place).
-        gu, gk, gv: Gradients for ``u``, ``k``, ``v`` respectively, shape ``[B, T, C]``, dtype ``torch.bfloat16`` (written in-place).
-    Notes:
-        - All tensors must be on the same CUDA device.
-        - Shapes must agree on ``B``, ``T`` and ``C``.
-    """
-    _validate_device_match((w, u, k, v, y, gy, gw, gu, gk, gv))
-    ops.backward_bf16(w, u, k, v, y, gy, gw, gu, gk, gv)
-def _validate_device_match(tensors: Tuple[Tensor, ...]) -> None:
-    """Minimal runtime validation that all tensors live on the same CUDA device."""
-    if not tensors:
-        return
-    device = tensors[0].device
-    if not device.type == "cuda":
-        raise RuntimeError("RWKV CUDA ops require CUDA tensors")
-    for t in tensors[1:]:
-        if t.device != device:
-            raise RuntimeError("All tensors must be on the same CUDA device")
-__all__ = [
-    "forward",
-    "forward_bf16",
-    "forward_with_state",
-    "forward_with_state_bf16",
-    "backward",
-    "backward_bf16",
-]

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

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

build/torch29-cxx11-cu126-x86_64-linux/_rwkv_44f2fa4.abi3.so DELETED Viewed

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

build/torch29-cxx11-cu126-x86_64-linux/metadata.json DELETED Viewed

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

build/torch29-cxx11-cu126-x86_64-linux/rwkv/__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")))