Add Kernel Hub build/torch-universal + torch-cpu for get_kernel (yarqa-attn, version 1, GitHub 098d19b)

Browse files

Files changed (8) hide show

build/torch-cpu/metadata.json +12 -0
build/torch-cpu/yarqa_attn/__init__.py +15 -0
build/torch-cpu/yarqa_attn/_chain.py +50 -0
build/torch-cpu/yarqa_attn/attn.py +217 -0
build/torch-universal/metadata.json +12 -0
build/torch-universal/yarqa_attn/__init__.py +15 -0
build/torch-universal/yarqa_attn/_chain.py +50 -0
build/torch-universal/yarqa_attn/attn.py +217 -0

build/torch-cpu/metadata.json ADDED Viewed

	@@ -0,0 +1,12 @@

+{
+  "name": "yarqa-attn",
+  "version": 1,
+  "summary": "SZL original compartment/plug-flow attention with SHA3 receipts (CPU)",
+  "license": "Apache-2.0",
+  "universal": true,
+  "python-depends": [],
+  "id": "_yarqa_attn_cpu_010",
+  "backend": {
+    "type": "cpu"
+  }
+}

build/torch-cpu/yarqa_attn/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""yarqa-attn public API. Compartment / plug-flow attention. Not a Flash/Flex/paged stack."""
+from ._chain import ReceiptChain
+from .attn import canal_bounds, compartment_mask, selfcheck, yarqa_attn
+__all__ = [
+    "ReceiptChain",
+    "canal_bounds",
+    "compartment_mask",
+    "selfcheck",
+    "yarqa_attn",
+]
+__version__ = "0.1.0"

build/torch-cpu/yarqa_attn/_chain.py ADDED Viewed

	@@ -0,0 +1,50 @@

+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""SHA3-256 receipt chain for partition boundaries and attention output."""
+from __future__ import annotations
+import hashlib
+import json
+from typing import Any, List, Optional, Tuple
+GENESIS = "0" * 64
+def _canon(obj: Any) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode("utf-8")
+def sha3_hex(body: bytes) -> str:
+    return hashlib.sha3_256(body).hexdigest()
+class ReceiptChain:
+    """Linked SHA3-256 receipts. Genesis prev is 64 zero hex digits."""
+    def __init__(self) -> None:
+        self._rows: List[dict] = []
+    def emit(self, payload: dict) -> str:
+        prev = self._rows[-1]["digest"] if self._rows else GENESIS
+        body = dict(payload)
+        body["seq"] = len(self._rows)
+        body["prev"] = prev
+        digest = sha3_hex(_canon(body))
+        row = {**body, "digest": digest}
+        self._rows.append(row)
+        return digest
+    def verify(self) -> Tuple[bool, int, int]:
+        prev = GENESIS
+        for i, row in enumerate(self._rows):
+            body = {k: v for k, v in row.items() if k != "digest"}
+            if row.get("prev") != prev or sha3_hex(_canon(body)) != row.get("digest"):
+                return False, i, i
+            prev = row["digest"]
+        return True, len(self._rows), -1
+    def head(self) -> Optional[str]:
+        return self._rows[-1]["digest"] if self._rows else None
+    def __len__(self) -> int:
+        return len(self._rows)

build/torch-cpu/yarqa_attn/attn.py ADDED Viewed

	@@ -0,0 +1,217 @@

+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""Compartment / plug-flow attention. Original SZL cut.
+Named attn.py (not _ops.py): kernel-builder generates
+torch-ext/<python_name>/_ops.py with add_op_namespace_prefix.
+CPU only. No Dao hopper, Sage csrc, vLLM paged .cu, cuDNN FMHA,
+TRT cubins, CuTeDSL, or flex_attention.py.
+"""
+from __future__ import annotations
+import ctypes
+from typing import List, Optional
+import torch
+import torch.nn.functional as F
+from ._chain import ReceiptChain, sha3_hex
+PATH = "torch_compartment"
+LAMBDA = "Conjecture 1"
+_ATOL = 1.0e-5
+_RTOL = 1.0e-5
+def canal_bounds(seq_len: int, n_canals: int) -> List[int]:
+    """Exclusive endpoints of contiguous canals. Remainder goes to earlier canals."""
+    if not isinstance(n_canals, int) or isinstance(n_canals, bool):
+        raise TypeError("n_canals must be an int")
+    if seq_len < 1:
+        raise ValueError("seq_len must be >= 1")
+    if n_canals < 1:
+        raise ValueError("n_canals must be >= 1")
+    if n_canals > seq_len:
+        raise ValueError("n_canals cannot exceed sequence length")
+    base, rem = divmod(seq_len, n_canals)
+    bounds = [0]
+    for i in range(n_canals):
+        width = base + (1 if i < rem else 0)
+        bounds.append(bounds[-1] + width)
+    return bounds
+def compartment_mask(seq_len: int, n_canals: int, *, device=None) -> torch.Tensor:
+    """Boolean keep-mask: True where query and key sit in the same canal."""
+    bounds = canal_bounds(seq_len, n_canals)
+    mask = torch.zeros(seq_len, seq_len, dtype=torch.bool, device=device)
+    for s, e in zip(bounds, bounds[1:]):
+        mask[s:e, s:e] = True
+    return mask
+def _require_cpu(*tensors: torch.Tensor) -> None:
+    for t in tensors:
+        if t.device.type != "cpu":
+            raise RuntimeError(
+                "YARQA-ATTN v0 is CPU-only. GPU cubins are not claimed. "
+                "This is not a Flash/Flex/paged stack."
+            )
+def _validate_qkv(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> None:
+    if q.ndim != 4 or k.ndim != 4 or v.ndim != 4:
+        raise ValueError("q, k, v must be rank-4 (batch, heads, seq, dim)")
+    if q.shape != k.shape or q.shape != v.shape:
+        raise ValueError("q, k, v must share shape (batch, heads, seq, dim) in v0")
+    if q.dtype != k.dtype or q.dtype != v.dtype:
+        raise ValueError("q, k, v dtype must match")
+def _within_canal(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+    try:
+        return F.scaled_dot_product_attention(
+            q, k, v, dropout_p=0.0, is_causal=False
+        )
+    except Exception:
+        scale = q.shape[-1] ** -0.5
+        scores = torch.matmul(q, k.transpose(-2, -1)) * scale
+        probs = torch.softmax(scores, dim=-1)
+        return torch.matmul(probs, v)
+def _block_diag_reference(
+    q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, n_canals: int
+) -> torch.Tensor:
+    """Naive full-attn-within-compartment: one SDPA with a block-diagonal keep-mask."""
+    seq = q.shape[2]
+    mask = compartment_mask(seq, n_canals, device=q.device)
+    return F.scaled_dot_product_attention(
+        q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False
+    )
+def _output_digest(y: torch.Tensor) -> str:
+    """SHA3-256 of contiguous float32 IEEE bytes. Numpy is not required.
+    GitHub CPU torch wheels often ship without numpy; a numpy conversion is a defect here.
+    """
+    x = y.detach().to(dtype=torch.float32, device="cpu").contiguous()
+    nbytes = int(x.numel()) * int(x.element_size())
+    if nbytes == 0:
+        return sha3_hex(b"")
+    buf = (ctypes.c_char * nbytes).from_address(x.data_ptr())
+    return sha3_hex(bytes(buf))
+def yarqa_attn(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    n_canals: int,
+    *,
+    chain: Optional[ReceiptChain] = None,
+) -> torch.Tensor:
+    """Attend inside each contiguous canal; concatenate along seq.
+    Not Flash tiled fusion, not Flex score_mod, not paged KV gather.
+    """
+    _require_cpu(q, k, v)
+    _validate_qkv(q, k, v)
+    seq = int(q.shape[2])
+    bounds = canal_bounds(seq, n_canals)
+    pieces = []
+    for start, end in zip(bounds, bounds[1:]):
+        pieces.append(
+            _within_canal(
+                q[:, :, start:end, :],
+                k[:, :, start:end, :],
+                v[:, :, start:end, :],
+            )
+        )
+    y = torch.cat(pieces, dim=2)
+    if chain is not None:
+        chain.emit(
+            {
+                "op": "yarqa_partition",
+                "path": PATH,
+                "n_canals": n_canals,
+                "bounds": list(bounds),
+                "q_shape": list(q.shape),
+                "dtype": str(q.dtype).replace("torch.", ""),
+                "lambda": LAMBDA,
+            }
+        )
+        chain.emit(
+            {
+                "op": "yarqa_output",
+                "path": PATH,
+                "n_canals": n_canals,
+                "output_digest": _output_digest(y),
+                "out_shape": list(y.shape),
+                "lambda": LAMBDA,
+            }
+        )
+    return y
+def _tamper_breaks(chain: ReceiptChain) -> bool:
+    if not chain._rows:
+        return False
+    saved = chain._rows[0].get("bounds")
+    chain._rows[0]["bounds"] = [0, 0]
+    ok, _, first = chain.verify()
+    chain._rows[0]["bounds"] = saved
+    return (not ok) and first == 0
+def _actually_splits(q, k, v, n_canals: int, y: torch.Tensor) -> bool:
+    if n_canals <= 1:
+        return False
+    y_one = yarqa_attn(q, k, v, 1)
+    if torch.allclose(y, y_one, atol=_ATOL, rtol=_RTOL):
+        return False
+    bounds = canal_bounds(int(q.shape[2]), n_canals)
+    widths = [e - s for s, e in zip(bounds, bounds[1:])]
+    return len(widths) == n_canals and min(widths) >= 1
+def selfcheck() -> dict:
+    torch.manual_seed(20260828)
+    q = torch.randn(2, 4, 16, 32)
+    k = torch.randn(2, 4, 16, 32)
+    v = torch.randn(2, 4, 16, 32)
+    n_canals = 4
+    chain = ReceiptChain()
+    y = yarqa_attn(q, k, v, n_canals, chain=chain)
+    ref = _block_diag_reference(q, k, v, n_canals)
+    err = float((y - ref).abs().max().item())
+    ok_chain, depth, brk = chain.verify()
+    split = _actually_splits(q, k, v, n_canals, y)
+    tamper = _tamper_breaks(chain)
+    ok = bool(
+        err < _ATOL
+        and ok_chain
+        and depth == 2
+        and brk == -1
+        and split
+        and tamper
+    )
+    return {
+        "ok": ok,
+        "max_abs_vs_compartment_ref": err,
+        "chain_ok": ok_chain,
+        "chain_depth": depth,
+        "chain_break": brk,
+        "tamper_detected": tamper,
+        "split": split,
+        "n_canals": n_canals,
+        "path": PATH,
+        "lambda": LAMBDA,
+        "python": "present",
+        "note": (
+            "CPU correctness vs naive within-compartment attn; "
+            "no speedup claimed; GPU cubins not claimed; not import-LIVE"
+        ),
+    }

build/torch-universal/metadata.json ADDED Viewed

	@@ -0,0 +1,12 @@

+{
+  "name": "yarqa-attn",
+  "version": 1,
+  "summary": "SZL original compartment/plug-flow attention with SHA3 receipts (CPU)",
+  "license": "Apache-2.0",
+  "universal": true,
+  "python-depends": [],
+  "id": "_yarqa_attn_universal_010",
+  "backend": {
+    "type": "cpu"
+  }
+}

build/torch-universal/yarqa_attn/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""yarqa-attn public API. Compartment / plug-flow attention. Not a Flash/Flex/paged stack."""
+from ._chain import ReceiptChain
+from .attn import canal_bounds, compartment_mask, selfcheck, yarqa_attn
+__all__ = [
+    "ReceiptChain",
+    "canal_bounds",
+    "compartment_mask",
+    "selfcheck",
+    "yarqa_attn",
+]
+__version__ = "0.1.0"

build/torch-universal/yarqa_attn/_chain.py ADDED Viewed

	@@ -0,0 +1,50 @@

+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""SHA3-256 receipt chain for partition boundaries and attention output."""
+from __future__ import annotations
+import hashlib
+import json
+from typing import Any, List, Optional, Tuple
+GENESIS = "0" * 64
+def _canon(obj: Any) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode("utf-8")
+def sha3_hex(body: bytes) -> str:
+    return hashlib.sha3_256(body).hexdigest()
+class ReceiptChain:
+    """Linked SHA3-256 receipts. Genesis prev is 64 zero hex digits."""
+    def __init__(self) -> None:
+        self._rows: List[dict] = []
+    def emit(self, payload: dict) -> str:
+        prev = self._rows[-1]["digest"] if self._rows else GENESIS
+        body = dict(payload)
+        body["seq"] = len(self._rows)
+        body["prev"] = prev
+        digest = sha3_hex(_canon(body))
+        row = {**body, "digest": digest}
+        self._rows.append(row)
+        return digest
+    def verify(self) -> Tuple[bool, int, int]:
+        prev = GENESIS
+        for i, row in enumerate(self._rows):
+            body = {k: v for k, v in row.items() if k != "digest"}
+            if row.get("prev") != prev or sha3_hex(_canon(body)) != row.get("digest"):
+                return False, i, i
+            prev = row["digest"]
+        return True, len(self._rows), -1
+    def head(self) -> Optional[str]:
+        return self._rows[-1]["digest"] if self._rows else None
+    def __len__(self) -> int:
+        return len(self._rows)

build/torch-universal/yarqa_attn/attn.py ADDED Viewed

	@@ -0,0 +1,217 @@

+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""Compartment / plug-flow attention. Original SZL cut.
+Named attn.py (not _ops.py): kernel-builder generates
+torch-ext/<python_name>/_ops.py with add_op_namespace_prefix.
+CPU only. No Dao hopper, Sage csrc, vLLM paged .cu, cuDNN FMHA,
+TRT cubins, CuTeDSL, or flex_attention.py.
+"""
+from __future__ import annotations
+import ctypes
+from typing import List, Optional
+import torch
+import torch.nn.functional as F
+from ._chain import ReceiptChain, sha3_hex
+PATH = "torch_compartment"
+LAMBDA = "Conjecture 1"
+_ATOL = 1.0e-5
+_RTOL = 1.0e-5
+def canal_bounds(seq_len: int, n_canals: int) -> List[int]:
+    """Exclusive endpoints of contiguous canals. Remainder goes to earlier canals."""
+    if not isinstance(n_canals, int) or isinstance(n_canals, bool):
+        raise TypeError("n_canals must be an int")
+    if seq_len < 1:
+        raise ValueError("seq_len must be >= 1")
+    if n_canals < 1:
+        raise ValueError("n_canals must be >= 1")
+    if n_canals > seq_len:
+        raise ValueError("n_canals cannot exceed sequence length")
+    base, rem = divmod(seq_len, n_canals)
+    bounds = [0]
+    for i in range(n_canals):
+        width = base + (1 if i < rem else 0)
+        bounds.append(bounds[-1] + width)
+    return bounds
+def compartment_mask(seq_len: int, n_canals: int, *, device=None) -> torch.Tensor:
+    """Boolean keep-mask: True where query and key sit in the same canal."""
+    bounds = canal_bounds(seq_len, n_canals)
+    mask = torch.zeros(seq_len, seq_len, dtype=torch.bool, device=device)
+    for s, e in zip(bounds, bounds[1:]):
+        mask[s:e, s:e] = True
+    return mask
+def _require_cpu(*tensors: torch.Tensor) -> None:
+    for t in tensors:
+        if t.device.type != "cpu":
+            raise RuntimeError(
+                "YARQA-ATTN v0 is CPU-only. GPU cubins are not claimed. "
+                "This is not a Flash/Flex/paged stack."
+            )
+def _validate_qkv(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> None:
+    if q.ndim != 4 or k.ndim != 4 or v.ndim != 4:
+        raise ValueError("q, k, v must be rank-4 (batch, heads, seq, dim)")
+    if q.shape != k.shape or q.shape != v.shape:
+        raise ValueError("q, k, v must share shape (batch, heads, seq, dim) in v0")
+    if q.dtype != k.dtype or q.dtype != v.dtype:
+        raise ValueError("q, k, v dtype must match")
+def _within_canal(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+    try:
+        return F.scaled_dot_product_attention(
+            q, k, v, dropout_p=0.0, is_causal=False
+        )
+    except Exception:
+        scale = q.shape[-1] ** -0.5
+        scores = torch.matmul(q, k.transpose(-2, -1)) * scale
+        probs = torch.softmax(scores, dim=-1)
+        return torch.matmul(probs, v)
+def _block_diag_reference(
+    q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, n_canals: int
+) -> torch.Tensor:
+    """Naive full-attn-within-compartment: one SDPA with a block-diagonal keep-mask."""
+    seq = q.shape[2]
+    mask = compartment_mask(seq, n_canals, device=q.device)
+    return F.scaled_dot_product_attention(
+        q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False
+    )
+def _output_digest(y: torch.Tensor) -> str:
+    """SHA3-256 of contiguous float32 IEEE bytes. Numpy is not required.
+    GitHub CPU torch wheels often ship without numpy; a numpy conversion is a defect here.
+    """
+    x = y.detach().to(dtype=torch.float32, device="cpu").contiguous()
+    nbytes = int(x.numel()) * int(x.element_size())
+    if nbytes == 0:
+        return sha3_hex(b"")
+    buf = (ctypes.c_char * nbytes).from_address(x.data_ptr())
+    return sha3_hex(bytes(buf))
+def yarqa_attn(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    n_canals: int,
+    *,
+    chain: Optional[ReceiptChain] = None,
+) -> torch.Tensor:
+    """Attend inside each contiguous canal; concatenate along seq.
+    Not Flash tiled fusion, not Flex score_mod, not paged KV gather.
+    """
+    _require_cpu(q, k, v)
+    _validate_qkv(q, k, v)
+    seq = int(q.shape[2])
+    bounds = canal_bounds(seq, n_canals)
+    pieces = []
+    for start, end in zip(bounds, bounds[1:]):
+        pieces.append(
+            _within_canal(
+                q[:, :, start:end, :],
+                k[:, :, start:end, :],
+                v[:, :, start:end, :],
+            )
+        )
+    y = torch.cat(pieces, dim=2)
+    if chain is not None:
+        chain.emit(
+            {
+                "op": "yarqa_partition",
+                "path": PATH,
+                "n_canals": n_canals,
+                "bounds": list(bounds),
+                "q_shape": list(q.shape),
+                "dtype": str(q.dtype).replace("torch.", ""),
+                "lambda": LAMBDA,
+            }
+        )
+        chain.emit(
+            {
+                "op": "yarqa_output",
+                "path": PATH,
+                "n_canals": n_canals,
+                "output_digest": _output_digest(y),
+                "out_shape": list(y.shape),
+                "lambda": LAMBDA,
+            }
+        )
+    return y
+def _tamper_breaks(chain: ReceiptChain) -> bool:
+    if not chain._rows:
+        return False
+    saved = chain._rows[0].get("bounds")
+    chain._rows[0]["bounds"] = [0, 0]
+    ok, _, first = chain.verify()
+    chain._rows[0]["bounds"] = saved
+    return (not ok) and first == 0
+def _actually_splits(q, k, v, n_canals: int, y: torch.Tensor) -> bool:
+    if n_canals <= 1:
+        return False
+    y_one = yarqa_attn(q, k, v, 1)
+    if torch.allclose(y, y_one, atol=_ATOL, rtol=_RTOL):
+        return False
+    bounds = canal_bounds(int(q.shape[2]), n_canals)
+    widths = [e - s for s, e in zip(bounds, bounds[1:])]
+    return len(widths) == n_canals and min(widths) >= 1
+def selfcheck() -> dict:
+    torch.manual_seed(20260828)
+    q = torch.randn(2, 4, 16, 32)
+    k = torch.randn(2, 4, 16, 32)
+    v = torch.randn(2, 4, 16, 32)
+    n_canals = 4
+    chain = ReceiptChain()
+    y = yarqa_attn(q, k, v, n_canals, chain=chain)
+    ref = _block_diag_reference(q, k, v, n_canals)
+    err = float((y - ref).abs().max().item())
+    ok_chain, depth, brk = chain.verify()
+    split = _actually_splits(q, k, v, n_canals, y)
+    tamper = _tamper_breaks(chain)
+    ok = bool(
+        err < _ATOL
+        and ok_chain
+        and depth == 2
+        and brk == -1
+        and split
+        and tamper
+    )
+    return {
+        "ok": ok,
+        "max_abs_vs_compartment_ref": err,
+        "chain_ok": ok_chain,
+        "chain_depth": depth,
+        "chain_break": brk,
+        "tamper_detected": tamper,
+        "split": split,
+        "n_canals": n_canals,
+        "path": PATH,
+        "lambda": LAMBDA,
+        "python": "present",
+        "note": (
+            "CPU correctness vs naive within-compartment attn; "
+            "no speedup claimed; GPU cubins not claimed; not import-LIVE"
+        ),
+    }