Skip to content
Back to skills

Vision Arch Gen Eval

ASecurity

Evaluates the classification performance of LLM-generated neural network architectures by training each for a single epoch on seven computer vision benchmarks. It measures Top-1 accuracy to assess architectural quality, while also tracking generation efficiency via hash validation speed and duplicate rejection rates. Use when the user wants to benchmark on MNIST, CelebA-Gender, CIFAR-10, CIFAR-100, ImageNette, SVHN, Places365, or asks about evaluating this task. Reports Top-1 accuracy after 1...

  • 3 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added September 11, 2026
researchpythonapiperformance

Works with

  • api

Security analysis

A100/100

Scanned September 11, 2026

npx -y skills add qhjqhj00/research-skills-pool --skill vision-arch-gen-eval --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Vision Arch Gen Eval?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Vision Arch Gen Eval
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/qhjqhj00-vision-arch-gen-eval/badge)](https://www.skillsdirectory.com/skills/qhjqhj00-vision-arch-gen-eval)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: vision-arch-gen-eval
description: Evaluates the classification performance of LLM-generated neural network architectures by training each for a single epoch on seven computer vision benchmarks. It measures Top-1 accuracy to assess architectural quality, while also tracking generation efficiency via hash validation speed and duplicate rejection rates. Use when the user wants to benchmark on MNIST, CelebA-Gender, CIFAR-10, CIFAR-100, ImageNette, SVHN, Places365, or asks about evaluating this task. Reports Top-1 accuracy after 1 epoch.
metadata:
  skill_kind: dataset_eval
  source_arxiv: 2512.24120
  bibtex_key: [REDACTED]
  confidence: high
---

# vision-arch-gen-eval

> Enhancing LLM-Based Neural Network Generation: Few-Shot Prompting and Efficient Validation for Automated Architecture Design — Vysyaraju et al. (2025) (arXiv:2512.24120, 2025)

## What this evaluates

Evaluates the classification performance of LLM-generated neural network architectures by training each for a single epoch on seven computer vision benchmarks. It measures Top-1 accuracy to assess architectural quality, while also tracking generation efficiency via hash validation speed and duplicate rejection rates.

## Datasets

- **MNIST** — total 70000; splits: full (70000)
- **CelebA-Gender** — total 202000; splits: full (202000)
- **CIFAR-10** — total 60000; splits: full (60000)
- **CIFAR-100** — total 60000; splits: full (60000)
- **ImageNette** — total 13000; splits: full (13000)
- **SVHN** — total 600000; splits: full (600000)
- **Places365** — total 1800000; splits: full (1800000)

## Metrics

- `Top-1 accuracy after 1 epoch` **(primary)** — range: [0, 1]
  - Fraction of correctly classified samples out of the total number of samples after training the generated architecture for exactly one epoch.
- `Hash computation time` — range: milliseconds
  - Wall-clock time required to compute the whitespace-normalized hash for deduplication validation.
- `Duplicates detected` — range: count
  - Count of functionally identical architectures identified and rejected during the validation phase.

## Input / output format

**Input**: Few-shot prompting examples (n=1 to 6) of neural network architectures alongside a target computer vision dataset specification.

**Output**: Generated neural network architecture code or configuration strings prefixed with 'alt-nn' variants.

## Scoring recipe

```python
for architecture in generated_architectures:
    for dataset in datasets:
        model = instantiate(architecture)
        train(model, dataset, epochs=1, optimizer='SGD', momentum=True)
        acc = compute_top1_accuracy(model, dataset)
        results[architecture][dataset] = acc

dataset_means = {ds: mean([r[ds] for r in results.values()]) for ds in datasets}
overall_mean = mean(dataset_means.values())
p_values = independent_t_test(variants, dataset_means)
```

## Common pitfalls

- Training is strictly limited to 1 epoch for rapid validation, which may not reflect the true convergence or final performance of the generated architectures.
- Batch sizes vary across datasets (64-4096), potentially introducing variance in accuracy that is unrelated to architectural quality.
- Whitespace-normalized hash validation only eliminates functionally identical architectures with formatting differences, missing semantically equivalent but structurally distinct designs.

## Evidence (verbatim from paper)

> Primary Metric: Top-1 accuracy after 1 epoch
Statistical Validation: Independent t-tests comparing variants within each dataset, dataset-balanced means for overall comparison

Training Configuration:
* •
    Epochs: 1 (for rapid validation)
* •
    Optimizer: SGD with momentum
* •
    Batch size: varies per dataset (typical: 64-4096)
* •
    Metric: Top-1 accuracy

## Citation

```bibtex
@misc{vysyaraju2025enhancing,
  title={Enhancing LLM-Based Neural Network Generation: Few-Shot Prompting and Efficient Validation for Automated Architecture Design},
  author={Vysyaraju et al. (2025)},
  year={2025},
  note={arXiv:2512.24120}
}
```

- arXiv: 2512.24120

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.