GraphArch-Regression

A unified regression dataset collated from multiple graph/architecture search sources (FBNet, Hiaml, Inception, NB101, NB201, NDS, OfaMB, OfaPN, OfaRN, SNAS, Twopath) for training and evaluating models that map ONNX-readable graph strings to a target metric.

Schema

• identifier (string): Source key for the example, e.g. FBNet_0, SNAS_42.
• space (string): Logical dataset source (FBNet, Hiaml, Inception, NB101, NB201, NDS, OfaMB, OfaPN, OfaRN, SNAS, Twopath).
• uid (string): Original UID, if provided by the source.
• arch_str (string): Architecture identity; first non-empty among arch_str, hash, uid.
• input (string): ONNX-readable graph string (onnx_readable).
• target_metric (string): Always val_accuracy.
• val_accuracy (number | null): Primary regression target (Accuracy)
• flops (number | null): FLOPs for the architecture (if available).
• params (number | null): Parameter count (if available).
• metadata (string): Python-dict-like string including only keys that start with zcp_ or lat_ (e.g., zero-cost proxies and latency measurements). Not populated for SNAS. These can be used for multi-objective regression.
• metainformation (string): Only for SNAS; Python-dict-like string of selected fields {arch_str, macro, train_time_sec, steps_ran, precision, batch_size}.

Dataset Size

With this dataset, we provide ONNX text for universal-NAS regression training over 611931 architectures:

• Amoeba: 4983
• DARTS: 5000
• DARTS_fix-w-d: 5000
• DARTS_lr-wd: 5000
• ENAS: 4999
• ENAS_fix-w-d: 5000
• FBNet: 5000
• Hiaml: 4629
• Inception: 580
• NASBench101 (NB101): 423624
• NASBench201 (NB201): 15625
• NASNet: 4846
• OfaMB: 7491
• OfaPN: 8206
• OfaRN: 10000
• PNAS: 4999
• PNAS_fix-w-d: 4559
• SNAS: 85500
• TwoPath: 6890

Tip: turn metadata or metainformation back into a dict with:

from ast import literal_eval
meta = literal_eval(row["metadata"])

How to load with 🤗 Datasets

from datasets import load_dataset
ds = load_dataset("akhauriyash/GraphArch-Regression")

Testing Graph Architecture Regression with a basic Gemma RLM model

Use the code below as reference for evaluating a basic RegressLM model ( better, more models to come! :) )

Note that the best practice is to fine-tune this base model on more NAS ONNX graph data, and few-shot transfer to the target search space (Say NASNet, etc.). If we want to finetune on 16 examples from say, ENAS, the optimal strategy we found was to construct a small NAS dataset of e.g., DARTS, NASNet, Amoeba, ENAS and use ~(1024, 1024, 1024, 16) samples from each, and up-sample (repeat) the 16 ENAS samples 8 times. Random-shuffle the dataset and fine-tune the RLM with 1e-4 LR (cosine decay) to avoid catastrophic forgetting. The code below is just illustrative to demonstrate non-trivial NAS performance. The model training corpus was only 1% NAS data, the rest was code.

import torch
import numpy as np
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
from scipy.stats import spearmanr
from tqdm import tqdm

REPO_ID = "akhauriyash/RLM-GemmaS-Code-v0"
DATASET = "akhauriyash/GraphArch-Regression"
dataset = load_dataset(DATASET, split="train")
tok = AutoTokenizer.from_pretrained(REPO_ID, trust_remote_code=True)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = AutoModelForSeq2SeqLM.from_pretrained(REPO_ID, trust_remote_code=True).to(device).eval()
MAX_ITEMS, BATCH_SIZE, spaces, results = 512, 4, ["NASBench101", "ENAS", "NASNet"], {}
n_out_tokens = getattr(model.config, "num_tokens_per_obj", 8) * getattr(model.config, "max_num_objs", 1)
n_out_tokens = model.config.num_tokens_per_obj * model.config.max_num_objs

for SPACE in spaces:
    inputs, targets = [], []
    for row in tqdm(dataset, desc=f"Processing {SPACE} till {MAX_ITEMS} items"):
        if row.get("space") == SPACE and "input" in row and "val_accuracy" in row:
            try:
                targets.append(float(row["val_accuracy"]))
                inputs.append(f"{SPACE}\n\n{row['input']}")
            except: continue
            if len(inputs) >= MAX_ITEMS: break
    preds = []
    for i in tqdm(range(0, len(inputs), BATCH_SIZE)):
        enc = tok(inputs[i:i+BATCH_SIZE], return_tensors="pt", truncation=True, padding=True, max_length=4096).to(device)
        batch_preds = []
        for _ in range(8):
            out = model.generate(**enc, max_new_tokens=n_out_tokens, min_new_tokens=n_out_tokens, do_sample=True, top_p=0.95, temperature=1.0)
            decoded = [tok.token_ids_to_floats(seq.tolist()) for seq in out]
            decoded = [d[0] if isinstance(d, list) and d else float("nan") for d in decoded]
            batch_preds.append(decoded)
        preds.extend(torch.tensor(batch_preds).median(dim=0).values.tolist())
    spear, _ = spearmanr(np.array(targets), np.array(preds))
    results[SPACE] = spear; print(f"Spearman ρ for {SPACE}: {spear:.3f}")

print("Spearman ρ | NASBench101 | ENAS | NASNet")
print(f"{REPO_ID} | " + " | ".join(f"{results[s]:.3f}" for s in spaces))

We got the following results when testing on a random subset of the GraphArch-Regression dataset.

Model ID                                 | NASBench101  | ENAS  | NASNet
akhauriyash/RegressLM-gemma-s-RLM-table3 | 0.384        | 0.211 | 0.209 

Credits

This dataset was collated from several graph/NAS sources, along with our own profiling where applicable. We export and generate the ONNX descriptions of all architectures in our dataset. Please credit and cite the original datasets accordingly.

Inception, Hiaml, Ofa-MB/PN/RN, Twopath: Mills, K. G., Han, F. X., Zhang, J., Chudak, F., Mamaghani, A. S., Salameh, M., Lu, W., Jui, S., & Niu, D. (2023). Gennape: Towards generalized neural architecture performance estimators. Proceedings of the AAAI Conference on Artificial Intelligence, 37(8), 9190–9199.

NDS: Radosavovic, Ilija, et al. "On network design spaces for visual recognition." Proceedings of the IEEE/CVF international conference on computer vision. 2019.

NB101: Ying, Chris, et al. "Nas-bench-101: Towards reproducible neural architecture search." International conference on machine learning. PMLR, 2019.

NB201: Dong, Xuanyi, and Yi Yang. "Nas-bench-201: Extending the scope of reproducible neural architecture search."

FBNet: Wu, Bichen, et al. "Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search." Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 2019.

Further, multi-objective latency and zero cost proxies were sourced from

Krishnakumar, Arjun, et al. "Nas-bench-suite-zero: Accelerating research on zero cost proxies." Advances in Neural Information Processing Systems 35 (2022): 28037-28051.

Akhauri, Yash, and Mohamed S. Abdelfattah. "Encodings for prediction-based neural architecture search." arXiv preprint arXiv:2403.02484 (2024).

Akhauri, Yash, and Mohamed Abdelfattah. "On latency predictors for neural architecture search." Proceedings of Machine Learning and Systems 6 (2024): 512-523.

Lee, Hayeon, et al. "Help: Hardware-adaptive efficient latency prediction for nas via meta-learning.".

Citations

If you found this dataset useful for your research, please cite the original sources above as well as:

@article{akhauri2025regressionlanguagemodelscode,
      title={Regression Language Models for Code}, 
      author={Yash Akhauri and Xingyou Song and Arissa Wongpanich and Bryan Lewandowski and Mohamed S. Abdelfattah},
      journal={arXiv preprint arXiv:2509.26476},
      year={2025}
}

@article{akhauri2025performance,
  title={Performance Prediction for Large Systems via Text-to-Text Regression},
  author={Akhauri, Yash and Lewandowski, Bryan and Lin, Cheng-Hsi and Reyes, Adrian N and Forbes, Grant C and Wongpanich, Arissa and Yang, Bangding and Abdelfattah, Mohamed S and Perel, Sagi and Song, Xingyou},
  journal={arXiv preprint arXiv:2506.21718},
  year={2025}
}