△ Mechanism confirmed, baseline not beaten 2026

Partial-ReNoise Neural Architecture Mutation

Implementation & benchmark of arXiv:2608.27649 — From Generation to Discovery: Diffusion Mutation Kernels for Circuit and Physical Design

Usefulness8/10

Difficulty6/10

Novelty6/10

Architecture Accuracy Scalability Sample efficiency Cnn Transformer Mlp Stochastic processes Probability Dynamical systems

Source paper: From Generation to Discovery: Diffusion Mutation Kernels for Circuit and Physical Design arXiv:2608.27649 ⓘ · analyzed Sep 1, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace independent architecture generation with a diffusion mutation kernel that starts from a known valid neural architecture, re-noises it for only a fraction of the diffusion horizon, and denoises it conditionally toward a new architecture. The resulting candidates should remain closer to the parent and retain validity at low mutation strength, while larger re-noising fractions should produce greater novelty and access to distinct architectural basins.

Formulas

$$K_{\gamma}(x'\mid x)=\int q(x_{\gamma T}\mid x)\prod_{t=\gamma T}^{1}p_{\theta}(x_{t-1}\mid x_t,c)\,dx_{1:\gamma T}.$$

$$q(x_t\mid x)=\mathcal N\left(\sqrt{\bar\alpha_t}x,(1-\bar\alpha_t)I\right),\qquad \bar\alpha_t=\prod_{s=1}^{t}(1-\beta_s).$$

$$x_{\gamma T}\leftarrow\sqrt{\bar\alpha_{\gamma T}}x+\sqrt{1-\bar\alpha_{\gamma T}}\,\epsilon,\quad \epsilon\sim\mathcal N(0,I),\qquad x_{t-1}\sim p_\theta(\cdot\mid x_t,c).$$

$$\operatorname{accept}(x')=\mathbf 1\{\operatorname{Compile}(x')=1,\ \operatorname{Params}(x')\le B_p,\ \operatorname{Latency}(x')\le B_l,\ \operatorname{Acc}(x')\ge A_0+\Delta\}.$$

Mathematical statement

Let x be a parent architecture encoding, x' a child architecture, T the total number of diffusion steps, and gamma in [0,1] the mutation fraction. Let q(x_gammaT | x) be the forward corruption distribution applied to the parent and p_theta(x_(t-1) | x_t,c) the learned reverse transition conditioned on task context c, such as parameter count or latency limits. The mutation kernel is K_gamma(x' | x) = integral q(x_gammaT | x) product from t=gammaT down to 1 of p_theta(x_(t-1) | x_t,c) dx_(1:gammaT). For a continuous embedding, use Gaussian forward corruption with alpha_bar_t equal to the product of (1-beta_s) from s=1 to t. For discrete graph tokens, use a categorical corruption kernel. The engineering prediction is that parent-child similarity decreases monotonically with gamma, while feasibility probability decreases much more slowly than novelty for small gamma.

Implementation notes

Use a dataset of valid CNN, MLP, or Transformer architectures encoded as fixed-length operation and edge tokens, or as a graph diffusion representation. Train a discrete diffusion model with conditioning vector c containing the target dataset, parameter budget, latency budget, and desired accuracy regime. During search, do not sample independently from the learned prior. Select an existing parent architecture x, choose gamma, corrupt it to timestep floor(gamma times T), and run the learned reverse model back to timestep zero. Pseudocode is: parent = archive.sample(); t = round(gamma*T); xt = forward_corrupt(parent,t); for s in range(t,0,-1): xt = reverse_sample(model,xt,s,context); child = decode(xt); if checker(child) and evaluate(child): archive.add(child). The checker must enforce acyclic graph structure, tensor-shape compatibility, parameter count, and hardware latency; measured validation accuracy is the final objective, not a model prediction. The paper contributes the anchored kernel and the separation between learned feasibility structure and external evaluation. Estimate the reverse model from architecture data and measure feasibility empirically with a held-out checking set. First experiment: use NAS-Bench-201 on CIFAR-10, train a small categorical diffusion model, and compare independent sampling against mutation from the best 20 architectures at gamma in {0.05, 0.15, 0.30, 0.60, 1.0}. Measure graph edit distance, validity rate, and benchmark accuracy. The predicted signature is monotonic growth of mean edit distance with gamma; for low gamma, validity should remain within 5 percentage points of the parent validity. As gamma approaches 1, behavior should approach independent-prior sampling, while gamma approaching 0 should produce near-duplicate children.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: No measurable effect

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a self-contained categorical partial re-noising architecture mutation MVP with validity checks, repair, an independent-prior baseline, and fixed-seed sweeps. The mechanism manifested: forward-token retention matched alpha_bar within 0.0028, edit distance increased monotonically from 0.000 at gamma=0 to 0.702 at gamma=1, and gamma=1 approached independent sampling with an edit-distance gap of 0.021. No accuracy improvement was demonstrated; post-repair validity was 100% by construction.

Agent confidence: 8/10

Baseline: Independent valid-prior sampling: mean parent-child edit distance 0.7231; validity 100%; synthetic mean accuracy approximately 77.27.
Idea: Mutation mean edit distance: gamma 0.05=0.0138, 0.15=0.0606, 0.30=0.2006, 0.60=0.4994, 1.0=0.7019. Raw validity was 98.5%, 95.5%, 85.0%, 75.5%, and 72.5% respectively; gamma=1 edit gap from independent was 0.0213; maximum retention error was 0.0028.

Limitations: This is a toy fixed-length categorical architecture space, not NAS-Bench-201 or CIFAR-10. The reverse model is hand-designed rather than trained, latency and accuracy are synthetic proxies, only one random seed was used, and repair makes post-repair validity uninformative.

How to run: python3 partial_renoise_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.27649) Sep 2, 2026

No significant difference vs. the tuned baseline (+0.1%, p=0.9195, wins 5 / 8 paired seeds).

Benchmark: Vision (image classification)
Model: cnn_small
Paired seeds: 8
Baseline mean: 0.8675
Idea mean: 0.8687
Effect (Δ): 0.0013 (+0.1%; negative = idea better)
Wins: 5 / 8 paired seeds
p-value: 0.9195 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±5.3%
Mechanism: Confirmed ✓
Practical effect: No effect
Baseline tuning: swept over 3 configs

Limitations:

The benchmark used a fast CIFAR-10 subset of 400 training and 100 test examples and 2 epochs after the larger run exceeded 2400 seconds; it is therefore a limited transfer test rather than a full NAS-Bench-201 search. The reverse diffusion model was represented by a minimal shape-compatible stochastic convolution mutation, not a learned discrete diffusion model, and no architecture archive, latency checker, parameter-budget search, or validation-accuracy NAS loop was tested.

How to run: python3 bench_partial_renoise.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Sep 1, 2026 latest Failed ✗

Agent confidence: 9/10

Built a structurally matched vision benchmark for partial re-noising CNN architecture mutation, using the same CNN task, paired seeds, shared learning-rate grid, and equal training budget for baseline and idea. The trained models showed the predicted decrease in parent-operation retention with mutation strength, with maximum observed-vs-predicted error 0.075 and confirmed=true. However, the best idea configuration had higher classification error than the tuned baseline (0.86875 vs 0.86750), with paired delta +0.00125 and permutation p=0.9195; therefore there is no measured benchmark improvement.

Baseline: Tuned cnn_small, best lr=0.003: mean CIFAR-10 subset classification error 0.86750, std 0.02905, 8 paired seeds.
Idea: PartialReNoiseCNN, best gamma=0.05 and lr=0.001: mean classification error 0.86875, std 0.03407, 8 paired seeds; paired delta idea-baseline +0.00125, p=0.9195.
Mechanism signature: Predicted parent-operation retention [0.9900, 0.9259, 0.7420, 0.0309] for gamma [0.05,0.15,0.30,1.0]; observed trained-model retention [1.0000,1.0000,0.6667,0.0000], maximum absolute error 0.07535, confirmed=true.

Benchmark result