Datasets:
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: ValueError
Message: Expected object or value
Traceback: Traceback (most recent call last):
File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1816, in _prepare_split_single
for key, table in generator:
^^^^^^^^^
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 613, in wrapped
for item in generator(*args, **kwargs):
~~~~~~~~~^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 281, in _generate_tables
examples = [ujson_loads(line) for line in batch.splitlines()]
~~~~~~~~~~~^^^^^^
File "/usr/local/lib/python3.14/site-packages/datasets/utils/json.py", line 20, in ujson_loads
return pd.io.json.ujson_loads(*args, **kwargs)
~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^
ValueError: Expected object or value
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 1369, 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 948, 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 1683, 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 1869, 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.
task_id string | spec string | observation string | reasoning string | actions list | verified bool | source string | messages list |
|---|---|---|---|---|---|---|---|
gen-fix-5 | This encoder fails validation: numHeads (8) is not divisible by numKVHeads (7). Repair the attention configuration in place with at most 2 actions. Do not rebuild the model from scratch. | Model: gen-fix-5
Components:
- input (input) params={"shape":[1,128]}
- embed (embedding) params={"numEmbeddings":20000,"embeddingDim":256}
- attn (groupedQueryAttention) params={"embedDim":256,"numHeads":8,"numKVHeads":7}
- head (linear) params={"inFeatures":256,"outFeatures":2}
- output (output)
Connections... | The issue is that numHeads (8) is not divisible by numKVHeads (7). I need to fix this with at most 2 actions.
Options:
1. Change numKVHeads to a value that divides 8: 1, 2, 4, or 8
2. Change numHeads to a value divisible by 7: 7, 14, etc. (but then embedDim must be divisible by numHeads, and 256/7 is not an integer)
... | [
{
"type": "update_params",
"name": "attn",
"params": {
"embedDim": 256,
"numHeads": 8,
"numKVHeads": 4
}
}
] | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-trim-6 | This 3-hidden-layer MLP uses 2048-wide layers and blows a 2M parameter budget. Shrink the widths in place so total params fit the budget, keeping all 3 hidden layers and consistent in/out features. Do not rebuild the model from scratch. | Model: gen-trim-6
Components:
- input (input) params={"shape":[1,64]}
- fc1 (linear) params={"inFeatures":64,"outFeatures":2048}
- act1 (relu)
- fc2 (linear) params={"inFeatures":2048,"outFeatures":2048}
- act2 (relu)
- fc3 (linear) params={"inFeatures":2048,"outFeatures":2048}
- act3 (relu)
- head (lin... | Let me calculate the parameter count for the current model and then find a width that fits within 2M parameters.
Current model parameters:
- fc1: 64 * 2048 + 2048 = 131,072 + 2,048 = 133,120
- fc2: 2048 * 2048 + 2048 = 4,194,304 + 2,048 = 4,196,352
- fc3: 2048 * 2048 + 2048 = 4,194,304 + 2,048 = 4,196,352
- head: 2048... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 64,
"outFeatures": 980
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 980,
"outFeatures": 980
}
},
{
"type": "update_params",
"name": "fc3",
"para... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-norm-7 | This MLP trains unstably. Insert a batchNorm1d after each of the 2 hidden linear layers (between the linear and its activation), with numFeatures matching each layer's output width. Do not rebuild the model from scratch. | Model: gen-norm-7
Components:
- input (input) params={"shape":[1,64]}
- fc1 (linear) params={"inFeatures":64,"outFeatures":256}
- act1 (relu)
- fc2 (linear) params={"inFeatures":256,"outFeatures":128}
- act2 (relu)
- head (linear) params={"inFeatures":128,"outFeatures":10}
- output (output)
Connections:
... | I need to insert batchNorm1d layers after each of the 2 hidden linear layers (fc1 and fc2), between the linear and its activation.
1. After fc1 (outFeatures=256), insert bn1 with numFeatures=256, between fc1 and act1
2. After fc2 (outFeatures=128), insert bn2 with numFeatures=128, between fc2 and act2
Current connect... | [
{
"type": "add_component",
"componentType": "batchNorm1d",
"name": "bn1",
"afterName": "fc1",
"params": {
"numFeatures": 256
}
},
{
"type": "add_component",
"componentType": "batchNorm1d",
"name": "bn2",
"afterName": "fc2",
"params": {
"numFeatures": 128
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-tower-8 | Design a two-tower retrieval scorer: a 32-feature user input and a 32-feature item input, each through its own 2-layer MLP tower ending at width 128, concatenated and scored by a linear head. Both tower outputs must have identical shape for the merge. Keep it under 10M params. | Model: gen-tower-8
Components:
- user_input (input) params={"shape":[1,32]}
- item_input (input) params={"shape":[1,32]}
- output (output)
Connections:
- user_input -> output
- item_input -> output | Let me design a two-tower retrieval scorer:
**User Tower:**
- user_input: [1, 32]
- user_fc1: Linear(32 → 64), ReLU
- user_fc2: Linear(64 → 128), ReLU
- Output: [1, 128]
**Item Tower:**
- item_input: [1, 32]
- item_fc1: Linear(32 → 64), ReLU
- item_fc2: Linear(64 → 128), ReLU
- Output: [1, 128]
**Merge:**
- concaten... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "user_input",
"params": {
"shape": [
1,
32
]
}
},
{
"componentType": "input",
"name": "item_input",
"params": {... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-grow-9 | This 2-hidden-layer MLP is far too small for its workload. Widen the hidden layers in place so total params land between 400k and 4M, keeping consistent in/out features. Do not rebuild the model from scratch. | Model: gen-grow-9
Components:
- input (input) params={"shape":[1,32]}
- fc1 (linear) params={"inFeatures":32,"outFeatures":8}
- act1 (relu)
- fc2 (linear) params={"inFeatures":8,"outFeatures":8}
- act2 (relu)
- head (linear) params={"inFeatures":8,"outFeatures":10}
- output (output)
Connections:
- input... | Current model has:
- fc1: 32 → 8, params = 32*8 + 8 = 264
- fc2: 8 → 8, params = 8*8 + 8 = 72
- head: 8 → 10, params = 8*10 + 10 = 90
Total: ~426 params
I need to widen the hidden layers so total params land between 400k and 4M.
Let me choose a hidden size. Let's try hidden_dim = 512:
- fc1: 32 → 512, params = 32*512... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 32,
"outFeatures": 1024
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 1024,
"outFeatures": 1024
}
},
{
"type": "update_params",
"name": "head",
"... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-mlp-10 | Design a dense classifier for a 32-feature input with 3 output classes. Use 3 hidden linear layers with ReLU and a linear head. Keep it under 10M params. | Model: gen-mlp-10
Components:
- input (input) params={"shape":[1,32]}
- output (output)
Connections:
- input -> output | I need to design a dense classifier with:
- Input: 32 features
- 3 hidden linear layers with ReLU activations
- A linear head for 3 output classes
- Under 10M parameters
Let me plan the architecture:
- input (32 features)
- Linear layer 1: 32 → 256
- ReLU 1
- Linear layer 2: 256 → 256
- ReLU 2
- Linear layer 3: 256 → ... | [
{
"type": "add_component",
"componentType": "linear",
"name": "linear1",
"afterName": "input",
"params": {
"inFeatures": 32,
"outFeatures": 256
}
},
{
"type": "add_component",
"componentType": "relu",
"name": "relu1",
"afterName": "linear1",
"params": {}
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-ae-11 | Design a dense autoencoder for 784-dim input: encode down to a 32-dim bottleneck and decode back to 784. Keep it valid and connected, under 20M params. | Model: gen-ae-11
Components:
- input (input) params={"shape":[1,784]}
- output (output)
Connections:
- input -> output | I need to design a dense autoencoder with:
- Input: 784-dim
- Bottleneck: 32-dim
- Output: 784-dim
- Under 20M params
Encoder: 784 -> 512 -> 256 -> 128 -> 64 -> 32
Decoder: 32 -> 64 -> 128 -> 256 -> 512 -> 784
Let me count parameters:
- 784->512: 784*512 + 512 = 401,920
- 512->256: 512*256 + 256 = 131,328
- 256->128:... | [
{
"type": "add_component",
"componentType": "linear",
"name": "enc_fc1",
"afterName": "input",
"params": {
"inFeatures": 784,
"outFeatures": 512
}
},
{
"type": "add_component",
"componentType": "linear",
"name": "enc_fc2",
"afterName": "enc_fc1",
"params":... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-cnn-12 | Design a convolutional classifier for a 3x28x28 image with 10 classes. Use 3 conv layers with ReLU and a linear head. Keep it under 50M params. | Model: gen-cnn-12
Components:
- input (input) params={"shape":[1,3,28,28]}
- output (output)
Connections:
- input -> output | I need to design a convolutional classifier for 3x28x28 images with 10 classes. Let me plan the architecture:
1. Input: 3x28x28
2. Conv2d layer 1: 3 -> 32 channels, kernel 3x3 → output: 32x26x26
3. ReLU
4. Conv2d layer 2: 32 -> 64 channels, kernel 3x3 → output: 64x24x24
5. ReLU
6. Conv2d layer 3: 64 -> 128 channels, k... | [
{
"type": "add_component",
"componentType": "conv2d",
"name": "conv1",
"afterName": "input",
"params": {
"inChannels": 3,
"outChannels": 32,
"kernelSize": 3
}
},
{
"type": "add_component",
"componentType": "relu",
"name": "relu1",
"afterName": "conv1",
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-fix-15 | This encoder fails validation: numHeads (8) is not divisible by numKVHeads (7). Repair the attention configuration in place with at most 2 actions. Do not rebuild the model from scratch. | Model: gen-fix-15
Components:
- input (input) params={"shape":[1,64]}
- embed (embedding) params={"numEmbeddings":20000,"embeddingDim":256}
- attn (groupedQueryAttention) params={"embedDim":256,"numHeads":8,"numKVHeads":7}
- head (linear) params={"inFeatures":256,"outFeatures":5}
- output (output)
Connections... | The problem is that numHeads (8) is not divisible by numKVHeads (7). I need to fix this with at most 2 actions.
Options:
1. Change numKVHeads to a value that divides 8: 1, 2, 4, or 8
2. Change numHeads to a value divisible by 7: 7, 14, etc. (but then embedDim 256 must be divisible by numHeads)
The simplest fix is to ... | [
{
"type": "update_params",
"name": "attn",
"params": {
"embedDim": 256,
"numHeads": 8,
"numKVHeads": 4
}
}
] | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-trim-16 | This 3-hidden-layer MLP uses 4096-wide layers and blows a 2M parameter budget. Shrink the widths in place so total params fit the budget, keeping all 3 hidden layers and consistent in/out features. Do not rebuild the model from scratch. | Model: gen-trim-16
Components:
- input (input) params={"shape":[1,64]}
- fc1 (linear) params={"inFeatures":64,"outFeatures":4096}
- act1 (relu)
- fc2 (linear) params={"inFeatures":4096,"outFeatures":4096}
- act2 (relu)
- fc3 (linear) params={"inFeatures":4096,"outFeatures":4096}
- act3 (relu)
- head (li... | Let me calculate the parameters for the current model:
- fc1: 64 * 4096 + 4096 = 262,144 + 4,096 = 266,240
- fc2: 4096 * 4096 + 4096 = 16,777,216 + 4,096 = 16,781,312
- fc3: 4096 * 4096 + 4096 = 16,777,216 + 4,096 = 16,781,312
- head: 4096 * 2 + 2 = 8,192 + 2 = 8,194
Total: ~33,837,058 params
Need to fit within 2M (2,... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 64,
"outFeatures": 982
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 982,
"outFeatures": 982
}
},
{
"type": "update_params",
"name": "fc3",
"para... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-tower-18 | Design a two-tower retrieval scorer: a 32-feature user input and a 128-feature item input, each through its own 2-layer MLP tower ending at width 128, concatenated and scored by a linear head. Both tower outputs must have identical shape for the merge. Keep it under 10M params. | Model: gen-tower-18
Components:
- user_input (input) params={"shape":[1,32]}
- item_input (input) params={"shape":[1,128]}
- output (output)
Connections:
- user_input -> output
- item_input -> output | Let me design a two-tower retrieval scorer:
**User Tower:**
- Input: 32 features
- Layer 1: Linear(32 → 64) + ReLU
- Layer 2: Linear(64 → 128) + ReLU
- Output: 128 features
**Item Tower:**
- Input: 128 features
- Layer 1: Linear(128 → 128) + ReLU
- Layer 2: Linear(128 → 128) + ReLU
- Output: 128 features
**Merge:**
... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "user_input",
"params": {
"shape": [
1,
32
]
}
},
{
"componentType": "input",
"name": "item_input",
"params": {... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-grow-19 | This 2-hidden-layer MLP is far too small for its workload. Widen the hidden layers in place so total params land between 400k and 4M, keeping consistent in/out features. Do not rebuild the model from scratch. | Model: gen-grow-19
Components:
- input (input) params={"shape":[1,32]}
- fc1 (linear) params={"inFeatures":32,"outFeatures":8}
- act1 (relu)
- fc2 (linear) params={"inFeatures":8,"outFeatures":8}
- act2 (relu)
- head (linear) params={"inFeatures":8,"outFeatures":10}
- output (output)
Connections:
- inpu... | Current model:
- fc1: 32 → 8 (params: 32*8 + 8 = 264)
- fc2: 8 → 8 (params: 8*8 + 8 = 72)
- head: 8 → 10 (params: 8*10 + 10 = 90)
Total current: ~426 params. Way too small.
I need to widen the hidden layers (fc1 and fc2) so total params land between 400k and 4M.
Let me try hidden size H:
- fc1: 32 → H: 32*H + H = 33... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 32,
"outFeatures": 1024
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 1024,
"outFeatures": 1024
}
},
{
"type": "update_params",
"name": "head",
"... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-mlp-20 | Design a dense classifier for a 16-feature input with 2 output classes. Use 2 hidden linear layers with ReLU and a linear head. Keep it under 10M params. | Model: gen-mlp-20
Components:
- input (input) params={"shape":[1,16]}
- output (output)
Connections:
- input -> output | I need to design a dense classifier with:
- 16-feature input
- 2 output classes
- 2 hidden linear layers with ReLU
- A linear head
- Under 10M parameters
Let me plan the architecture:
1. Input: 16 features
2. Linear layer 1: 16 → 128
3. ReLU 1
4. Linear layer 2: 128 → 64
5. ReLU 2
6. Linear head: 64 → 2
7. Output
Par... | [
{
"type": "add_component",
"componentType": "linear",
"name": "hidden1",
"afterName": "input",
"params": {
"inFeatures": 16,
"outFeatures": 128
}
},
{
"type": "add_component",
"componentType": "relu",
"name": "relu1",
"afterName": "hidden1",
"params": {}
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-cnn-22 | Design a convolutional classifier for a 3x28x28 image with 2 classes. Use 3 conv layers with ReLU and a linear head. Keep it under 50M params. | Model: gen-cnn-22
Components:
- input (input) params={"shape":[1,3,28,28]}
- output (output)
Connections:
- input -> output | Let me design a convolutional classifier for 3x28x28 images with 2 classes.
Architecture:
1. Input: 3x28x28
2. Conv2d(3, 32, 3) -> ReLU -> output: 32x26x26
3. Conv2d(32, 64, 3) -> ReLU -> output: 64x24x24
4. Conv2d(64, 128, 3) -> ReLU -> output: 128x22x22
5. Flatten: 128*22*22 = 128*484 = 61952
6. Linear(61952, 256) -... | [
{
"type": "add_component",
"componentType": "conv2d",
"name": "conv1",
"afterName": "input",
"params": {
"inChannels": 3,
"outChannels": 32,
"kernelSize": 3
}
},
{
"type": "add_component",
"componentType": "relu",
"name": "relu1",
"afterName": "conv1",
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-fix-25 | This encoder fails validation: numHeads (8) is not divisible by numKVHeads (3). Repair the attention configuration in place with at most 2 actions. Do not rebuild the model from scratch. | Model: gen-fix-25
Components:
- input (input) params={"shape":[1,64]}
- embed (embedding) params={"numEmbeddings":20000,"embeddingDim":96}
- attn (groupedQueryAttention) params={"embedDim":96,"numHeads":8,"numKVHeads":3}
- head (linear) params={"inFeatures":96,"outFeatures":5}
- output (output)
Connections:
... | The issue is that numHeads (8) is not divisible by numKVHeads (3). I need to fix this with at most 2 actions.
Options:
1. Change numKVHeads to a value that divides 8: 1, 2, 4, or 8
2. Change numHeads to a value divisible by 3: 3, 6, 9, 12... but embedDim is 96, so numHeads must divide 96. Options: 3 (96/3=32✓), 6 (96/... | [
{
"type": "update_params",
"name": "attn",
"params": {
"embedDim": 96,
"numHeads": 8,
"numKVHeads": 4
}
}
] | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-trim-26 | This 2-hidden-layer MLP uses 2048-wide layers and blows a 2M parameter budget. Shrink the widths in place so total params fit the budget, keeping all 2 hidden layers and consistent in/out features. Do not rebuild the model from scratch. | Model: gen-trim-26
Components:
- input (input) params={"shape":[1,128]}
- fc1 (linear) params={"inFeatures":128,"outFeatures":2048}
- act1 (relu)
- fc2 (linear) params={"inFeatures":2048,"outFeatures":2048}
- act2 (relu)
- head (linear) params={"inFeatures":2048,"outFeatures":10}
- output (output)
Connect... | Let me calculate the parameters for the current model:
- fc1: 128 * 2048 + 2048 = 262,144 + 2,048 = 264,192
- fc2: 2048 * 2048 + 2048 = 4,194,304 + 2,048 = 4,196,352
- head: 2048 * 10 + 10 = 20,480 + 10 = 20,490
Total: ~4,480,034 — way over 2M budget.
I need to find a width H such that total params ≤ 2,000,000:
- fc1:... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 128,
"outFeatures": 1345
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 1345,
"outFeatures": 1345
}
},
{
"type": "update_params",
"name": "head",
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-grow-29 | This 2-hidden-layer MLP is far too small for its workload. Widen the hidden layers in place so total params land between 400k and 4M, keeping consistent in/out features. Do not rebuild the model from scratch. | Model: gen-grow-29
Components:
- input (input) params={"shape":[1,32]}
- fc1 (linear) params={"inFeatures":32,"outFeatures":8}
- act1 (relu)
- fc2 (linear) params={"inFeatures":8,"outFeatures":8}
- act2 (relu)
- head (linear) params={"inFeatures":8,"outFeatures":2}
- output (output)
Connections:
- input... | Current model:
- fc1: 32 → 8, params = 32*8 + 8 = 264
- fc2: 8 → 8, params = 8*8 + 8 = 72
- head: 8 → 2, params = 8*2 + 2 = 18
Total: ~354 params (tiny)
Need to widen hidden layers so total params land between 400k and 4M.
Let me think about a hidden size H:
- fc1: 32 → H, params = 32*H + H = 33H
- fc2: H → H, params... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 32,
"outFeatures": 640
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 640,
"outFeatures": 640
}
},
{
"type": "update_params",
"name": "head",
"par... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-mlp-30 | Design a dense classifier for a 16-feature input with 2 output classes. Use 2 hidden linear layers with ReLU and a linear head. Keep it under 10M params. | Model: gen-mlp-30
Components:
- input (input) params={"shape":[1,16]}
- output (output)
Connections:
- input -> output | I need to design a dense classifier with:
- 16-feature input
- 2 output classes
- 2 hidden linear layers with ReLU
- A linear head
- Under 10M params
Let me design the architecture:
1. Input: 16 features
2. Linear layer 1: 16 -> 128
3. ReLU 1
4. Linear layer 2: 128 -> 64
5. ReLU 2
6. Linear head: 64 -> 2
7. Output
Pa... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "input",
"params": {
"shape": [
1,
16
]
}
},
{
"componentType": "linear",
"name": "linear1",
"params": {
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-ae-31 | Design a dense autoencoder for 256-dim input: encode down to a 32-dim bottleneck and decode back to 256. Keep it valid and connected, under 20M params. | Model: gen-ae-31
Components:
- input (input) params={"shape":[1,256]}
- output (output)
Connections:
- input -> output | I need to design a dense autoencoder with:
- Input: 256-dim
- Bottleneck: 32-dim
- Output: 256-dim
- Under 20M params
Let me design an encoder-decoder architecture:
Encoder:
- Linear: 256 → 128
- ReLU
- Linear: 128 → 64
- ReLU
- Linear: 64 → 32
Decoder:
- Linear: 32 → 64
- ReLU
- Linear: 64 → 128
- ReLU
- Linear: 12... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "input",
"params": {
"shape": [
1,
256
]
}
},
{
"componentType": "linear",
"name": "enc_fc1",
"params": {
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-cnn-32 | Design a convolutional classifier for a 3x32x32 image with 10 classes. Use 3 conv layers with ReLU and a linear head. Keep it under 50M params. | Model: gen-cnn-32
Components:
- input (input) params={"shape":[1,3,32,32]}
- output (output)
Connections:
- input -> output | Let me design a convolutional classifier for 3x32x32 images with 10 classes.
Architecture plan:
1. Input: 3x32x32
2. Conv2D(3->32, 3x3) → ReLU → 32x30x30
3. Conv2D(32->64, 3x3) → ReLU → 64x28x28
4. Conv2D(64->128, 3x3) → ReLU → 128x26x26
5. Flatten → 128*26*26 = 86528
6. Linear(86528->256) → ReLU
7. Linear(256->10)
W... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "input",
"params": {
"shape": [
1,
3,
32,
32
]
}
},
{
"componentType": "conv2d",
"name": "conv1... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-fix-35 | This encoder fails validation: numHeads (8) is not divisible by numKVHeads (5). Repair the attention configuration in place with at most 2 actions. Do not rebuild the model from scratch. | Model: gen-fix-35
Components:
- input (input) params={"shape":[1,128]}
- embed (embedding) params={"numEmbeddings":20000,"embeddingDim":256}
- attn (groupedQueryAttention) params={"embedDim":256,"numHeads":8,"numKVHeads":5}
- head (linear) params={"inFeatures":256,"outFeatures":2}
- output (output)
Connection... | The issue is that numHeads (8) is not divisible by numKVHeads (5). I need to fix this with at most 2 actions.
Options:
1. Change numKVHeads to a value that divides 8: 1, 2, 4, or 8
2. Change numHeads to a value divisible by 5: 5, 10, 15, 20...
If I change numKVHeads to 4 (divides 8 evenly), that's 1 action.
If I chan... | [
{
"type": "update_params",
"name": "attn",
"params": {
"embedDim": 256,
"numHeads": 8,
"numKVHeads": 4
}
}
] | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-trim-36 | This 2-hidden-layer MLP uses 2048-wide layers and blows a 2M parameter budget. Shrink the widths in place so total params fit the budget, keeping all 2 hidden layers and consistent in/out features. Do not rebuild the model from scratch. | Model: gen-trim-36
Components:
- input (input) params={"shape":[1,64]}
- fc1 (linear) params={"inFeatures":64,"outFeatures":2048}
- act1 (relu)
- fc2 (linear) params={"inFeatures":2048,"outFeatures":2048}
- act2 (relu)
- head (linear) params={"inFeatures":2048,"outFeatures":10}
- output (output)
Connectio... | Let me calculate the current parameter count and find a width that fits within 2M parameters.
Current parameters:
- fc1: 64 * 2048 + 2048 = 131,072 + 2,048 = 133,120
- fc2: 2048 * 2048 + 2048 = 4,194,304 + 2,048 = 4,196,352
- head: 2048 * 10 + 10 = 20,480 + 10 = 20,490
Total: 133,120 + 4,196,352 + 20,490 = 4,349,962
... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 64,
"outFeatures": 1376
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 1376,
"outFeatures": 1376
}
},
{
"type": "update_params",
"name": "head",
"... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-tower-38 | Design a two-tower retrieval scorer: a 64-feature user input and a 64-feature item input, each through its own 2-layer MLP tower ending at width 128, concatenated and scored by a linear head. Both tower outputs must have identical shape for the merge. Keep it under 10M params. | Model: gen-tower-38
Components:
- user_input (input) params={"shape":[1,64]}
- item_input (input) params={"shape":[1,64]}
- output (output)
Connections:
- user_input -> output
- item_input -> output | Let me design a two-tower retrieval scorer:
**User Tower:**
- Input: 64 features
- Layer 1: Linear(64 → 256), ReLU
- Layer 2: Linear(256 → 128), ReLU
- Output: 128 features
**Item Tower:**
- Input: 64 features
- Layer 1: Linear(64 → 256), ReLU
- Layer 2: Linear(256 → 128), ReLU
- Output: 128 features
**Merge:**
- Co... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "user_input",
"params": {
"shape": [
1,
64
]
}
},
{
"componentType": "input",
"name": "item_input",
"params": {... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-grow-39 | This 2-hidden-layer MLP is far too small for its workload. Widen the hidden layers in place so total params land between 400k and 4M, keeping consistent in/out features. Do not rebuild the model from scratch. | Model: gen-grow-39
Components:
- input (input) params={"shape":[1,64]}
- fc1 (linear) params={"inFeatures":64,"outFeatures":16}
- act1 (relu)
- fc2 (linear) params={"inFeatures":16,"outFeatures":16}
- act2 (relu)
- head (linear) params={"inFeatures":16,"outFeatures":2}
- output (output)
Connections:
- i... | Current model:
- fc1: 64 → 16 (params: 64*16 + 16 = 1,040)
- fc2: 16 → 16 (params: 16*16 + 16 = 272)
- head: 16 → 2 (params: 16*2 + 2 = 34)
Total: ~1,346 params (way too small)
I need to widen the hidden layers to get between 400k and 4M params.
Let me try hidden size H:
- fc1: 64 → H (params: 64*H + H = 65H)
- fc2: ... | [
{
"type": "update_params",
"name": "fc1",
"params": {
"inFeatures": 64,
"outFeatures": 1024
}
},
{
"type": "update_params",
"name": "fc2",
"params": {
"inFeatures": 1024,
"outFeatures": 1024
}
},
{
"type": "update_params",
"name": "head",
"... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
gen-mlp-40 | Design a dense classifier for a 48-feature input with 2 output classes. Use 2 hidden linear layers with ReLU and a linear head. Keep it under 10M params. | Model: gen-mlp-40
Components:
- input (input) params={"shape":[1,48]}
- output (output)
Connections:
- input -> output | I need to design a dense classifier for a 48-feature input with 2 output classes. Requirements:
- 2 hidden linear layers with ReLU
- A linear head
- Under 10M parameters
Let me design the architecture:
- Input: 48 features
- Hidden layer 1: 48 -> 256, ReLU
- Hidden layer 2: 256 -> 128, ReLU
- Linear head: 128 -> 2
Pa... | [
{
"type": "replace_model",
"components": [
{
"componentType": "input",
"name": "input",
"params": {
"shape": [
1,
48
]
}
},
{
"componentType": "linear",
"name": "linear1",
"params": {
... | true | claude:verified | [
{
"role": "system",
"content": "You are a neural-architecture design agent. You edit a structured model graph by emitting actions.\nRespond with ONE JSON object and nothing else: { \"actions\": [ <action> ... ] }\n\nAction types:\n- { \"type\": \"add_component\", \"componentType\": \"<layer>\", \"name\": \"... |
End of preview.
arch-reasoning-claude
306 verified (spec -> reasoning -> design) traces for neural-architecture design, minted by claude-sonnet-4-6 and filtered by a deterministic verifier.
Each row pairs a natural-language architecture spec with the model's reasoning and its final structured design (a batch of typed graph edits). Every row's design was applied to the task's start graph and re-graded by the deterministic verifier of neurarch-arch-bench: no trace enters this set unless its design provably solves its spec. No human judge, no LLM judge.
Provenance and yield
- Model:
claude-sonnet-4-6(Anthropic API), rejection-sampled. - Tasks: 500 procedurally generated (generator v1, seed 20260708).
- Mint-time yield: 327/451 = 72.5% verified (49 API failures excluded).
- Released rows: 306, each re-verified under the repository's current rubric (v2), which adds the linear-width consistency check of the paper's Algorithm 1. The 21 mint-time-verified rows that fail v2's stricter width check are excluded; they are exactly the blind-spot class the paper's grounding study documents.
Schema
One JSON object per line: task_id, spec, observation (serialized start
graph), reasoning, actions (the verified edit batch), verified: true,
source, and a chat-format messages array ready for SFT.
Reproduce / extend
git clone https://github.com/neurarch-ai/neurarch-arch-bench
ANTHROPIC_API_KEY=... node training/reasoning_traces.mjs --provider=claude --count=500 --delay=800 --out=my-traces
A private seed produces reasoning data whose designs never appeared on the public web. Companion set: arch-reasoning-grok.
- Downloads last month
- 61