ParaGen-Bench

A benchmark for parameter / weight generation — methods that generate the weights of a target neural network rather than training it. Each benchmark cell is an <arch>__<dataset> pair; a generator is trained on that cell's checkpoint pool and evaluated by loading its generated weights into the target architecture and measuring task performance.

Seven tasks: image classification, text classification, image segmentation, reinforcement learning, code generation, mathematical reasoning and multimodal understanding (the last three are LoRA adapters of language / vision-language models).

Access

Repository: https://huggingface.co/datasets/AnonymousAuthorEE33/ParaGen-Bench

Whole repository

from huggingface_hub import snapshot_download
root = snapshot_download(repo_id="AnonymousAuthorEE33/ParaGen-Bench", repo_type="dataset")

Metadata and prompts only (small)

root = snapshot_download(repo_id="AnonymousAuthorEE33/ParaGen-Bench", repo_type="dataset",
                         allow_patterns=["metadata/*", "prompt/*", "README.md"])

One cell (its pool, base checkpoint and prompts)

task, cell = "image_classification", "image_cnn__cifar10"
arch, dataset = cell.split("__")
root = snapshot_download(repo_id="AnonymousAuthorEE33/ParaGen-Bench", repo_type="dataset",
                         allow_patterns=[f"ckpt/{task}/{cell}/*", f"zoo/{dataset}/{arch}/*",
                                         f"prompt/{task}/{cell}.json", f"metadata/registry/{task}.json"])

Layout

All parts are aligned by the cell key <arch>__<dataset>.

path	content
metadata/registry/<task>.json	one registry per task: models[].runs[] with architecture, dataset, hyperparameters, training and collection logs, per-checkpoint scores, ckpt_path (base checkpoint) and pool_path (checkpoint pool)
metadata/configs/<task>/<cell>/<model_id>/	config.json and collect_config.json of a run
metadata/code/<task>/	loading helpers (text classification, reinforcement learning)
prompt/<task>/<cell>.json	50 text descriptions of the cell, split 30 train / 10 val / 10 test
prompt/prompts.json	index of all prompts
zoo/<dataset>/<arch>/<model_id>	the converged base checkpoint a pool was collected from
ckpt/<task>/<cell>/<model_id>/	the checkpoint pool of the cell

<task> is one of image_classification, text_classification, image_segmentation, reinforcement_learning, code_generation, mathematical_reasoning, multimodal_understanding.

Prompts

Every cell has 50 prompts: natural-language descriptions of the target model, used as the condition for prompt-conditioned weight generation. They are split 30 train / 10 val / 10 test.

The prompts were written by Qwen/Qwen3-VL-32B-Instruct from a fact sheet of the cell (architecture, parameter count, initialization, dataset, classes, input format). Each prompt passed an automatic check (names, numbers, length, duplicates), a consistency check in which Qwen3-VL-32B-Instruct compares the prompt against the fact sheet and rejects unsupported or contradictory content, and a manual inspection of a random sample of the retained prompts.

p = json.load(open(f"{root}/prompt/image_classification/image_cnn__cifar10.json"))
p["train"], p["val"], p["test"]        # 30 / 10 / 10 strings

Checkpoint pools

task	pool files	content
image classification, image segmentation	collect_000.pth … collect_199.pth	model_state_dict of the full network
text classification	collect_000.pth … collect_199.pth	model_state_dict; load with metadata/code/text_classification/assemble.py
reinforcement learning	collect_000.pth … collect_099.pth	model_state_dict of the policy / Q-network; see metadata/code/reinforcement_learning/
code generation, mathematical reasoning, multimodal understanding	step00201/ … step00300/	one PEFT LoRA adapter per directory (adapter_config.json, adapter_model.safetensors); the base model is named in the registry (base_model_name)

Quickstart

import json, glob, torch
from huggingface_hub import snapshot_download

root = snapshot_download("AnonymousAuthorEE33/ParaGen-Bench", repo_type="dataset",
                         allow_patterns=["metadata/*", "prompt/*"])

# 1) enumerate the cells of every task
TASKS = ["image_classification", "text_classification", "image_segmentation", "reinforcement_learning",
         "code_generation", "mathematical_reasoning", "multimodal_understanding"]
runs = []
for task in TASKS:
    reg = json.load(open(f"{root}/metadata/registry/{task}.json"))
    for m in reg["models"]:
        for r in m["runs"]:
            if r.get("pool_path"):
                runs.append({"task": task, "cell": f"{m['model_name']}__{r['dataset']}", **r})

# 2) prompts and checkpoint pool of one cell
task, cell = "image_classification", "image_cnn__cifar10"
prompts = json.load(open(f"{root}/prompt/{task}/{cell}.json"))          # keys: train / val / test
run = next(r for r in runs if r["task"] == task and r["cell"] == cell)
root = snapshot_download("AnonymousAuthorEE33/ParaGen-Bench", repo_type="dataset",
                         allow_patterns=[f"{run['pool_path']}/*"])
pool = sorted(glob.glob(f"{root}/{run['pool_path']}/*.pth"))
state_dict = torch.load(pool[0], map_location="cpu")["model_state_dict"]

Text classification:

import sys; sys.path.insert(0, f"{root}/metadata/code/text_classification")
from assemble import assemble
state_dict = assemble(f"{root}/{run['ckpt_path']}", pool[0])            # base checkpoint, pool checkpoint

LoRA tasks:

from transformers import AutoModelForCausalLM      # multimodal cells: AutoModelForImageTextToText
from peft import PeftModel
base = AutoModelForCausalLM.from_pretrained(run["base_model_name"])
model = PeftModel.from_pretrained(base, f"{root}/{run['pool_path']}/step00201")

Reproducibility

Every registry run records its configuration, the score of the base checkpoint and the score of the pool checkpoints. To verify a cell, build the architecture, load a pool checkpoint and evaluate it on the cell's dataset; the result should match the recorded value.