Dataset Preview
The full dataset viewer is not available (click to read why). Only showing a preview of the rows.
The dataset generation failed
Error code: DatasetGenerationError
Exception: TypeError
Message: Couldn't cast array of type string to null
Traceback: Traceback (most recent call last):
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1835, in _prepare_split_single
for key, table in generator:
^^^^^^^^^
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 621, in wrapped
for item in generator(*args, **kwargs):
~~~~~~~~~^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 361, in _generate_tables
self._cast_table(pa_table, json_field_paths=json_field_paths),
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 132, in _cast_table
pa_table = table_cast(pa_table, self.info.features.arrow_schema)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2381, in table_cast
return cast_table_to_schema(table, schema)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2315, in cast_table_to_schema
cast_array_to_feature(
~~~~~~~~~~~~~~~~~~~~~^
table[name] if name in table_column_names else pa.array([None] * len(table), type=schema.field(name).type),
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
feature,
^^^^^^^^
)
^
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 1861, in wrapper
return pa.chunked_array([func(chunk, *args, **kwargs) for chunk in array.chunks])
~~~~^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2071, in cast_array_to_feature
_c(children[name] if name in array_fields else null_array, subfeature)
~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 1863, in wrapper
return func(array, *args, **kwargs)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2121, in cast_array_to_feature
casted_array_values = _c(array.values, feature.feature)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 1863, in wrapper
return func(array, *args, **kwargs)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2155, in cast_array_to_feature
return array_cast(
array,
...<2 lines>...
allow_decimal_to_str=allow_decimal_to_str,
)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 1863, in wrapper
return func(array, *args, **kwargs)
File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2014, in array_cast
raise TypeError(f"Couldn't cast array of type {_short_str(array.type)} to {_short_str(pa_type)}")
TypeError: Couldn't cast array of type string to null
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 1379, in compute_config_parquet_and_info_response
parquet_operations, partial, estimated_dataset_info = stream_convert_to_parquet(
~~~~~~~~~~~~~~~~~~~~~~~~~^
builder, max_dataset_size_bytes=max_dataset_size_bytes
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
)
^
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 956, in stream_convert_to_parquet
builder._prepare_split(split_generator=splits_generators[split], file_format="parquet")
~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1702, in _prepare_split
for job_id, done, content in self._prepare_split_single(
~~~~~~~~~~~~~~~~~~~~~~~~~~^
gen_kwargs=gen_kwargs, job_id=job_id, **_prepare_split_args
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
):
^
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1887, in _prepare_split_single
raise DatasetGenerationError("An error occurred while generating the dataset") from e
datasets.exceptions.DatasetGenerationError: An error occurred while generating the datasetNeed help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.
step int64 | call int64 | index int64 | task string | seed int64 | text string | reward float64 | result dict |
|---|---|---|---|---|---|---|---|
0 | 1 | 0 | level1/40_LayerNorm | 20,261,121 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization
# This kernel fuses the mean calculation, variance calculation, and the
# final scaling/shifting into a single pass over the normalization dimension.
# It handles multi-dimensional no... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0027952189,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.7310395688,
"peak_rss_bytes": 1260642304,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
0 | 1 | 1 | level1/40_LayerNorm | 20,261,122 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization.
# This kernel performs fusion of mean and variance calculation followed by normalization.
# It uses a two-pass approach (or one pass with shared memory depending on size)
# but is optimized... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 1.7496742513,
"peak_rss_bytes": 1009508352,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs... |
0 | 1 | 2 | level1/40_LayerNorm | 20,261,123 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of LayerNorm for high performance on Blackwell.
# It performs fusion of mean, variance, and the final scaling/shifting
# in a single pass (or minimal passes) to maximize memory bandwidth.
@triton.autotune(
... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0022829328,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.9540794529000003,
"peak_rss_bytes": 1260711936,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp... |
0 | 1 | 3 | level1/40_LayerNorm | 20,261,124 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of LayerNorm for high performance on Blackwell architecture.
# This kernel fuses the mean and variance calculation into a single pass (or minimal passes)
# and performs the normalization in a fused kernel to... | 1 | {
"component": "correct",
"correct": true,
"speedup": 0.9854601095,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 3.3972501364,
"peak_rss_bytes": 1259839488,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
0 | 1 | 4 | level1/40_LayerNorm | 20,261,125 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization.
# This implementation fuses the mean, variance, and normalization steps
# into a single pass (plus a reduction pass) to minimize memory traffic.
# Optimization: Use a two-pass reduction (su... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0022690357,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 3.4522173069,
"peak_rss_bytes": 1260584960,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
0 | 1 | 5 | level1/40_LayerNorm | 20,261,126 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton Kernel for Layer Normalization
# This kernel fuses the mean and variance calculation and the normalization step
# into a single pass over the last dimension (normalized_shape).
# It uses a block-based reduction for the mea... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 2.2348075323,
"peak_rss_bytes": 893915136,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs/... |
0 | 1 | 6 | level1/40_LayerNorm | 20,261,127 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of LayerNorm
# This kernel fuses the mean and variance calculation into a single pass over the
# last dimension, reducing memory bandwidth requirements significantly compared
# to eager PyTorch's multi-pas... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0018737454,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 3.1965267118,
"peak_rss_bytes": 1261142016,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
0 | 1 | 7 | level1/40_LayerNorm | 20,261,128 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton Kernel for Fused Layer Normalization
# This kernel handles the mean and variance calculation in a single pass
# for the last dimension, then applies the scaling and shifting.
# It uses a block-based reduction for the mean ... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 2.1488882415,
"peak_rss_bytes": 894771200,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs/... |
1 | 2 | 0 | level1/40_LayerNorm | 20,361,221 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton Kernel for Layer Normalization
# This kernel fuses the mean, variance, and normalization into a single pass
# to minimize memory reads/writes on the RTX PRO 6000 Blackwell.
@triton.autotune(
configs=[
triton.Co... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 1.9614749961000002,
"peak_rss_bytes": 1002795008,
"peak_gpu_bytes": 1421148160,
"workdir": "/root/autodl-tmp/cuda-... |
1 | 2 | 1 | level1/40_LayerNorm | 20,361,222 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization
# Optimized for Blackwell architecture by using efficient reductions and
# fused scale/shift operations to minimize memory passes.
@triton.autotune(
configs=[
triton.Config({'BLO... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0002860103,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.6782392282,
"peak_rss_bytes": 1259929600,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
1 | 2 | 2 | level1/40_LayerNorm | 20,361,223 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton Kernel for Layer Normalization
# Optimized for Blackwell (high memory bandwidth, large threads per block)
# This kernel performs the mean and variance reduction in a single pass over the last dimension.
@triton.jit
def _la... | 1 | {
"component": "correct",
"correct": true,
"speedup": 0.9999459936,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.6217882838,
"peak_rss_bytes": 1259900928,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
1 | 2 | 3 | level1/40_LayerNorm | 20,361,224 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization for high-performance GPU execution.
# This kernel fuses the mean, variance, and normalization steps into a single pass
# over the reduction dimension to minimize memory bandwidth usage... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.00020086,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.8440282103000003,
"peak_rss_bytes": 1260736512,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/c... |
1 | 2 | 4 | level1/40_LayerNorm | 20,361,225 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization
# This kernel fuses mean, variance, and normalization into a single pass
# to minimize memory bandwidth usage (O(1) pass over the normalized dimensions).
@triton.autotune(
configs=[
... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 2.1018351149,
"peak_rss_bytes": 940929024,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs/... |
1 | 2 | 5 | level1/40_LayerNorm | 20,361,226 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization
# This kernel fuses the mean and variance calculation into a single pass (or minimal passes)
# and performs the normalization in a single fused operation to minimize memory bandwidth.
@triton... | -0.1 | {
"component": "format",
"correct": false,
"speedup": null,
"hacks": [],
"details": {}
} |
1 | 2 | 6 | level1/40_LayerNorm | 20,361,227 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization.
# This fuses the mean, variance, and normalization steps into a single pass
# over the last dimension of the tensor, significantly reducing memory traffic
# compared to the eager PyTorch imp... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0001105928,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.8866117243,
"peak_rss_bytes": 1259999232,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
1 | 2 | 7 | level1/40_LayerNorm | 20,361,228 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization
# Optimized for the RTX PRO 6000 Blackwell GPU.
# This kernel fuses the mean, variance calculation, and the final affine transformation
# into a single pass (or minimal passes) to redu... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0005963505,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.7144737113,
"peak_rss_bytes": 1260675072,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
2 | 3 | 0 | level1/40_LayerNorm | 20,461,321 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization.
# LayerNorm(x) = (x - mean) / sqrt(var + eps) * weight + bias
# This kernel fuses the mean/variance calculation and the final normalization.
@triton.autotune(
configs=[
tr... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 1.9314817991000002,
"peak_rss_bytes": 1071927296,
"peak_gpu_bytes": 1421148160,
"workdir": "/root/autodl-tmp/cuda-... |
2 | 3 | 1 | level1/40_LayerNorm | 20,461,322 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of LayerNorm
# LayerNorm(x) = (x - mean) / sqrt(var + eps) * weight + bias
# We fuse the mean and variance calculation into a single pass over the features.
# For this specific task, the normalized_shape is ... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0028400651,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.6484919414,
"peak_rss_bytes": 1259929600,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
2 | 3 | 2 | level1/40_LayerNorm | 20,461,323 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of LayerNorm
# Optimized for Blackwell (high memory bandwidth, wide SIMD)
# We fuse the mean and variance calculation into a single pass to minimize global memory reads.
@triton.jit
def _layernorm_kernel(
... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0025761865,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.6533923279,
"peak_rss_bytes": 1260609536,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
2 | 3 | 3 | level1/40_LayerNorm | 20,461,324 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton kernel for Layer Normalization
# Fusion: Calculates Mean and Variance in a single pass (or two, but with fused reduction)
# Handles the (batch, features, dim1, dim2) layout where normalization is over (dim1, dim2).
@triton... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 2.2446681093,
"peak_rss_bytes": 932384768,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs/... |
2 | 3 | 4 | level1/40_LayerNorm | 20,461,325 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of LayerNorm for high performance on Blackwell.
# This kernel fuses the mean and variance calculations into a single pass
# per row of the last dimension (dim2), significantly reducing memory bandwidth.
@tr... | -0.1 | {
"component": "format",
"correct": false,
"speedup": null,
"hacks": [],
"details": {}
} |
2 | 3 | 5 | level1/40_LayerNorm | 20,461,326 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton Kernel for fused Layer Normalization
# This kernel performs the mean and variance calculation in a single pass
# (or minimal passes) and applies the affine transformation (weight/bias).
# It handles arbitrary leading dimen... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0020946046,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.7523793038,
"peak_rss_bytes": 1260711936,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
2 | 3 | 6 | level1/40_LayerNorm | 20,461,327 | ```python
import torch
import torch.nn as nn
import torch.nn.functional as F
# To optimize LayerNorm for an RTX 6000 Blackwell, we need to consider
# the specific memory access patterns and the shape of the input.
# The input shape is (batch_size, features, dim1, dim2).
# LayerNorm is applied over the last dimension (... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 1.7132254858,
"peak_rss_bytes": 893960192,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs/... |
2 | 3 | 7 | level1/40_LayerNorm | 20,461,328 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization
# Optimized for Blackwell architecture:
# 1. Kernel Fusion: Performs mean, variance, and normalization in a single pass.
# 2. Shared Memory: Uses shared memory for reduction to minimi... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 1.9827379268,
"peak_rss_bytes": 1117728768,
"peak_gpu_bytes": 1423245312,
"workdir": "/root/autodl-tmp/cuda-gemma4... |
3 | 4 | 0 | level1/40_LayerNorm | 20,561,421 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization
# Optimized for Blackwell (RTX PRO 6000) by fusing mean and variance reduction.
# This avoids multiple passes over the input tensor.
@triton.jit
def _layernorm_kernel(
X, Y, weigh... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0011180612,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.708423201,
"peak_rss_bytes": 1260621824,
"peak_gpu_bytes": 2459238400,
"workdir": "/root/autodl-tmp/cuda-g... |
3 | 4 | 1 | level1/40_LayerNorm | 20,561,422 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton implementation of Layer Normalization
# This optimizes memory access by performing mean and variance calculations
# in a single pass over the last dimension (normalized_shape),
# then applying the transformation in a seco... | 1 | {
"component": "correct",
"correct": true,
"speedup": 1.0020604551,
"hacks": [],
"details": {
"sandbox": {
"component": "ok",
"returncode": 0,
"elapsed_seconds": 2.6928614751,
"peak_rss_bytes": 1260564480,
"peak_gpu_bytes": 2425683968,
"workdir": "/root/autodl-tmp/cuda-... |
3 | 4 | 2 | level1/40_LayerNorm | 20,561,423 | ```python
import torch
import torch.nn as nn
import triton
import triton.language as tl
# Triton Kernel for Layer Normalization
# We optimize by fusing the mean, variance, and normalization into a single pass
# while handling the reduction via a tiled approach to ensure high throughput on Blackwell.
@triton.autotune(... | -0.1 | {
"component": "crash",
"correct": false,
"speedup": null,
"hacks": [],
"details": {
"sandbox": {
"component": "crash",
"returncode": 1,
"elapsed_seconds": 1.6942563578,
"peak_rss_bytes": 894083072,
"peak_gpu_bytes": 0,
"workdir": "/root/autodl-tmp/cuda-gemma4-llm/runs/... |
End of preview.
Correct, But Not Kernels — data bundle
Data behind the Gemma 4 Paper Track writeup Correct, But Not Kernels
(paper and code: https://github.com/xiningli/correct-but-not-kernels, Apache-2.0;
this bundle: CC BY 4.0). Files keep repository-relative runs/... paths. Download
the bundle as release-data/ inside a checkout of the code repository (the frozen R3 loader rejects paths outside it), then, with
PyTorch installed:
(cd release-data && sha256sum -c SHA256SUMS)
python -m research.paper_v1.reproduce --data release-data/data --out /tmp/paper-recheck
This rebuilds the R3 confirmation report (Section 4.1), the kernel-use decomposition (4.2) and the training-dynamics tables (4.3), and compares each with the committed receipts. No GPU is needed and nothing is re-executed.
| Contents | Paths under data/runs/ |
|---|---|
| 5,600 saved Level-2 programs and their replay traces (ATen ops, CUDA kernel names) | reliability-v2/capability-v4/, diagnostics-v5/terminal-audit-20261016/replay/ |
| R3 held-out scores: base and 9 fine-tuned policies, 960 programs each | autodl-westb-reboot-20261006/*/extracted/... |
| GRPO training rollouts (6 runs), SFT data and base candidates, checkpoint evaluations | replication-v1.1/training/, replication-v1.1/confirmation/ |
| Worker logs for one seed's base candidates (crash causes) | replication-v1.1/confirmation/SFT-20261022/... |
| Consumer-GPU replay attempts | portability-v1-20261020/run-r3/ |
| Issue-style repair records (Section 4.4) | diagnostics-v5/terminal-audit-20261016/diagnostics/, diagnostics-v6-resume31b/terminal-audit-20261017/ |
Not included: Gemma weights and LoRA adapters (adapter hashes are in the code
repository's audit receipts), KernelBench sources (pinned revision and per-file
hashes in env/kernelbench.lock.json; MIT licence upstream), and compile workdirs.
R3 training files come from an archive with SHA-256
8cc3de5ecadc11e6ce5339dacba4bafc702e0f79d4892f57f927cb07b9f01e74; MANIFEST.json
lists every file's origin, size and hash.
Generated programs are outputs of google/gemma-4-12B-it. They were executed only
inside the study's sandboxes. Treat them as untrusted code.
Public corpora (Section 4.5)
The two public corpora are not redistributed. Download them from their sources
and check the hashes recorded in evidence/paper-public-audit-20261026/:
| Corpus | Source | Licence |
|---|---|---|
AI CUDA Engineer archive, level_{1,2,3}.parquet |
huggingface.co/datasets/SakanaAI/AI-CUDA-Engineer-Archive | CC BY 4.0 |
KernelBook, dataset_permissive.parquet |
huggingface.co/datasets/GPUMODE/KernelBook | June 9 Researcher Reciprocity License |
python -m research.public_audit_v1.sakana_static --data <dir with level_*.parquet> --out sakana-static.json
python -m research.public_audit_v1.kernelbook_static --data dataset_permissive.parquet --out kernelbook-static.json
Both scripts only parse source text and the archive's logged profiles; no corpus code is compiled or executed.
- Downloads last month
- 92