Pith. sign in

REVIEW 2 major objections 5 minor 26 references

An LLM builds a task-specific NAS search space by turning a seed network into named module slots, and the two methods together set new records on 11 of 17 diverse tasks.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-10 14:12 UTC pith:Z4FP2VJA

load-bearing objection Clean LLM-to-NAS handoff via slotted architectures; SOTA on 11/17 tasks with ablations that actually separate the two mechanisms. the 2 major comments →

arxiv 2607.07984 v1 pith:Z4FP2VJA submitted 2026-07-08 cs.AI

Agentic Neural Architecture Search

Seokhoon Jeong , Mijung Kim , Taehwan Kim This is my paper
classification cs.AI
keywords neural architecture searchlarge language modelsslotted architecturesearch space constructionAgentNAScombinatorial recombinationNAS-Bench-360Unseen NAS
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Neural architecture search usually needs a hand-built search space for every new task, while large language models can invent whole networks but only sample them one at a time. This paper claims the right division of labor is: let the language model first design a strong seed network and its training recipe, then carve that seed into a “slotted architecture”—a scaffold of named, interchangeable modules—so ordinary NAS can combinatorially recombine the modules without any manual space engineering. Instantiated as AgentNAS, the pipeline is tested on 17 classification, regression, segmentation, and tagging tasks spanning many data modalities. The language-model seed alone already beats published baselines on most tasks; NAS then adds further gains on most of them by recombining slots in ways independent language-model samples cannot. The same pattern holds across three models of different strength, and the full system sets a new best result on 11 of the 17 tasks, including under a blind protocol that hides domain labels.

Core claim

LLM-driven seed design and conventional NAS are complementary rather than substitutable: the language model supplies both a high-quality seed and an automatically constructed, task-specific search space (the slotted architecture), while NAS finds additional performance by combinatorial recombination across slots—a mode of search that matched-budget independent LLM sampling does not replicate—yielding new state-of-the-art results on 11 of 17 diverse tasks.

What carries the argument

The slotted architecture: after the language model produces a seed network, a planner decomposes it into a scaffold with named module-level slots (and optional additive “glue” slots plus a learning-rate multiplier slot) whose alternatives automatically define a bounded discrete search space that standard NAS algorithms can explore while preserving the seed’s macro structure.

Load-bearing premise

That the language model’s slotted neighborhood around the seed—keeping the seed’s overall depth, width, and backbone while only swapping modules and glue—contains enough of the good architectures for the task that NAS gains reflect real complementarity rather than recovery from a lucky seed or a poorly varied space.

What would settle it

On a held-out suite of the same diversity, run matched-budget independent LLM sampling past the saturation point and show that it matches or exceeds the LLM-seed-plus-NAS trajectory on most tasks; or show that a stronger, manually engineered or open-ended space around the same seeds systematically beats the LLM-constructed slotted space.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Task-specific NAS search spaces no longer need to be hand-designed; a language model can emit both the seed and the space.
  • Architecture search can be budget-allocated as “LLM until saturation, then NAS recombination,” rather than pure LLM sampling or pure fixed-space NAS.
  • The same three-phase pipeline can be dropped onto new modalities and blind settings without rewriting search-space grammars.
  • Gains attributed to “LLM NAS” should be decomposed into seed quality versus combinatorial search over the induced slots.
  • Weaker language models may still benefit if a stronger model only designs the slots, because the complementarity pattern holds across capability levels.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Search-space quality, not only seed quality, is a first-class object of study for agentic design; the Darcy Flow contrast shows that structurally diverse slot alternatives matter more than raw seed score.
  • If modularization is required to keep block-stack seeds searchable, automatic granularity control becomes a necessary sub-problem for any LLM-to-NAS handoff.
  • The method suggests a practical template for other design domains where an open-ended generator can propose a scaffold and a combinatorial optimizer can recombine parts.
  • Blind-setting results imply that data-driven exploration can sometimes outperform domain-prior prescriptions when the language model otherwise short-circuits exploration.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. The paper proposes AgentNAS, a three-phase pipeline that uses an LLM to generate a seed architecture and training recipe (Phase 1), decompose that seed into a slotted architecture with named module-level and additive glue slots plus a learning-rate multiplier slot (Phase 2), and then run conventional discrete NAS (default: regularized evolution) inside that automatically constructed space (Phase 3). On 17 tasks from NAS-Bench-360 and Unseen NAS, the full pipeline reports new best results on 11 tasks; ablations argue that LLM seed design and NAS combinatorial recombination are complementary, that matched-budget further LLM sampling saturates while NAS still improves, and that the pattern holds across three Claude models of different capability.

Significance. If the results hold under the stated protocols, the work is a clear contribution to automated architecture design: it cleanly separates LLM-driven space construction from NAS-driven combinatorial search, evaluates on two diverse public suites (including a blind Unseen-NAS setting), and supplies multi-LLM, fixed-seed, search-algorithm, multi-seed, and modularization ablations plus released code. The slotted-architecture mechanism is a practical answer to the long-standing manual search-space bottleneck in NAS, and the complementarity evidence (Tables 1–3, Figure 3, Appendices A.3–A.4, A.7.3) is more carefully instrumented than most LLM-for-NAS papers.

major comments (2)
  1. The central complementarity claim rests on the premise that the Phase-2 slotted space (≤20 slots × ≤8 alternatives, macro structure frozen after optional modularization) is a high-density neighborhood of good architectures rather than a local cage around a lucky seed. Section 5.3 already shows this can fail: Sonnet’s Darcy Flow spectral slots retain the same einsum channel-mixing form, so NAS has no useful variation, while Opus’s element-wise spectral alternative succeeds. Limitations also note that weaker models can emit degenerate spaces. The paper should elevate this from a case study into an explicit discussion of when Phase 2 is expected to succeed or fail, and ideally add a simple quantitative diagnostic of slot diversity / structural variation (e.g., fraction of alternatives that change operator family or connectivity) correlated with NAS gain magnitude across the six analysis tas
  2. Budget and selection protocol are carefully described but still leave residual ambiguity for the headline SOTA-on-11 claim. Phase 1 and Phase 3 each use a 160-evaluation cap with patience 64, proxy training at 0.3 of proposed epochs, and a non-seed best-validation selection rule that reports second-best when NAS fails to beat the seed (Section 4.3). Actual budgets therefore vary by early stopping and by LLM early termination (Limitations). Table 3 also notes unreproduced fixed-seed numbers and OOM on Darcy under the 11 GB constraint. A short consolidated budget table (evaluations actually run, wall-clock/GPU hours already partly in A.1, and whether the reported architecture came from Phase 1 or Phase 3) for all 17 tasks would make the comparison to einspace-500 and conventional NAS fully auditable.
minor comments (5)
  1. Tables 1–2 mix metrics (1−acc, Rel. L2, MAE8, 1−AUROC, 1−F1, 1−mAP). A one-line note in each caption that lower is always better (already stated in the table headers) and that ranks are computed on the reported metric would reduce reader friction.
  2. Figure 3 is central to the complementarity argument; ensure axis scales and the Haiku Darcy special case (NAS from 160-budget seed while LLM continues to 480) are fully legible in the caption without requiring the main text.
  3. Appendix A.2 training-recipe table is valuable; a brief main-text pointer that NAS reuses the LLM recipe except for the LR multiplier slot would help readers who skip the appendix.
  4. Related Work §2.2 correctly notes that prior LLM-NAS work uses LLMs as operators inside the loop rather than as search-space constructors; a short explicit contrast table (role of LLM / role of NAS / space source) would make the novelty claim sharper.
  5. Minor presentation: arXiv id and Claude model dates in the manuscript should be checked for consistency with the public release; code URL is appreciated and should remain stable.

Circularity Check

0 steps flagged

No circular derivation: empirical NAS/LLM pipeline evaluated on held-out tests and external published baselines; complementarity is measured, not forced by construction.

full rationale

AgentNAS is an empirical systems paper, not a first-principles derivation. Its load-bearing claims (SOTA on 11/17 tasks; LLM seed and slotted NAS are complementary) rest on train/proxy/validation selection with test metrics never exposed to the pipeline, comparison to published baselines from NAS-Bench-360, Unseen NAS, and einspace, and ablations (LLM-only vs full pipeline; fixed-seed+NAS; matched-budget continued LLM sampling vs NAS; RE/RS/GDAS; multi-seed). Phase 2’s slotted space is an engineered neighborhood of the seed, but performance on that space is not tautological: NAS can and does fail to improve (e.g., Darcy Flow under Sonnet’s spectral slots; several tasks where seed already ceilings), and the paper reports those failures. There is no self-definitional identity between inputs and claimed outputs, no fitted parameter renamed as a prediction of a related quantity, no load-bearing uniqueness theorem imported from overlapping authors, and no ansatz smuggled in via self-citation. Same-LLM design of seed and slots is methodological coupling, not circular reasoning. Score 0 is the honest finding.

Axiom & Free-Parameter Ledger

6 free parameters · 5 axioms · 3 invented entities

The central claim rests on empirical pipeline design choices and standard NAS/LLM assumptions rather than free physical constants. The main free parameters are search budgets, slot caps, and proxy training settings that define what ‘complementary’ means under the reported compute. Invented entities are methodological constructs (slotted architecture, glue slots) with no independent physical status.

free parameters (6)
  • Phase-1/Phase-3 evaluation budget = 160 evals, patience 64
    Hard cap of 160 architecture evaluations per phase with patience 64; directly shapes when LLM sampling is declared saturated and when NAS is credited with gains.
  • proxy_epoch_fraction = 0.3
    Candidates trained at 30% of full epochs under a 60-minute GPU-time cap; ranking quality depends on this proxy correlating with full training.
  • max_slots / max_alternatives_per_slot = 20 × 8
    Slot Planner capped at 20 slots and 8 alternatives each; defines the size and expressivity of the NAS space.
  • learning-rate multiplier set = {0.25,0.5,1,2,4}
    Virtual LR slot uses fixed multipliers {0.25, 0.5, 1.0, 2.0, 4.0} of the seed recipe; ad hoc discrete grid.
  • evolution population / tournament = pop=16, tournament=5
    Population 16, tournament size 5, max 10 generations, 50/50 single/double-slot mutation; unoptimized search hyperparameters.
  • LLM temperature and model choice = T=0.7; Claude family
    Claude Sonnet 4.6 (main), Haiku 4.5, Opus 4.6 at temperature 0.7; seed and space quality scale with model capability.
axioms (5)
  • ad hoc to paper A high-quality seed plus module-level interchangeable slots preserves useful macro structure while exposing the degrees of freedom where combinatorial NAS is most effective.
    Core design hypothesis of Phase 2 (Section 3.2); motivated by hierarchical/cell-based NAS literature but not proved.
  • domain assumption Proxy validation metrics at 30% epochs under VRAM/time caps rank architectures consistently enough with full training for selection.
    Standard NAS proxy assumption; failures (e.g., DeepSea val/test misalignment) are noted in Limitations.
  • domain assumption Only validation metrics may guide search; test metrics stay hidden until final reporting.
    Stated protocol in Section 3.1 and 4.3; required for fair comparison to published baselines.
  • domain assumption Regularized evolution (and RS/GDAS) over a discrete categorical slot space is a valid explorer of the LLM-defined neighborhood.
    Phase 3 default; Appendix A.3 shows modest algorithm differences without hyperparameter tuning.
  • domain assumption Blind Unseen-NAS setting (no domain metadata) is a meaningful test of domain-agnostic design.
    Section 4.1; LLM still sometimes infers domain from shapes (Table 12).
invented entities (3)
  • Slotted architecture no independent evidence
    purpose: Scaffold that turns an LLM seed into a bounded, named-slot search space for conventional NAS without manual space engineering.
    Primary methodological invention of the paper; independent evidence is only the empirical gains on the 17 tasks.
  • Additive glue slots (default identity) no independent evidence
    purpose: Allow NAS to insert optional ops/activations/skips between modules without breaking seed behavior.
    Design choice in Phase 2; no external validation beyond AgentNAS runs.
  • Modularizer agent no independent evidence
    purpose: Group block-stack primitives into coherent modules before slotting to avoid unstable fine-grained spaces.
    Optional Phase-1.5 component; ablation in Appendix A.7.3 only.

pith-pipeline@v1.1.0-grok45 · 38670 in / 3728 out tokens · 32490 ms · 2026-07-10T14:12:55.510022+00:00 · methodology

0 comments
read the original abstract

Neural architecture search (NAS) methods have grown increasingly efficient, yet they remain bounded by manually engineered search spaces that require substantial domain expertise and must be rebuilt for every new task. Large language models (LLMs) can generate architectures in an open-ended space, but how to optimally divide the labor between LLM-driven design and NAS-driven search remains unexplored. We propose a mechanism that bridges these two paradigms: an LLM produces a high-quality seed architecture, then decomposes it into a "slotted architecture", a scaffold with named, interchangeable module slots that automatically defines a bounded, task-specific search space for conventional NAS to explore, without manual engineering. We instantiate this mechanism in AgentNAS, a modular three-phase pipeline in which each component's contribution can be measured independently. On 17 tasks spanning classification, dense regression, segmentation, and multi-label tagging across diverse modalities (NAS-Bench-360 and Unseen NAS), AgentNAS establishes a new state of the art on 11 tasks, outperforming published baselines including task-specific expert designs. Ablation studies show that the two search mechanisms are broadly complementary: the LLM-generated seed already surpasses published baselines on the majority of tasks, and NAS delivers additional gains in most cases through combinatorial recombination across slots, a mode of search that independent LLM samples cannot replicate. These patterns hold across three LLMs of different capability levels, confirming that the division of labor is robust. Our code is available at https://github.com/alroimfebruary/AgentNAS.

Figures

Figures reproduced from arXiv: 2607.07984 by Mijung Kim, Seokhoon Jeong, Taehwan Kim.

Figure 1
Figure 1. Figure 1: The AgentNAS pipeline. Phase 1 iteratively prompts an LLM to propose, implement, and train candidate architectures, returning a seed architecture and its training recipe. Given the updated leaderboard and self-generated summary with the proxy scores of proposed architectures, an LLM iteratively improves architectures until it saturates. Phase 2 decomposes the seed into a slotted architecture with per-slot … view at source ↗
Figure 2
Figure 2. Figure 2: Slotted architecture for the Spherical task. Module-level slots such as stacked DWP-SE-GELU or stacked MBConv-SE-SiLU are replaceable, while additive glue slots provide optional normalizations or activation functions between modules. The architecture discovered by NAS is unconventional yet substantially stronger. NAS-Bench-360. We compare with four baselines: (i) WideResNet-16-4 (Zagoruyko & Komodakis, 201… view at source ↗
Figure 3
Figure 3. Figure 3: Budget–performance trajectories (lower is better). Solid: LLM-only search; dashed: LLM + NAS. Each point reports the best non-seed architecture. Colors: Sonnet 4.6 (blue), Opus 4.6 (pink), Haiku 4.5 (green). On Darcyflow, Haiku, starting from a 320-budget architecture, created degenerate search spaces that could not pass our validation gate even with multiple trials, so we report the NAS result from a 160-… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

26 extracted references · 26 canonical work pages · 4 internal anchors

  1. [1]

    www.cinc.org, 2017

    InComputing in Cardiology, CinC 2007, Rennes, France, September 24-27, 2017. www.cinc.org, 2017. doi: 10.22489/CINC.2017.065-469. URL https: //doi.org/10.22489/CinC.2017.065-469. Cohen, T. S., Geiger, M., K¨ohler, J., and Welling, M. Spher- ical cnns. In6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - ...

    work page doi:10.22489/cinc.2017.065-469 2007

  2. [2]

    doi: 10.1109/CVPR.2019.00186

    Computer Vision Foundation / IEEE, 2019. doi: 10.1109/CVPR.2019.00186. URL http://openac cess.thecvf.com/content_CVPR_2019/ht ml/Dong_Searching_for_a_Robust_Neura l_Architecture_in_Four_GPU_Hours_CVP R_2019_paper.html. Dong, X. and Yang, Y . Nas-bench-201: Extending the scope of reproducible neural architecture search. In8th International Conference on Le...

    work page doi:10.1109/cvpr.2019.00186 2019

  3. [3]

    Ericsson, L., Espinosa, M., Yang, C., Antoniou, A., Storkey, A., Cohen, S

    URL https://jmlr.org/papers/v20/ 18-598.html. Ericsson, L., Espinosa, M., Yang, C., Antoniou, A., Storkey, A., Cohen, S. B., McDonagh, S., and Crowley, E. J. einspace: Searching for neural architectures from fun- damental operations. In Globersons, A., Mackey, L., Belgrave, D., Fan, A., Paquet, U., Tomczak, J. M., and Zhang, C. (eds.),Advances in Neural I...

    work page doi:10.1109/taslp.2021.3133208 2024

  4. [4]

    URL https: //doi.org/10.1109/ICCV.2019.00332

    doi: 10.1109/ICCV.2019.00332. URL https: //doi.org/10.1109/ICCV.2019.00332. He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV , USA, June 27-30, 2016, pp. 770–778. IEEE Computer Society, 2016. doi: 10.1109/CVPR.201 6.90. URL http...

    work page doi:10.1109/iccv.2019.00332 2019

  5. [5]

    URL http://proceedings.mlr.press/ v115/li20c.html. Li, Y . and King, I. Autograph: Automated graph neural network. In Yang, H., Pasupa, K., Leung, A. C., Kwok, J. T., Chan, J. H., and King, I. (eds.),Neural Informa- tion Processing - 27th International Conference, ICONIP 2020, Bangkok, Thailand, November 23-27, 2020, Pro- ceedings, Part II, volume 12533 o...

    work page doi:10.1007/978-3-030-63833-7 2020

  6. [6]

    Morris, C., Jurado, M., and Zutty, J

    URL https://doi.org/10.1145/332170 7.3321729. Morris, C., Jurado, M., and Zutty, J. LLM guided evolution - the automation of models advancing models. In Li, X. and Handl, J. (eds.),Proceedings of the Genetic and Evolutionary Computation Conference, GECCO 2024, Melbourne, VIC, Australia, July 14-18, 2024. ACM, 2024. doi: 10.1145/3638529.3654178. URL https:...

    work page doi:10.1145/332170 2024

  7. [7]

    URL https: //doi.org/10.1145/3638529.3654017

    doi: 10.1145/3638529.3654017. URL https: //doi.org/10.1145/3638529.3654017. Novikov, A., Vu, N., Eisenberger, M., Dupont, E., Huang, P., Wagner, A. Z., Shirobokov, S., Kozlovskii, B., Ruiz, F. J. R., Mehrabian, A., Kumar, M. P., See, A., Chaudhuri, S., Holland, G., Davies, A., Nowozin, S., Kohli, P., and Balog, M. Alphaevolve: A coding agent for scientifi...

    work page doi:10.1145/3638529.3654017 2025

  8. [8]

    LeMo-NADe: Multi-Parameter Neural Architecture Discovery with LLMs

    URL https://doi.org/10.48550/arXiv .2402.18443. Real, E., Moore, S., Selle, A., Saxena, S., Leon-Suematsu, Y . I., Tan, J., Le, Q. V ., and Kurakin, A. Large-scale evolution of image classifiers. In Precup, D. and Teh, Y . W. (eds.),Proceedings of the 34th International Con- ference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017,...

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv 2017

  9. [9]

    Real, E., Aggarwal, A., Huang, Y ., and Le, Q

    URL http://proceedings.mlr.press/ v70/real17a.html. Real, E., Aggarwal, A., Huang, Y ., and Le, Q. V . Regular- ized evolution for image classifier architecture search. In 12 Agentic Neural Architecture Search The Thirty-Third AAAI Conference on Artificial Intelli- gence, AAAI 2019, The Thirty-First Innovative Applica- tions of Artificial Intelligence Con...

    work page doi:10.1609/aaai.v33i01.33014780 2019

  10. [10]

    AgentRxiv: Towards Collaborative Autonomous Research

    URL https://proceedings.neurips. cc/paper/2021/hash/84fdbc3ac902561c0 0871c9b0c226756-Abstract.html. Romera-Paredes, B., Barekatain, M., Novikov, A., Balog, M., Kumar, M. P., Dupont, E., Ruiz, F. J. R., Ellen- berg, J. S., Wang, P., Fawzi, O., Kohli, P., and Fawzi, A. Mathematical discoveries from program search with large language models.Nat., 625(7995):...

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.1038/s41586-023-06924-6 2021

  11. [11]

    AgentRxiv: Towards Collaborative Autonomous Research

    doi: 10.48550/ARXIV.2503.18102. URL https: //doi.org/10.48550/arXiv.2503.18102. Schmidgall, S., Su, Y ., Wang, Z., Sun, X., Wu, J., Yu, X., Liu, J., Moor, M., Liu, Z., and Barsoum, E. Agent lab- oratory: Using LLM agents as research assistants. In Christodoulopoulos, C., Chakraborty, T., Rose, C., and Peng, V . (eds.),Findings of the Association for Compu...

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.2503.18102 2025

  12. [12]

    URL https://openreview.net/forum ?id=k5Z1tSidYY. Song, Z. and Jiang, Z. Adaptive mamba neural operators

    work page

  13. [13]

    Song, Z., Zhen, X., and Jiang, Z

    URL https://openreview.net/forum ?id=OenyzvFZPs. Song, Z., Zhen, X., and Jiang, Z. Can large language mod- els design effective neural operators for solving partial differential equations? In3rd AI for Math Workshop: To- ward Self-Evolving Scientific Agents, 2026. URLhttps: //openreview.net/forum?id=6GCIuS0oO0&. Sumbul, G., Charfuelan, M., Demir, B., and ...

    work page doi:10.1109/igarss.2019.89 2026

  14. [14]

    The AI Scientist-v2: Workshop-Level Automated Scientific Discovery via Agentic Tree Search

    URL https://openreview.net/forum ?id=BJlS634tPr. Yamada, Y ., Lange, R. T., Lu, C., Hu, S., Lu, C., Fo- erster, J. N., Clune, J., and Ha, D. The AI scientist- v2: Workshop-level automated scientific discovery via agentic tree search.CoRR, abs/2504.08066, 2025. doi: 10.48550/ARXIV.2504.08066. URL https://doi. org/10.48550/arXiv.2504.08066. Yang, S., Yu, X....

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.2504.08066 2025

  15. [15]

    <EXPLORE> {purpose} </EXPLORE> Launch the Data Explorer to analyze the dataset

    work page

  16. [16]

    arch_NNN

    <EXPERIMENT> Propose up to {n_gpu} architectures for parallel evaluation. For each: <ARCH id="arch_NNN"> <DESCRIPTION> {high-level architecture description} </DESCRIPTION> <REASONING> {why this design, what you expect} </REASONING> <TRAINING_RECIPE> {optimizer, lr, scheduler, epochs, ...} </TRAINING_RECIPE>,→ </ARCH> </EXPERIMENT> To modify a prior archit...

    work page

  17. [17]

    **Execution output:**

    <STOP> <FINAL_SELECTION> {arch_ids for full training} </FINAL_SELECTION> </STOP> After receiving experiment results: <SUMMARY> {what worked, what failed, surprises, next direction} </SUMMARY> ## Constraints - {vram_mb} MB VRAM per GPU - Proxy training: {proxy_epoch_pct}% of proposed epochs, {time_limit_min}-min GPU cap,→ - Final training: full proposed ep...

    work page

  18. [18]

    - x shape: (batch, {input_shape}) - output shape: (batch, {output_spec}) - Imports: torch, torch.nn, torch.nn.functional, stdlib only

    Model code: a class`Architecture`extending`nn.Module`, with __init__(self) and forward(self, x). - x shape: (batch, {input_shape}) - output shape: (batch, {output_spec}) - Imports: torch, torch.nn, torch.nn.functional, stdlib only. - NO pre-trained weights. No torchvision.models, no timm, no checkpoints

    work page

  19. [19]

    optimizer

    Training config: JSON dict (schema below). Use ONLY the fields listed. Wrap model in```python```, config in```json```. ## Constraints - VRAM cap: {vram_mb} MB. - Proxy: {proxy_epoch_pct}% of proposed epochs, {time_limit}-min GPU cap. Final: full proposed epochs, 24-hour GPU cap. - Loss: {loss_info} # CrossEntropyLoss / BCEWithLogitsLoss / regression Outpu...

    work page

  20. [20]

    Copy them VERBATIM -- no renames, no reordering, no layer-construction changes

    All helper classes the original used (RegNetBlock, FNOBlock, ...). Copy them VERBATIM -- no renames, no reordering, no layer-construction changes

    work page

  21. [21]

    Each must: - Have a docstring stating the contract, e.g.: '''INTERNAL: BatchNorm + ReLU + SE + residual baked in

    NEW per-stage Stage classes (Stage1, Stage2, Stage3, ...). Each must: - Have a docstring stating the contract, e.g.: '''INTERNAL: BatchNorm + ReLU + SE + residual baked in. Outer norm/act/skip slots SHOULD be Identity.''' - In __init__, instantiate blocks/parameters in the SAME order with the SAME hyperparameters as the original stage construction. - In f...

    work page

  22. [22]

    Task: {task_name}, Input shape: (batch, ...)

    Rewritten Architecture class: - Same helper attributes (stem, pool, head, ...) constructed identically. - Each repeated stage replaced by`self.stageN = StageN()`(instead of `nn.ModuleList([...])`). - Architecture.forward simplified to: # data-augmentation block (UNCHANGED, copy verbatim) x = self.stem(x) x = self.stage1(x); x = self.stage2(x); ... x = sel...

    work page

  23. [23]

    Seed choice (always first)

    work page

  24. [24]

    Domain-specific novel ops -- e.g.: - audio: frequency-band processing, multi-scale temporal conv - images: multi-scale feature extraction, deformable conv - 1D sigs: dilated causal conv, wavelet-inspired blocks

    work page

  25. [25]

    Standard alternatives (conv3x3, conv1x1, depthwise-separable, squeeze-excite, self-attention)

    work page

  26. [26]

    name": "stageN_op

    Identity (pass-through) and Zero (outputs zeros) -- let NAS discover that a component is unnecessary. ## Slot JSON format single-input: { "name": "stageN_op", "class_name": "SLOT_stageN_op", "description": ..., "input_shape": [...], "output_shape": [...], "interface": "single", "seed_description": ..., "alternatives": [...] } dual-input (skip/composition)...

    work page