phanerozoic commited on Jul 19

Commit

905e624

verified ·

1 Parent(s): be4c1e1

Uploaded using `kernel-builder`.

Browse files

Files changed (45) hide show

build/torch211-cxx11-cu126-x86_64-linux/__init__.py +114 -0
build/torch211-cxx11-cu126-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch211-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch211-cxx11-cu126-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch211-cxx11-cu126-x86_64-linux/metadata.json +36 -0
build/torch211-cxx11-cu128-x86_64-linux/__init__.py +114 -0
build/torch211-cxx11-cu128-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch211-cxx11-cu128-x86_64-linux/_ops.py +9 -0
build/torch211-cxx11-cu128-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch211-cxx11-cu128-x86_64-linux/metadata.json +38 -0
build/torch211-cxx11-cu130-x86_64-linux/__init__.py +114 -0
build/torch211-cxx11-cu130-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch211-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch211-cxx11-cu130-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch211-cxx11-cu130-x86_64-linux/metadata.json +38 -0
build/torch212-cxx11-cu126-x86_64-linux/__init__.py +114 -0
build/torch212-cxx11-cu126-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch212-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch212-cxx11-cu126-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch212-cxx11-cu126-x86_64-linux/metadata.json +36 -0
build/torch212-cxx11-cu130-x86_64-linux/__init__.py +114 -0
build/torch212-cxx11-cu130-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch212-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch212-cxx11-cu130-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch212-cxx11-cu130-x86_64-linux/metadata.json +38 -0
build/torch212-cxx11-cu132-x86_64-linux/__init__.py +114 -0
build/torch212-cxx11-cu132-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch212-cxx11-cu132-x86_64-linux/_ops.py +9 -0
build/torch212-cxx11-cu132-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch212-cxx11-cu132-x86_64-linux/metadata.json +38 -0
build/torch213-cxx11-cu126-x86_64-linux/__init__.py +114 -0
build/torch213-cxx11-cu126-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch213-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch213-cxx11-cu126-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch213-cxx11-cu126-x86_64-linux/metadata.json +36 -0
build/torch213-cxx11-cu130-x86_64-linux/__init__.py +114 -0
build/torch213-cxx11-cu130-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch213-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch213-cxx11-cu130-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch213-cxx11-cu130-x86_64-linux/metadata.json +38 -0
build/torch213-cxx11-cu132-x86_64-linux/__init__.py +114 -0
build/torch213-cxx11-cu132-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so +3 -0
build/torch213-cxx11-cu132-x86_64-linux/_ops.py +9 -0
build/torch213-cxx11-cu132-x86_64-linux/binary_gemm/__init__.py +26 -0
build/torch213-cxx11-cu132-x86_64-linux/metadata.json +38 -0

build/torch211-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch211-cxx11-cu126-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:b0726f6e858bd28e6f7afec48f47ccb1b74cf5e0213fd015036b1b5bdf9d03d7
+size 433992

build/torch211-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch211-cxx11-cu126-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "sHJvboWL0o5vev7Ej0fMsbdM9eAhP9AVA2sbW9+dA9c=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch211-cxx11-cu128-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch211-cxx11-cu128-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:1d94c2e858f5285c82375e55ffeabe003db5b49f3c0f27bc178aff911554010b
+size 655336

build/torch211-cxx11-cu128-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch211-cxx11-cu128-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu128-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "HZTC6Fj1KFyCN15V/+q+AD21tJ88Dye8F4r/kRVUAQs=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch211-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch211-cxx11-cu130-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:73836d8e9c2e4fd31428ec170ee045ac2488cddf0a4dcebb2abe7c2a22fbf7f6
+size 682200

build/torch211-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch211-cxx11-cu130-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "c4NtjpwuT9MUKOwXDuBFrCSIzd8KTc67Kr58KiL79/Y=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch212-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch212-cxx11-cu126-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:cfc06dfc659837c4190ea30bb4b6296a6bb8513b9fc4e3376fe649f79b6dd91a
+size 439624

build/torch212-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch212-cxx11-cu126-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+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/torch212-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "z8Bt/GWYN8QZDqMLtLYpamu4UTufxOM3b+ZJ95tt2Ro=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch212-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch212-cxx11-cu130-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:d35024ab6c50dcf278e73b13bb43933e1136403d8b9a3b8f91c0564312895ebf
+size 687272

build/torch212-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch212-cxx11-cu130-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+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/torch212-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "01Akq2xQ3PJ45zsTu0OTPhE2QD2LmjuPkcBWQxKJXr8=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch212-cxx11-cu132-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch212-cxx11-cu132-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:cd3c83131d08f6d8ea35a82715caa2f9c918be096e0ccc408189d22a7cd6818a
+size 726192

build/torch212-cxx11-cu132-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch212-cxx11-cu132-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+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/torch212-cxx11-cu132-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "zTyDEx0I9tjqNagnFcqi+ckYvgluDMxAgYnSKnzWgYo=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch213-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch213-cxx11-cu126-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:65b2374bfd12bf73d357aa8b65328b19085187c6b1ca37d1dfedc8f9d2b86a4f
+size 439464

build/torch213-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch213-cxx11-cu126-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+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/torch213-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "ZbI3S/0Sv3PTV6qLZTKLGQhRh8axyjfR3+3I+dK4ak8=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch213-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch213-cxx11-cu130-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:9a16adc9320c70979199f783d70716c648d7a4471ce5f926f584dc17283c0f05
+size 687120

build/torch213-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch213-cxx11-cu130-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+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/torch213-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "mhatyTIMcJeRmfeD1wcWxkjXpEcc5fkm9YTcFyg8DwU=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}

build/torch213-cxx11-cu132-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,114 @@

+"""binary-gemm: W1A8 matrix products for binary-weight language models.
+Each weight is one bit meaning +1 or -1, with one fp16 scale per group of G
+weights: at G = 128 that is 1.125 effective bits, against 2 bits for a ternary
+layer and 16 for bf16. Activations are quantized per token to int8.
+Binary weights are not a special case of ternary. Writing the stored bit as
+b = (w + 1) / 2, the inner product is 2 * sum_{b_i = 1} a_i - sum_i a_i, so the
+weight is never materialized as a number. The kernel resolves four weights at a
+time through a nibble table feeding __dp4a.
+Ternary companions on the Hub: phanerozoic/bitnet-tc (CUDA),
+phanerozoic/bitnet-cpu (CPU).
+"""
+from typing import Optional, Tuple
+import torch
+from ._ops import ops
+__all__ = [
+    "pack_weights", "unpack_weights", "quantize_activation", "binary_gemm",
+    "binary_linear", "BinaryLinear",
+]
+GROUP = 128
+def pack_weights(w: torch.Tensor) -> torch.Tensor:
+    """Pack a ``{-1, +1}`` int8 ``[N, K]`` matrix to ``[N, K//32]`` int32.
+    Bit j of word i holds weight ``32*i + j``: set means +1, clear means -1.
+    Zeros are treated as -1, so a ternary tensor will not round-trip.
+    """
+    return ops.pack_weights(w.contiguous().to(torch.int8))
+def unpack_weights(wq: torch.Tensor, K: int) -> torch.Tensor:
+    """Inverse of :func:`pack_weights`, for tests and for a reference path."""
+    bits = wq.to(torch.int32)
+    idx = torch.arange(32, device=wq.device, dtype=torch.int32)
+    out = ((bits.unsqueeze(-1) >> idx) & 1).to(torch.int8)
+    return (out.reshape(wq.shape[0], -1)[:, :K] * 2 - 1)
+def quantize_activation(x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """bf16 ``[..., K]`` -> (int8 ``[M, K]``, fp32 per-token scale ``[M]``)."""
+    q, s = ops.quantize_activation(x.contiguous().to(torch.bfloat16))
+    return q, s
+def binary_gemm(act_q: torch.Tensor, act_scale: torch.Tensor, wq: torch.Tensor,
+                wscale: torch.Tensor, bias: Optional[torch.Tensor] = None,
+                group_size: int = GROUP) -> torch.Tensor:
+    """int8 activations times packed binary weights -> bf16 ``[M, N]``."""
+    return ops.binary_gemm(act_q, act_scale, wq, wscale, bias, group_size)
+def binary_linear(x: torch.Tensor, wq: torch.Tensor, wscale: torch.Tensor,
+                  bias: Optional[torch.Tensor] = None,
+                  group_size: int = GROUP) -> torch.Tensor:
+    """One-shot forward: quantize the activation, then the packed product.
+    Trailing batch dimensions are preserved."""
+    shape = x.shape[:-1]
+    q, s = quantize_activation(x)
+    out = binary_gemm(q, s, wq, wscale, bias, group_size)
+    return out.reshape(*shape, out.shape[-1])
+class BinaryLinear(torch.nn.Module):
+    """Drop-in for a binary-weight ``nn.Linear``. Holds packed weights and their
+    group scales; nothing is stored at higher precision."""
+    def __init__(self, in_features: int, out_features: int, bias: bool = False,
+                 group_size: int = GROUP, device=None):
+        super().__init__()
+        assert in_features % 32 == 0, "in_features must be a multiple of 32"
+        assert in_features % group_size == 0, "in_features must be a multiple of group_size"
+        self.in_features = in_features
+        self.out_features = out_features
+        self.group_size = group_size
+        self.register_buffer(
+            "wq", torch.zeros(out_features, in_features // 32, dtype=torch.int32,
+                              device=device))
+        self.register_buffer(
+            "wscale", torch.ones(out_features, in_features // group_size,
+                                 dtype=torch.float16, device=device))
+        self.bias = torch.nn.Parameter(
+            torch.zeros(out_features, device=device)) if bias else None
+    @classmethod
+    def from_dense(cls, lin: torch.nn.Linear, group_size: int = GROUP) -> "BinaryLinear":
+        """Binarize an existing linear by sign, with the group scale set to the
+        group's mean absolute weight, which is the scale that minimizes squared
+        error for a sign-quantized group."""
+        W = lin.weight.data
+        N, K = W.shape
+        m = cls(K, N, bias=lin.bias is not None, group_size=group_size,
+                device=W.device)
+        signs = torch.where(W >= 0, 1, -1).to(torch.int8)
+        m.wq.copy_(pack_weights(signs))
+        m.wscale.copy_(W.reshape(N, K // group_size, group_size).abs().mean(-1)
+                       .to(torch.float16))
+        if lin.bias is not None:
+            m.bias.data.copy_(lin.bias.data)
+        return m
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return binary_linear(x, self.wq, self.wscale, self.bias, self.group_size)
+    def extra_repr(self) -> str:
+        bits = 1 + 16 / self.group_size
+        return (f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"group_size={self.group_size}, effective_bits={bits:.3f}")

build/torch213-cxx11-cu132-x86_64-linux/_binary_gemm_cuda_31ce78e.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:c81218433482ffc1f9565ba27445822bd9e765fda89e15a6313ac62355416309
+size 726032

build/torch213-cxx11-cu132-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _binary_gemm_cuda_31ce78e
+ops = torch.ops._binary_gemm_cuda_31ce78e
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_binary_gemm_cuda_31ce78e::{op_name}"

build/torch213-cxx11-cu132-x86_64-linux/binary_gemm/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+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/torch213-cxx11-cu132-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "binary-gemm",
+  "id": "_binary_gemm_cuda_31ce78e",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "fwn5WUojHrxLQwNl70+IAx7FZfHJQI9O+Zp5h4F+n7Y=",
+      "_binary_gemm_cuda_31ce78e.abi3.so": "yBIYQzSC/8H5VluidEWCK9nnZf2onhWmMTrGI1VBYwk=",
+      "_ops.py": "cGdYjoXrblpZs8DIqLlPArXWztTZ+wWrveEjvYq+5/0=",
+      "binary_gemm/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "31ce78ecfe5b53cd413fd76785b351410c1f610a",
+      "dirty": false
+    }
+  }
+}