✗ Failed on benchmark 2026

Derivative-Jet MLP Compression

Implementation & benchmark of arXiv:2608.21752 — Width-Independent Compressibility of Deep Neural Networks

Usefulness8/10
Difficulty6/10
Novelty7/10

Source paper: Width-Independent Compressibility of Deep Neural Networks arXiv:2608.21752 ⓘ · analyzed Aug 29, 2026

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

Idea description

Compress a trained wide analytic-activation MLP by fitting a narrow same-depth student to the teacher's function values and input derivatives, rather than matching only outputs on a calibration dataset. Choose the student width from the input dimension and target error, with a target scaling m = O((log(1/epsilon))^d_in), and use sequential layer fitting plus channel reweighting to limit error accumulation through depth.

Formulas

$$m(\varepsilon,d_{\mathrm{in}})=O\!\left((\log(1/\varepsilon))^{d_{\mathrm{in}}}\right)$$
$$J_K f(x_0)=\left\{\partial^\alpha f(x_0):\alpha\in\mathbb{N}_0^{d_{\mathrm{in}}},\ |\alpha|\le K\right\},\qquad \#J_K=\binom{K+d_{\mathrm{in}}}{d_{\mathrm{in}}}$$
$$f(x)=\sum_{|\alpha|\le K}\frac{\partial^\alpha f(x_0)}{\alpha!}(x-x_0)^\alpha+R_{K+1}(x),\qquad (x-x_0)^\alpha=\prod_{i=1}^{d_{\mathrm{in}}}(x_i-x_{0,i})^{\alpha_i}$$
$$\mathcal{L}_{\mathrm{jet}}=\sum_{a=1}^{A}\sum_{|\alpha|\le K}w_\alpha\left\|\partial^\alpha h_{\mathrm{student}}(x_a)-\partial^\alpha h_{\mathrm{teacher}}(x_a)\right\|_2^2+\lambda\sum_{a=1}^{A}\left\|h_{\mathrm{student}}(x_a)-h_{\mathrm{teacher}}(x_a)\right\|_2^2$$

Mathematical statement

The paper's central width-independent compressibility claim is that, for a fixed deep MLP with analytic activation, a narrow same-depth network can uniformly approximate the teacher on a bounded domain with width m = O((log(1/epsilon))^d_in). Here epsilon > 0 is the allowed uniform approximation error and d_in is the effective input dimension, not the teacher hidden width. The construction matches a finite derivative jet J_K f(x_0) = {partial^alpha f(x_0) : |alpha| <= K} at anchor points x_0, where alpha = (alpha_1,...,alpha_d_in) is a multi-index, |alpha| = sum_i alpha_i, and partial^alpha = partial_(x_1)^alpha_1 ... partial_(x_d_in)^alpha_d_in. Analyticity makes the Taylor remainder decrease rapidly with K, so K is proportional to log(1/epsilon). The number of multivariate derivatives through order K is binomial(K + d_in, d_in), which is O(K^d_in), giving the width dependence. The practical adaptation minimizes value and derivative mismatch, while channel rescaling preserves layer output scale.

Implementation notes

Integrate this as an offline compressor for a trained wide MLP, not as a modification to the ordinary training forward pass. Let the teacher be h_0(x) = x and h_l(x) = phi(W_l h_(l-1)(x) + b_l), for layers l = 1,...,L, with analytic activation phi. Construct a student with the same depth L and target hidden width m. Set d_in from the actual input representation, choose derivative order K, and initialize m = c times binomial(K + d_in, d_in), testing several constants c. Generate A anchor points in the bounded deployment domain using a low-discrepancy sequence, a grid for low-dimensional inputs, or a calibration set. Use forward-mode automatic differentiation to compute teacher layer values and derivatives partial^alpha h_l at every anchor; begin with K = 1 because higher-order jets become expensive. Initialize the student by random projection, neuron clustering, or ordinary weight matching. Fit layers sequentially: freeze earlier student layers, compute student jets, and minimize the displayed L_jet with Adam. Use w_alpha = rho^|alpha| divided by alpha factorial so high-order derivatives do not dominate. After each layer, normalize each student channel by its activation RMS s_j, divide its incoming parameters by s_j + delta, and multiply the matching outgoing weight column by s_j + delta. This preserves the layer's scale while improving conditioning. The mathematics supplies the jet objective and width scaling; anchor density, constants, derivative order, and reweighting strength are empirical. First test a width-1024, depth-6 tanh MLP on MNIST or CIFAR-10 embeddings, compressing to widths 16, 32, 64, and 128. Compare against magnitude pruning and output-only distillation at equal depth and parameter count. Measure dense-grid function error, test accuracy, parameter count, and inference latency. Success means lower uniform function error than output-only distillation at the same width, or at least an 8x parameter reduction with less than 1 percentage point accuracy loss.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Not run

Methodology: Toy-system gate first; the benchmark stage runs only after a pass. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built and reran a fixed-seed PyTorch derivative-jet compressor using value plus first-order input-gradient matching, compared with output-only fitting at equal depth, widths, and optimization steps. The Taylor sanity check passed: first-order remainder log2 slopes were 2.008–2.031, and jet counts matched C(K+d,d). Jet fitting improved dense-grid RMSE by 70.0% at width 16 and 72.7% at width 32, but worsened it by 35.5% at width 8, so the effect is promising but not uniformly reliable.

Agent confidence
8/10
Baseline
Output-only grid RMSE: width 8=0.001700, 16=0.003587, 32=0.003149; parameters 177, 609, 2241.
Idea
Value+gradient jet grid RMSE: width 8=0.002304, 16=0.001078, 32=0.000860; identical parameter counts. Jet/output RMSE ratios: 1.355, 0.300, 0.273. Teacher parameters: 8577.

Limitations: Only first-order input gradients were tested; higher-order jets, sequential layer fitting, channel reweighting, low-discrepancy anchors, pruning, classification accuracy, latency/FLOP measurements, multiple seeds, and empirical width scaling across input dimensions and target epsilons were not tested.

How to run: python3 jet_compression.py

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

Verification history

Stage 2 — Benchmark Failed ✗

Agent confidence: 9/10

Implemented derivative-jet distillation on the tabular Friedman#1 track, which matches the idea because it is MLP function compression. Across 8 paired seeds, the tuned output-only baseline achieved MSE 7.230 versus 7.472 for value-plus-gradient jets; the idea lost on 7/8 seeds, and its derivative MSE was also worse (idea/baseline ratio 1.254), so the predicted mechanism did not transfer at benchmark scale.

Baseline
mlp_tiny narrow student, tuned lr=0.02: mean test MSE 7.2297, std 0.2721; per-seed [6.7833, 7.0209, 7.3385, 7.2918, 6.9377, 7.4491, 7.3572, 7.6589]; 1441 parameters.
Idea
Same student and budget with value-plus-first-input-gradient jet loss, lr=0.01 and jet_weight=0.25: mean test MSE 7.4723, std 0.2645; per-seed [7.2587, 7.9463, 7.3486, 7.3837, 7.0200, 7.5494, 7.6689, 7.6028]. Paired delta +0.2426 MSE, 1/8 wins, permutation p=0.0242 for the observed difference in the wrong direction; derivative-MSE ratio 1.2541.
Mechanism signature
The stage-1 prediction that jets reduce derivative mismatch and improve narrow-student value error was not reproduced: derivative mismatch increased by 25.4% and test MSE increased by 3.36% relative to baseline.
Limitations:

Only the tabular track, first-order input derivatives, one narrow width (32), one fixed jet hyperparameter setting, and a small teacher/student training budget were tested. Sequential layer fitting, channel reweighting, higher-order jets, pruning, latency/FLOPs, and other tracks were not tested. The prior toy Taylor sanity check passed, but this stage-2 benchmark did not confirm practical benefit.

How to run: python3 stage2_jet_bench.py

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 9/10

Built derivative-jet distillation as a local modification for the tabular Friedman#1 MLP benchmark; tabular was selected because the idea is an MLP compression/distillation method. Across 8 paired seeds, value-plus-gradient jets were essentially identical to the tuned output-only compression baseline (50.1779 vs 50.1724 MSE), with permutation p=0.16455 and therefore no significant win. The width sweep showed lower error at larger widths, but it did not establish the proposed jet-specific mechanism because the same capacity trend is expected from ordinary fitting.

Baseline
Output-only distillation, width 32, 8-seed mean MSE 50.172411, std 5.348989; tuned sweep best config epochs=72, lr=0.001, weight_decay=0.0.
Idea
Value plus first-input-gradient jet distillation, width 32, grad_weight=0.2, 8-seed mean MSE 50.177919, std 5.353465; paired delta +0.005508 (higher is worse), 2/8 wins, permutation p=0.16455.
Mechanism signature
Jet student test MSE by width: 8=169.5715, 16=105.2390, 32=50.7595, 64=22.8287 on two seeds per width; K=1,d_in=10 jet count=11. The monotonic width improvement is a capacity signal, not quantitative evidence that derivatives improve over output-only fitting.
Limitations:

Only the tabular track was tested; no vision, sequence, or dynamics transfer was evaluated. The mechanism width sweep used two seeds per width, only first-order input derivatives were used, and sequential layer fitting/channel reweighting/higher-order jets were not tested. The local jet optimization was CPU-only after teacher training and used a fixed 512-example calibration subset.

How to run: python3 bench_jet.py

Artifacts

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