tasks/cpu-decoder-graph-executor/instruction.md

A faster executor for transformer-decoder compute graphs

/app/reference_executor.py runs transformer-decoder compute graphs on CPU. Write an executor that computes the same thing faster.

Submission format

• Deliverable: /app/output/executor.py, plus any helper modules placed beside it in /app/output/.
• Only /app/output/ is collected and graded. Everything else under /app is reference material. Grading happens in a separate environment, so your submission must be self-contained inside /app/output/. Other paths, running processes, and environment state do not carry over.
• It must expose exactly one entry point:

build_executor(graph_spec: dict,
               weights: dict[str, numpy.ndarray],
               n_workers: int) -> Callable[[numpy.ndarray], numpy.ndarray]

• The returned callable takes x of shape (T, d_model), dtype float32, and returns the final hidden states of shape (T, d_model), dtype float32.
• It will be called many times with different inputs but the same weights.

Data notes

• graph_spec describes a decoder stack. It contains n_layers, d_model, d_ff, n_heads, n_kv_heads, head_dim, T, rms_eps, a per-layer list of nodes, and a final node. Each node has an operation, named inputs, an output name, and a weight name.
• weights maps every weight name in the spec to a C-contiguous float32 array, plus rope_cos, rope_sin and attn_mask.
• n_workers is 8.

/app/reference_executor.py defines what a correct forward pass is: its module docstring states the semantics of every node type, and its code is the tie-breaker if anything is ambiguous. Read it. /app/graph_spec.py builds instances and their weights from an integer seed.

Correctness

For every call, output y is compared against the reference's y_ref on the same input. Both bounds must hold:

$$\max (\mathrm{\mid }y-y_{ref}\mathrm{\mid })\le {10}^{-3}\backslash max(|y\; -\; y\_\{ref\}|)\; \backslash le\; 10^\{-3\}$$

$$\frac{\parallel y-y_{ref}{\parallel }_F}{\parallel y_{ref}{\parallel }_F}\le {10}^{-3}\backslash frac\{\backslash lVert\; y\; -\; y\_\{ref\}\; \backslash rVert\_F\}\{\backslash lVert\; y\_\{ref\}\; \backslash rVert\_F\}\; \backslash le\; 10^\{-3\}$$

• Reassociating a reduction (changing accumulation order) is fine; dropping work is not.
• A single instance that violates either bound scores the whole submission 0.

How you are measured

• Your executor and the reference are built for the same instance in two separate processes, then timed head to head.
• The two are called alternately with a fresh input each repetition. Whichever one isn't being called is suspended so it can't consume cycles, and which one goes first alternates between repetitions.
• 3 warmup repetitions are discarded.
• Instance time = fastest of 15 timed repetitions.
• Instance speedup = reference_time / your_time.
• Score = geometric mean of the per-instance speedups over a sealed set of instances, built from seeds you've never seen, drawn from the ranges below.
• Maximize this geometric-mean speedup on the sealed set. An executor that just delegates to the reference scores zero; any larger speedup scores higher, with no ceiling where further improvement stops counting.

The sealed instances use the same generator and ranges as the public ones:

d_model	192, 256 or 384
d_ff / d_model	2.6875 or 4.0, rounded to a multiple of 32
n_layers	16 or 32
n_heads	4 or 8, head_dim = d_model // n_heads
n_kv_heads	n_heads, n_heads // 2 or n_heads // 4
T	1, 8 or 32, with 1 drawn half the time

Budget and environment

• build_executor must return within 20 seconds per instance. Each call to the returned callable must finish within 120 seconds. Time spent in build_executor is not included in the runtime metric.
• The container has 8 CPUs, 14 GiB of memory, 0 GPUs and no network. Each executor process is pinned to 8 CPUs and starts with OPENBLAS_NUM_THREADS=OMP_NUM_THREADS=MKL_NUM_THREADS=NUMEXPR_NUM_THREADS=8. The only third-party Python packages installed are numpy and threadpoolctl.
• Threads are yours to use, and so are helper processes, but the harness suspends your whole process tree whenever the reference is on the clock, and a process that detaches from that tree stays suspended for good.

Developing

python3 /app/bench.py measures whatever is in /app/output/ against the reference on the 16 public instances (seeds 0-15). It uses the same protocol, tolerances, and worker budget as the sealed run. It prints per-instance times, ratios, equivalence errors, and the geometric mean. python3 /app/bench.py --seeds 0,4,9 restricts it to those seeds. Public instances are for development only; nothing about them is graded.

A submission scores 0 if any of the following holds:

• /app/output/executor.py is missing.
• It fails to import.
• It has the wrong signature.
• It raises.
• It exceeds a budget.
• It returns the wrong shape or dtype.
• It returns values that are not finite.
• It violates either equivalence bound on any instance.