△ Mechanism confirmed, baseline not beaten 2026

Entropy-Feedback Zeroth-Order Cooling

Implementation & benchmark of arXiv:2607.14245 — Information-Theoretic Adaptive Cooling for Deterministic MPPI via Entropy Feedback

Usefulness7/10
Difficulty5/10
Novelty6/10

Source paper: Information-Theoretic Adaptive Cooling for Deterministic MPPI via Entropy Feedback arXiv:2607.14245 ⓘ · analyzed Aug 30, 2026

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

Idea description

Replace a fixed temperature schedule in a population-based, derivative-free neural-network optimizer with a feedback controller driven by the entropy of candidate importance weights. When candidate losses are diffuse, the optimizer cools rapidly to exploit progress; when one or a few candidates dominate, cooling slows to prevent irreversible population collapse and loss of exploration.

Formulas

$$w_i(t)=\frac{\exp\left(-(J_i-J_{\min})/\tau_t\right)}{\sum_{j=1}^{N}\exp\left(-(J_j-J_{\min})/\tau_t\right)},\qquad H_t=-\sum_{i=1}^{N}w_i(t)\log w_i(t),\qquad h_t=\frac{H_t}{\log N}.$$
$$\mathrm{ESS}_t=\exp(H_t),\qquad \frac{\mathrm{ESS}_t}{N}=\exp\left(-(1-h_t)\log N\right).$$
$$b(h_t)=\frac{1}{1+\exp(-(h_t-h_c)/\delta)},\qquad \tau_{t+1}=\tau_t\exp\left[-\alpha\left(\varepsilon+(1-\varepsilon)b(h_t)\right)\right].$$
$$\theta_{t+1}=(1-\gamma)\theta_t+\gamma\sum_{i=1}^{N}w_i(t)\theta_t^{(i)},\qquad \theta_t^{(i)}=\theta_t+\sigma_t\epsilon_i,\quad \epsilon_i\sim\mathcal{N}(0,I).$$

Mathematical statement

At optimization iteration t, sample N candidate parameter vectors theta_i(t)=theta_t+sigma_t epsilon_i, where epsilon_i is drawn from a standard Gaussian and J_i is the candidate minibatch loss. Define temperature-tau importance weights w_i=exp(-(J_i-J_min)/tau_t) divided by the sum over candidates, Shannon entropy H_t=-sum_i w_i log(w_i), and normalized entropy h_t=H_t/log(N). The effective sample size is ESS_t=exp(H_t), so entropy directly measures population collapse. Let h_c be the critical normalized entropy and delta a smoothing width. Define b(h)=sigmoid((h-h_c)/delta) and update tau_{t+1}=tau_t exp(-alpha[epsilon+(1-epsilon)b(h_t)]), with cooling gain alpha>0 and small mandatory rate epsilon>0. Cooling is fast for h_t well above h_c and slow but nonzero below h_c. Update the parameter center with the weighted candidate mean and optionally damping gamma.

Implementation notes

1. Integration point: implement this as a zeroth-order optimizer for a small neural network, derivative-free fine-tuning of a pretrained model, or optimization of prompts or low-rank adapter parameters. At each optimizer step, draw N perturbations of the current trainable parameter vector, evaluate every candidate on the same minibatch, and replace the ordinary fixed-temperature softmax weighting and hand-designed cooling schedule with the entropy controller above. Use antithetic perturbations when memory permits and keep a separate validation minibatch for monitoring collapse.

2. Pseudocode:

initialize theta, tau=tau0
for t in range(T):
    eps = Normal(0,I,N)
    candidates = theta + sigma * eps
    losses = [loss(model(candidate), minibatch) for candidate in candidates]
    z = -(losses - min(losses)) / tau
    w = softmax(z)
    H = -sum(w * log(w + 1e-12))
    h = H / log(N)
    b = sigmoid((h - hcrit) / delta)
    theta_mean = sum_i(w[i] * candidates[i])
    theta = (1-gamma)*theta + gamma*theta_mean
    tau = tau * exp(-alpha*(epsilon_floor + (1-epsilon_floor)*b))

3. Computed directly from the mechanism: normalized importance-weight entropy, effective sample size, and the thresholded temperature update. Estimated empirically: threshold h_c, cooling gain alpha, perturbation scale sigma, and damping gamma. Start with h_c=0.5, delta=0.05, alpha=0.05, epsilon=0.02, and gamma=1; tune only h_c in the first ablation. Clip the logits before softmax for numerical stability.

4. First cheap experiment: optimize a two-layer ReLU MLP on MNIST using N=64 or 128 Gaussian candidates per step and compare against the same zeroth-order optimizer with exponential cooling, constant temperature, and a manually tuned ESS floor. Run five seeds on a 10,000-example subset. The quantitative prediction is that normalized entropy will repeatedly approach h_c from above rather than falling immediately toward zero; the slope of log(tau_t) should change from approximately -alpha when h_t>h_c+2delta to approximately -alpha epsilon when h_t<h_c-2delta. The measured ESS at transition should be N^{h_c}; for N=128 and h_c=0.5, the predicted transition is ESS approximately 11.3. Reject the mechanism if the cooling-rate change is absent or transition ESS differs by more than 20%.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significantly worse ✗

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 and ran an entropy-feedback zeroth-order optimizer verification on a 24-dimensional ill-conditioned quadratic. The ESS identity error was 4.44e-16, the transition prediction ESS=N^0.5=11.31 was observed as 11 for h=0.494, and measured cooling slopes matched the predicted controller rates at h=0.1, 0.5, and 0.9 to numerical precision. In the five-seed toy comparison, feedback reached mean final loss 1.056 versus 2.256 for fixed exponential cooling, but constant temperature was better at 0.135; thus the mechanism manifested, but a universal optimization win was not established.

Agent confidence
8/10
Baseline
Fixed exponential cooling: final quadratic loss 2.256 +/- 0.411; last-20 normalized entropy 0.00063; final temperature 1.234e-4.
Idea
Entropy feedback: final quadratic loss 1.056 +/- 0.415; last-20 normalized entropy 0.222; final temperature 0.113. Predicted versus observed cooling slopes: h=0.1, 0.00101643 versus 0.00101643; h=0.5, 0.0255 versus 0.0255; h=0.9, 0.0499836 versus 0.0499836. Constant-temperature reference achieved 0.135 final loss.

Limitations: The completed experiment is a toy quadratic rather than MNIST or a neural network, uses five seeds, and does not compare equal wall-clock/FLOPs against gradient-based training. The reusable entropy_cooling.py module save was interrupted by the protocol error and may be incomplete; verify_entropy_cooling.py and results.json contain the executed, reproducible results.

How to run: python3 verify_entropy_cooling.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.14245)

Significantly WORSE than the tuned baseline (+0.3%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark
Tabular regression (Friedman)
Model
mlp_tiny
Paired seeds
8
Baseline mean
210.2836
Idea mean
210.9054
Effect (Δ)
0.6218 (+0.3%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect
±0.2%
Mechanism
Confirmed ✓
Practical effect
Hurts
Baseline tuning
swept over 3 configs
Limitations:

Only the small tabular track was tested, with 400 training examples, N=16 candidates, and 12 zeroth-order steps. No vision, sequence, dynamics, wall-clock, or FLOP-normalized comparison was run. The baseline lr sweep was degenerate because lr is inert in the custom zeroth-order loop; this limitation is reflected in the report.

How to run: python3 entropy_feedback_bench.py

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

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 9/10

Built entropy-feedback zeroth-order cooling for the structurally matched tabular Friedman regression track with identical mlp_tiny architecture, population, perturbation scale, steps, data, and paired seeds. The mechanism signature was confirmed, with transition ESS 4.19 observed versus 4.0 predicted and cooling rates close to the predicted high- and low-entropy rates. Performance was significantly worse than fixed exponential cooling, so worked=false.

Baseline
Fixed exponential cooling, best swept configuration lr=0.001: test MSE 210.284 +/- 5.265 over 8 seeds.
Idea
Entropy feedback at lr=0.001: test MSE 210.905 +/- 5.310 over 8 seeds; paired delta +0.622, 0/8 wins, permutation p=0.0081; mechanism confirmed.

Benchmark result

Significantly WORSE than the tuned baseline (+0.3%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark
Tabular regression (Friedman)
Model
mlp_tiny
Paired seeds
8
Baseline mean
210.2836
Idea mean
210.9054
Effect (Δ)
0.6218 (+0.3%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect
±0.2%
Mechanism
Confirmed ✓
Practical effect
Hurts
Baseline tuning
swept over 3 configs
Limitations:

Only the small tabular track was tested, with 400 training examples, N=16 candidates, and 12 zeroth-order steps. No vision, sequence, dynamics, wall-clock, or FLOP-normalized comparison was run. The baseline lr sweep was degenerate because lr is inert in the custom zeroth-order loop; this limitation is reflected in the report.

How to run: python3 entropy_feedback_bench.py

Artifacts

Implementation overview ⬇ Download all as ZIP 6 files · code, reports and structured results