Datasets:

Genghan
/

NKIBench

+---
+license: apache-2.0
+language:
+- en
+tags:
+- nki
+- aws-neuron
+- trainium
+- inferentia
+- kernel
+- gpu-kernel
+- benchmark
+- code
+pretty_name: NKIBench
+size_categories:
+- n<1K
+---
+# NKIBench
+NKIBench is a benchmark of AWS [Neuron Kernel Interface (NKI)](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/nki/index.html) kernels paired with NumPy reference implementations. Each task provides a specification, a ground-truth NumPy forward pass, and an optimized NKI kernel targeting AWS Trainium / Inferentia devices, together with tooling to compile, check numerical correctness, and measure on-device latency.
+## Dataset structure
+```
+NKIBench/
+├── seeds/               # YAML task specifications (shape-agnostic templates)
+├── reference/           # NumPy reference implementations with concrete shapes
+├── kernels/             # Optimized NKI kernels (one per case)
+├── summary.json         # Index mapping task → case → {seed, reference, kernel}
+└── kernel_wrapper.py    # Profiler: compile, correctness check, latency benchmark
+```
+### `summary.json`
+The canonical index. Each entry maps a task name to one or more parameter cases and the files that implement them:
+```json
+{
+  "matmul": {
+    "seed": "./seeds/matmul.yaml",
+    "cases": {
+      "3": {
+        "values": {"K": 5120, "M": 4096, "N": 12288},
+        "impls": [{
+          "task":   "./reference/matmul_M4096_N12288_K5120_numpy_2.py",
+          "kernel": "./kernels/matmul_M4096_N12288_K5120_0.py"
+        }]
+      }
+    }
+  }
+}
+```
+### `seeds/*.yaml`
+A shape-agnostic specification: the task name, its symbolic parameters, an input generator, and a NumPy `forward` implementation.
+```yaml
+test_name: matmul
+parameters: [M, N, K]
+input: |
+  lhs = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  rhs = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  return [lhs, rhs]
+impl: |
+  def forward(lhs, rhs):
+    return np.matmul(lhs, rhs)
+```
+### `reference/*.py`
+A shape-concrete NumPy reference. Exposes:
+- `get_inputs()` — produces randomized numpy input tensors.
+- `forward(*inputs)` — ground-truth computation.
+- `transform_to_nki_inputs(inputs)` — reshapes numpy inputs into the tile layout the NKI kernel expects.
+- `transform_nki_outputs(k_res, ref)` — reshapes kernel outputs back to reference layout.
+### `kernels/*.py`
+Optimized NKI kernels using `neuronxcc.nki`. Each file defines a `kernel` (or `optimized_kernel`) function decorated with `@nki.jit`, written against tiled SBUF/PSUM/HBM memory on AWS Neuron hardware.
+## Task list
+| Task | Category | Parameters (one sample case) |
+|---|---|---|
+| `matmul` | GEMM | M=4096, N=12288, K=5120 |
+| `transpose_matmul` | GEMM | M=4096, K=2048, N=10944 |
+| `bmm` | Batched GEMM | B=16, M=4096, K=64, N=4096 |
+| `bmm_softmax` | Fused attention block | B=16, K=64, M=4096, N=4096 |
+| `rmsnorm_matmul` | Fused norm + GEMM | M=4096, N=2048, K=1024 |
+| `matmul_add_rmsnorm` | Fused GEMM + residual + norm | M=4096, N=2048, K=2048 |
+| `add_rmsnorm_matmul` | Fused residual + norm + GEMM | M=4096, N=2048, K=1024 |
+| `swiglu` | Activation | M=4096, N=3072, K=1024 |
+| `silu` | Activation | M=4096, N=7168 |
+| `gqa_full` | Grouped-query attention | B=1, N=4096, QH=16, KH=8, D=128 |
+| `rope_single_freq_apply` | Rotary position embedding | B=1, H=64, N=4096, D=128 |
+| `lora` | LoRA low-rank update | M=4096, N=12288, K=5120, R=128 |
+| `adamw` | Optimizer step | M=10944, N=2048 |
+| `mamba` | Mamba SSM block | M=7168, C=256, S=16 |
+## Usage
+```bash
+# Clone the dataset
+hf download Genghan/NKIBench --repo-type dataset --local-dir NKIBench
+cd NKIBench
+```
+```python
+# Profile one kernel on an AWS Neuron-enabled instance (e.g. trn1 / inf2).
+# Requires: neuronx-cc, neuronx-runtime, and the `neuron-profile` CLI.
+import json
+from kernel_wrapper import NKIKernel
+summary = json.load(open("summary.json"))
+case = summary["matmul"]["cases"]["3"]["impls"][0]
+k = NKIKernel(program_path=case["kernel"], base_numpy_path=case["task"])
+result = k.profile(save_fields=["mac_count"])
+print("compiled:", result.compiled)
+print("correct :", result.correct)
+print("latency :", result.metadata.get("latency"), "ms")
+```
+`NKIKernel.profile()` compiles the kernel, validates numerical correctness against the NumPy reference over multiple random seeds (L2-norm relative tolerance `2e-5`), and benchmarks latency via `neuron-profile`. `float16` inside a kernel is rejected to avoid silent precision loss.
+## Hardware requirements
+Running the kernels requires AWS Neuron hardware (Trainium / Inferentia2). The NumPy references in `reference/` and the YAML seeds are portable and can be inspected or extended anywhere.
+## Intended uses
+- Evaluating code generation / kernel synthesis systems on AWS NKI.
+- Studying handwritten-vs-generated kernel performance.
+- Training/fine-tuning models to produce NKI code, using the seed + reference pair as the task specification.
+## Citation
+If you use NKIBench in your work, please cite the repository.
+```bibtex
+@misc{nkibench,
+  title  = {NKIBench: A Benchmark of AWS NKI Kernels},
+  author = {Gong, Genghan},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/Genghan/NKIBench}
+}
+```

kernel_wrapper.py ADDED Viewed

	@@ -0,0 +1,233 @@

+import json, uuid, time, tempfile
+import os
+import traceback
+import numpy as np
+import sys
+import re
+from pathlib import Path
+from pydantic import BaseModel, Field
+class KernelProperties(BaseModel):
+    """
+    Single Kernel Execution
+    """
+    compiled: bool = False
+    correct: bool = False
+    runnable: bool = False
+    metadata: dict = Field(default_factory=dict)
+# Function to load module from file path
+def load_module_from_path(file_path):
+    parent_dir = str(Path(file_path).parent)
+    if parent_dir not in sys.path:
+        sys.path.append(parent_dir)
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("module", file_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load module from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+def l2norm_allclose(v_k, v_r, rel_tol=1e-5):
+    return np.linalg.norm((v_k - v_r).astype(np.float64)) < rel_tol * np.linalg.norm(v_r.astype(np.float64))
+def check_correctness_numpy(output_nki, output_task, res, rel_tol=2e-5):
+    # output_nki is a list
+    # output_task is a tuple or a single array
+    if not isinstance(output_task, tuple):
+        output_task_tuple = (output_task,)
+    else:
+        output_task_tuple = output_task
+    is_correct = True
+    if len(output_nki) != len(output_task_tuple):
+        res.metadata.setdefault("correctness_error", []).append(
+            f"Num outputs mismatch: nki={len(output_nki)} vs ref={len(output_task_tuple)}"
+        )
+        res.correct = False
+        return
+    for i, (v_k, v_r) in enumerate(zip(output_nki, output_task_tuple)):
+        if hasattr(v_r, "shape") and hasattr(v_k, "shape"):
+            if v_k.shape != v_r.shape:
+                res.metadata.setdefault("correctness_error", []).append(f"Output {i} shape mismatch, expected {v_r.shape}, got {v_k.shape}; ")
+                is_correct = False
+            if not l2norm_allclose(v_k, v_r, rel_tol=rel_tol):
+                max_diff = np.amax(np.abs(v_k - v_r))
+                avg_diff = np.mean(np.abs(v_k - v_r))
+                max_rel_diff = np.amax(np.abs(v_k - v_r) / np.abs(v_r))
+                l2norm_diff = np.linalg.norm((v_k - v_r).astype(np.float64))
+                l2norm_ref = np.linalg.norm(v_r.astype(np.float64))
+                l2norm_rel_diff = l2norm_diff / l2norm_ref
+                res.metadata.setdefault("correctness_error", []).append(f"Output {i} value mismatch, max diff {max_diff:.6f}, avg diff {avg_diff:.6f}, max rel diff {max_rel_diff:.6f}, l2norm diff {l2norm_diff:.6f}, l2norm ref {l2norm_ref:.6f}, l2norm rel diff {l2norm_rel_diff:.6f}")
+                is_correct = False
+        else:
+            # abs_diff = np.abs(v_k - v_r)
+            if np.issubdtype(type(v_r), np.floating) or np.issubdtype(type(v_k), np.floating):
+                if not l2norm_allclose(v_k, v_r, rel_tol=rel_tol):
+                    res.metadata.setdefault("correctness_error", []).append(f"Output {i} value mismatch, expected {v_r}, got {v_k};")
+                    is_correct = False
+            else:
+                if v_k != v_r:
+                    res.metadata.setdefault("correctness_error", []).append(f"Output {i} value mismatch, expected {v_r}, got {v_k}; ")
+                    is_correct = False
+    res.correct = is_correct
+def check_precision_and_correctness(program_path, output_nki, output_task, res, rel_tol):
+    with open(program_path, 'r') as f:
+        program_code = f.read()
+    # Remove all the comments
+    program_code = re.sub(r'#.*', '', program_code)
+    # If "bfloat16" or "float16" is used
+    if "float16" in program_code:
+        res.metadata["correctness_error"] = "Float16 is used in the program."
+        res.correct = False
+        return
+    check_correctness_numpy(output_nki, output_task, res, rel_tol=rel_tol)
+import neuronxcc.nki as nki
+def get_latency(nki_kernel_fn, nki_inputs, artifact_dir):
+    kernel_id = uuid.uuid4()
+    neff_path = os.path.join(artifact_dir, f"neff_{kernel_id}.neff")
+    ntff_path = os.path.join(artifact_dir, f"ntff_{kernel_id}.ntff")
+    nki.baremetal(
+        nki_kernel_fn,
+        save_neff_name=neff_path,
+        save_trace_name=ntff_path,
+        additional_compile_opt="--disable-dge --logical-nc-config=1"
+    )(*nki_inputs)
+    summary_profile_path = os.path.join(artifact_dir, f"profile_{kernel_id}.json")
+    summary_profile_cmd = f"neuron-profile view --output-format summary-json -n {neff_path} -s {ntff_path} > {summary_profile_path}"
+    os.system(summary_profile_cmd)
+    summary = json.load(open(summary_profile_path, 'r'))
+    latency_ms = summary[next(iter(summary))]["total_time"] * 1e3
+    return latency_ms
+def benchmark_latency(warmpup_iterations, benchmark_iterations, nki_kernel_fn, nki_inputs, artifact_dir):
+    for _ in range(warmpup_iterations):
+        nki.baremetal(
+            nki_kernel_fn,
+            additional_compile_opt="--disable-dge --logical-nc-config=1"
+        )(*nki_inputs)
+    latency_ms_list = []
+    for _ in range(benchmark_iterations):
+        latency_ms = get_latency(nki_kernel_fn, nki_inputs, artifact_dir)
+        latency_ms_list.append(latency_ms)
+    runtime_stats = {
+        "mean_ms": np.mean(latency_ms_list),
+        "min_ms": np.min(latency_ms_list),
+        "max_ms": np.max(latency_ms_list),
+        "rel_diffs": (np.max(latency_ms_list) - np.min(latency_ms_list)) / np.min(latency_ms_list)
+    }
+    return runtime_stats
+class NKIKernel:
+    def __init__(self, program_path: str, base_numpy_path: str):
+        self.program_path = program_path
+        self.base_numpy_path = base_numpy_path
+        self.res = KernelProperties()
+        self.rel_tol = 2e-5
+        self.perf_tol = 0.01
+    def profile(self, save_fields: list[str] = []):
+        os.environ["NEURON_CC_FLAGS"] = "--auto-cast=none"
+        os.environ['NEURON_RT_NUM_CORES']= '1'
+        np.random.seed(42)
+        task_module = load_module_from_path(self.base_numpy_path)
+        task_fn = task_module.forward
+        task_np_input_fn = task_module.get_inputs
+        task_np_inputs = task_np_input_fn()
+        task_nki_output_fn = task_module.transform_nki_outputs
+        self.res = KernelProperties()
+        new_profile_name = f"nki_{uuid.uuid4()}"
+        with tempfile.TemporaryDirectory(dir="/tmp", prefix=f"{new_profile_name}_") as artifact_dir:
+            neff_path = os.path.join(artifact_dir, f"kernel_file.neff")
+            ntff_path = os.path.join(artifact_dir, f"kernel_profile.ntff")
+            try:
+                nki_kernel_module = load_module_from_path(self.program_path)
+                if hasattr(nki_kernel_module, "kernel"):
+                    nki_kernel_fn = nki_kernel_module.kernel
+                elif hasattr(nki_kernel_module, "optimized_kernel"):
+                    nki_kernel_fn = nki_kernel_module.optimized_kernel
+                else:
+                    raise ValueError(f"No kernel function found in {self.program_path}")
+                # Get the transform_to_nki_inputs function
+                if hasattr(task_module, "transform_to_nki_inputs"):
+                    task_nki_input_fn = task_module.transform_to_nki_inputs
+                else:
+                    raise ValueError(f"No transform_to_nki_inputs function found in {self.program_path} or {self.base_numpy_path}")
+                nki_inputs = task_nki_input_fn(task_np_inputs)
+                output_nki = nki.baremetal(
+                    nki_kernel_fn,
+                    save_neff_name=neff_path,
+                    save_trace_name=ntff_path,
+                    additional_compile_opt="--disable-dge --logical-nc-config=1"
+                )(*nki_inputs)
+                self.res.compiled = True
+                self.res.runnable = True
+            except Exception as e:
+                print(f"Compilation failure. Error: {e}")
+                self.res.metadata["compilation_error"] = str(e)
+                self.res.metadata["compilation_traceback"] = traceback.format_exc()
+                return self.res
+            try:
+                for rnd_seed in [0, 21, 42, 63, 84]:
+                    np.random.seed(rnd_seed)
+                    task_np_inputs = task_np_input_fn()
+                    nki_inputs = task_nki_input_fn(task_np_inputs)
+                    output_task = task_fn(*task_np_inputs)
+                    output_nki_raw = nki.baremetal(
+                        nki_kernel_fn,
+                        additional_compile_opt="--disable-dge --logical-nc-config=1"
+                    )(*nki_inputs)
+                    output_nki = task_nki_output_fn(output_nki_raw, output_task)
+                    check_precision_and_correctness(self.program_path, output_nki, output_task, self.res, self.rel_tol)
+                    if not self.res.correct:
+                        break
+            except Exception as e:
+                print(f"Correct checking failure. Error: {e}")
+                self.res.metadata["correctness_error"] = str(e)
+                return self.res
+            if not self.res.correct:
+                return self.res
+            try:
+                runtime_stats = benchmark_latency(2, 10, nki_kernel_fn, nki_inputs, artifact_dir)
+                rel_diff = runtime_stats["rel_diffs"]
+                rel_diff_list = [rel_diff]
+                runtime_stats_list = [runtime_stats]
+                while rel_diff > self.perf_tol:
+                    print(f"Retry: {self.program_path } at {len(rel_diff_list)}; rel_diffs: {rel_diff_list}")
+                    time.sleep(1)
+                    rel_diff_list.append(rel_diff)
+                    runtime_stats_list.append(runtime_stats)
+                    if len(rel_diff_list) > 2: # Just retry twice. In paper, we did 10 times.
+                        break
+                runtime_stats = runtime_stats_list[np.argmin(rel_diff_list)]
+                self.res.metadata["latency"] = runtime_stats["mean_ms"]
+                self.res.metadata["min_ms"] = runtime_stats["min_ms"]
+                self.res.metadata["max_ms"] = runtime_stats["max_ms"]
+                self.res.metadata["rel_diffs"] = runtime_stats["rel_diffs"]
+                summary_profile_path = os.path.join(artifact_dir, f"{new_profile_name}_summary_profile.json")
+                summary_profile_cmd = f"neuron-profile view --output-format summary-json -n {neff_path} -s {ntff_path} > {summary_profile_path}"
+                os.system(summary_profile_cmd)
+                summary = json.load(open(summary_profile_path, 'r'))
+                profile_result = summary[next(iter(summary))]
+                for field in save_fields:
+                    if field in profile_result.keys():
+                        self.res.metadata[field] = profile_result[field]
+            except Exception as e:
+                print(f"Benchmarking failure. Error: {e}")
+                self.res.metadata["benchmarking_error"] = traceback.format_exc()
+                return self.res
+            return self.res

kernels/adamw_M10944_N2048_0.py ADDED Viewed

	@@ -0,0 +1,66 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2, v3, v4):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v5 = nl.ndarray((10944, 2048), dtype=np.float32, buffer=nl.shared_hbm)
+    v6 = nl.ndarray((nl.par_dim(128), 1), dtype=np.float32, name='memset.643', buffer=nl.sbuf)
+    v7 = nl.ndarray((86, 2, nl.par_dim(128), 1024), dtype=np.float32, name='theta_local_608', buffer=nl.sbuf)
+    v8 = nl.ndarray((86, 2, nl.par_dim(128), 1024), dtype=np.float32, name='m_local_602', buffer=nl.sbuf)
+    v9 = nl.ndarray((86, 2, nl.par_dim(128), 1024), dtype=np.float32, name='v_local_596', buffer=nl.sbuf)
+    v10 = nl.ndarray((86, 2, nl.par_dim(128), 1024), dtype=np.float32, name='g_local_590', buffer=nl.sbuf)
+    v11 = nl.ndarray((86, 2, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v12 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v13 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v14 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v15 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v16 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v17 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v18 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v19 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v20 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v21 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v22 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v23 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v24 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v25 = nl.ndarray((86, 2, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v6[nl.arange(128)[:, None], 0] = nisa.memset(shape=(128, 1), value=np.dtype(np.uint16).type(0), dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+    for i0 in nl.affine_range(86):
+        for i1 in nl.affine_range(2):
+            v7[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v1[128 * i0 + nl.arange(128)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0)
+            v8[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v3[128 * i0 + nl.arange(128)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0)
+            v9[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v4[128 * i0 + nl.arange(128)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0)
+            v10[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[128 * i0 + nl.arange(128)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0)
+            for i2 in nl.affine_range(2):
+                v12[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v7[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(1e-05), reverse0=True, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v13[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.subtract(v7[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], v12[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v14[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v8[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.9), reverse0=True, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v15[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v10[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.1), reverse0=True, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v16[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.add(v14[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], v15[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v17[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v16[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.01), reverse0=True, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v18[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v9[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.999), reverse0=True, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v19[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v10[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.001), reverse0=True, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v20[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.multiply(v19[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], v10[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v21[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.add(v18[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], v20[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v22[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.activation(op=nl.sqrt, data=v21[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], bias=v6[nl.arange(128)[:, None], 0], scale=1000.0, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v23[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v22[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.add, operand0=np.dtype(np.float32).type(1e-08), reverse0=False, dtype=np.float32, mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, engine=nki.isa.unknown_engine)
+                v24[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.reciprocal(data=v23[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v25[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.multiply(v17[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], v24[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                v11[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]] = nl.subtract(v13[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], v25[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0, dtype=np.float32)
+                ' end loop i2 '
+            nl.store(v5[128 * i0 + nl.arange(128)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], value=v11[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=-128 * i0 + -1 * nl.arange(128)[:, None] + 10943 >= 0)
+            ' end loop i1 '
+        ' end loop i0 '
+    return v5

kernels/add_rmsnorm_matmul_M4096_N2048_K1024_0.py ADDED Viewed

	@@ -0,0 +1,80 @@

+import math
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+@nki.jit
+def kernel(x_tensor, w_tensor, eps, z_tensor, g_tensor):
+  # Specialized for M=4096, N=2048, K=1024
+  M, K, N = 4096, 1024, 2048
+  # Verify input shapes match our specialization
+  assert x_tensor.shape == (M, K)
+  assert w_tensor.shape == (K, N)
+  assert z_tensor.shape == (M, K)
+  assert g_tensor.shape == (K,)
+  TILE_M = 128
+  TILE_K = 128
+  TILE_N = 512 # nl.tile_size.gemm_moving_fmax
+  # Generate tensor indices to index input tensor
+  ix = nl.arange(TILE_M)[:, None]
+  iw = nl.arange(1)[:, None]
+  iy = nl.arange(K)[None, :]
+  iz = nl.arange(TILE_N)[None, :]
+  result = nl.ndarray((M, N), dtype=x_tensor.dtype, buffer=nl.shared_hbm)
+  # Load RMSNorm weight once, reused by rows/tiles of x_tensor
+  g_tile = nl.load(g_tensor.reshape((1, K))[iw, iy])
+  # Process 128 rows at a time due to 128-partition tile size limitation
+  # Since we're not reducing across the first dimension
+  # Tiles can be processed independently
+  for i in nl.affine_range(32):  # 4096 / 128 = 32 iterations
+    # Load input data from external memory to on-chip memory
+    x_tile = nl.load(x_tensor[i * TILE_M + ix, iy])
+    z_tile = nl.load(z_tensor[i * TILE_M + ix, iy])
+    a_tile = nl.add(x_tile, z_tile)
+    # Compute element-wise square of x_tensor
+    in_square = nl.square(a_tile)
+    # Calculate sum of squared elements, along last dimension
+    square_sum = nl.sum(in_square, axis=[1])
+    # Scale and get a reciprocal
+    mean = square_sum / K
+    mean = nl.add(mean, eps)
+    # Take square root of mean and then reciprocal with
+    # rsqrt API (one ISA instruction)
+    rms_reciprocal = nl.rsqrt(mean)
+    # Scale the input tensor
+    rmsnorm_out_tile = nl.multiply(a_tile, rms_reciprocal)
+    # Broadcast weight along first axis to match tensor shape
+    # num_rows_active = min(num_rows - i * 128, 128)
+    g_bcast = g_tile.broadcast_to((TILE_M, K))
+    # Multiply with the RMSNorm weight
+    rmsnorm_out_tile[...] = nl.multiply(rmsnorm_out_tile, g_bcast)
+    # Load w_tensor
+    for n in nl.affine_range(4):  # 2048 / 512 = 4 iterations
+      res_psum = nl.zeros((TILE_M, TILE_N), nl.float32, buffer=nl.psum)
+      for k in nl.affine_range(8):  # 1024 / 128 = 8 iterations
+        w_tile = nl.load(w_tensor[k * TILE_K:(k + 1) * TILE_K, n * TILE_N:(n + 1) * TILE_N])
+        res_psum += nl.matmul(rmsnorm_out_tile[:, k * TILE_K: (k + 1) * TILE_K], w_tile)
+      res_sb = nl.copy(res_psum, dtype=result.dtype)
+      nl.store(result[i * TILE_M + ix, n * TILE_N + iz], value=res_sb)
+  return result

kernels/bmm_B16_M4096_K64_N4096_0.py ADDED Viewed

	@@ -0,0 +1,47 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v3 = nl.ndarray((16, 32, 128, 4096), dtype=np.float32, buffer=nl.shared_hbm)
+    v4 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v5 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_77', buffer=nl.sbuf)
+    v6 = nl.ndarray((16, 4, nl.par_dim(64), 1024), dtype=np.float32, name='rhs_local_45', buffer=nl.sbuf)
+    v7 = nl.ndarray((4, 16, 4, 8, nl.par_dim(128), 64), dtype=np.float32, name='', buffer=nl.sbuf)
+    v8 = nl.zeros((16, 4, 4, 8, nl.par_dim(64), 128), dtype=np.float32, name='34.73', buffer=nl.psum, lazy_initialization=True)
+    v9 = nl.ndarray((4, 16, 4, nl.par_dim(64), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v10 = nl.zeros((16, 4, 4, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v11 = nl.ndarray((16, 4, 8, 4, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v5[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v4[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(16):
+        for i1 in nl.affine_range(4):
+            v6[i0, i1, nl.arange(64)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[i0, nl.arange(64)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            for i2 in nl.affine_range(4):
+                for i3 in nl.affine_range(8):
+                    v7[i1, i0, i2, i3, nl.arange(128)[:, None], nl.arange(64)[None, :]] = nl.load(v1[i0, 1024 * i2 + 128 * i3 + nl.arange(128)[:, None], nl.arange(64)[None, :]], dtype=np.float32, mask=None)
+                    v8[i0, i1, i2, i3, nl.arange(64)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v7[i1, i0, i2, i3, nl.arange(128)[:, None], nl.arange(64)[None, :]], v5[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v9[i1, i0, i2, nl.arange(64)[:, None], 128 * i3 + nl.arange(128)[None, :]] = nl.copy(v8[i0, i1, i2, i3, nl.arange(64)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i3 '
+                for i4 in nl.affine_range(8):
+                    for i5 in nl.affine_range(2):
+                        v10[i0, i1, i2, i4, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.nc_matmul(v9[i1, i0, i2, nl.arange(64)[:, None], 128 * i4 + nl.arange(128)[None, :]], v6[i0, i1, nl.arange(64)[:, None], 512 * i5 + nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                        v11[i0, i2, i4, i1, nl.arange(128)[:, None], 512 * i5 + nl.arange(512)[None, :]] = nl.copy(v10[i0, i1, i2, i4, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                        ' end loop i5 '
+                    nl.store(v3[i0, i4 + 8 * i2, nl.arange(128)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], value=v11[i0, i2, i4, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=None)
+                    ' end loop i4 '
+                ' end loop i2 '
+            ' end loop i1 '
+        ' end loop i0 '
+    return v3

kernels/bmm_softmax_B16_K64_M4096_N4096_0.py ADDED Viewed

	@@ -0,0 +1,75 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v3 = nl.ndarray((16, 32, 128, 4096), dtype=np.float32, buffer=nl.shared_hbm)
+    v4 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v5 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_140', buffer=nl.sbuf)
+    v6 = nl.ndarray((16, 4, nl.par_dim(64), 1024), dtype=np.float32, name='rhs_local_89', buffer=nl.sbuf)
+    v7 = nl.ndarray((4, 16, 4, 8, nl.par_dim(128), 64), dtype=np.float32, name='', buffer=nl.sbuf)
+    v8 = nl.zeros((16, 4, 4, 8, nl.par_dim(64), 128), dtype=np.float32, name='73.136', buffer=nl.psum, lazy_initialization=True)
+    v9 = nl.ndarray((4, 16, 4, nl.par_dim(64), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v10 = nl.zeros((16, 4, 4, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v11 = nl.ndarray((4, 8, 16, 4, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v12 = nl.ndarray((16, 4, 8, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v13 = nl.ndarray((16, 4, 8, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v14 = nl.ndarray((4, 8, 16, 4, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v15 = nl.ndarray((16, 4, 8, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v16 = nl.ndarray((16, 4, 8, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v17 = nl.ndarray((16, 4, 8, 4, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v18 = nl.ndarray((16, 4, 4, 8, 2, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v19 = nl.ndarray((16, 4, 8, 4, 2, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v5[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v4[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(16):
+        for i1 in nl.affine_range(4):
+            v6[i0, i1, nl.arange(64)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[i0, nl.arange(64)[:, None], 1024 * i1 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            for i2 in nl.affine_range(4):
+                for i3 in nl.affine_range(8):
+                    v7[i1, i0, i2, i3, nl.arange(128)[:, None], nl.arange(64)[None, :]] = nl.load(v1[i0, 1024 * i2 + 128 * i3 + nl.arange(128)[:, None], nl.arange(64)[None, :]], dtype=np.float32, mask=None)
+                    v8[i0, i1, i2, i3, nl.arange(64)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v7[i1, i0, i2, i3, nl.arange(128)[:, None], nl.arange(64)[None, :]], v5[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v9[i1, i0, i2, nl.arange(64)[:, None], 128 * i3 + nl.arange(128)[None, :]] = nl.copy(v8[i0, i1, i2, i3, nl.arange(64)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i3 '
+                for i4 in nl.affine_range(8):
+                    for i5 in nl.affine_range(2):
+                        v10[i0, i1, i2, i4, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.nc_matmul(v9[i1, i0, i2, nl.arange(64)[:, None], 128 * i4 + nl.arange(128)[None, :]], v6[i0, i1, nl.arange(64)[:, None], 512 * i5 + nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                        v11[i2, i4, i0, i1, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.copy(v10[i0, i1, i2, i4, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                        v18[i0, i1, i2, i4, i5, nl.arange(128)[:, None], 0] = nisa.tensor_reduce(nl.max, data=v11[i2, i4, i0, i1, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, axis=[1], dtype=np.float32, negate=False)
+                        v12[i0, i2, i4, nl.arange(128)[:, None], 0] = nl.loop_reduce(v18[i0, i1, i2, i4, i5, nl.arange(128)[:, None], 0], op=np.max, loop_indices=[i1, i5], mask=None, dtype=np.float32)
+                        ' end loop i5 '
+                    ' end loop i4 '
+                ' end loop i2 '
+            ' end loop i1 '
+        for i6 in nl.affine_range(4):
+            for i7 in nl.affine_range(8):
+                v13[i0, i6, i7, nl.arange(128)[:, None], 0] = nisa.tensor_scalar(data=v12[i0, i6, i7, nl.arange(128)[:, None], 0], op0=nl.maximum, operand0=np.dtype(np.float32).type(-3.4028235e+38), reverse0=False, op1=nl.multiply, operand1=np.dtype(np.float32).type(-1.0), reverse1=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                for i8 in nl.affine_range(4):
+                    for i9 in nl.affine_range(2):
+                        v14[i6, i7, i0, i8, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.activation(op=nl.exp, data=v11[i6, i7, i0, i8, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], bias=v13[i0, i6, i7, nl.arange(128)[:, None], 0], scale=1.0, mask=None, dtype=np.float32)
+                        v19[i0, i6, i7, i8, i9, nl.arange(128)[:, None], 0] = nisa.tensor_reduce(nl.add, data=v14[i6, i7, i0, i8, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, axis=[1], dtype=np.float32, negate=False)
+                        v15[i0, i6, i7, nl.arange(128)[:, None], 0] = nl.loop_reduce(v19[i0, i6, i7, i8, i9, nl.arange(128)[:, None], 0], op=np.add, loop_indices=[i8, i9], mask=None, dtype=np.float32)
+                        ' end loop i9 '
+                    ' end loop i8 '
+                v16[i0, i6, i7, nl.arange(128)[:, None], 0] = nisa.reciprocal(data=v15[i0, i6, i7, nl.arange(128)[:, None], 0], mask=None, dtype=np.float32)
+                for i10 in nl.affine_range(4):
+                    for i11 in nl.affine_range(2):
+                        v17[i0, i6, i7, i10, nl.arange(128)[:, None], 512 * i11 + nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v14[i6, i7, i0, i10, i11, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.multiply, operand0=v16[i0, i6, i7, nl.arange(128)[:, None], 0], reverse0=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                        ' end loop i11 '
+                    nl.store(v3[i0, 8 * i6 + i7, nl.arange(128)[:, None], 1024 * i10 + nl.arange(1024)[None, :]], value=v17[i0, i6, i7, i10, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=None)
+                    ' end loop i10 '
+                ' end loop i7 '
+            ' end loop i6 '
+        ' end loop i0 '
+    return v3

kernels/gqa_full_B1_N4096_QH16_KH8_D128_0.py ADDED Viewed

	@@ -0,0 +1,115 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2, v3):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v4 = nl.ndarray((1, 8, 2, 32, 128, 128), dtype=np.float32, buffer=nl.shared_hbm)
+    v5 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v6 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_224', buffer=nl.sbuf)
+    v7 = nl.ndarray((32, 2, nl.par_dim(128), 1024), dtype=np.float32, name='146.215', buffer=nl.sbuf)
+    v8 = nl.zeros((32, 2, 8, nl.par_dim(128), 128), dtype=np.float32, name='146.220', buffer=nl.psum, lazy_initialization=True)
+    v9 = nl.ndarray((2, 32, nl.par_dim(128), 8, 128), dtype=np.float32, name='q_pftranspose_146', buffer=nl.sbuf)
+    v10 = nl.ndarray((2, 4, 4, nl.par_dim(128), 1024), dtype=np.float32, name='150.229', buffer=nl.sbuf)
+    v11 = nl.zeros((2, 4, 4, 8, nl.par_dim(128), 128), dtype=np.float32, name='150.234', buffer=nl.psum, lazy_initialization=True)
+    v12 = nl.ndarray((2, 4, nl.par_dim(128), 8, 512), dtype=np.float32, name='k_pftranspose_150', buffer=nl.sbuf)
+    v13 = nl.zeros((32, 2, 4, 2, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v14 = nl.ndarray((32, 2, 4, 2, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v15 = nl.ndarray((2, 4, 2, 32, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v16 = nl.ndarray((8, 4, nl.par_dim(128), 1024), dtype=np.float32, name='v_local_169', buffer=nl.sbuf)
+    v17 = nl.ndarray((2, 2, 4, 32, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v18 = nl.ndarray((32, 2, 4, 2, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v19 = nl.ndarray((2, 4, 2, 32, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v20 = nl.ndarray((2, 4, 2, 32, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v21 = nl.ndarray((32, 2, 4, 2, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v22 = nl.zeros((2, 2, 4, 32, 2, 4, 4, nl.par_dim(128), 128), dtype=np.float32, name='135.238', buffer=nl.psum, lazy_initialization=True)
+    v23 = nl.ndarray((8, 4, 2, 4, 2, 32, nl.par_dim(128), 128), dtype=np.float32, name='t51_pftranspose_135', buffer=nl.sbuf)
+    v24 = nl.zeros((2, 2, 4, 32, nl.par_dim(128), 128), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v25 = nl.ndarray((2, 4, 2, 32, nl.par_dim(128), 128), dtype=np.float32, name='', buffer=nl.sbuf)
+    v26 = nl.ndarray((2, 2, 4, 4, 2, 32, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v27 = nl.ndarray((2, 2, 4, 32, 2, 4, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v6[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v5[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(32):
+        for i1 in nl.affine_range(2):
+            v7[i0, i1, nl.arange(128)[:, None, None], 128 * nl.arange(8)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v1[i0, nl.arange(128)[:, None, None], 8 * i1 + nl.arange(8)[None, :, None], nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+            for i2 in nl.affine_range(8):
+                v8[i0, i1, i2, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v7[i0, i1, nl.arange(128)[:, None], 128 * i2 + nl.arange(128)[None, :]], v6[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                v9[i1, i0, nl.arange(128)[:, None], i2, nl.arange(128)[None, :]] = nl.copy(v8[i0, i1, i2, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                ' end loop i2 '
+            ' end loop i1 '
+        ' end loop i0 '
+    for i3 in nl.affine_range(2):
+        for i4 in nl.affine_range(4):
+            for i5 in nl.affine_range(4):
+                v10[i3, i4, i5, nl.arange(128)[:, None, None], 128 * nl.arange(8)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v2[0, i4 + 4 * i3, i5, nl.arange(128)[:, None, None], nl.arange(8)[None, :, None], nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+                for i6 in nl.affine_range(8):
+                    v11[i3, i4, i5, i6, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v10[i3, i4, i5, nl.arange(128)[:, None], 128 * i6 + nl.arange(128)[None, :]], v6[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v12[i3, i4, nl.arange(128)[:, None], i6, 128 * i5 + nl.arange(128)[None, :]] = nl.copy(v11[i3, i4, i5, i6, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i6 '
+                ' end loop i5 '
+            ' end loop i4 '
+        for i7 in nl.affine_range(2):
+            for i8 in nl.affine_range(4):
+                for i9 in nl.affine_range(4):
+                    for i10 in nl.affine_range(2):
+                        for i11 in nl.affine_range(32):
+                            v13[i11, i7, i8, i10, i3, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.nc_matmul(v9[i7, i11, nl.arange(128)[:, None], i10 + 2 * i8, nl.arange(128)[None, :]], v12[i3, i9, nl.arange(128)[:, None], i8 + 4 * i7, nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                            v14[i11, i7, i8, i10, i3, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v13[i11, i7, i8, i10, i3, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.08838835154663706), reverse0=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                            v26[i3, i7, i8, i9, i10, i11, nl.arange(128)[:, None], 0] = nisa.tensor_reduce(nl.max, data=v14[i11, i7, i8, i10, i3, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, axis=[1], dtype=np.float32, negate=False)
+                            v15[i7, i8, i10, i11, nl.arange(128)[:, None], 0] = nl.loop_reduce(v26[i3, i7, i8, i9, i10, i11, nl.arange(128)[:, None], 0], op=np.max, loop_indices=[i3, i9], mask=None, dtype=np.float32)
+                            ' end loop i11 '
+                        ' end loop i10 '
+                    ' end loop i9 '
+                ' end loop i8 '
+            ' end loop i7 '
+        ' end loop i3 '
+    for i12 in nl.affine_range(8):
+        for i13 in nl.affine_range(4):
+            v16[i12, i13, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v3[0, 4 * i12 + i13, nl.arange(128)[:, None], nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i13 '
+        ' end loop i12 '
+    for i14 in nl.affine_range(2):
+        for i15 in nl.affine_range(2):
+            for i16 in nl.affine_range(4):
+                for i17 in nl.affine_range(32):
+                    v17[i14, i15, i16, i17, nl.arange(128)[:, None], 0] = nisa.tensor_scalar(data=v15[i15, i16, i14, i17, nl.arange(128)[:, None], 0], op0=nl.maximum, operand0=np.dtype(np.float32).type(-3.4028235e+38), reverse0=False, op1=nl.multiply, operand1=np.dtype(np.float32).type(-1.0), reverse1=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                    for i18 in nl.affine_range(2):
+                        for i19 in nl.affine_range(4):
+                            v18[i17, i15, i16, i14, i18, i19, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.activation(op=nl.exp, data=v14[i17, i15, i16, i14, i18, i19, nl.arange(128)[:, None], nl.arange(512)[None, :]], bias=v17[i14, i15, i16, i17, nl.arange(128)[:, None], 0], scale=1.0, mask=None, dtype=np.float32)
+                            v27[i14, i15, i16, i17, i18, i19, nl.arange(128)[:, None], 0] = nisa.tensor_reduce(nl.add, data=v18[i17, i15, i16, i14, i18, i19, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, axis=[1], dtype=np.float32, negate=False)
+                            v19[i15, i16, i14, i17, nl.arange(128)[:, None], 0] = nl.loop_reduce(v27[i14, i15, i16, i17, i18, i19, nl.arange(128)[:, None], 0], op=np.add, loop_indices=[i19, i18], mask=None, dtype=np.float32)
+                            ' end loop i19 '
+                        ' end loop i18 '
+                    v20[i15, i16, i14, i17, nl.arange(128)[:, None], 0] = nisa.reciprocal(data=v19[i15, i16, i14, i17, nl.arange(128)[:, None], 0], mask=None, dtype=np.float32)
+                    for i20 in nl.affine_range(2):
+                        for i21 in nl.affine_range(4):
+                            v21[i17, i15, i16, i14, 4 * i20 + i21, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v18[i17, i15, i16, i14, i20, i21, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.multiply, operand0=v20[i15, i16, i14, i17, nl.arange(128)[:, None], 0], reverse0=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                            for i22 in nl.affine_range(4):
+                                v22[i14, i15, i16, i17, i20, i21, i22, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v21[i17, i15, i16, i14, 4 * i20 + i21, nl.arange(128)[:, None], 128 * i22 + nl.arange(128)[None, :]], v6[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                                v23[4 * i20 + i21, i22, i15, i16, i14, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.copy(v22[i14, i15, i16, i17, i20, i21, i22, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                                ' end loop i22 '
+                            ' end loop i21 '
+                        ' end loop i20 '
+                    for i23 in nl.affine_range(8):
+                        for i24 in nl.affine_range(4):
+                            v24[i14, i15, i16, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]] += nisa.nc_matmul(v23[i23, i24, i15, i16, i14, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]], v16[i23, i24, nl.arange(128)[:, None], 128 * i16 + 512 * i15 + nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                            ' end loop i24 '
+                        ' end loop i23 '
+                    v25[i15, i16, i14, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.copy(v24[i14, i15, i16, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    nl.store(v4[0, i16 + 4 * i15, i14, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]], value=v25[i15, i16, i14, i17, nl.arange(128)[:, None], nl.arange(128)[None, :]], mask=None)
+                    ' end loop i17 '
+                ' end loop i16 '
+            ' end loop i15 '
+        ' end loop i14 '
+    return v4

kernels/lora_M4096_N12288_K5120_R128_0.py ADDED Viewed

	@@ -0,0 +1,123 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2, v3, v4):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v5 = nl.ndarray((8, 4, 128, 96, 128), dtype=np.float32, buffer=nl.shared_hbm)
+    v6 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v7 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_111', buffer=nl.sbuf)
+    v8 = nl.ndarray((5, 8, nl.par_dim(128), 128), dtype=np.float32, name='a_local_56', buffer=nl.sbuf)
+    v9 = nl.ndarray((2, 4, 5, 4, nl.par_dim(128), 1024), dtype=np.float32, name='38.102', buffer=nl.sbuf)
+    v10 = nl.zeros((2, 4, 5, 4, 8, nl.par_dim(128), 128), dtype=np.float32, name='38.107', buffer=nl.psum, lazy_initialization=True)
+    v11 = nl.ndarray((2, 4, 5, nl.par_dim(128), 8, 512), dtype=np.float32, name='x_pftranspose_38', buffer=nl.sbuf)
+    v12 = nl.zeros((2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v13 = nl.ndarray((2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v14 = nl.ndarray((2, 12, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v15 = nl.zeros((2, 12, 4, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v16 = nl.ndarray((12, 2, 4, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v17 = nl.ndarray((12, 4, 2, 5, nl.par_dim(128), 1024), dtype=np.float32, name='w_local_73', buffer=nl.sbuf)
+    v18 = nl.ndarray((12, 4, 2, 4, 2, 4, nl.par_dim(128), 640), dtype=np.float32, name='', buffer=nl.sbuf)
+    v19 = nl.zeros((12, 4, 2, 4, 2, 4, 5, nl.par_dim(128), 128), dtype=np.float32, name='38.122', buffer=nl.psum, lazy_initialization=True)
+    v20 = nl.ndarray((12, 2, 4, 4, 2, nl.par_dim(128), 5, 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v21 = nl.zeros((12, 4, 2, 4, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v22 = nl.full((12, 2, 4, 2, 4, nl.par_dim(128), 512), fill_value=np.dtype(np.float32).type(0), dtype=np.float32, name='', buffer=nl.sbuf)
+    v23 = nl.ndarray((2, 4, 12, 2, 4, nl.par_dim(128), 512), dtype=np.float32, name='.o0_pftranspose_42', buffer=nl.sbuf)
+    v24 = nl.zeros((12, 2, 4, 2, 4, 4, nl.par_dim(128), 128), dtype=np.float32, name='42.130', buffer=nl.psum, lazy_initialization=True)
+    v25 = nl.ndarray((12, 2, 4, 2, 4, 4, nl.par_dim(128), 128), dtype=np.float32, name='42.143', buffer=nl.sbuf)
+    v7[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v6[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(5):
+        for i1 in nl.affine_range(8):
+            v8[i0, i1, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v3[8 * i0 + i1, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i1 '
+        ' end loop i0 '
+    for i2 in nl.affine_range(2):
+        for i3 in nl.affine_range(4):
+            for i4 in nl.affine_range(5):
+                for i5 in nl.affine_range(4):
+                    v9[i2, i3, i4, i5, nl.arange(128)[:, None, None], 128 * nl.arange(8)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v1[i3 + 4 * i2, i5, nl.arange(128)[:, None, None], 8 * i4 + nl.arange(8)[None, :, None], nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+                    for i6 in nl.affine_range(8):
+                        v10[i2, i3, i4, i5, i6, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v9[i2, i3, i4, i5, nl.arange(128)[:, None], 128 * i6 + nl.arange(128)[None, :]], v7[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                        v11[i2, i3, i4, nl.arange(128)[:, None], i6, 128 * i5 + nl.arange(128)[None, :]] = nl.copy(v10[i2, i3, i4, i5, i6, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                        ' end loop i6 '
+                    ' end loop i5 '
+                ' end loop i4 '
+            for i7 in nl.affine_range(5):
+                for i8 in nl.affine_range(8):
+                    v12[i2, i3, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v8[i7, i8, nl.arange(128)[:, None], nl.arange(128)[None, :]], v11[i2, i3, i7, nl.arange(128)[:, None], i8, nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                    ' end loop i8 '
+                ' end loop i7 '
+            v13[i2, i3, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.copy(v12[i2, i3, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i3 '
+        for i9 in nl.affine_range(12):
+            v14[i2, i9, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v4[nl.arange(128)[:, None], 1024 * i9 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            for i10 in nl.affine_range(4):
+                for i11 in nl.affine_range(2):
+                    for i12 in nl.affine_range(4):
+                        v15[i2, i9, i10, i11, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.nc_matmul(v14[i2, i9, nl.arange(128)[:, None], 512 * i11 + 128 * i12 + nl.arange(128)[None, :]], v13[i2, i10, nl.arange(128)[:, None], nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                        v16[i9, i11, i12, i2, i10, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.copy(v15[i2, i9, i10, i11, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                        ' end loop i12 '
+                    ' end loop i11 '
+                ' end loop i10 '
+            ' end loop i9 '
+        ' end loop i2 '
+    for i13 in nl.affine_range(12):
+        for i14 in nl.sequential_range(4):
+            for i15 in nl.affine_range(2):
+                for i16 in nl.affine_range(5):
+                    v17[i13, i14, i15, i16, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[i16 + 5 * i15 + 10 * i14, nl.arange(128)[:, None], 1024 * i13 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i16 '
+                ' end loop i15 '
+            for i17 in nl.affine_range(2):
+                for i18 in nl.affine_range(4):
+                    for i19 in nl.affine_range(2):
+                        for i20 in nl.affine_range(4):
+                            v18[i13, i14, i17, i18, i19, i20, nl.arange(128)[:, None, None], 128 * nl.arange(5)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v1[4 * i17 + i18, i20, nl.arange(128)[:, None, None], 5 * i19 + 10 * i14 + nl.arange(5)[None, :, None], nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+                            for i21 in nl.affine_range(5):
+                                v19[i13, i14, i17, i18, i19, i20, i21, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v18[i13, i14, i17, i18, i19, i20, nl.arange(128)[:, None], 128 * i21 + nl.arange(128)[None, :]], v7[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                                v20[i13, i17, i18, i14, i19, nl.arange(128)[:, None], i21, 128 * i20 + nl.arange(128)[None, :]] = nl.copy(v19[i13, i14, i17, i18, i19, i20, i21, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                                ' end loop i21 '
+                            ' end loop i20 '
+                        ' end loop i19 '
+                    for i22 in nl.affine_range(2):
+                        for i23 in nl.affine_range(4):
+                            for i24 in nl.affine_range(2):
+                                for i25 in nl.affine_range(5):
+                                    v21[i13, i14, i17, i18, i22, i23, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v17[i13, i14, i24, i25, nl.arange(128)[:, None], 128 * i23 + 512 * i22 + nl.arange(128)[None, :]], v20[i13, i17, i18, i14, i24, nl.arange(128)[:, None], i25, nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                                    ' end loop i25 '
+                                ' end loop i24 '
+                            v22[i13, i22, i23, i17, i18, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.loop_reduce(v21[i13, i14, i17, i18, i22, i23, nl.arange(128)[:, None], nl.arange(512)[None, :]], op=np.add, loop_indices=[i14], mask=None, dtype=np.float32)
+                            ' end loop i23 '
+                        ' end loop i22 '
+                    ' end loop i18 '
+                ' end loop i17 '
+            ' end loop i14 '
+        for i26 in nl.affine_range(2):
+            for i27 in nl.affine_range(4):
+                for i28 in nl.affine_range(2):
+                    for i29 in nl.affine_range(4):
+                        v23[i26, i27, i13, i28, i29, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.add(v22[i13, i28, i29, i26, i27, nl.arange(128)[:, None], nl.arange(512)[None, :]], v16[i13, i28, i29, i26, i27, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, dtype=np.float32)
+                        ' end loop i29 '
+                    for i30 in nl.affine_range(4):
+                        for i31 in nl.affine_range(4):
+                            v24[i13, i26, i27, i28, i30, i31, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v23[i26, i27, i13, i28, i30, nl.arange(128)[:, None], 128 * i31 + nl.arange(128)[None, :]], v7[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                            v25[i13, i26, i27, i28, i30, i31, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.copy(v24[i13, i26, i27, i28, i30, i31, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                            nl.store(v5[4 * i26 + i27, i31, nl.arange(128)[:, None], i30 + 4 * i28 + 8 * i13, nl.arange(128)[None, :]], value=v25[i13, i26, i27, i28, i30, i31, nl.arange(128)[:, None], nl.arange(128)[None, :]], mask=None)
+                            ' end loop i31 '
+                        ' end loop i30 '
+                    ' end loop i28 '
+                ' end loop i27 '
+            ' end loop i26 '
+        ' end loop i13 '
+    return v5

kernels/mamba_M7168_C256_S16_0.py ADDED Viewed

	@@ -0,0 +1,68 @@

+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.isa as nisa
+import numpy as np
+@nki.jit
+def kernel(delta, u, a, b, c):
+    channels, seq_len = delta.shape
+    output = nl.ndarray((channels, seq_len), dtype=delta.dtype,
+                        buffer=nl.shared_hbm)
+    _, state_size = a.shape
+    # We can relax this using mask paramters in all the NKI API calls
+    assert channels % 128 == 0
+    # Map channels to the partition dimension
+    # Tile channels to comply with NKI tile size constraints
+    channel_psize = nl.tile_size.pmax
+    n_channel_tile = channels // channel_psize
+    # partial accumulated scanC result with processed states
+    scanC_accum = nl.zeros((n_channel_tile, nl.par_dim(channel_psize), seq_len), dtype=delta.dtype)
+    # Second outer loop with state_size, partial parallel
+    for i_state in nl.affine_range(state_size):
+        # Inner loop: tiling channels
+        for i_channel_tile in nl.affine_range(n_channel_tile):
+            channel_start = i_channel_tile * channel_psize
+            # Load the relevant tile from delta and A
+            delta_i = nl.load(delta[channel_start:channel_start+channel_psize, 0:seq_len])
+            A_i = nl.load(a[channel_start:channel_start+channel_psize, i_state])
+            # Step 1&2: Element-wise multiplication of delta_i and A_i and then exponential
+            deltaA = nisa.activation(op=nl.exp, data=delta_i, scale=A_i)
+            # Load the relevant tile from u and B
+            u_i = nl.load(u[channel_start:channel_start+channel_psize, 0:seq_len])
+            B_i = nl.load(b[i_state:i_state+1, 0:seq_len])
+            # Step 3: Element-wise multiplication of delta_i, B_i and u_i
+            deltaU = nisa.tensor_tensor(delta_i, u_i, op=nl.multiply)
+            B_i_bcast = B_i.broadcast_to((channel_psize, seq_len))
+            deltaBu = nisa.tensor_tensor(deltaU, B_i_bcast, op=nl.multiply)
+            # Step 4: Associative scan between deltaA and deltaBu
+            scan_res = nki.isa.tensor_tensor_scan(deltaA, deltaBu, initial=0,
+                    op0=np.multiply, op1=np.add)
+            # Load the relevant tile from C
+            C_i = nl.load(c[i_state:i_state+1, 0:seq_len])
+            # Step 5: Element-wise multiplication of scan_res and C_i
+            C_i_bcast = C_i.broadcast_to((channel_psize, seq_len))
+            scanC = nisa.tensor_tensor(scan_res, C_i_bcast, op=nl.multiply)
+            # Step 6: Accumulation of scanC along state_size dimension
+            scanC_accum[i_channel_tile, 0:channel_psize, 0:seq_len] += scanC
+    # Store scanC_accum for a single batch to output
+    for i_channel_tile in nl.affine_range(n_channel_tile):
+        channel_start = i_channel_tile * channel_psize
+        nl.store(output[channel_start:channel_start+channel_psize, 0:seq_len],
+                scanC_accum[i_channel_tile, 0:channel_psize, 0:seq_len])
+    return output

kernels/matmul_M4096_N12288_K5120_0.py ADDED Viewed

	@@ -0,0 +1,53 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v3 = nl.ndarray((32, 128, 12288), dtype=np.float32, buffer=nl.shared_hbm)
+    v4 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v5 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_80', buffer=nl.sbuf)
+    v6 = nl.ndarray((12, 5, 8, nl.par_dim(128), 1024), dtype=np.float32, name='rhs_local_49', buffer=nl.sbuf)
+    v7 = nl.ndarray((12, 32, 5, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v8 = nl.zeros((12, 32, 5, 8, nl.par_dim(128), 128), dtype=np.float32, name='38.76', buffer=nl.psum, lazy_initialization=True)
+    v9 = nl.ndarray((12, 32, 5, nl.par_dim(128), 8, 128), dtype=np.float32, name='', buffer=nl.sbuf)
+    v10 = nl.zeros((12, 32, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v11 = nl.ndarray((32, 12, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v5[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v4[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(12):
+        for i1 in nl.affine_range(5):
+            for i2 in nl.affine_range(8):
+                v6[i0, i1, i2, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[i2 + 8 * i1, nl.arange(128)[:, None], nl.arange(1024)[None, :] + 1024 * i0], dtype=np.float32, mask=None)
+                ' end loop i2 '
+            ' end loop i1 '
+        for i3 in nl.affine_range(32):
+            for i4 in nl.affine_range(5):
+                v7[i0, i3, i4, nl.arange(128)[:, None, None], 128 * nl.arange(8)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v1[i3, nl.arange(128)[:, None, None], nl.arange(8)[None, :, None] + 8 * i4, nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+                for i5 in nl.affine_range(8):
+                    v8[i0, i3, i4, i5, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v7[i0, i3, i4, nl.arange(128)[:, None], 128 * i5 + nl.arange(128)[None, :]], v5[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v9[i0, i3, i4, nl.arange(128)[:, None], i5, nl.arange(128)[None, :]] = nl.copy(v8[i0, i3, i4, i5, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i5 '
+                ' end loop i4 '
+            for i6 in nl.affine_range(2):
+                for i7 in nl.affine_range(5):
+                    for i8 in nl.affine_range(8):
+                        v10[i0, i3, i6, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v9[i0, i3, i7, nl.arange(128)[:, None], i8, nl.arange(128)[None, :]], v6[i0, i7, i8, nl.arange(128)[:, None], 512 * i6 + nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                        ' end loop i8 '
+                    ' end loop i7 '
+                v11[i3, i0, nl.arange(128)[:, None], 512 * i6 + nl.arange(512)[None, :]] = nl.copy(v10[i0, i3, i6, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                ' end loop i6 '
+            nl.store(v3[i3, nl.arange(128)[:, None], nl.arange(1024)[None, :] + 1024 * i0], value=v11[i3, i0, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=None)
+            ' end loop i3 '
+        ' end loop i0 '
+    return v3

kernels/matmul_add_rmsnorm_M4096_N2048_K2048_0.py ADDED Viewed

	@@ -0,0 +1,48 @@

+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+@nki.jit
+def kernel(x_tensor, w_tensor, eps, z_tensor, g_tensor):
+  M, K = x_tensor.shape
+  K_, N = w_tensor.shape
+  # Make sure shapes match
+  assert N == g_tensor.shape[0]
+  assert K_ == K
+  assert N == w_tensor.shape[1]
+  assert M == z_tensor.shape[0]
+  assert N == z_tensor.shape[1]
+  TILE_M = 128
+  TILE_K = 128
+  TILE_N = 512 # nl.tile_size.gemm_moving_fmax
+  ix = nl.arange(TILE_M)[:, None]
+  iw = nl.arange(1)[:, None]
+  iy = nl.arange(N)[None, :]
+  iz = nl.arange(TILE_N)[None, :]
+  ik = nl.arange(K)[None, :]
+  result = nl.ndarray((M, N), dtype=x_tensor.dtype, buffer=nl.shared_hbm)
+  g_tile = nl.load(g_tensor.reshape((1, N))[iw, iy])
+  for i in nl.affine_range(M // TILE_M):
+    rmsnorm_in_tile = nl.ndarray((TILE_M, N), dtype=x_tensor.dtype, buffer=nl.sbuf)
+    x_tiles = nl.load(x_tensor[i * TILE_M + ix, ik])
+    for n in nl.affine_range(N // TILE_N):
+      res_psum = nl.zeros((TILE_M, TILE_N), nl.float32, buffer=nl.psum)
+      for k in nl.affine_range(K // TILE_K):
+        w_tile = nl.load(w_tensor[k * TILE_K: (k + 1) * TILE_K, n * TILE_N: (n + 1) * TILE_N])
+        res_psum += nl.matmul(x_tiles[:, k * TILE_K: (k + 1) * TILE_K], w_tile)
+      res_sb = nl.copy(res_psum, dtype=result.dtype)
+      rmsnorm_in_tile[ix, n * TILE_N + iz] = res_sb
+    z_tile = nl.load(z_tensor[i * TILE_M + ix, iy])
+    a_tile = nl.add(rmsnorm_in_tile, z_tile)
+    in_square = nl.square(a_tile)
+    square_sum = nl.sum(in_square, axis=[1])
+    mean = square_sum / N  # Changed from K to N - normalize over output dimension
+    mean = nl.add(mean, eps)
+    rms_reciprocal = nl.rsqrt(mean)
+    rmsnorm_out_tile = nl.multiply(a_tile, rms_reciprocal)
+    g_bcast = g_tile.broadcast_to((TILE_M, N))
+    rmsnorm_out_tile[...] = nl.multiply(rmsnorm_out_tile, g_bcast)
+    nl.store(result[i * TILE_M + ix, iy], value=rmsnorm_out_tile)
+  return result

kernels/rmsnorm_matmul_M4096_N2048_K1024_0.py ADDED Viewed

	@@ -0,0 +1,75 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v3 = nl.ndarray((32, 128, 2048), dtype=np.float32, buffer=nl.shared_hbm)
+    v4 = nl.ndarray((nl.par_dim(128), 1), dtype=np.float32, name='memset.174', buffer=nl.sbuf)
+    v5 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v6 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_168', buffer=nl.sbuf)
+    v7 = nl.ndarray((4, 8, nl.par_dim(128), 1024), dtype=np.float32, name='input_tensor_local_112', buffer=nl.sbuf)
+    v8 = nl.ndarray((4, 8, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v9 = nl.ndarray((4, 8, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v10 = nl.ndarray((4, 8, nl.par_dim(128), 1024), dtype=np.float32, name='input_tensor_local_118', buffer=nl.sbuf)
+    v11 = nl.ndarray((4, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v12 = nl.zeros((4, 8, 2, 4, nl.par_dim(128), 128), dtype=np.float32, name='93.164', buffer=nl.psum, lazy_initialization=True)
+    v13 = nl.ndarray((2, 4, 4, 8, nl.par_dim(128), 128), dtype=np.float32, name='t26_pftranspose_93', buffer=nl.sbuf)
+    v14 = nl.ndarray((4, 2, 2, 4, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v15 = nl.zeros((2, 4, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v16 = nl.ndarray((4, 8, 2, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v17 = nl.ndarray((4, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v18 = nl.ndarray((4, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v19 = nl.ndarray((4, 8, 2, nl.par_dim(128), 1), dtype=np.float32, name='', buffer=nl.sbuf)
+    v4[nl.arange(128)[:, None], 0] = nisa.memset(shape=(128, 1), value=np.dtype(np.uint16).type(0), dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+    v6[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v5[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(4):
+        for i1 in nl.affine_range(8):
+            v7[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v1[8 * i0 + i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            for i2 in nl.affine_range(2):
+                v17[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.activation(op=nl.square, data=v7[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], bias=v4[nl.arange(128)[:, None], 0], scale=1.0, mask=None, dtype=np.float32)
+                v18[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v17[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.multiply, operand0=np.dtype(np.float32).type(0.0009765625), reverse0=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                v19[i0, i1, i2, nl.arange(128)[:, None], 0] = nisa.tensor_reduce(nl.add, data=v18[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, axis=[1], dtype=np.float32, negate=False)
+                v8[i0, i1, nl.arange(128)[:, None], 0] = nl.loop_reduce(v19[i0, i1, i2, nl.arange(128)[:, None], 0], op=np.add, loop_indices=[i2], mask=None, dtype=np.float32)
+                ' end loop i2 '
+            v9[i0, i1, nl.arange(128)[:, None], 0] = nisa.activation(op=nl.rsqrt, data=v8[i0, i1, nl.arange(128)[:, None], 0], bias=v4[nl.arange(128)[:, None], 0], scale=1.0, mask=None, dtype=np.float32)
+            v10[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v1[8 * i0 + i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            for i3 in nl.affine_range(2):
+                v11[i0, i1, i3, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v10[i0, i1, nl.arange(128)[:, None], 512 * i3 + nl.arange(512)[None, :]], op0=nl.multiply, operand0=v9[i0, i1, nl.arange(128)[:, None], 0], reverse0=False, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                for i4 in nl.affine_range(4):
+                    v12[i0, i1, i3, i4, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v11[i0, i1, i3, nl.arange(128)[:, None], 128 * i4 + nl.arange(128)[None, :]], v6[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v13[i3, i4, i0, i1, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.copy(v12[i0, i1, i3, i4, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i4 '
+                ' end loop i3 '
+            ' end loop i1 '
+        for i5 in nl.affine_range(2):
+            for i6 in nl.affine_range(2):
+                for i7 in nl.affine_range(4):
+                    v14[i0, i5, i6, i7, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[i7 + 4 * i6, nl.arange(128)[:, None], 1024 * i5 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i7 '
+                ' end loop i6 '
+            for i8 in nl.affine_range(8):
+                for i9 in nl.affine_range(2):
+                    for i10 in nl.affine_range(2):
+                        for i11 in nl.affine_range(4):
+                            v15[i5, i0, i8, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v13[i10, i11, i0, i8, nl.arange(128)[:, None], nl.arange(128)[None, :]], v14[i0, i5, i10, i11, nl.arange(128)[:, None], 512 * i9 + nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                            ' end loop i11 '
+                        ' end loop i10 '
+                    v16[i0, i8, i5, nl.arange(128)[:, None], 512 * i9 + nl.arange(512)[None, :]] = nl.copy(v15[i5, i0, i8, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i9 '
+                nl.store(v3[i8 + 8 * i0, nl.arange(128)[:, None], 1024 * i5 + nl.arange(1024)[None, :]], value=v16[i0, i8, i5, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=None)
+                ' end loop i8 '
+            ' end loop i5 '
+        ' end loop i0 '
+    return v3

kernels/rope_single_freq_apply_B1_H64_N4096_D128_0.py ADDED Viewed

	@@ -0,0 +1,71 @@

+import neuronxcc.nki as nki
+import neuronxcc.nki.isa as nisa
+import neuronxcc.nki.language as nl
+@nki.jit
+def kernel(x_in, cos, sin):
+  """
+  Applies rotary position embeddings.
+  Expected layout:
+  x_in: [d_head, S]
+  cos, sin: [d_head // 2, S]
+  This implementation uses first and second halves i.e.,
+    result[:d_head/2] = embedding[:d_head/2] * cos - embedding[d_head/2:] * sin
+    result[d_head/2:]  = embedding[d_head/2:] * cos + embedding[:d_head/2] * sin
+  """
+  d_head, S = x_in.shape
+  half_d = d_head // 2
+  assert d_head <= 128
+  assert tuple(cos.shape) == (half_d, S)
+  assert cos.shape == sin.shape
+  x_out = nl.ndarray((d_head, S), dtype=x_in.dtype, buffer=nl.shared_hbm)
+  # Indices for selecting upper, lower partitions.
+  i_upper = nl.arange(half_d)[:, None]
+  i_lower = i_upper + half_d
+  # Tile along the S dimension.
+  tile_size_S = 512
+  i_dh = nl.arange(d_head)[:, None]
+  i_S = nl.arange(tile_size_S)[None, :]
+  for i_S_offset in range(0, S, tile_size_S):
+    # Load input tensor.
+    x_in_sb = nl.ndarray((d_head, tile_size_S), dtype=x_in.dtype, buffer=nl.sbuf)
+    x_in_sb[i_dh, i_S] = nl.load(x_in[i_dh, i_S + i_S_offset])
+    # Pack cos and sin on partition dimension to save sbuf usage.
+    sb_coeff = nl.ndarray((d_head, tile_size_S), dtype=x_in.dtype, buffer=nl.sbuf)
+    sb_cos = sb_coeff[i_upper, i_S]
+    sb_sin = sb_coeff[i_lower, i_S]
+    sb_cos = nl.load(cos[i_upper, i_S + i_S_offset])
+    sb_sin = nl.load(sin[i_upper, i_S + i_S_offset])
+    x_out_sb = nl.ndarray((d_head, tile_size_S), dtype=x_in.dtype, buffer=nl.sbuf)
+    # Inlined RoPE_sbuf implementation
+    sb_e = x_in_sb[i_upper, i_S]
+    # copy to make sure tensortensor have both inputs with the same base partition
+    sb_o = nl.copy(x_in_sb[i_lower, i_S])
+    e_cos_sin = nl.ndarray((d_head, tile_size_S), dtype=x_in_sb.dtype, buffer=nl.sbuf)
+    e_cos = e_cos_sin[i_upper, i_S]
+    e_sin = e_cos_sin[i_lower, i_S]
+    o_cos_sin = nl.ndarray((d_head, tile_size_S), dtype=x_in_sb.dtype, buffer=nl.sbuf)
+    o_cos = o_cos_sin[i_upper, i_S]
+    o_sin = o_cos_sin[i_lower, i_S]
+    e_cos = nisa.tensor_tensor(sb_e, sb_cos, nl.multiply)
+    o_cos = nisa.tensor_tensor(sb_o, sb_cos, nl.multiply)
+    e_sin = nisa.tensor_tensor(sb_e, sb_sin, nl.multiply)
+    o_sin = nisa.tensor_tensor(sb_o, sb_sin, nl.multiply)
+    x_out_sb[i_upper, i_S] = nisa.tensor_tensor(e_cos, o_sin, nl.subtract) # even * cos -  odd * sin
+    x_out_sb[i_lower, i_S] = nisa.tensor_tensor(o_cos, e_sin, nl.add)      #  odd * cos + even * sin
+    # Store output tensor.
+    nl.store(x_out[i_dh, i_S + i_S_offset], x_out_sb)
+  return x_out

kernels/silu_M4096_N7168_0.py ADDED Viewed

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

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v2 = nl.ndarray((128, 32, 7168), dtype=np.float32, buffer=nl.shared_hbm)
+    v3 = nl.ndarray((nl.par_dim(128), 1), dtype=np.float32, name='memset.172', buffer=nl.sbuf)
+    v4 = nl.ndarray((32, 7, nl.par_dim(128), 1024), dtype=np.float32, name='x_local_152', buffer=nl.sbuf)
+    v5 = nl.ndarray((32, 7, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v6 = nl.ndarray((32, 7, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v7 = nl.ndarray((32, 7, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v8 = nl.ndarray((32, 7, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v3[nl.arange(128)[:, None], 0] = nisa.memset(shape=(128, 1), value=np.dtype(np.uint16).type(0), dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+    for i0 in nl.affine_range(32):
+        for i1 in nl.affine_range(7):
+            v4[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v1[nl.arange(128)[:, None], i0, nl.arange(1024)[None, :] + 1024 * i1], dtype=np.float32, mask=None)
+            for i2 in nl.affine_range(2):
+                v6[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.activation(op=nl.exp, data=v4[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], bias=v3[nl.arange(128)[:, None], 0], scale=-1.0, mask=None, dtype=np.float32)
+                v7[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v6[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.add, operand0=np.dtype(np.float32).type(1), reverse0=True, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                v8[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.reciprocal(data=v7[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, dtype=np.float32)
+                v5[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]] = nl.multiply(v4[i0, i1, nl.arange(128)[:, None], 512 * i2 + nl.arange(512)[None, :]], v8[i0, i1, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, dtype=np.float32)
+                ' end loop i2 '
+            nl.store(v2[nl.arange(128)[:, None], i0, nl.arange(1024)[None, :] + 1024 * i1], value=v5[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=None)
+            ' end loop i1 '
+        ' end loop i0 '
+    return v2

kernels/swiglu_M4096_N3072_K1024_0.py ADDED Viewed

	@@ -0,0 +1,113 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2, v3, v4):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v5 = nl.ndarray((32, 128, 1024), dtype=np.float32, buffer=nl.shared_hbm)
+    v6 = nl.ndarray((nl.par_dim(128), 1), dtype=np.float32, name='memset.200', buffer=nl.sbuf)
+    v7 = nl.shared_constant(np.identity(128, dtype=np.float32))
+    v8 = nl.ndarray((nl.par_dim(128), 128), dtype=np.float32, name='identity_local_182', buffer=nl.sbuf)
+    v9 = nl.ndarray((3, 8, nl.par_dim(128), 1024), dtype=np.float32, name='w_gate_local_109', buffer=nl.sbuf)
+    v10 = nl.ndarray((3, 8, 4, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v11 = nl.zeros((3, 8, 4, 8, nl.par_dim(128), 128), dtype=np.float32, name='95.178', buffer=nl.psum, lazy_initialization=True)
+    v12 = nl.ndarray((3, 8, nl.par_dim(128), 8, 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v13 = nl.zeros((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v14 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v15 = nl.ndarray((3, 8, nl.par_dim(128), 1024), dtype=np.float32, name='w_up_local_118', buffer=nl.sbuf)
+    v16 = nl.ndarray((3, 8, 4, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v17 = nl.zeros((3, 8, 4, 8, nl.par_dim(128), 128), dtype=np.float32, name='95.193', buffer=nl.psum, lazy_initialization=True)
+    v18 = nl.ndarray((3, 8, nl.par_dim(128), 8, 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v19 = nl.zeros((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v20 = nl.ndarray(shape=(3, 8, 8, 128, 512), dtype=np.float32, name='_spill_163', buffer=nl.hbm)
+    v21 = nl.ndarray((3, 8, nl.par_dim(128), 1024), dtype=np.float32, name='w_down_local_126', buffer=nl.sbuf)
+    v22 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='_reload_166', buffer=nl.sbuf)
+    v23 = nl.zeros((8, 4, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v24 = nl.ndarray((8, 4, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v25 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v26 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v27 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v28 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v29 = nl.ndarray((3, 8, 8, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.sbuf)
+    v6[nl.arange(128)[:, None], 0] = nisa.memset(shape=(128, 1), value=np.dtype(np.uint16).type(0), dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+    v8[nl.arange(128)[:, None], nl.arange(128)[None, :]] = nl.load(v7[nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+    for i0 in nl.affine_range(3):
+        for i1 in nl.affine_range(8):
+            v9[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v4[i1, nl.arange(128)[:, None], 1024 * i0 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i1 '
+        for i2 in nl.affine_range(8):
+            for i3 in nl.affine_range(4):
+                v10[i0, i2, i3, nl.arange(128)[:, None, None], 128 * nl.arange(8)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v1[i2, i3, nl.arange(128)[:, None, None], nl.arange(8)[None, :, None], nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+                for i4 in nl.affine_range(8):
+                    v11[i0, i2, i3, i4, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v10[i0, i2, i3, nl.arange(128)[:, None], 128 * i4 + nl.arange(128)[None, :]], v8[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v12[i0, i2, nl.arange(128)[:, None], i4, 128 * i3 + nl.arange(128)[None, :]] = nl.copy(v11[i0, i2, i3, i4, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i4 '
+                ' end loop i3 '
+            for i5 in nl.affine_range(8):
+                for i6 in nl.affine_range(8):
+                    v13[i0, i2, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v9[i0, i6, nl.arange(128)[:, None], 128 * i5 + nl.arange(128)[None, :]], v12[i0, i2, nl.arange(128)[:, None], i6, nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                    ' end loop i6 '
+                v14[i0, i5, i2, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.copy(v13[i0, i2, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                ' end loop i5 '
+            ' end loop i2 '
+        ' end loop i0 '
+    for i7 in nl.affine_range(3):
+        for i8 in nl.affine_range(8):
+            v15[i7, i8, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[i8, nl.arange(128)[:, None], 1024 * i7 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i8 '
+        for i9 in nl.affine_range(8):
+            for i10 in nl.affine_range(4):
+                v16[i7, i9, i10, nl.arange(128)[:, None, None], 128 * nl.arange(8)[None, :, None] + nl.arange(128)[None, None, :]] = nl.load(v1[i9, i10, nl.arange(128)[:, None, None], nl.arange(8)[None, :, None], nl.arange(128)[None, None, :]], dtype=np.float32, mask=None)
+                for i11 in nl.affine_range(8):
+                    v17[i7, i9, i10, i11, nl.arange(128)[:, None], nl.arange(128)[None, :]] = nisa.nc_matmul(v16[i7, i9, i10, nl.arange(128)[:, None], 128 * i11 + nl.arange(128)[None, :]], v8[nl.arange(128)[:, None], nl.arange(128)[None, :]], is_stationary_onezero=False, is_moving_onezero=True, mask=None, is_transpose=True)
+                    v18[i7, i9, nl.arange(128)[:, None], i11, 128 * i10 + nl.arange(128)[None, :]] = nl.copy(v17[i7, i9, i10, i11, nl.arange(128)[:, None], nl.arange(128)[None, :]], dtype=np.float32, mask=None)
+                    ' end loop i11 '
+                ' end loop i10 '
+            for i12 in nl.affine_range(8):
+                for i13 in nl.affine_range(8):
+                    v19[i7, i12, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v15[i7, i13, nl.arange(128)[:, None], 128 * i12 + nl.arange(128)[None, :]], v18[i7, i9, nl.arange(128)[:, None], i13, nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                    ' end loop i13 '
+                v25[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.activation(op=nl.exp, data=v14[i7, i12, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], bias=v6[nl.arange(128)[:, None], 0], scale=-1.0, mask=None, dtype=np.float32)
+                v26[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.tensor_scalar(data=v25[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]], op0=nl.add, operand0=np.dtype(np.float32).type(1), reverse0=True, dtype=np.float32, mask=None, engine=nki.isa.unknown_engine)
+                v27[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nisa.reciprocal(data=v26[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, dtype=np.float32)
+                v28[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.multiply(v14[i7, i12, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], v27[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, dtype=np.float32)
+                v29[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.multiply(v28[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]], v19[i7, i12, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None, dtype=np.float32)
+                nl.store(v20[i7, i12, i9, nl.arange(128)[:, None], nl.arange(512)[None, :]], value=v29[i7, i9, i12, nl.arange(128)[:, None], nl.arange(512)[None, :]], mask=None)
+                ' end loop i12 '
+            ' end loop i9 '
+        ' end loop i7 '
+    for i14 in nl.affine_range(3):
+        for i15 in nl.affine_range(8):
+            v21[i14, i15, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v3[i15 + 8 * i14, nl.arange(128)[:, None], nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i15 '
+        ' end loop i14 '
+    for i16 in nl.affine_range(8):
+        for i17 in nl.affine_range(3):
+            for i18 in nl.affine_range(8):
+                v22[i17, i18, i16, nl.arange(128)[:, None], nl.arange(512)[None, :]] = nl.load(v20[i17, i18, i16, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                ' end loop i18 '
+            ' end loop i17 '
+        for i19 in nl.affine_range(4):
+            for i20 in nl.affine_range(2):
+                for i21 in nl.affine_range(3):
+                    for i22 in nl.affine_range(8):
+                        v23[i16, i19, i20, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v22[i21, i22, i16, nl.arange(128)[:, None], 128 * i19 + nl.arange(128)[None, :]], v21[i21, i22, nl.arange(128)[:, None], 512 * i20 + nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=None)
+                        ' end loop i22 '
+                    ' end loop i21 '
+                v24[i16, i19, nl.arange(128)[:, None], 512 * i20 + nl.arange(512)[None, :]] = nl.copy(v23[i16, i19, i20, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=None)
+                ' end loop i20 '
+            nl.store(v5[i19 + 4 * i16, nl.arange(128)[:, None], nl.arange(1024)[None, :]], value=v24[i16, i19, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=None)
+            ' end loop i19 '
+        ' end loop i16 '
+    return v5

kernels/transpose_matmul_M4096_K2048_N10944_0.py ADDED Viewed

	@@ -0,0 +1,42 @@

+import numpy as np
+import neuronxcc.nki as nki
+import neuronxcc.nki.language as nl
+import neuronxcc.nki.typing as nt
+import neuronxcc.nki.isa as nisa
+from neuronxcc.nki import trace
+from neuronxcc.nki.language import par_dim
+@nki.jit
+def kernel(v1, v2):
+    import numpy as np
+    import neuronxcc.nki as nki
+    import neuronxcc.nki.language as nl
+    import neuronxcc.nki.typing as nt
+    import neuronxcc.nki.isa as nisa
+    from neuronxcc.nki import trace
+    from neuronxcc.nki.language import par_dim
+    v3 = nl.ndarray((32, 128, 10944), dtype=np.float32, buffer=nl.shared_hbm)
+    v4 = nl.ndarray((4, 16, nl.par_dim(128), 1024), dtype=np.float32, name='lhs_local_41', buffer=nl.sbuf)
+    v5 = nl.ndarray((4, 11, 16, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    v6 = nl.zeros((4, 11, 8, 2, nl.par_dim(128), 512), dtype=np.float32, name='', buffer=nl.psum, lazy_initialization=True)
+    v7 = nl.ndarray((4, 8, 11, nl.par_dim(128), 1024), dtype=np.float32, name='', buffer=nl.sbuf)
+    for i0 in nl.affine_range(4):
+        for i1 in nl.affine_range(16):
+            v4[i0, i1, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v1[nl.arange(128)[:, None], i1, 1024 * i0 + nl.arange(1024)[None, :]], dtype=np.float32, mask=None)
+            ' end loop i1 '
+        for i2 in nl.affine_range(11):
+            for i3 in nl.affine_range(16):
+                v5[i0, i2, i3, nl.arange(128)[:, None], nl.arange(1024)[None, :]] = nl.load(v2[nl.arange(128)[:, None], i3, 1024 * i2 + nl.arange(1024)[None, :]], dtype=np.float32, mask=-1024 * i2 + -1 * nl.arange(1024)[None, :] + 10943 >= 0)
+                ' end loop i3 '
+            for i4 in nl.affine_range(8):
+                for i5 in nl.affine_range(2):
+                    for i6 in nl.affine_range(16):
+                        v6[i0, i2, i4, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]] += nisa.nc_matmul(v4[i0, i6, nl.arange(128)[:, None], nl.arange(128)[None, :] + 128 * i4], v5[i0, i2, i6, nl.arange(128)[:, None], 512 * i5 + nl.arange(512)[None, :]], is_stationary_onezero=False, is_moving_onezero=False, mask=-512 * i5 + -1024 * i2 + -1 * nl.arange(512)[None, :] + 10943 >= 0)
+                        ' end loop i6 '
+                    v7[i0, i4, i2, nl.arange(128)[:, None], 512 * i5 + nl.arange(512)[None, :]] = nl.copy(v6[i0, i2, i4, i5, nl.arange(128)[:, None], nl.arange(512)[None, :]], dtype=np.float32, mask=-512 * i5 + -1024 * i2 + -1 * nl.arange(512)[None, :] + 10943 >= 0)
+                    ' end loop i5 '
+                nl.store(v3[8 * i0 + i4, nl.arange(128)[:, None], 1024 * i2 + nl.arange(1024)[None, :]], value=v7[i0, i4, i2, nl.arange(128)[:, None], nl.arange(1024)[None, :]], mask=-1024 * i2 + -1 * nl.arange(1024)[None, :] + 10943 >= 0)
+                ' end loop i4 '
+            ' end loop i2 '
+        ' end loop i0 '
+    return v3

reference/adamw_M10944_N2048_numpy_1.py ADDED Viewed

	@@ -0,0 +1,49 @@

+import numpy as np
+M = 10944
+N = 2048
+def get_inputs():
+    theta = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+    g = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+    m = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+    v = np.abs(np.random.normal(loc=0, scale=1.0, size=(M, N))).astype(np.float32)
+    return [theta, g, m, v]
+def forward(theta, g, m, v):
+  theta_t = theta - 1e-5 * theta
+  m_t = 0.9 * m + 0.1 * g
+  v_t = 0.999 * v + 0.001 * g * g
+  v_hat = v_t * 1000
+  new_theta_t = theta_t - 0.01 * m_t / (np.sqrt(v_hat) + 1e-8)
+  return new_theta_t
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (10944, 2048)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (10944, 2048)))  # input[1] -> tensor_input[1]
+    tensor_inputs.append(np.reshape(inputs[2], (10944, 2048)))  # input[2] -> tensor_input[2]
+    tensor_inputs.append(np.reshape(inputs[3], (10944, 2048)))  # input[3] -> tensor_input[3]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/add_rmsnorm_matmul_M4096_N2048_K1024_numpy_1.py ADDED Viewed

	@@ -0,0 +1,48 @@

+import numpy as np
+M = 4096
+N = 2048
+K = 1024
+def get_inputs():
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  eps = 1e-5
+  z = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  g = np.random.normal(loc=0, scale=1.0, size=(K,)).astype(np.float32)
+  return [x, w, eps, z, g]
+def forward(x, w, eps, z, g):
+  y = x + z
+  t = np.square(y)
+  t = np.divide(t, y.shape[-1])
+  t = np.sum(t, axis=-1, keepdims=True)
+  t = (t + eps).astype(y.dtype)
+  y = y / np.sqrt(t)
+  y = y * g
+  return np.matmul(y, w)
+def transform_to_nki_inputs(inputs):
+    return inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/bmm_B16_M4096_K64_N4096_numpy_1.py ADDED Viewed

	@@ -0,0 +1,42 @@

+import numpy as np
+B = 16
+K = 64
+M = 4096
+N = 4096
+def get_inputs():
+    lhs = np.random.normal(loc=0, scale=1.0, size=(B, M, K)).astype(np.float32)
+    rhs = np.random.normal(loc=0, scale=1.0, size=(B, K, N)).astype(np.float32)
+    return [lhs, rhs]
+def forward(lhs, rhs):
+  return np.matmul(lhs, rhs)
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (16, 4096, 64)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (16, 64, 4096)))  # input[1] -> tensor_input[1]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/bmm_softmax_B16_K64_M4096_N4096_numpy_1.py ADDED Viewed

	@@ -0,0 +1,46 @@

+import numpy as np
+B = 16
+K = 64
+M = 4096
+N = 4096
+def get_inputs():
+    lhs = np.random.normal(loc=0, scale=1.0, size=(B, M, K)).astype(np.float32)
+    rhs = np.random.normal(loc=0, scale=1.0, size=(B, K, N)).astype(np.float32)
+    return [lhs, rhs]
+def forward(lhs, rhs):
+  x = np.matmul(lhs, rhs)
+  max_x = np.max(x, axis=2, keepdims=True)
+  exp_x = np.exp(x - max_x)
+  sum_exp = np.sum(exp_x, axis=2, keepdims=True)
+  return exp_x / sum_exp
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (16, 4096, 64)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (16, 64, 4096)))  # input[1] -> tensor_input[1]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/gqa_full_B1_N4096_QH16_KH8_D128_numpy_2.py ADDED Viewed

	@@ -0,0 +1,58 @@

+import numpy as np
+B = 1
+N = 4096
+QH = 16
+KH = 8
+D = 128
+def get_inputs():
+    q = np.random.normal(loc=0, scale=1.0, size=(B, N, QH, D)).astype(np.float32)
+    k = np.random.normal(loc=0, scale=1.0, size=(B, N, KH, D)).astype(np.float32)
+    v = np.random.normal(loc=0, scale=1.0, size=(B, N, KH, D)).astype(np.float32)
+    return [q, k, v]
+def forward(q, k, v):
+  n_rep = QH // KH
+  xk = np.repeat(k, n_rep, axis=2)
+  xv = np.repeat(v, n_rep, axis=2)
+  xq = q.transpose(0, 2, 1, 3)
+  xk = xk.transpose(0, 2, 1, 3)
+  xv = xv.transpose(0, 2, 1, 3)
+  attention = (xq @ xk.transpose(0, 1, 3, 2)) / np.float32(np.sqrt(D))
+  exp_attention = np.exp(attention - np.max(attention, axis=-1, keepdims=True))
+  attention = exp_attention / np.sum(exp_attention, axis=-1, keepdims=True)
+  output = attention @ xv
+  return output
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (32, 128, 16, 128)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (1, 8, 4, 128, 8, 128)))  # input[1] -> tensor_input[1]
+    tensor_inputs.append(np.reshape(inputs[2], (1, 32, 128, 1024)))  # input[2] -> tensor_input[2]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/lora_M4096_N12288_K5120_R128_numpy_1.py ADDED Viewed

	@@ -0,0 +1,48 @@

+import numpy as np
+M = 4096
+N = 12288
+K = 5120
+R = 128
+def get_inputs():
+    x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+    w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+    a = np.random.normal(loc=0, scale=1.0, size=(K, R)).astype(np.float32)
+    b = np.random.normal(loc=0, scale=1.0, size=(R, N)).astype(np.float32)
+    return [x, w, a, b]
+def forward(x, w, a, b):
+  y1 = np.matmul(x, w)
+  y2 = np.matmul(np.matmul(x, a), b)
+  return y1 + y2
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (8, 4, 128, 40, 128)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (40, 128, 12288)))  # input[1] -> tensor_input[1]
+    tensor_inputs.append(np.reshape(inputs[2], (40, 128, 128)))  # input[2] -> tensor_input[2]
+    tensor_inputs.append(np.reshape(inputs[3], (128, 12288)))  # input[3] -> tensor_input[3]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/mamba_M7168_C256_S16_numpy_1.py ADDED Viewed

	@@ -0,0 +1,44 @@

+import numpy as np
+M = 7168
+C = 256
+S = 16
+def get_inputs():
+    delta = np.random.normal(loc=0, scale=0.05, size=(C, M)).astype(np.float32)
+    u = np.random.normal(loc=0, scale=0.05, size=(C, M)).astype(np.float32)
+    a = np.random.normal(loc=0, scale=0.05, size=(C, S)).astype(np.float32)
+    b = np.random.normal(loc=0, scale=0.05, size=(S, M)).astype(np.float32)
+    c = np.random.normal(loc=0, scale=0.05, size=(S, M)).astype(np.float32)
+    return [delta, u, a, b, c]
+def forward(delta, u, a, b, c):
+  deltaA = np.exp(delta[:, None, :] * a[:, :, None])
+  deltaB_u = delta[:, None, :] * b[None, :, :] * u[:, None, :]
+  scan_res = np.ndarray((C, S, M), dtype=np.float32)
+  for i in range(M):
+      prev_state = scan_res[..., i - 1] if i > 0 else 0
+      scan_res[..., i] = deltaA[..., i] * prev_state + deltaB_u[..., i]
+  out = np.sum(c[None, :, :] * scan_res, axis=-2)
+  return out
+def transform_to_nki_inputs(inputs):
+    return inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/matmul_M4096_N12288_K5120_numpy_2.py ADDED Viewed

	@@ -0,0 +1,41 @@

+import numpy as np
+M = 4096
+N = 12288
+K = 5120
+def get_inputs():
+    lhs = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+    rhs = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+    return [lhs, rhs]
+def forward(lhs, rhs):
+  return np.matmul(lhs, rhs)
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (32, 128, 40, 128)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (40, 128, 12288)))  # input[1] -> tensor_input[1]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/matmul_add_rmsnorm_M4096_N2048_K2048_numpy_1.py ADDED Viewed

	@@ -0,0 +1,42 @@

+import numpy as np
+M = 4096
+N = 2048
+K = 2048
+def get_inputs():
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  eps = 1e-5
+  z = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+  g = np.random.normal(loc=0, scale=1.0, size=(N,)).astype(np.float32)
+  return [x, w, eps, z, g]
+def forward(x, w, eps, z, g):
+  y = np.matmul(x, w) + z
+  rms = np.sqrt(np.mean(y ** 2, axis=-1, keepdims=True) + eps)
+  return y * g / rms
+def transform_to_nki_inputs(inputs):
+    return inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/rmsnorm_matmul_M4096_N2048_K1024_numpy_1.py ADDED Viewed

	@@ -0,0 +1,54 @@

+import numpy as np
+M = 4096
+N = 2048
+K = 1024
+def get_inputs():
+    x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+    w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+    return [x, w]
+def forward(input_tensor, weight_matrix):
+  # RMSNorm calculations
+  squared_input = np.square(input_tensor)
+  scaled_square = np.divide(squared_input, K)
+  rms_sum = np.sum(scaled_square, axis=1, keepdims=True)
+  rms_norm = np.sqrt(rms_sum)
+  normalized = np.divide(input_tensor, rms_norm)
+  # Matrix multiplication
+  matmul_result = np.matmul(normalized, weight_matrix)
+  return matmul_result
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (32, 128, 1024)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (8, 128, 2048)))  # input[1] -> tensor_input[1]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/rope_single_freq_apply_B1_H64_N4096_D128_numpy_1.py ADDED Viewed

	@@ -0,0 +1,27 @@

+import numpy as np
+B = 1
+H = 64
+N = 4096
+D = 128
+def get_inputs():
+    x = np.random.normal(loc=0, scale=1.0, size=(D, B*H*N)).astype(np.float32)
+    freqs_cos = np.random.normal(loc=0, scale=1.0, size=(D // 2, B*H*N)).astype(np.float32)
+    freqs_sin = np.random.normal(loc=0, scale=1.0, size=(D // 2, B*H*N)).astype(np.float32)
+    return [x, freqs_cos, freqs_sin]
+def forward(x, freqs_cos, freqs_sin):
+    half_h = D // 2
+    x0 = x[:half_h, :]
+    x1 = x[half_h:, :]
+    x_out_0 = x0 * freqs_cos - x1 * freqs_sin
+    x_out_1 = x0 * freqs_sin + x1 * freqs_cos
+    x_out = np.concatenate([x_out_0, x_out_1], axis=0)
+    return x_out
+def transform_to_nki_inputs(inputs):
+    return inputs
+def transform_nki_outputs(k_res, ref):
+    return (k_res,)

reference/silu_M4096_N7168_numpy_0.py ADDED Viewed

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

+import numpy as np
+M = 4096
+N = 7168
+def get_inputs():
+    x = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+    return [x]
+def forward(x):
+  return x / (1 + np.exp(-x))
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (128, 32, 7168)))  # input[0] -> tensor_input[0]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/swiglu_M4096_N3072_K1024_numpy_2.py ADDED Viewed

	@@ -0,0 +1,48 @@

+import numpy as np
+M = 4096
+N = 3072
+K = 1024
+def get_inputs():
+    x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+    w_up = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+    w_down = np.random.normal(loc=0, scale=1.0, size=(N, K)).astype(np.float32)
+    w_gate = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+    return [x, w_up, w_down, w_gate]
+def forward(x, w_up, w_down, w_gate):
+  up_feature = np.matmul(x, w_up)
+  gate_feature = np.matmul(x, w_gate)
+  activated_gate_feature = gate_feature / (1 + np.exp(-gate_feature))
+  return np.matmul(activated_gate_feature * up_feature, w_down)
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (8, 4, 128, 8, 128)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (8, 128, 3072)))  # input[1] -> tensor_input[1]
+    tensor_inputs.append(np.reshape(inputs[2], (24, 128, 1024)))  # input[2] -> tensor_input[2]
+    tensor_inputs.append(np.reshape(inputs[3], (8, 128, 3072)))  # input[3] -> tensor_input[3]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

reference/transpose_matmul_M4096_K2048_N10944_numpy_1.py ADDED Viewed

	@@ -0,0 +1,42 @@

+import numpy as np
+M = 4096
+N = 10944
+K = 2048
+def get_inputs():
+    lhs = np.random.normal(loc=0, scale=1.0, size=(K, M)).astype(np.float32)
+    rhs = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+    return [lhs, rhs]
+def forward(lhs, rhs):
+  lhs_t = np.transpose(lhs, axes=(1, 0))
+  return np.matmul(lhs_t, rhs)
+def transform_to_nki_inputs(inputs):
+    tensor_inputs = []
+    tensor_inputs.append(np.reshape(inputs[0], (128, 16, 4096)))  # input[0] -> tensor_input[0]
+    tensor_inputs.append(np.reshape(inputs[1], (128, 16, 10944)))  # input[1] -> tensor_input[1]
+    return tensor_inputs
+def transform_nki_outputs(k_res, ref):
+    # Ensure outputs are in tuple form
+    if not isinstance(k_res, tuple):
+        k_res = (k_res,)
+    refs = ref if isinstance(ref, tuple) else (ref,)
+    k_outs = []
+    for v, r in zip(k_res, refs):
+        if hasattr(r, "shape"):
+            k_outs.append(np.reshape(v, r.shape))
+        else:
+            k_outs.append(v)
+    return k_outs

seeds/adamw.yaml ADDED Viewed

	@@ -0,0 +1,24 @@

+test_name: adamw
+parameters:
+- M
+- N
+input: |
+  theta = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+  g = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+  m = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+  v = np.abs(np.random.normal(loc=0, scale=1.0, size=(M, N))).astype(np.float32)
+  return [theta, g, m, v]
+impl: |
+  def forward(theta, g, m, v):
+    theta_t = theta - 1e-5 * theta
+    m_t = 0.9 * m + 0.1 * g
+    v_t = 0.999 * v + 0.001 * g * g
+    v_hat = v_t * 1000
+    new_theta_t = theta_t - 0.01 * m_t / (np.sqrt(v_hat) + 1e-8)
+    return new_theta_t
+comments: |
+  AdamW update at t=1, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01

seeds/add_rmsnorm_matmul.yaml ADDED Viewed

	@@ -0,0 +1,25 @@

+test_name: add_rmsnorm_matmul
+parameters:
+- M
+- N
+- K
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  eps = 1e-5
+  z = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  g = np.random.normal(loc=0, scale=1.0, size=(K,)).astype(np.float32)
+  return [x, w, eps, z, g]
+impl: |
+  def forward(x, w, eps, z, g):
+    y = x + z
+    t = np.square(y)
+    t = np.divide(t, y.shape[-1])
+    t = np.sum(t, axis=-1, keepdims=True)
+    t = (t + eps).astype(y.dtype)
+    y = y / np.sqrt(t)
+    y = y * g
+    return np.matmul(y, w)

seeds/bmm.yaml ADDED Viewed

	@@ -0,0 +1,16 @@

+test_name: bmm
+parameters:
+- B
+- M
+- K
+- N
+input: |
+  lhs = np.random.normal(loc=0, scale=1.0, size=(B, M, K)).astype(np.float32)
+  rhs = np.random.normal(loc=0, scale=1.0, size=(B, K, N)).astype(np.float32)
+  return [lhs, rhs]
+impl: |
+  def forward(lhs, rhs):
+    return np.matmul(lhs, rhs)

seeds/bmm_softmax.yaml ADDED Viewed

	@@ -0,0 +1,20 @@

+test_name: bmm_softmax
+parameters:
+- B
+- K
+- M
+- N
+input: |
+  lhs = np.random.normal(loc=0, scale=1.0, size=(B, M, K)).astype(np.float32)
+  rhs = np.random.normal(loc=0, scale=1.0, size=(B, K, N)).astype(np.float32)
+  return [lhs, rhs]
+impl: |
+  def forward(lhs, rhs):
+    x = np.matmul(lhs, rhs)
+    max_x = np.max(x, axis=2, keepdims=True)
+    exp_x = np.exp(x - max_x)
+    sum_exp = np.sum(exp_x, axis=2, keepdims=True)
+    return exp_x / sum_exp

seeds/gqa_full.yaml ADDED Viewed

	@@ -0,0 +1,32 @@

+test_name: gqa_full
+parameters:
+- B
+- N
+- QH
+- KH
+- D
+input: |
+  q = np.random.normal(loc=0, scale=1.0, size=(B, N, QH, D)).astype(np.float32)
+  k = np.random.normal(loc=0, scale=1.0, size=(B, N, KH, D)).astype(np.float32)
+  v = np.random.normal(loc=0, scale=1.0, size=(B, N, KH, D)).astype(np.float32)
+  return [q, k, v]
+impl: |
+  def forward(q, k, v):
+    n_rep = QH // KH
+    xk = np.repeat(k, n_rep, axis=2)
+    xv = np.repeat(v, n_rep, axis=2)
+    xq = q.transpose(0, 2, 1, 3)
+    xk = xk.transpose(0, 2, 1, 3)
+    xv = xv.transpose(0, 2, 1, 3)
+    attention = (xq @ xk.transpose(0, 1, 3, 2)) / np.float32(np.sqrt(D))
+    exp_attention = np.exp(attention - np.max(attention, axis=-1, keepdims=True))
+    attention = exp_attention / np.sum(exp_attention, axis=-1, keepdims=True)
+    output = attention @ xv
+    return output

seeds/lora.yaml ADDED Viewed

	@@ -0,0 +1,20 @@

+test_name: lora
+parameters:
+- M
+- N
+- K
+- R
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  a = np.random.normal(loc=0, scale=1.0, size=(K, R)).astype(np.float32)
+  b = np.random.normal(loc=0, scale=1.0, size=(R, N)).astype(np.float32)
+  return [x, w, a, b]
+impl: |
+  def forward(x, w, a, b):
+    y1 = np.matmul(x, w)
+    y2 = np.matmul(np.matmul(x, a), b)
+    return y1 + y2

seeds/mamba.yaml ADDED Viewed

	@@ -0,0 +1,25 @@

+test_name: mamba
+parameters:
+- M
+- C
+- S
+input: |
+    delta = np.random.normal(loc=0, scale=0.05, size=(C, M)).astype(np.float32)
+    u = np.random.normal(loc=0, scale=0.05, size=(C, M)).astype(np.float32)
+    a = np.random.normal(loc=0, scale=0.05, size=(C, S)).astype(np.float32)
+    b = np.random.normal(loc=0, scale=0.05, size=(S, M)).astype(np.float32)
+    c = np.random.normal(loc=0, scale=0.05, size=(S, M)).astype(np.float32)
+    return [delta, u, a, b, c]
+impl: |
+  def forward(delta, u, a, b, c):
+    deltaA = np.exp(delta[:, None, :] * a[:, :, None])
+    deltaB_u = delta[:, None, :] * b[None, :, :] * u[:, None, :]
+    scan_res = np.ndarray((C, S, M), dtype=np.float32)
+    for i in range(M):
+        prev_state = scan_res[..., i - 1] if i > 0 else 0
+        scan_res[..., i] = deltaA[..., i] * prev_state + deltaB_u[..., i]
+    out = np.sum(c[None, :, :] * scan_res, axis=-2)
+    return out

seeds/matmul.yaml ADDED Viewed

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

+test_name: matmul
+parameters:
+- M
+- N
+- K
+input: |
+  lhs = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  rhs = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  return [lhs, rhs]
+impl: |
+  def forward(lhs, rhs):
+    return np.matmul(lhs, rhs)

seeds/matmul_add_rmsnorm.yaml ADDED Viewed

	@@ -0,0 +1,20 @@

+test_name: matmul_add_rmsnorm
+parameters:
+- M
+- N
+- K
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  eps = 1e-5
+  z = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+  g = np.random.normal(loc=0, scale=1.0, size=(N,)).astype(np.float32)
+  return [x, w, eps, z, g]
+impl: |
+  def forward(x, w, eps, z, g):
+    y = np.matmul(x, w) + z
+    rms = np.sqrt(np.mean(y ** 2, axis=-1, keepdims=True) + eps)
+    return y * g / rms

seeds/rmsnorm_matmul.yaml ADDED Viewed

	@@ -0,0 +1,30 @@

+test_name: rmsnorm_matmul
+parameters:
+- M
+- N
+- K
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  return [x, w]
+impl: |
+  def forward(input_tensor, weight_matrix):
+    # RMSNorm calculations
+    squared_input = np.square(input_tensor)
+    scaled_square = np.divide(squared_input, K)
+    rms_sum = np.sum(scaled_square, axis=1, keepdims=True)
+    rms_norm = np.sqrt(rms_sum)
+    normalized = np.divide(input_tensor, rms_norm)
+    # Matrix multiplication
+    matmul_result = np.matmul(normalized, weight_matrix)
+    return matmul_result
+comments: |
+  This is a simple RMSNorm (without learnable parameters) + Matmul kernel. NeuronPy compiler can lower this.

seeds/rope_single_freq_apply.yaml ADDED Viewed

	@@ -0,0 +1,23 @@

+test_name: rope_single_freq_apply
+parameters:
+- B
+- H
+- N
+- D
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(D, B*H*N)).astype(np.float32)
+  freqs_cos = np.random.normal(loc=0, scale=1.0, size=(D // 2, B*H*N)).astype(np.float32)
+  freqs_sin = np.random.normal(loc=0, scale=1.0, size=(D // 2, B*H*N)).astype(np.float32)
+  return [x, freqs_cos, freqs_sin]
+impl: |
+  def forward(x, freqs_cos, freqs_sin):
+    half_h = D // 2
+    x0 = x[:half_h, :]
+    x1 = x[half_h:, :]
+    x_out_0 = x0 * freqs_cos - x1 * freqs_sin
+    x_out_1 = x0 * freqs_sin + x1 * freqs_cos
+    x_out = np.concatenate([x_out_0, x_out_1], axis=0)
+    return x_out

seeds/silu.yaml ADDED Viewed

	@@ -0,0 +1,13 @@

+test_name: silu
+parameters:
+- M
+- N
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(M, N)).astype(np.float32)
+  return [x]
+impl: |
+  def forward(x):
+    return x / (1 + np.exp(-x))

seeds/swiglu.yaml ADDED Viewed

	@@ -0,0 +1,20 @@

+test_name: swiglu
+parameters:
+- M
+- N
+- K
+input: |
+  x = np.random.normal(loc=0, scale=1.0, size=(M, K)).astype(np.float32)
+  w_up = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  w_down = np.random.normal(loc=0, scale=1.0, size=(N, K)).astype(np.float32)
+  w_gate = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  return [x, w_up, w_down, w_gate]
+impl: |
+  def forward(x, w_up, w_down, w_gate):
+    up_feature = np.matmul(x, w_up)
+    gate_feature = np.matmul(x, w_gate)
+    activated_gate_feature = gate_feature / (1 + np.exp(-gate_feature))
+    return np.matmul(activated_gate_feature * up_feature, w_down)

seeds/transpose_matmul.yaml ADDED Viewed

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

+test_name: transpose_matmul
+parameters:
+- M
+- K
+- N
+input: |
+  lhs_t = np.random.normal(loc=0, scale=1.0, size=(K, M)).astype(np.float32)
+  rhs = np.random.normal(loc=0, scale=1.0, size=(K, N)).astype(np.float32)
+  return [lhs_t, rhs]
+impl: |
+  def forward(lhs_t, rhs):
+    return np.matmul(np.transpose(lhs_t, axes=(1, 0)), rhs)

summary.json ADDED Viewed

	@@ -0,0 +1,258 @@

+{
+    "swiglu": {
+        "seed": "./seeds/swiglu.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "K": 1024,
+                    "M": 4096,
+                    "N": 3072
+                },
+                "impls": [
+                    {
+                        "task": "./reference/swiglu_M4096_N3072_K1024_numpy_2.py",
+                        "kernel": "./kernels/swiglu_M4096_N3072_K1024_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "matmul_add_rmsnorm": {
+        "seed": "./seeds/matmul_add_rmsnorm.yaml",
+        "cases": {
+            "1": {
+                "values": {
+                    "K": 2048,
+                    "M": 4096,
+                    "N": 2048
+                },
+                "impls": [
+                    {
+                        "task": "./reference/matmul_add_rmsnorm_M4096_N2048_K2048_numpy_1.py",
+                        "kernel": "./kernels/matmul_add_rmsnorm_M4096_N2048_K2048_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "add_rmsnorm_matmul": {
+        "seed": "./seeds/add_rmsnorm_matmul.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "K": 1024,
+                    "M": 4096,
+                    "N": 2048
+                },
+                "impls": [
+                    {
+                        "task": "./reference/add_rmsnorm_matmul_M4096_N2048_K1024_numpy_1.py",
+                        "kernel": "./kernels/add_rmsnorm_matmul_M4096_N2048_K1024_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "matmul": {
+        "seed": "./seeds/matmul.yaml",
+        "cases": {
+            "3": {
+                "values": {
+                    "K": 5120,
+                    "M": 4096,
+                    "N": 12288
+                },
+                "impls": [
+                    {
+                        "task": "./reference/matmul_M4096_N12288_K5120_numpy_2.py",
+                        "kernel": "./kernels/matmul_M4096_N12288_K5120_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "gqa_full": {
+        "seed": "./seeds/gqa_full.yaml",
+        "cases": {
+            "0": {
+                "values": {
+                    "B": 1,
+                    "D": 128,
+                    "KH": 8,
+                    "N": 4096,
+                    "QH": 16
+                },
+                "impls": [
+                    {
+                        "task": "./reference/gqa_full_B1_N4096_QH16_KH8_D128_numpy_2.py",
+                        "kernel": "./kernels/gqa_full_B1_N4096_QH16_KH8_D128_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "rmsnorm_matmul": {
+        "seed": "./seeds/rmsnorm_matmul.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "K": 1024,
+                    "M": 4096,
+                    "N": 2048
+                },
+                "impls": [
+                    {
+                        "task": "./reference/rmsnorm_matmul_M4096_N2048_K1024_numpy_1.py",
+                        "kernel": "./kernels/rmsnorm_matmul_M4096_N2048_K1024_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "rope_single_freq_apply": {
+        "seed": "./seeds/rope_single_freq_apply.yaml",
+        "cases": {
+            "1": {
+                "values": {
+                    "B": 1,
+                    "H": 64,
+                    "N": 4096,
+                    "D": 128
+                },
+                "impls": [
+                    {
+                        "task": "./reference/rope_single_freq_apply_B1_H64_N4096_D128_numpy_1.py",
+                        "kernel": "./kernels/rope_single_freq_apply_B1_H64_N4096_D128_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "bmm": {
+        "seed": "./seeds/bmm.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "B": 16,
+                    "K": 64,
+                    "M": 4096,
+                    "N": 4096
+                },
+                "impls": [
+                    {
+                        "task": "./reference/bmm_B16_M4096_K64_N4096_numpy_1.py",
+                        "kernel": "./kernels/bmm_B16_M4096_K64_N4096_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "bmm_softmax": {
+        "seed": "./seeds/bmm_softmax.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "B": 16,
+                    "K": 64,
+                    "M": 4096,
+                    "N": 4096
+                },
+                "impls": [
+                    {
+                        "task": "./reference/bmm_softmax_B16_K64_M4096_N4096_numpy_1.py",
+                        "kernel": "./kernels/bmm_softmax_B16_K64_M4096_N4096_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "transpose_matmul": {
+        "seed": "./seeds/transpose_matmul.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "K": 2048,
+                    "M": 4096,
+                    "N": 10944
+                },
+                "impls": [
+                    {
+                        "task": "./reference/transpose_matmul_M4096_K2048_N10944_numpy_1.py",
+                        "kernel": "./kernels/transpose_matmul_M4096_K2048_N10944_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "lora": {
+        "seed": "./seeds/lora.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "K": 5120,
+                    "M": 4096,
+                    "N": 12288,
+                    "R": 128
+                },
+                "impls": [
+                    {
+                        "task": "./reference/lora_M4096_N12288_K5120_R128_numpy_1.py",
+                        "kernel": "./kernels/lora_M4096_N12288_K5120_R128_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "adamw": {
+        "seed": "./seeds/adamw.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "M": 10944,
+                    "N": 2048
+                },
+                "impls": [
+                    {
+                        "task": "./reference/adamw_M10944_N2048_numpy_1.py",
+                        "kernel": "./kernels/adamw_M10944_N2048_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "silu": {
+        "seed": "./seeds/silu.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "M": 4096,
+                    "N": 7168
+                },
+                "impls": [
+                    {
+                        "task": "./reference/silu_M4096_N7168_numpy_0.py",
+                        "kernel": "./kernels/silu_M4096_N7168_0.py"
+                    }
+                ]
+            }
+        }
+    },
+    "mamba": {
+        "seed": "./seeds/mamba.yaml",
+        "cases": {
+            "2": {
+                "values": {
+                    "C": 256,
+                    "M": 7168,
+                    "S": 16
+                },
+                "impls": [
+                    {
+                        "task": "./reference/mamba_M7168_C256_S16_numpy_1.py",
+                        "kernel": "./kernels/mamba_M7168_C256_S16_0.py"
+                    }
+                ]
+            }
+        }
+    }
+}