Datasets:
The dataset viewer is not available for this split.
Error code: TooBigContentError
Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.
Code-Regression
Paper | GitHub Repository | Project Page
A unified regression dataset collated from three sources (APPS, KBSS, CDSS) along with our own custom profiling for training and evaluating regression models that map code strings to a target metric. This dataset supports "code-to-metric regression," which involves predicting numeric outcomes of code executions using Regression Language Models (RLM), as described in the linked paper.
Link for Graph-Regression dataset: https://huggingface.co/datasets/akhauriyash/GraphArch-Regression
Link for Base Gemma-Adapted RLM model: https://huggingface.co/akhauriyash/RLM-GemmaS-Code-v0
Schema
- identifier (string): Source key for the example, e.g.
APPS_0
,KBSS_1
,CDSS_42
. - space (string): Logical dataset split/source (
APPS
,KBSS
, orCDSS
). - input (string): The input string (
shortest_onnx
). - target_metric (string): Always
val_accuracy
. - val_accuracy (number | null): The regression target.
- metric_type (string): Auxiliary metric family for this row:
memory_bytes
for APPS and CDSSlatency_ms
for KBSS
- metadata (string): A Python-dict-like string with source-specific information:
- APPS:
problem_metainformation
cast to string. - KBSS:
{'stddev_ms': <value>}
. - CDSS: subset of fields
{s_id, p_id, u_id, date, language, original_language, filename_ext, status, cpu_time, memory, code_size}
.
- APPS:
This dataset has 7502559 rows:
- APPS: 98932
- CDSS (CodeNets): 7391012
- KBSS (Triton Kernels): 12615
Tip: turn
metadata
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/Code-Regression")
Sample Usage with RegressLM
The regress_lm
library provides the RegressLM
class for decoding floating-point predictions from a given input and fine-tuning against new data. Below is an example of how to instantiate RegressLM
and use it for inference.
from regress_lm import core
from regress_lm import rlm
# Create RegressLM from scratch. Optionally, use `from_t5gemma_encoder`.
reg_lm = rlm.RegressLM.from_scratch(max_input_len=2048)
# Example (x,y) pairs, which can be fine-tuned against.
examples = [core.Example(x='hello', y=0.3), core.Example(x='world', y=-0.3)]
reg_lm.fine_tune(examples)
# Query inputs.
query1, query2 = core.ExampleInput(x='hi'), core.ExampleInput(x='bye')
samples1, samples2 = reg_lm.sample([query1, query2], num_samples=128)
Testing Code-Regression with a basic Gemma RLM model
Use the code below as reference for evaluating a basic RegressLM model ( better, more models to come! :) )
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/Code-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, 16, ["KBSS", "CDSS", "APPS"], {}
language = None # Specify language for CDSS, e.g. "python"
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 "target" in row:
try:
lang = eval(row['metadata'])['language'] if SPACE == "CDSS" else None
if SPACE != "CDSS" or language is None or lang == language:
targets.append(float(row["target"]))
if SPACE == "CDSS":
inputs.append(f"# {SPACE}
# Language: {lang}
{row['input']}")
else:
inputs.append(f"{SPACE}
{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=2048).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 Ο | KBSS | CDSS | APPS")
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 Code-Regression dataset.
Model ID | KBSS | CDSS | APPS
akhauriyash/RegressLM-gemma-s-RLM-table3 | 0.527 | 0.787 | 0.926
Credits
This dataset was collated from several sources, along with our own latency and memory profiling. We thank the authors for their efforts.
APPS: Hendrycks, D., Basart, S., Kadavath, S., Mazeika, M., Arora, A., Guo, E., Burns, C., Puranik, S., He, H., Song, D., & Steinhardt, J. (2021). Measuring Coding Challenge Competence With APPS. NeurIPS.
CDSS (CodeNet): Puri, R., Kung, D. S., Janssen, G., Zhang, W., Domeniconi, G., Zolotov, V., Dolby, J., Chen, J., Choudhury, M., Decker, L., & others. (2021). Codenet: A large-scale ai for code dataset for learning a diversity of coding tasks.
KBSS (KernelBook): Paliskara, S., & Saroufim, M. (2025). KernelBook. https://huggingface.co/datasets/GPUMODE/KernelBook
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}
}
- Downloads last month
- 137