Build uploaded using `kernels`.

.gitattributes

@@ -93,3 +93,4 @@ build/torch210-cxx11-cu130-aarch64-linux/_rwkv_cuda_efd954c.abi3.so filter=lfs d
 build/torch29-cxx11-cu126-aarch64-linux/_rwkv_cuda_efd954c.abi3.so filter=lfs diff=lfs merge=lfs -text
 build/torch29-cxx11-cu128-aarch64-linux/_rwkv_cuda_efd954c.abi3.so filter=lfs diff=lfs merge=lfs -text
 build/torch29-cxx11-cu130-aarch64-linux/_rwkv_cuda_efd954c.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch210-cu128-x86_64-windows/_rwkv_cuda_38ccc47.pyd filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,9 @@
+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

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

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

@@ -0,0 +1,15 @@
+{
+  "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

@@ -0,0 +1,26 @@
+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")))