tools/factory/specs/conformer_conv_module.py

"""Spec for `conformer-conv-module` — the Conformer/Zipformer convolution module, fused end to end."""
import pathlib
import sys

sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from spec import TaskSpec

SPEC = TaskSpec(
    name="conformer-conv-module",
    title="Write a fast fused Conformer convolution-module kernel",
    blurb=("Every speech encoder in production — Conformer, Zipformer, the Whisper-sized ASR models that "
           "replaced the plain transformer block — carries a convolution module next to its attention: "
           "layer-norm, a pointwise projection to 2C with a GLU gate, a wide depthwise convolution along "
           "time, a frozen batch-norm affine, SiLU, a second pointwise projection, and a residual add. It "
           "is two GEMMs with a stencil wedged between them, and eager PyTorch runs it as eight kernels "
           "with a transpose on either side of the depthwise conv."),
    keywords=["mle", "kernel-generation", "audio", "asr", "conformer", "speech", "depthwise-conv", "glu",
              "fused-block", "compute-bound"],
    module="conv_module.py",
    func="conformer_conv_module",
    signature="conformer_conv_module(x, ln_w, ln_b, w1, b1, dw, bn_w, bn_b, w2, b2, eps=1e-5)",
    returns_doc="""The Conformer convolution module, including its residual connection.

Args:
    x:            (B, T, C)  bfloat16 — encoder hidden states, time-major inside a batch entry.
    ln_w, ln_b:   (C,)       float32  — LayerNorm affine.
    w1:           (2C, C)    bfloat16 — pointwise projection to the GLU pair.
    b1:           (2C,)      bfloat16 — its bias.
    dw:           (C, K)     bfloat16 — depthwise convolution taps, K odd.
    bn_w, bn_b:   (C,)       float32  — folded batch-norm scale and shift.
    w2:           (C, C)     bfloat16 — output pointwise projection.
    b2:           (C,)       bfloat16 — its bias.
    eps:          float               — LayerNorm epsilon, default 1e-5.

Returns:
    y: (B, T, C) bfloat16.""",

    reference_imports="import torch\nimport torch.nn.functional as F",
    reference_src='''
def conformer_conv_module(x, ln_w, ln_b, w1, b1, dw, bn_w, bn_b, w2, b2, eps=1e-5):
    """The module written out as eight separate fp32 ops.

    Correct and simple — it is the numerical SPECIFICATION, not a performance target.
    """
    B, T, C = x.shape
    K = dw.shape[-1]
    xf = x.float()

    h = F.layer_norm(xf, (C,), ln_w.float(), ln_b.float(), eps)
    h = h @ w1.float().t() + b1.float()                                  # (B, T, 2C)
    a, g = h.chunk(2, dim=-1)
    h = a * torch.sigmoid(g)                                             # GLU

    h = h.transpose(1, 2)                                                # (B, C, T)
    h = F.conv1d(h, dw.float().unsqueeze(1), None, padding=(K - 1) // 2, groups=C)
    h = h * bn_w.float().view(1, C, 1) + bn_b.float().view(1, C, 1)
    h = h * torch.sigmoid(h)                                             # SiLU
    h = h.transpose(1, 2)                                                # (B, T, C)

    h = h @ w2.float().t() + b2.float()
    return (xf + h).to(x.dtype)
''',
    make_inputs_src='''
def _mk(B, T, C, K, seed):
    gen = torch.Generator(device="cuda").manual_seed(seed)
    x = torch.randn(B, T, C, device="cuda", dtype=torch.bfloat16, generator=gen)
    ln_w = (1 + 0.05 * torch.randn(C, device="cuda", generator=gen)).float()
    ln_b = (0.02 * torch.randn(C, device="cuda", generator=gen)).float()
    w1 = (torch.randn(2 * C, C, device="cuda", generator=gen) * C ** -0.5).to(torch.bfloat16)
    b1 = (0.02 * torch.randn(2 * C, device="cuda", generator=gen)).to(torch.bfloat16)
    dw = (torch.randn(C, K, device="cuda", generator=gen) * K ** -0.5).to(torch.bfloat16)
    bn_w = (1 + 0.05 * torch.randn(C, device="cuda", generator=gen)).float()
    bn_b = (0.02 * torch.randn(C, device="cuda", generator=gen)).float()
    w2 = (torch.randn(C, C, device="cuda", generator=gen) * C ** -0.5).to(torch.bfloat16)
    b2 = (0.02 * torch.randn(C, device="cuda", generator=gen)).to(torch.bfloat16)
    return x, ln_w, ln_b, w1, b1, dw, bn_w, bn_b, w2, b2, 1e-5
''',
    flops_src='''
def canonical_work(B, T, C, K):
    """FLOPs of the three contractions, from the SHAPE ALONE.

    Pointwise 1: (B*T, C) x (C, 2C) = 2*B*T*C*2C. Depthwise: K taps per (time, channel) = 2*B*T*C*K.
    Pointwise 2: (B*T, C) x (C, C) = 2*B*T*C*C. The LayerNorm, the GLU, the batch-norm affine, the SiLU and
    the residual add are all O(B*T*C) elementwise and are not counted -- they are the fusion opportunity,
    not the work. Compute-bound: the score is achieved TFLOP/s against this fixed count.
    """
    return 2 * B * T * C * (3 * C + K)
''',
    flops_formula="2 * B * T * C * (3*C + K)",

    metric="TFLOP/s",
    compare="tensor",
    tol=2e-2,
    shape_names=("B", "T", "C", "K"),
    grader_shapes=[(48, 1500, 1024, 31), (32, 3000, 1024, 31), (64, 1500, 768, 31),
                   (40, 2000, 1024, 31), (96, 1500, 640, 31)],
    measure_shapes=[(40, 1500, 1024, 31), (28, 3000, 1024, 31), (56, 1500, 768, 31),
                    (32, 2000, 1024, 31), (80, 1500, 640, 31)],
    measure_quick_shapes=[(8, 1500, 1024, 31), (4, 1000, 768, 31), (16, 500, 640, 31)],
    correct_shapes=[(2, 137, 256, 15), (3, 64, 128, 7), (1, 1500, 1024, 31), (5, 33, 192, 31)],

    spec_md="""One block, seven stages, one residual:

```
h = layer_norm(x, eps) * ln_w + ln_b                       # over the C axis, per (b, t)
h = h @ w1^T + b1                                          # (B, T, 2C)
a, g = h[..., :C], h[..., C:]
h = a * sigmoid(g)                                         # GLU: first half gated by the second

h[b, c, t] = sum_k dw[c, k] * h[b, c, t + k - (K-1)//2]     # depthwise, zero-padded, non-causal
h = h * bn_w + bn_b                                        # per channel
h = h * sigmoid(h)                                         # SiLU

h = h @ w2^T + b2                                          # (B, T, C)
y = x + h
```

Note the details that a re-implementation gets wrong:

* The **GLU split is contiguous, not interleaved**: rows `0..C-1` of `w1` produce the value half and rows
  `C..2C-1` produce the gate half. That is `torch.chunk(h, 2, dim=-1)`, not a stride-2 view. Reading it as
  interleaved pairs is a **0.39** relative error and swapping the two halves is **0.37**.
* The depthwise convolution is **non-causal and symmetric**: `padding = (K-1)//2` with `K` odd, so the
  output length equals `T` and tap `k` reaches `k - (K-1)//2` samples away. It is zero-padded at both ends,
  and it runs over the **time** axis with one independent filter per channel. Padding it causally instead
  (`K-1` on the left, none on the right) is a **0.39** relative error.
* The batch-norm is already **folded into an affine** — `bn_w` and `bn_b` are the inference-time scale and
  shift, there are no running statistics to compute and nothing is reduced over the batch.
* The LayerNorm is over the **`C` axis only**, with the biased (`1/C`) variance, and the residual is added to
  the **original** `x`, not to the normalised one.

`/app/reference.py` runs all of it in fp32 as eight separate ops, with two transposes around the depthwise
convolution. That is the numerical specification, not a performance target.""",

    contract_md="""| arg | shape | dtype | meaning |
|-----|-------|-------|---------|
| `x` | `(B, T, C)` | `bfloat16` | hidden states, contiguous |
| `ln_w`, `ln_b` | `(C,)` | `float32` | LayerNorm affine |
| `w1` | `(2C, C)` | `bfloat16` | pointwise projection, **row-major, out-features first** |
| `b1` | `(2C,)` | `bfloat16` | bias for `w1` |
| `dw` | `(C, K)` | `bfloat16` | depthwise taps, one filter per channel |
| `bn_w`, `bn_b` | `(C,)` | `float32` | folded batch-norm affine |
| `w2` | `(C, C)` | `bfloat16` | output projection, same layout as `w1` |
| `b2` | `(C,)` | `bfloat16` | bias for `w2` |
| `eps` | — | `float` | LayerNorm epsilon, `1e-5` in every graded call |

Both projections are applied as `h @ W^T`, i.e. `W` is stored the way `nn.Linear` stores it.

**Return** a single tensor `y` of shape `(B, T, C)` and dtype **bfloat16**.

All inputs are **read-only**; nothing is updated in place. `K` is **odd** (31 in every graded shape; 7 and 15
appear in the correctness shapes) and may exceed `T` — `(5, 33, 192, 31)` is a correctness shape, where the
zero padding covers most of the receptive field. `T` is ragged (`33`, `64`, `137`) and is never a multiple of
a tile size.""",

    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `C` 640–1024
(Conformer-large is 512–1024 wide), `K = 31` — the standard Conformer depthwise kernel — `T` 1500–3000
frames, which at a 40 ms subsampled frame rate is one to two minutes of audio, and `B` 32–96 utterances per
batch. Every graded shape is **295–610 GFLOP**. A 17-layer encoder runs this block once per layer, so it is
a few percent of every ASR forward and it is entirely fusable.""",

    correctness_md="""`y` must match the reference (evaluated in fp32) within **relative Frobenius error
`2e-2`** at every graded shape, including the timed ones.""",

    perf_md="""Two GEMMs — `(B*T, C) x (C, 2C)` and `(B*T, C) x (C, C)` — with a depthwise stencil, a GLU, an
affine and a SiLU between them. At the graded sizes `B*T` is 48k–96k rows, so both GEMMs are large and
tensor-core bound; everything else is elementwise and should cost nothing.

In the reference it costs a great deal. There are **six** full-size `(B, T, C)` or `(B, T, 2C)` fp32
temporaries — the normalised input, the projection output at 2C, the GLU result, the conv output, the affine
output, the SiLU output — plus **two transposes** to get `(B, T, C)` into the `(B, C, T)` layout `F.conv1d`
demands and back. At `B=32, T=3000, C=1024` the 2C temporary alone is 786 MB. And all of it runs in fp32, at
a quarter of the bf16 tensor-core rate.

The kernel to write keeps a tile of `(rows of B*T) x C` resident and pushes it through the whole chain:

* **Fuse the LayerNorm into the first GEMM's prologue.** It is a row-wise reduction over `C`, and the GEMM
  wants that row in shared memory anyway.
* **Fuse the GLU into the first GEMM's epilogue.** Compute both halves of the `2C` output in the same tile —
  they share the same A operand — and emit `a * sigmoid(g)` directly, so the `2C`-wide tensor never exists.
* **Do not transpose for the depthwise conv.** The stencil is along `T` with an independent filter per
  channel, so a tile that owns `T_tile` consecutive frames of `C_tile` channels needs a halo of `(K-1)/2 = 15`
  frames on each side and nothing else. Loading a haloed tile is far cheaper than materialising a transposed
  copy of the whole tensor, and the halo can be re-read from the GLU output in shared memory if the tile is
  large enough along `T`.
* **Fuse the affine, the SiLU and the second GEMM's prologue**, and fold the residual `+ x` into that GEMM's
  epilogue — `x` is already the tile you started from.

`K = 31` is wide enough that the depthwise conv is not free: it is `2*B*T*C*K` FLOPs (about 1% of the total
here) but its access pattern, if you get it wrong, costs far more than its arithmetic. The two natural
schedules are a haloed shared-memory tile along `T`, or holding `K` running registers per channel and
sliding — the second wins when `C_tile` is small.

The weights are small — `w1` is at most `2*1024*1024` bf16 = 4 MB and `w2` half that — so they stay in L2
across the whole grid.""",

    precision_md="""`x`, both projection weights, their biases and the depthwise taps are **bfloat16**; the
LayerNorm and batch-norm affines are **float32**; the output is **bfloat16**.

Do the LayerNorm reduction, the GLU sigmoid, the depthwise accumulation, the affine, the SiLU and both GEMM
accumulations in **fp32**. The GEMM `k` dimension is only `C` (640–1024), which is comfortably inside the
gate with fp32 accumulation of bf16 products.

The tolerance was measured against an independent implementation that runs both projections as bf16 matmuls
with fp32 accumulation, computes the LayerNorm statistics explicitly instead of calling `F.layer_norm`, and
evaluates the depthwise convolution as an `unfold` + `einsum` rather than `F.conv1d` — a different reduction
order at every stage. The observed relative Frobenius error against the fp32 reference was **1.9e-3**,
stable across `C` 256–1024, `T` 137–3000 and `K` 15–31. The `2e-2` gate is ~10x that.

For scale, the drop-the-feature checks all land 17–20x above the gate: dropping the GLU gate entirely
(passing the first half through unchanged) is **0.34**, swapping the value and gate halves is **0.37**,
reading the `2C` projection as interleaved pairs is **0.39**, and padding the depthwise convolution causally
is **0.39**. Every structural detail above is genuinely graded.

**fp8 is not acceptable here**: the contract fixes the output at bf16, and the SiLU sits directly on the
depthwise output whose per-channel scale varies by more than an e4m3 mantissa can absorb.""",
).validate()