Pith. sign in

REVIEW 3 major objections 4 minor 5 cited by

Training Transformers with Enforced Lipschitz Constants

T0 review · 3 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read The paper claims that transformers can be trained with a certified Lipschitz bound enforced at every step, and that a 10-Lipschitz 145M-parameter transformer reaches 21.2% validation accuracy on FineWeb10B while an unconstrained version…

desk verdict First feasibility demo of Lipschitz-bounded transformer training, but the word 'enforced' outruns the proof and the implementation's actual update-norm bound. read the letter →

arxiv 2507.13338 v1 pith:PDIB3KYY submitted 2025-07-17 cs.LG

Laker Newhouse , R. Preston Hess , Franz Cesista , Andrii Zahorodnii , Jeremy Bernstein , Phillip Isola This is my paper
classification cs.LG
keywords LipschitzneuralnetworkstransformertrainingspectralnormalizationsoftcaphammerMuonoptimizerweightnormconstraintsstability
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper tries to establish that a modern transformer can be trained with a certified Lipschitz bound—a guarantee on how much the output can change under input perturbation—enforced at every optimizer step, not merely at initialization. The authors develop efficient spectral weight-constraint tools and, using an optimizer whose updates have bounded spectral norm, train a 145M-parameter transformer with a certified bound of 10 to 21.2% validation accuracy on web text; the same model without weight constraints diverges, while a <2-Lipschitz transformer reaches 60% validation accuracy on Shakespeare text. Matching a tuned baseline's 39.4% accuracy requires relaxing the certified bound to about $10^{264}$, a number the paper itself singles out as a limitation. The result matters because it shows that stability scaffolding treated as essential—layer norm, QK norm, and logit tanh softcapping—can be removed under enforced Lipschitz constraints, opening a concrete route to certified robustness and low-precision training in a modern architecture.

What carries the argument

The load-bearing mechanism is a per-step spectral constraint on weight matrices, realized by two new methods: spectral soft cap and spectral hammer. Spectral soft cap approximates the ideal singular-value map $\sigma\mapsto\min(\sigma_{\max},\sigma)$ by composing odd polynomials $p_1(x)=x-\alpha x^3$ and $p_2(x)=x+\alpha x^3$, which act directly on the singular values without computing an SVD; Theorem 3.1 selects the smallest $\alpha$ that makes $\sigma_{\max}$ a fixed point of the joint map 'weight decay + bounded-norm optimizer update + soft cap', exploiting the optimizer's provable update-norm bound. Around this core, the architecture is made composable: residual connections become convex combinations $\frac{N-1}{N}x+\frac{1}{N}\mathrm{block}(x)$, attention uses $1/d$ instead of $1/\sqrt{d}$ logit scaling, and GeLU is divided by its maximum derivative, so every block has a bounded Lipschitz constant computed from its weight norms.

What would settle it

Instrument a full 145M-parameter training run and compute the spectral norm of every Muon weight update; if any update exceeds the learning rate times the inflation factor (1.14502, with the paper's 1.05 safety margin), the premise of Theorem 3.1 is violated. Alternatively, after every step with spectral soft cap applied, check whether any singular value of any constrained weight exceeds $\sigma_{\max}$; a single violation during training would falsify the claim that the bound is enforced throughout.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central claim is that imposing a spectral-norm cap on every weight matrix after every update, with no normalization layers, produces a transformer with a computable global Lipschitz upper bound that holds throughout training, and that such transformers retain nontrivial performance. The headline scaling evidence is a 145M-parameter transformer with spectral normalization at $\sigma_{\max}=1$ and a final logit scale of 8: it is certified 10-Lipschitz, reaches 21.2% validation accuracy on FineWeb10B internet text, and trains stably without layer norm, QK norm, or logit tanh softcapping, while an unconstrained version of the same model diverges. With $\sigma_{\max}=16$ the accuracy matches the 39.4% tuned baseline, at the cost of a certified bound of roughly $10^{264}$. At small scale, a certified <2-Lipschitz transformer reaches 60% validation accuracy on Shakespeare text, and a Muon-trained MLP with certified bound 15.2 matches the clean accuracy of an AdamW+weight-decay baseline with bound 7618.8 while degrading more slowly under $\ell_2$ adversarial attack.

Load-bearing premise

The 'enforced' guarantee rests on Muon's update having spectral norm at most the learning rate, and on the equilibrium proof checking only the largest singular value at the cap; if either fails, the certified Lipschitz bound is not actually enforced during training.

Editorial extensions

If this is right

  • Layer norm, QK norm, and logit tanh softcapping are not necessary for stable transformer training at 145M scale when every weight matrix is spectrally constrained at each step; the 10-Lipschitz model trains stably without all of them.
  • Optimizer choice changes the Lipschitz-versus-performance frontier: with Muon's bounded-norm updates, weight decay and spectral normalization reach equal loss at substantially smaller certified bounds than with AdamW.
  • Adversarial robustness tracks the certified bound: a CIFAR-10 MLP with bound 15.2 matches the clean accuracy of a bound-7618.8 baseline while keeping higher accuracy under larger $\ell_2$ perturbations.
  • Certified performance at competitive accuracy is currently expensive in bound: matching the 39.4% web-text baseline inflates the certified Lipschitz bound to $\sim 10^{264}$, and inspection of activation norms (max entry ~160 vs ~148,000 for the baseline) indicates this bound is very loose.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural extension the authors do not pursue is replacing the layerwise composition bound with activation-aware or semidefinite-programming certificates; those could plausibly certify the 21% model at a far smaller constant than 10, since the observed activations run far below the worst-case bounds.
  • If the low activation magnitudes observed under enforced constraints persist at larger scale, low-precision training and inference become more plausible than current baselines suggest; the paper states this as a hope, not a demonstrated benefit.
  • The optimizer-dependence result implies the Lipschitz-versus-performance tradeoff is not a fixed property of the network alone but of the coupled optimizer-constraint dynamics; testing other optimizers with bounded update norms would show whether Muon's advantage is unique.
  • The paper notes its learning-rate coupling can over-constrain because it assumes worst-case alignment between updates and weights; if so, a weaker constraint that exploits the actual update-weight alignment could hold the same certified bound with better performance.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. The paper asks whether transformers can be trained with small, enforced Lipschitz bounds throughout training. It introduces two spectral norm constraint methods, spectral soft cap and spectral hard cap, plus a spectral hammer for AdamW, and compares seven constraint methods under Muon and AdamW on MLPs and small transformers. The main scaling result is a 145M-parameter transformer trained on FineWeb10B with a stated 10-Lipschitz bound that reaches 21.2% validation accuracy and trains stably without layer norm, QK norm, or logit softcapping, while an unconstrained variant diverges. Matching the NanoGPT speedrun baseline (39.4% accuracy) requires increasing the computed Lipschitz bound to about 10^264. The paper’s theoretical certificate for the soft-cap method is Theorem 3.1, proved in Appendix A through an equilibrium analysis of the interaction between weight decay, the Muon update, and the cap polynomial.

Significance. If the theoretical certificate were airtight, the paper would make a useful contribution: it demonstrates feasibility of norm-constrained transformer training at 145M scale, provides an extensive empirical comparison (roughly 2400 training runs), releases code and data, and includes adversarial robustness checks consistent with lower Lipschitz bounds. The paper is also honest about limitations, including the looseness of its Lipschitz upper bound and the astronomical bound needed to match the speedrun baseline. However, the central 'enforced throughout training' claim is only as strong as the proof that the constraints actually hold at every step, and that proof has a gap and a mismatch with the implementation. The empirical achievements are credible, but the certification claim needs repair.

major comments (3)
  1. [Appendix A, Eqs. (4)-(6)] Theorem 3.1's proof rests on the unproven reduction 'we can consider only x = σmax because, in this case, larger x will decrease if a smaller x decreases' (Appendix A, after Eq. (5)). The map being analyzed is T(x) = p2(p1(x(1-λη)+η)), which is a degree-9 polynomial in x, and the condition computed in Eq. (6) only forces T(σmax) ≤ σmax. This does not by itself imply T(x) ≤ x for all x ∈ [0, σmax], nor does it rule out overshoot from values just below σmax. Since Theorem 3.1 is the paper's theoretical certificate that spectral soft cap enforces the bound, this gap must be closed either by proving the asserted monotonicity/contraction property or by giving an explicit interval-wise verification.
  2. [Appendix E (NanoGPT experiments) and Theorem 3.1] There is a mismatch between the theorem's assumption and the implementation used in the headline experiments. Theorem 3.1 assumes that Muon's update has spectral norm at most η, but Appendix E states that the NanoGPT runs use orthogonalization coefficients that inflate a singular value to 1.14502 and then multiply by an extra 1.05 'to be safe around numerical precision errors.' The actual update can therefore have spectral norm up to roughly 1.2η, so the α chosen by the quartic solver in Appendix A is not certified for those runs. Similarly, the 2-iteration spectral normalization used for the 10-Lipschitz row in Table 1 is reported to overshoot σmax by about 10% in practice. The paper should either use coefficients that provably satisfy the η bound, feed the true update-norm bound into the equilibrium calculation, or report per-step or post-training measured spectral norms that substantiate the stated Lipschitz bounds.
  3. [Section 4.2 and Table 1] The computed Lipschitz bound for the transformers is a composition of weight-norm bounds and activation-norm bounds that are themselves derived from weight norms. Because the reported weight constraints are only approximate (spectral normalization overshoots by about 10%, and the soft-cap proof is not yet certified under the actual Muon coefficients), any violation in a layer's spectral norm propagates multiplicatively through residual connections and can materially change the stated bound, particularly for the 10^264 row. The paper should report the actual maximum weight norms and computed Lipschitz bound of the final checkpoints for each Table 1 row so readers can see the difference between the intended bound and the certified bound.
minor comments (4)
  1. [Appendix B, Eq. (11)] Equation (11) has an unmatched parenthesis and an incompletely closed bracket in the expression for clip[−β,β](x), which makes the formula harder to parse than the surrounding derivations.
  2. [Appendix E] The statement that spectral normalization with 2 iterations produces norms that exceed σmax by 'around 10%' is not accompanied by measured values; reporting the actual post-training spectral norms for the rows of Table 1 would make the enforcement claims checkable.
  3. [General notation] The paper switches between 'spectral norm' and 'RMS → RMS operator norm' (Section 3.1) without always flagging the distinction in later appendices, for example in Proposition B.0.1, where 'spectral norm of the weights' should refer to the same rescaled operator norm used in the main text.
  4. [Table 1 caption] The caption notes that the authors' matching run uses 2.8B tokens but does not explicitly draw attention to the 4x token budget relative to the 0.7B-token speedrun baseline; this is a relevant comparison detail and should be stated in the caption or table notes.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the enforced Lipschitz bounds are computed from weight-norm constraints via proven composition rules and verified empirically against external baselines; self-citations serve as independent building blocks rather than load-bearing reductions.

full rationale

The paper's central claim is that transformers can be trained under enforced Lipschitz bounds and that the bounds are maintained throughout training. The Lipschitz bound is not fitted to observed accuracy: Section 4.2 and Appendix C define an algorithm that computes a bound from enforced weight norms using composition and addition rules, and the reported accuracies (e.g., 21.2% for the 10-Lipschitz model, Table 1) are measured after training under fixed constraints. Theorem 3.1 is an equilibrium derivation with explicit assumptions (update norm bounded by the learning rate, odd polynomial form) and does not assume the conclusion. The architectural components borrowed from Large et al. (2024), Muon, and Modula are prior external or published results used as building blocks, and the main empirical comparison is against the external NanoGPT speedrun baseline and LipsFormer, so the central result has independent content. A few caveats that are not circularity: the monotonicity reduction in Appendix A is asserted without proof, the implementation's update-norm inflation factor (1.14502 x 1.05) mildly exceeds the theorem's stated bound, and spectral normalization admits ~10% overshoot; these are rigor or correctness gaps, not reductions to inputs. The paper also honestly states that weight-norm and scale hyperparameters were chosen by sweeping rather than predicted, which further separates the empirical results from any fitted claim. No circular step was found.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

The central claims rest on the Muon update-norm guarantee (external, via You 2025), the residual and attention Lipschitz properties from Large et al., and standard matrix norm facts. No new entities are introduced. Free parameters are the constraint strengths and logit scales, selected by sweeps.

free parameters (3)
  • sigma_max (weight norm cap) = 1 (10-Lipschitz model), 16 (baseline-matching model)
    Swept; determines the enforced spectral norm target and hence the Lipschitz bound.
  • final logit scale = 8 (10-Lipschitz model)
    Chosen by hand; affects the Lipschitz bound because logits are not downscaled.
  • attention logit scale = varied (not reported as single value)
    A hyperparameter in the Lipschitz bound via Theorem C.1; the authors state no principled way to select it (Discussion).
assumptions (5)
  • domain assumption Muon's weight update has spectral norm bounded by the learning rate eta
    Used in the proof of Theorem 3.1 (Appendix A) and the weight-decay equilibrium argument. They follow You [2025] to ensure the orthogonalizing polynomial never exceeds 1, but this is an external guarantee, not proven in this paper.
  • domain assumption The residual reparameterization (1-alpha)x + alpha block(x) with alpha=1/N is 1-Lipschitz if the block is 1-Lipschitz and input norm <=1
    From Large et al., Proposition 4, used in Section 4.1 and the Lipschitz computation. The authors note the bound breaks if activation norms exceed 1.
  • domain assumption Functional attention with 1/d scaling is 1-Lipschitz for unit-norm inputs
    From Large et al., Proposition 7, extended in Theorem C.1 to non-unit inputs; used in the Lipschitz bound algorithm.
  • standard math GeLU's maximum derivative is 1.1289, so GeLU/1.1289 is 1-Lipschitz
    Used in Step 2 of the Lipschitz computation; standard fact.
  • standard math Softmax row sums to 1, giving attention matrix L_infinity operator norm 1
    Used in proof of Theorem C.1.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Training Transformers with Enforced Lipschitz Constants." pith.science (2026). https://pith.science/paper/PDIB3KYY

@misc{pith2026250713338,
  author       = {Pith},
  title        = {Pith review of: Training Transformers with Enforced Lipschitz Constants},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PDIB3KYY}},
  note         = {Machine review of arXiv:2507.13338}
}
read the original abstract

Neural networks are often highly sensitive to input and weight perturbations. This sensitivity has been linked to pathologies such as vulnerability to adversarial examples, divergent training, and overfitting. To combat these problems, past research has looked at building neural networks entirely from Lipschitz components. However, these techniques have not matured to the point where researchers have trained a modern architecture such as a transformer with a Lipschitz certificate enforced beyond initialization. To explore this gap, we begin by developing and benchmarking novel, computationally-efficient tools for maintaining norm-constrained weight matrices. Applying these tools, we are able to train transformer models with Lipschitz bounds enforced throughout training. We find that optimizer dynamics matter: switching from AdamW to Muon improves standard methods -- weight decay and spectral normalization -- allowing models to reach equal performance with a lower Lipschitz bound. Inspired by Muon's update having a fixed spectral norm, we co-design a weight constraint method that improves the Lipschitz vs. performance tradeoff on MLPs and 2M parameter transformers. Our 2-Lipschitz transformer on Shakespeare text reaches validation accuracy 60%. Scaling to 145M parameters, our 10-Lipschitz transformer reaches 21% accuracy on internet text. However, to match the NanoGPT baseline validation accuracy of 39.4%, our Lipschitz upper bound increases to 10^264. Nonetheless, our Lipschitz transformers train without stability measures such as layer norm, QK norm, and logit tanh softcapping.

Figures

Figures reproduced from arXiv: 2507.13338 by the authors.

Figure 1
Figure 1. To train fast and stably, regulate the gradients and also the weights. Current research is considering efficient computational primitives for spectrally regulating gradient updates, e.g. Muon [Jordan et al., 2024b]. There is an opportunity to construct similar techniques to spectrally regulate the weights themselves. While weight decay with parameter λ does implicitly contract singular values by a fixed proportion U… view at source ↗
Figure 2
Figure 2. Using Muon instead of AdamW improves the Lipschitz vs. performance tradeoff for standard weight regularization techniques. We train 1600 MLPs on CIFAR-10 (left) and 800 transformers on Shakespeare text (right), varying the optimizer and weight constraint method. Weight decay and spectral normalization reach better loss with lower Lipschitz bound when using Muon. Two weight constraint methods that we design—spectral … view at source ↗
Figure 3
Figure 3. Networks trained with Muon and spectral soft cap have lower Lipschitz bounds and are more adversarially robust. Lower Lipschitz bounds have been linked to greater adversarial robustness [Cisse et al., 2017, Huang et al., 2021]. To assess this effect in our models, we train a CIFAR-10 MLP with a Lipschitz bound of 15.2 (Muon + spectral soft cap), which matches the 45% clean accuracy of a baseline model (AdamW + weigh… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Left: Weight constraint methods designed for Muon lie on the frontier of the Lipschitz vs. loss tradeoff. Each point shows the lowest validation loss achieved at a given Lipschitz bound across all MLP runs on CIFAR-10. In the low loss regime, staying on the tradeoff fr…
Figure 5
Figure 5. Figure 5: Spectral soft cap is a weight constraint method that applies the above odd polynomial to a weight matrix, which applies it to all singular values in parallel. First it applies p1(x) = x − αx3 , then it applies p2(x) = x + αx3 . The composition is depicted for α = 0.2 (…

Discussion (0). Sign in to comment.

Forward citations

Cited by 5 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Can Transformers Really Do It All? On the Compatibility of Inductive Biases Across Tasks

    cs.LG 2026-07 conditional novelty 7.0 of 10

    Learned replacement non-linearities show transformers are rarely optimal for algorithmic tasks, with benefits that are task-specific, while language/code gains are smaller and more transferable.

  2. ST-LoRA: Single Trajectory LoRA Ensemble for Uncertainty Aware Agricultural Segmentation

    cs.CV 2026-08 conditional novelty 6.0 of 10

    Combining LoRA with snapshot ensembling yields a parameter-efficient uncertainty-aware segmentation ensemble that matches snapshot full-rank baselines, with feed-forward layers identified as the critical LoRA target.

  3. Improving Neural Network Training by Decoupling the Magnitude and Direction of Weight Vectors

    cs.LG 2026-06 unverdicted novelty 6.0 of 10

    Splitting weight matrices into a fixed-norm direction and learnable per-row/column magnitudes improves LLM training over AdamW/Muon, removes weight decay and warmup, and transfers the optimal LR across width.

  4. Understanding Rate-Distortion Performance in Distributed Transformer Inference

    cs.LG 2026-01 unverdicted novelty 6.0 of 10

    Deeper transformer layers produce intermediate representations that are harder to lossy-compress, and the paper links this to growing covariance and Rademacher complexity.

  5. Multi-Horizon Consistency as Geometry: When Latent Dynamics Contract, and When They Do Not

    cs.LG 2026-07 conditional novelty 5.0 of 10

    A multi-horizon consistency loss contracts latent dynamics on Moving-MNIST but not on action-conditioned or natural-video domains; a fitted noise-injection law claims to unify them.

Reference graph

Works this paper leans on

18 extracted references · 16 canonical work pages · cited by 5 Pith papers

  1. [1]

    Remove spectral soft cap and embed projections

    work page

  2. [2]

    Use CenterNorm: mean subtraction with learnable entrywise scale and bias

    work page

  3. [3]

    Notably, the official implementation of LipsFormer uses ϵ = 0

    Use scaled-head cosine attention with ϵ = 10 −6, τ = 12 , ν = 1 . Notably, the official implementation of LipsFormer uses ϵ = 0. According to their Theorem 1, this choice may make a finite Lipschitz bound impossible. We set ϵ >0 to fix the issue

    work page

  4. [4]

    Cited on page 17

    URL https://kexue.fm/archives/10795. Cited on page 17. Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. Cited on pages 3 and 4. Yusuke Tsuzuku, Issei Sato, and Masashi Sugiyama. Lipschitz-m...

    work page 2014

  5. [5]

    Insert residual connections with learnable strength α, initialized to 1/nresidual_connections

    work page

  6. [6]

    Xavier normal initialize linear layers, then apply spectral normalization W 7→ W/∥W ∥∗

    work page

  7. [7]

    Include drop path: every residual connection is skipped with p = 0.5 and, if taken, is scaled up by 1/(1 − p), matching their official implementation which uses nn.Dropout

    work page

  8. [8]

    Use weight decay 0.1, matching their implementation (not applied to scalar parameters)

    work page

Show all 18 references
  1. [9]

    Use the Muon optimizer to give LipsFormer the fairest comparison, copying hyperparameters from our run. We tested training with AdamW for all parameters, an exact replication, but found performance degraded sigificantly: after 1770 steps, validation loss was 4.86 (compared to ...

  2. [10]

    For non-weight-matrix parameters, use Adam hyperparameters η = 0 .001, β1 = 0 .9, β2 = 0.999, ϵ = 10−8 to match their implementation

  3. [11]

    Heuristically scale down attention output by 1/nheads to match their implementation

  4. [18]

    Bounding the Lipschitz constant of LipsFormer

    Use cosine learning rate schedule with decay to 0 to match their implementation. Bounding the Lipschitz constant of LipsFormer. In Table 1, we report that our trained implementa- tion of LipsFormer has a Lipschitz upper bound of 10130. To calculate this value, we use the final...

    2009

  5. [2016]

    Peter Bartlett, Dylan J

    Cited on page 2. Peter Bartlett, Dylan J. Foster, and Matus Telgarsky. Spectrally-normalized margin bounds for neural networks. In Neural Information Processing Systems, 2017. Cited on pages 1, 3, and 4. Jeremy Bernstein. The Modula docs, 2025. URL https://docs.modula.systems/...

    2017

  6. [2017]

    Aladin Virmaux and Kevin Scaman

    Cited on page 8. Aladin Virmaux and Kevin Scaman. Lipschitz regularity of deep neural networks: Analysis and efficient estimation. In Neural Information Processing Systems, 2018. Cited on page 3. Yuh-Shyang Wang, Tsui-Wei Weng, and Luca Daniel. Verification of neural network c...

    2018

  7. [2018]

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin

    Cited on pages 1 and 4. Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Neural Information Processing Systems,

  8. [2020]

    13 Mitchell Wortsman, Peter J

    Cited on page 3. 13 Mitchell Wortsman, Peter J. Liu, Lechao Xiao, Katie Everett, Alex Alemi, Ben Adlam, John D. Co- Reyes, Izzeddin Gur, Abhishek Kumar, Roman Novak, Jeffrey Pennington, Jascha Sohl-Dickstein, Kelvin Xu, Jaehoon Lee, Justin Gilmer, and Simon Kornblith. Small-sc...

    2024 arXiv

  9. [2024]

    James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang

    Cited on pages 1 and 3. James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: Composable transformations of Python+NumPy programs, 2018. URL http...

    2018 arXiv

  10. [2025]

    I Can’t Believe It’s Not Better!

    Cited on pages 4 and 15. Xianbiao Qi, Jianan Wang, Yihao Chen, Yukai Shi, and Lei Zhang. LipsFormer: Introducing Lipschitz continuity to vision transformers. In International Conference on Learning Representations, 2023. Cited on pages 1, 3, 8, 9, 10, and 22. Mihaela Rosca, Th...

    2023

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.