piper-kernels 0.1.0__py3-none-any.whl

piper_kernels/__init__.py

@@ -0,0 +1 @@
+"""Reusable PyTorch inference operators and optimized kernels."""

piper_kernels/attention/__init__.py

@@ -0,0 +1 @@
+"""Optimized attention operators."""

piper_kernels/attention/backends/__init__.py

@@ -0,0 +1 @@
+"""Optional optimized backends for attention operators."""

piper_kernels/convrot/__init__.py

@@ -0,0 +1,5 @@
+"""Rotated quantized weights with transparent PyTorch linear dispatch."""
+
+from ._int8.tensor import ConvRotInt8Tensor
+
+__all__ = ["ConvRotInt8Tensor"]

piper_kernels/convrot/_int8/__init__.py

@@ -0,0 +1 @@
+"""Internal INT8 ConvRot implementation."""

piper_kernels/convrot/_int8/backends/__init__.py

@@ -0,0 +1 @@
+"""Optional optimized backends for INT8 ConvRot operators."""

piper_kernels/convrot/_int8/backends/triton.py

@@ -0,0 +1,357 @@
+"""Triton backend for rotated INT8 W8A8 linear layers."""
+
+# Triton's JIT launcher accepts compile-time options not represented in its
+# Python call signature.
+# pyright: reportCallIssue=false
+
+import torch
+import triton
+import triton.language as tl
+from triton.language.extra import libdevice
+
+
+@triton.jit
+def _hadamard_stage(values, offsets, stride: tl.constexpr):
+    """Apply one H4 Kronecker factor to a flattened regular Hadamard row."""
+    digit = (offsets // stride) % 4
+    base = offsets - digit * stride
+    a = tl.gather(values, base, 0)
+    b = tl.gather(values, base + stride, 0)
+    c = tl.gather(values, base + 2 * stride, 0)
+    d = tl.gather(values, base + 3 * stride, 0)
+    return tl.where(
+        digit == 0,
+        a + b + c - d,
+        tl.where(
+            digit == 1,
+            a + b - c + d,
+            tl.where(digit == 2, a - b + c + d, -a + b + c + d),
+        ),
+    )
+
+
+@triton.jit
+def _normalize_for_int8(values, scale, logical_dtype_code: tl.constexpr):
+    """Normalize values without dividing by an underflowed logical scale."""
+    if logical_dtype_code == 1:
+        logical_scale = scale.to(tl.float16)
+        safe_logical_scale = tl.where(logical_scale == 0, 1.0, logical_scale).to(tl.float16)
+        scaled = (values / safe_logical_scale).to(tl.float16)
+        return tl.where(
+            logical_scale == 0,
+            values.to(tl.float32) / scale,
+            scaled.to(tl.float32),
+        )
+    elif logical_dtype_code == 2:
+        return (values / scale.to(tl.bfloat16)).to(tl.bfloat16)
+    else:
+        return values / scale
+
+
+@triton.jit
+def _rotate_groups_kernel(
+    x_ptr,
+    out_ptr,
+    row_width,
+    groups_per_row,
+    group_size: tl.constexpr,
+    inverse_sqrt_group: tl.constexpr,
+):
+    group_id = tl.program_id(0)
+    row = group_id // groups_per_row
+    group = group_id % groups_per_row
+    offsets = tl.arange(0, group_size)
+    pointers = x_ptr + row * row_width + group * group_size + offsets
+    values = tl.load(pointers).to(tl.float32)
+
+    values = _hadamard_stage(values, offsets, 1)
+    values = _hadamard_stage(values, offsets, 4)
+    if group_size >= 64:
+        values = _hadamard_stage(values, offsets, 16)
+    if group_size >= 256:
+        values = _hadamard_stage(values, offsets, 64)
+
+    tl.store(out_ptr + row * row_width + group * group_size + offsets, values * inverse_sqrt_group)
+
+
+@triton.jit
+def _quantize_rows_kernel(
+    x_ptr,
+    q_ptr,
+    scale_ptr,
+    row_width,
+    block_size: tl.constexpr,
+    input_dtype_code: tl.constexpr,
+):
+    row = tl.program_id(0)
+    offsets = tl.arange(0, block_size)
+    mask = offsets < row_width
+    values = tl.load(x_ptr + row * row_width + offsets, mask=mask, other=0.0)
+    scale = tl.maximum(tl.max(tl.abs(values), axis=0) / 127.0, 1e-30)
+    scaled = _normalize_for_int8(values, scale, input_dtype_code)
+    quantized = tl.clamp(libdevice.rint(scaled.to(tl.float32)), -128.0, 127.0).to(tl.int8)
+    tl.store(q_ptr + row * row_width + offsets, quantized, mask=mask)
+    tl.store(scale_ptr + row, scale)
+
+
+@triton.jit
+def _requantize_addmm_rows_kernel(
+    q_ptr,
+    scale_ptr,
+    update_ptr,
+    row_width,
+    stride_q_row,
+    stride_q_col,
+    stride_scale_row,
+    stride_update_row,
+    stride_update_col,
+    beta,
+    alpha,
+    block_size: tl.constexpr,
+    logical_dtype_code: tl.constexpr,
+    has_base: tl.constexpr,
+    has_update: tl.constexpr,
+):
+    row = tl.program_id(0)
+    offsets = tl.arange(0, block_size)
+    mask = offsets < row_width
+    if has_base:
+        quantized = tl.load(
+            q_ptr + row * stride_q_row + offsets * stride_q_col,
+            mask=mask,
+            other=0,
+        )
+        old_scale = tl.load(scale_ptr + row * stride_scale_row)
+        values = beta * quantized.to(tl.float32) * old_scale
+    else:
+        values = tl.zeros((block_size,), dtype=tl.float32)
+    if has_update:
+        update = tl.load(
+            update_ptr + row * stride_update_row + offsets * stride_update_col,
+            mask=mask,
+            other=0.0,
+        )
+        values += alpha * update.to(tl.float32)
+    if logical_dtype_code == 1:
+        values = values.to(tl.float16)
+    elif logical_dtype_code == 2:
+        values = values.to(tl.bfloat16)
+    scale = tl.maximum(tl.max(tl.abs(values).to(tl.float32), axis=0) / 127.0, 1e-30)
+    scaled = _normalize_for_int8(values, scale, logical_dtype_code)
+    quantized = tl.clamp(libdevice.rint(scaled.to(tl.float32)), -128.0, 127.0).to(tl.int8)
+    tl.store(
+        q_ptr + row * stride_q_row + offsets * stride_q_col,
+        quantized,
+        mask=mask,
+    )
+    tl.store(scale_ptr + row * stride_scale_row, scale)
+
+
+@triton.jit
+def _int8_matmul_kernel(
+    activation_ptr,
+    weight_ptr,
+    output_ptr,
+    activation_scale_ptr,
+    weight_scale_ptr,
+    bias_ptr,
+    m,
+    n,
+    k,
+    stride_am,
+    stride_ak,
+    stride_wn,
+    stride_wk,
+    stride_om,
+    stride_on,
+    block_m: tl.constexpr,
+    block_n: tl.constexpr,
+    block_k: tl.constexpr,
+    has_bias: tl.constexpr,
+):
+    pid_m = tl.program_id(0)
+    pid_n = tl.program_id(1)
+    offsets_m = pid_m * block_m + tl.arange(0, block_m)
+    offsets_n = pid_n * block_n + tl.arange(0, block_n)
+    offsets_k = tl.arange(0, block_k)
+
+    activation_pointers = (
+        activation_ptr + offsets_m[:, None] * stride_am + offsets_k[None, :] * stride_ak
+    )
+    weight_pointers = weight_ptr + offsets_n[None, :] * stride_wn + offsets_k[:, None] * stride_wk
+    accumulator = tl.zeros((block_m, block_n), dtype=tl.int32)
+
+    for k_offset in range(tl.cdiv(k, block_k)):
+        activation = tl.load(
+            activation_pointers,
+            mask=(offsets_m[:, None] < m) & (offsets_k[None, :] < k - k_offset * block_k),
+            other=0,
+        )
+        weight = tl.load(
+            weight_pointers,
+            mask=(offsets_n[None, :] < n) & (offsets_k[:, None] < k - k_offset * block_k),
+            other=0,
+        )
+        accumulator += tl.dot(activation, weight)
+        activation_pointers += block_k * stride_ak
+        weight_pointers += block_k * stride_wk
+
+    activation_scale = tl.load(activation_scale_ptr + offsets_m, mask=offsets_m < m, other=0.0)
+    weight_scale = tl.load(weight_scale_ptr + offsets_n, mask=offsets_n < n, other=0.0)
+    result = accumulator.to(tl.float32) * activation_scale[:, None] * weight_scale[None, :]
+    if has_bias:
+        bias = tl.load(bias_ptr + offsets_n, mask=offsets_n < n, other=0.0)
+        result += bias[None, :]
+
+    output_pointers = output_ptr + offsets_m[:, None] * stride_om + offsets_n[None, :] * stride_on
+    tl.store(
+        output_pointers,
+        result,
+        mask=(offsets_m[:, None] < m) & (offsets_n[None, :] < n),
+    )
+
+
+@torch.library.custom_op("piper_kernels::convrot_int8_linear", mutates_args=())
+def triton_convrot_int8_linear(
+    activation: torch.Tensor,
+    weight: torch.Tensor,
+    weight_scale: torch.Tensor,
+    bias: torch.Tensor | None,
+    group_size: int,
+) -> torch.Tensor:
+    """Run ConvRot activation rotation, dynamic quantization, and INT8 GEMM."""
+    original_shape = activation.shape
+    activation_2d = activation.reshape(-1, original_shape[-1]).contiguous()
+    m, k = activation_2d.shape
+    n = weight.shape[0]
+    if m == 0 or n == 0:
+        return activation.new_empty((*original_shape[:-1], n))
+
+    groups_per_row = k // group_size
+    rotated = torch.empty_like(activation_2d)
+    _rotate_groups_kernel[(m * groups_per_row,)](
+        activation_2d,
+        rotated,
+        k,
+        groups_per_row,
+        group_size=group_size,
+        inverse_sqrt_group=group_size**-0.5,
+        num_warps=4,
+    )
+
+    quantized = torch.empty_like(rotated, dtype=torch.int8)
+    activation_scale = torch.empty(m, device=activation.device, dtype=torch.float32)
+    quant_block = max(128, triton.next_power_of_2(k))
+    if activation.dtype is torch.float16:
+        input_dtype_code = 1
+    elif activation.dtype is torch.bfloat16:
+        input_dtype_code = 2
+    else:
+        input_dtype_code = 0
+    _quantize_rows_kernel[(m,)](
+        rotated,
+        quantized,
+        activation_scale,
+        k,
+        block_size=quant_block,
+        input_dtype_code=input_dtype_code,
+        num_warps=8,
+    )
+
+    output = torch.empty((m, n), device=activation.device, dtype=activation.dtype)
+    block_m = 32 if m < 64 else 64
+    block_n = 64 if n < 128 else 128
+    block_k = 32
+    grid = (triton.cdiv(m, block_m), triton.cdiv(n, block_n))
+    bias_pointer = bias if bias is not None else activation
+    _int8_matmul_kernel[grid](
+        quantized,
+        weight,
+        output,
+        activation_scale,
+        weight_scale,
+        bias_pointer,
+        m,
+        n,
+        k,
+        quantized.stride(0),
+        quantized.stride(1),
+        weight.stride(0),
+        weight.stride(1),
+        output.stride(0),
+        output.stride(1),
+        block_m=block_m,
+        block_n=block_n,
+        block_k=block_k,
+        has_bias=bias is not None,
+        num_stages=3,
+        num_warps=4,
+    )
+    return output.reshape(*original_shape[:-1], n)
+
+
+def triton_convrot_int8_addmm_(
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    mat1: torch.Tensor,
+    mat2: torch.Tensor,
+    group_size: int,
+    beta: float,
+    alpha: float,
+) -> None:
+    """Apply an addmm update in the rotated basis and requantize the weight in place."""
+    out_features, in_features = qdata.shape
+    has_update = alpha != 0 and mat1.shape[1] != 0
+    if has_update:
+        mat2_contiguous = mat2.contiguous()
+        rotated_mat2 = torch.empty_like(mat2_contiguous)
+        groups_per_row = in_features // group_size
+        _rotate_groups_kernel[(mat2.shape[0] * groups_per_row,)](
+            mat2_contiguous,
+            rotated_mat2,
+            in_features,
+            groups_per_row,
+            group_size=group_size,
+            inverse_sqrt_group=group_size**-0.5,
+            num_warps=4,
+        )
+        update = torch.mm(mat1, rotated_mat2)
+    else:
+        update = qdata
+
+    if mat1.dtype is torch.float16:
+        logical_dtype_code = 1
+    elif mat1.dtype is torch.bfloat16:
+        logical_dtype_code = 2
+    else:
+        logical_dtype_code = 0
+    requant_block = max(128, triton.next_power_of_2(in_features))
+    _requantize_addmm_rows_kernel[(out_features,)](
+        qdata,
+        scale,
+        update,
+        in_features,
+        qdata.stride(0),
+        qdata.stride(1),
+        scale.stride(0),
+        update.stride(0),
+        update.stride(1),
+        beta,
+        alpha,
+        block_size=requant_block,
+        logical_dtype_code=logical_dtype_code,
+        has_base=beta != 0,
+        has_update=has_update,
+        num_warps=8,
+    )
+
+
+@triton_convrot_int8_linear.register_fake
+def _triton_convrot_int8_linear_fake(
+    activation: torch.Tensor,
+    weight: torch.Tensor,
+    _weight_scale: torch.Tensor,
+    _bias: torch.Tensor | None,
+    _group_size: int,
+) -> torch.Tensor:
+    return activation.new_empty((*activation.shape[:-1], weight.shape[0]))

piper_kernels/convrot/_int8/dispatch.py

@@ -0,0 +1,182 @@
+"""Internal backend selection for INT8 ConvRot operators."""
+
+import math
+
+import torch
+
+from .reference import reference_addmm_, reference_linear, validate_storage
+
+try:
+    from .backends.triton import (
+        triton_convrot_int8_addmm_ as _triton_addmm_,
+    )
+    from .backends.triton import (
+        triton_convrot_int8_linear as _triton_linear,
+    )
+except ModuleNotFoundError as exc:
+    if exc.name != "triton":
+        raise
+    _triton_addmm_ = None
+    _triton_linear = None
+
+
+def _can_use_triton(activation: torch.Tensor, qdata: torch.Tensor) -> bool:
+    return (
+        _triton_linear is not None
+        and activation.device.type == "cuda"
+        and activation.device == qdata.device
+        and activation.dtype in (torch.float16, torch.bfloat16, torch.float32)
+        and torch.cuda.get_device_capability(activation.device) >= (7, 5)
+    )
+
+
+def _validate_scalar(value: int | float | complex, name: str) -> float:
+    if isinstance(value, complex):
+        raise TypeError(f"ConvRot INT8 addmm_ {name} must be a real number, got {value}")
+    converted = float(value)
+    if not math.isfinite(converted):
+        raise ValueError(f"ConvRot INT8 addmm_ {name} must be finite, got {value}")
+    return converted
+
+
+def _validate_addmm(
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    dtype: torch.dtype,
+    group_size: int,
+    mat1: torch.Tensor,
+    mat2: torch.Tensor,
+) -> None:
+    validate_storage(qdata, scale, group_size, dtype)
+    if qdata.device.type == "meta":
+        raise ValueError("ConvRot INT8 addmm_ cannot update a meta tensor without values")
+    if mat1.ndim != 2 or mat2.ndim != 2:
+        raise ValueError(
+            "ConvRot INT8 addmm_ matrices must be 2-D, "
+            f"got shapes {tuple(mat1.shape)} and {tuple(mat2.shape)}"
+        )
+    expected_mat1 = (qdata.shape[0], mat2.shape[0])
+    expected_mat2 = (mat1.shape[1], qdata.shape[1])
+    if tuple(mat1.shape) != expected_mat1 or tuple(mat2.shape) != expected_mat2:
+        raise ValueError(
+            "ConvRot INT8 addmm_ shape mismatch: expected "
+            f"mat1 {expected_mat1} and mat2 {expected_mat2} for weight {tuple(qdata.shape)}, "
+            f"got {tuple(mat1.shape)} and {tuple(mat2.shape)}"
+        )
+    if mat1.device != qdata.device or mat2.device != qdata.device:
+        raise ValueError(
+            "ConvRot INT8 addmm_ weight and matrices must share a device, "
+            f"got {qdata.device}/{mat1.device}/{mat2.device}"
+        )
+    if mat1.dtype is not dtype or mat2.dtype is not dtype:
+        raise ValueError(
+            "ConvRot INT8 addmm_ matrices must match the weight's logical dtype, "
+            f"got {dtype}/{mat1.dtype}/{mat2.dtype}"
+        )
+    if mat1.layout is not torch.strided or mat2.layout is not torch.strided:
+        raise ValueError("ConvRot INT8 addmm_ matrices must use strided layout")
+    if torch.is_grad_enabled() and (mat1.requires_grad or mat2.requires_grad):
+        raise RuntimeError(
+            "ConvRot INT8 addmm_ does not support autograd; detach the matrices or use no_grad"
+        )
+
+
+def _can_use_triton_addmm(qdata: torch.Tensor, mat1: torch.Tensor) -> bool:
+    return (
+        _triton_addmm_ is not None
+        and qdata.device.type == "cuda"
+        and mat1.device == qdata.device
+        and torch.cuda.get_device_capability(qdata.device) >= (7, 5)
+    )
+
+
+@torch.library.custom_op(
+    "piper_kernels::convrot_int8_addmm_",
+    mutates_args=("qdata", "scale"),
+)
+def _convrot_int8_addmm_op(
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    mat1: torch.Tensor,
+    mat2: torch.Tensor,
+    group_size: int,
+    beta: float,
+    alpha: float,
+) -> None:
+    if _can_use_triton_addmm(qdata, mat1):
+        assert _triton_addmm_ is not None
+        _triton_addmm_(qdata, scale, mat1, mat2, group_size, beta, alpha)
+        return
+    reference_addmm_(qdata, scale, mat1, mat2, group_size, beta, alpha)
+
+
+@_convrot_int8_addmm_op.register_fake
+def _convrot_int8_addmm_fake(
+    _qdata: torch.Tensor,
+    _scale: torch.Tensor,
+    _mat1: torch.Tensor,
+    _mat2: torch.Tensor,
+    _group_size: int,
+    _beta: float,
+    _alpha: float,
+) -> None:
+    return None
+
+
+def _addmm_(
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    dtype: torch.dtype,
+    group_size: int,
+    mat1: torch.Tensor,
+    mat2: torch.Tensor,
+    *,
+    beta: int | float | complex = 1,
+    alpha: int | float | complex = 1,
+) -> None:
+    """Apply the logical ``beta * weight + alpha * mat1 @ mat2`` update in place."""
+    _validate_addmm(qdata, scale, dtype, group_size, mat1, mat2)
+    beta_float = _validate_scalar(beta, "beta")
+    alpha_float = _validate_scalar(alpha, "alpha")
+    if beta_float == 1 and alpha_float == 0:
+        return
+    _convrot_int8_addmm_op(
+        qdata,
+        scale,
+        mat1,
+        mat2,
+        group_size,
+        beta_float,
+        alpha_float,
+    )
+
+
+def _linear(
+    activation: torch.Tensor,
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    group_size: int,
+    bias: torch.Tensor | None = None,
+) -> torch.Tensor:
+    """Apply raw ConvRot INT8 storage to a floating-point activation.
+
+    ``qdata`` stores the two-dimensional INT8 weight in its rotated basis,
+    and ``scale`` contains one float32 value per output channel. This is the
+    internal storage-level ABI. Consumers should call
+    :func:`torch.nn.functional.linear` with a ``ConvRotInt8Tensor`` weight.
+    """
+    validate_storage(qdata, scale, group_size, activation.dtype)
+    if activation.ndim == 0 or activation.shape[-1] != qdata.shape[1]:
+        actual = 0 if activation.ndim == 0 else activation.shape[-1]
+        raise ValueError(f"ConvRot linear input has {actual} features, expected {qdata.shape[1]}")
+    if activation.device != qdata.device:
+        raise ValueError(
+            "ConvRot activation and weight must share a device, "
+            f"got {activation.device}/{qdata.device}"
+        )
+    if bias is not None and not isinstance(bias, torch.Tensor):
+        raise TypeError(f"ConvRot linear bias must be a tensor or None, got {type(bias).__name__}")
+    if _can_use_triton(activation, qdata):
+        assert _triton_linear is not None
+        return _triton_linear(activation, qdata, scale, bias, group_size)
+    return reference_linear(activation, qdata, scale, group_size, bias)

piper_kernels/convrot/_int8/reference.py

@@ -0,0 +1,132 @@
+"""Portable reference implementation for INT8 ConvRot linear layers."""
+
+import torch
+
+from .._rotation import rotate_groups, validate_group_size
+
+_SUPPORTED_LOGICAL_DTYPES = (torch.float16, torch.bfloat16, torch.float32)
+
+
+def quantize_weight(
+    weight: torch.Tensor,
+    group_size: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Rotate and quantize a dense two-dimensional weight per output row."""
+    validate_group_size(group_size)
+    if weight.ndim != 2:
+        raise ValueError(
+            f"ConvRot INT8 high-precision weight must be 2-D, got shape {tuple(weight.shape)}"
+        )
+    if weight.dtype not in _SUPPORTED_LOGICAL_DTYPES:
+        raise ValueError(
+            "ConvRot INT8 high-precision weight must use float16, bfloat16, or float32, "
+            f"got {weight.dtype}"
+        )
+    if weight.device.type == "meta":
+        raise ValueError("ConvRot INT8 cannot quantize a meta tensor without values")
+    if weight.shape[1] % group_size:
+        raise ValueError(
+            f"ConvRot in_features {weight.shape[1]} is not divisible by group size {group_size}"
+        )
+    return dynamic_quantize_rows(rotate_groups(weight, group_size))
+
+
+def validate_storage(
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    group_size: int,
+    dtype: torch.dtype,
+) -> None:
+    """Validate INT8 ConvRot storage and its logical floating-point dtype."""
+    validate_group_size(group_size)
+    if qdata.dtype is not torch.int8 or qdata.ndim != 2:
+        raise ValueError(
+            f"ConvRot INT8 qdata must be a 2-D int8 tensor, got {qdata.dtype} {qdata.shape}"
+        )
+    if qdata.shape[1] % group_size:
+        raise ValueError(
+            f"ConvRot in_features {qdata.shape[1]} is not divisible by group size {group_size}"
+        )
+    expected_scale_shape = (qdata.shape[0], 1)
+    if scale.dtype is not torch.float32 or tuple(scale.shape) != expected_scale_shape:
+        raise ValueError(
+            f"ConvRot INT8 scale must be float32 with shape {expected_scale_shape}, "
+            f"got {scale.dtype} {tuple(scale.shape)} for qdata {tuple(qdata.shape)}"
+        )
+    if scale.device != qdata.device:
+        raise ValueError(
+            f"ConvRot INT8 qdata and scale must share a device, got {qdata.device}/{scale.device}"
+        )
+    if dtype not in _SUPPORTED_LOGICAL_DTYPES:
+        raise ValueError(
+            f"ConvRot logical dtype must be float16, bfloat16, or float32, got {dtype}"
+        )
+
+
+def dynamic_quantize_rows(value: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    """Dynamically quantize each row to signed INT8 with a float32 scale."""
+    scale = (value.float().abs().amax(dim=-1, keepdim=True) / 127.0).clamp(min=1e-30)
+    logical_scale = scale.to(value.dtype)
+    if value.dtype is torch.float16:
+        scale_underflowed = logical_scale == 0
+        safe_logical_scale = torch.where(
+            scale_underflowed,
+            torch.ones_like(logical_scale),
+            logical_scale,
+        )
+        scaled = value / safe_logical_scale
+        scaled = torch.where(scale_underflowed, value.float() / scale, scaled.float())
+    else:
+        # The minimum scale remains representable in bfloat16 and float32.
+        scaled = value / logical_scale
+    qdata = scaled.round().clamp(-128, 127).to(torch.int8)
+    return qdata, scale
+
+
+def reference_addmm_(
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    mat1: torch.Tensor,
+    mat2: torch.Tensor,
+    group_size: int,
+    beta: float,
+    alpha: float,
+) -> None:
+    """Add a matrix product to a logical ConvRot weight and requantize it in place."""
+    if beta == 0:
+        rotated_weight = torch.zeros(qdata.shape, device=qdata.device, dtype=mat1.dtype)
+    else:
+        rotated_weight = qdata.to(mat1.dtype) * scale.to(mat1.dtype)
+    rotated_mat2 = rotate_groups(mat2, group_size)
+    merged = torch.addmm(rotated_weight, mat1, rotated_mat2, beta=beta, alpha=alpha)
+    merged_qdata, merged_scale = dynamic_quantize_rows(merged)
+    qdata.copy_(merged_qdata)
+    scale.copy_(merged_scale)
+
+
+def reference_linear(
+    activation: torch.Tensor,
+    qdata: torch.Tensor,
+    scale: torch.Tensor,
+    group_size: int,
+    bias: torch.Tensor | None = None,
+) -> torch.Tensor:
+    """Run the portable PyTorch ConvRot W8A8 linear implementation."""
+    original_shape = activation.shape
+    activation_2d = activation.reshape(-1, original_shape[-1])
+    rotated = rotate_groups(activation_2d, group_size)
+    activation_qdata, activation_scale = dynamic_quantize_rows(rotated)
+    if activation.device.type == "cpu":
+        accumulated = activation_qdata.to(torch.int32) @ qdata.T.to(torch.int32)
+    else:
+        # Float32 represents each INT8 product exactly. Only very long reductions
+        # can round the integer sum, which is preferable to rejecting the shape.
+        accumulated = activation_qdata.float() @ qdata.T.float()
+    result = (
+        accumulated.to(torch.float32)
+        * activation_scale.to(torch.float32)
+        * scale.reshape(1, -1).to(torch.float32)
+    )
+    if bias is not None:
+        result += bias.to(torch.float32)
+    return result.to(activation.dtype).reshape(*original_shape[:-1], qdata.shape[0])

piper_kernels/convrot/_int8/tensor.py

@@ -0,0 +1,150 @@
+"""Tensor subclass representing rotated INT8 W8A8 weights."""
+
+from collections.abc import Callable
+from typing import Any, ClassVar
+
+import torch
+from torchao.utils import TorchAOBaseTensor
+
+from .._rotation import rotate_groups
+from .dispatch import _addmm_, _linear
+from .reference import quantize_weight, validate_storage
+
+
+class ConvRotInt8Tensor(TorchAOBaseTensor):
+    """INT8 rotated weight with per-output scale and logical floating dtype."""
+
+    tensor_data_names: ClassVar[list[str]] = ["qdata", "scale"]
+    tensor_attribute_names: ClassVar[list[str]] = ["group_size", "dtype"]
+
+    def __new__(
+        cls,
+        qdata: torch.Tensor,
+        scale: torch.Tensor,
+        group_size: int,
+        dtype: torch.dtype = torch.bfloat16,
+    ) -> "ConvRotInt8Tensor":
+        validate_storage(qdata, scale, group_size, dtype)
+        return torch.Tensor._make_wrapper_subclass(
+            cls,
+            qdata.shape,
+            device=qdata.device,
+            dtype=dtype,
+            requires_grad=False,
+        )
+
+    def __init__(
+        self,
+        qdata: torch.Tensor,
+        scale: torch.Tensor,
+        group_size: int,
+        dtype: torch.dtype = torch.bfloat16,
+    ) -> None:
+        super().__init__()
+        if self.dtype is not dtype:
+            raise RuntimeError(f"ConvRot wrapper dtype mismatch: {self.dtype} != {dtype}")
+        self.qdata = qdata
+        self.scale = scale
+        self.group_size = group_size
+
+    @classmethod
+    def from_packed(
+        cls,
+        qdata: torch.Tensor,
+        scale: torch.Tensor,
+        *,
+        group_size: int,
+        dtype: torch.dtype = torch.bfloat16,
+    ) -> "ConvRotInt8Tensor":
+        """Normalize serialized INT8 ConvRot storage into its canonical representation."""
+        return cls(
+            qdata.contiguous(),
+            scale.reshape(-1, 1).contiguous(),
+            group_size,
+            dtype,
+        )
+
+    @classmethod
+    def from_hp(
+        cls,
+        hp_tensor: torch.Tensor,
+        *,
+        group_size: int,
+    ) -> "ConvRotInt8Tensor":
+        """Rotate and quantize a high-precision weight into ConvRot INT8 storage."""
+        source = hp_tensor.detach()
+        qdata, scale = quantize_weight(source, group_size)
+        return cls(qdata.contiguous(), scale.contiguous(), group_size, source.dtype)
+
+    def dequantize(self) -> torch.Tensor:
+        """Recover the logical weight in the unrotated basis."""
+        rotated = self.qdata.to(self.dtype) * self.scale.to(self.dtype)
+        return rotate_groups(rotated, self.group_size)
+
+    def _stable_hash_for_caching(self) -> str:
+        """Return a metadata fingerprint for AOTAutograd's cross-process cache."""
+        return repr(
+            (
+                type(self).__qualname__,
+                tuple(self.shape),
+                self.stride(),
+                str(self.device),
+                str(self.dtype),
+                self.group_size,
+                tuple(self.qdata.shape),
+                self.qdata.stride(),
+                tuple(self.scale.shape),
+                self.scale.stride(),
+            )
+        )
+
+
+@ConvRotInt8Tensor.implements(torch.ops.aten.linear.default)
+@ConvRotInt8Tensor.implements_torch_function(torch.nn.functional.linear)
+def _convrot_linear_dispatch(
+    _func: Callable[..., torch.Tensor],
+    _types: tuple[type, ...],
+    args: tuple[Any, ...],
+    _kwargs: dict[str, Any],
+) -> torch.Tensor:
+    activation = args[0]
+    weight = args[1]
+    bias = args[2] if len(args) > 2 else None
+    if not isinstance(activation, torch.Tensor) or not isinstance(weight, ConvRotInt8Tensor):
+        raise TypeError(
+            "ConvRot linear dispatch requires a tensor input and ConvRotInt8Tensor weight"
+        )
+    if bias is not None and not isinstance(bias, torch.Tensor):
+        raise TypeError(f"ConvRot linear bias must be a tensor or None, got {type(bias).__name__}")
+    return _linear(
+        activation,
+        weight.qdata,
+        weight.scale,
+        weight.group_size,
+        bias,
+    )
+
+
+@ConvRotInt8Tensor.implements(torch.ops.aten.addmm_.default)
+def _convrot_addmm_dispatch(
+    _func: Callable[..., torch.Tensor],
+    _types: tuple[type, ...],
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> ConvRotInt8Tensor:
+    weight, mat1, mat2 = args
+    if not isinstance(weight, ConvRotInt8Tensor):
+        raise TypeError(f"ConvRot addmm_ weight must be ConvRotInt8Tensor, got {type(weight)}")
+    if not isinstance(mat1, torch.Tensor) or not isinstance(mat2, torch.Tensor):
+        raise TypeError("ConvRot addmm_ matrices must be tensors")
+    _addmm_(
+        weight.qdata,
+        weight.scale,
+        weight.dtype,
+        weight.group_size,
+        mat1,
+        mat2,
+        beta=kwargs.get("beta", 1),
+        alpha=kwargs.get("alpha", 1),
+    )
+    return weight

piper_kernels/convrot/_rotation.py

@@ -0,0 +1,50 @@
+"""Portable rotation primitives shared by ConvRot storage formats."""
+
+import math
+from functools import cache
+
+import torch
+
+SUPPORTED_GROUP_SIZES = (16, 64, 256)
+
+
+def validate_group_size(group_size: int) -> None:
+    """Validate a regular block-Hadamard group size supported by ConvRot."""
+    if group_size not in SUPPORTED_GROUP_SIZES:
+        supported = ", ".join(map(str, SUPPORTED_GROUP_SIZES))
+        raise ValueError(f"ConvRot group size must be one of {supported}, got {group_size}")
+
+
+@cache
+def build_hadamard(
+    size: int,
+    device: torch.device | None = None,
+    dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+    """Build ConvRot's normalized regular Hadamard matrix in its fixed H4 order."""
+    validate_group_size(size)
+    device = torch.device("cpu") if device is None else device
+    h4 = torch.tensor(
+        ((1, 1, 1, -1), (1, 1, -1, 1), (1, -1, 1, 1), (-1, 1, 1, 1)),
+        device=device,
+        dtype=dtype,
+    )
+    result = h4
+    current_size = 4
+    while current_size < size:
+        result = torch.kron(result, h4)
+        current_size *= 4
+    return result / math.sqrt(size)
+
+
+def rotate_groups(value: torch.Tensor, group_size: int) -> torch.Tensor:
+    """Multiply groups along the final dimension by ConvRot's regular Hadamard."""
+    validate_group_size(group_size)
+    features = value.shape[-1]
+    if features % group_size:
+        raise ValueError(
+            f"ConvRot feature dimension {features} is not divisible by group size {group_size}"
+        )
+    matrix = build_hadamard(group_size, value.device, value.dtype)
+    grouped = value.reshape(-1, features // group_size, group_size)
+    return torch.matmul(grouped, matrix).reshape(value.shape)

piper_kernels-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: piper-kernels
+Version: 0.1.0
+Summary: Reusable PyTorch inference operators and Triton kernels.
+Keywords: inference,pytorch,quantization,triton
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: torch>=2.12
+Requires-Dist: torchao>=0.17 ; extra == 'convrot'
+Requires-Dist: triton>=3.7 ; sys_platform == 'linux' and extra == 'triton'
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/Boffee/piper-kernels
+Project-URL: Repository, https://github.com/Boffee/piper-kernels.git
+Project-URL: Issues, https://github.com/Boffee/piper-kernels/issues
+Project-URL: Changelog, https://github.com/Boffee/piper-kernels/blob/main/CHANGELOG.md
+Provides-Extra: convrot
+Provides-Extra: triton
+Description-Content-Type: text/markdown
+
+# Piper Kernels
+
+Reusable PyTorch inference operators and optimized kernels for the Piper ecosystem and
+other consumers.
+
+Piper Kernels requires Python 3.14 or newer.
+
+The package owns operator semantics, portable PyTorch references, tensor subclasses,
+and optimized backends. It deliberately does not know about model repositories,
+checkpoint metadata, pipeline frameworks, or device-offloading policy.
+
+## Planned operators
+
+| Package | Role |
+|---|---|
+| `piper_kernels.convrot` | ConvRot quantized tensors and linear operators; INT8 today, INT4 planned |
+| `piper_kernels.attention` | Attention operators, including a future SageAttention backend |
+
+## ConvRot INT8
+
+Quantize a dense weight, or wrap existing checkpoint storage without dequantizing it,
+then use the resulting tensor as a normal linear weight:
+
+```python
+import torch
+
+from piper_kernels.convrot import ConvRotInt8Tensor
+
+weight = ConvRotInt8Tensor.from_hp(dense_weight, group_size=64)
+checkpoint_weight = ConvRotInt8Tensor.from_packed(qdata, scale, group_size=64)
+output = torch.nn.functional.linear(activation, weight, bias)
+
+# In-place low-rank update with the standard Tensor.addmm_ contract.
+weight.addmm_(lora_b, lora_a, alpha=lora_strength)
+```
+
+`addmm_` computes `weight = beta * weight + alpha * (mat1 @ mat2)` and requantizes
+the result. It preserves the ConvRot tensor and packed storage identities, allowing
+offload integrations to keep their existing buffers. Repeated updates are lossy, so
+reload a pristine base weight before changing or removing a previously merged adapter.
+This is an inference operation and does not support autograd.
+
+The operator selects its Triton implementation on supported CUDA devices and otherwise
+uses the portable PyTorch reference. Install the tensor format and optimized backend with
+`piper-kernels[convrot,triton]`. The base package does not require TorchAO or Triton, so
+future attention-only consumers do not inherit quantization-specific dependencies.
+
+## Dependency direction
+
+Applications such as Piper consume this package. Integrations such as torch-offload may
+optionally recognize its tensor types, but `piper-kernels` does not depend on either
+project.
+
+## Development
+
+```shell
+uv sync --dev
+uv run pytest
+uv run ruff check .
+uv run pyright
+uv build
+```
+
+GPU tests use the `gpu` pytest marker. The pre-commit test hook hides CUDA so commits run
+the portable suite; run `uv run pytest` directly to exercise installed GPU backends.
+
+## Releases
+
+Releases follow the compatibility and release policy in [VERSIONING.md](VERSIONING.md).
+Distribution artifacts are built from version tags and published to PyPI by GitHub Actions
+using Trusted Publishing; maintainers do not upload releases from local environments.

piper_kernels-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+piper_kernels/__init__.py,sha256=ggMj1e9e0LuF9GUeZnp7PvQaNCGBpIlhxTlOiBwU7W4,66
+piper_kernels/attention/__init__.py,sha256=2k-ybu6cMcnR6QLY5UvPnTYVm_V8ympLOb7nmHnwE5o,37
+piper_kernels/attention/backends/__init__.py,sha256=P4wocoqF6iqnSEItmSTAQmn8hRsB3K-Bkctea7u7twg,59
+piper_kernels/convrot/__init__.py,sha256=ub9XxG2p8GAJsrh5mShJ9dR7hgsBoJGHUsdO_cd1iyo,152
+piper_kernels/convrot/_int8/__init__.py,sha256=uTtxVgR-L8z7FQVNM5EyH5NPiIssrX2pDCMZMKo7bgM,44
+piper_kernels/convrot/_int8/backends/__init__.py,sha256=AEekqIVKK5ymxVwDgHc_Nxh21IiM1naoxlxQaLi8I1M,62
+piper_kernels/convrot/_int8/backends/triton.py,sha256=TZ2sVBb-YjnFeGSBQwcQgGD_Q73LMjjsybni7Q0RFp0,11015
+piper_kernels/convrot/_int8/dispatch.py,sha256=MBdrxW_HMLKiJ6mq0SGRxvNRQeFmb_jAeNpAMqPXerM,6312
+piper_kernels/convrot/_int8/reference.py,sha256=GLBxFlD-vqEvKwZ1B78vN2g0DK_eC9OIlHPyCRX_4T0,5191
+piper_kernels/convrot/_int8/tensor.py,sha256=NSEO2DLpHFjhpwjMKzbOYYCeYuijQ9_9nSyTuzkSKIA,4833
+piper_kernels/convrot/_rotation.py,sha256=8NqN9H4kQBQfDJ4r0P4TBDSjRapY48F5s3h11Bfffbc,1714
+piper_kernels-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+piper_kernels-0.1.0.dist-info/licenses/NOTICE,sha256=7TOge4kGFKahwn-Pzxp3yw3Y64VbKHoovlnRioY2oHQ,129
+piper_kernels-0.1.0.dist-info/WHEEL,sha256=lrO5MD1WVAWzcbNy_L2BwtfPrcM3KfUFpbKYXLkJX4A,80
+piper_kernels-0.1.0.dist-info/METADATA,sha256=5lC8vjSgc8SHHTxEs67S6fcJAnxw32AI8a8-kekQfs8,3800
+piper_kernels-0.1.0.dist-info/RECORD,,

piper_kernels-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.1
+Root-Is-Purelib: true
+Tag: py3-none-any

piper_kernels-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

piper_kernels-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,4 @@
+Piper Kernels
+Copyright 2026 Piper Kernels contributors
+
+This product includes software developed by Piper Kernels contributors.