A robot picking up an unfamiliar sponge, towel, or rope does not know how stiff, stretchy, or damped it is. It usually discovers this by poking the object and watching what happens. Learned dynamics models, meaning networks that predict how an object's points will move under an action, are normally either trained for one material or handed a history of observations and asked to infer the material implicitly. The principled alternative is meta-learning, which learns a model that can be quickly fitted to each new object from a few observations. That approach is expensive, because training it requires differentiating through the per-object fitting procedure. We propose a cheaper route that exploits a physical fact. In mass-spring cloth and in common elastic material models, forces are linear in the material constants once the deformation is known. A dynamics model whose last layer multiplies learned deformation features by per-object coefficients can therefore be adapted to a new object by a single small least-squares solve. It needs no gradient steps at test time and no unrolled inner loop during training.
The same construction exposes an optimization question that has been noticed but not resolved. Solving a layer exactly gives it an effectively infinite learning rate, while the rest of the network creeps along under a single global step size and a diagonal (per-coordinate) optimizer such as Adam. Closed-Form Last Layer Optimization reports that its exact last-layer solve combines poorly with Adam. We test whether that clash comes from Adam's per-coordinate statistics going stale as the solved head changes, and whether a matrix-structured optimizer that models correlations between parameters removes it. The note therefore connects four things. The rigid-body limitation of current system identification is the application gap. The cost of nested optimization is the constraint. The closed-form solve is the mechanism. Uniform learning rates and the parameter-independence assumption are the optimization lens for training the shared backbone.
Core Claim
The per-object material head is a matrix $W_\tau$, meaning the material coefficients of object $\tau$. It maps backbone features $\Phi_\theta(x) \in \mathbb{R}^{N \times d}$ to per-node accelerations $Y \in \mathbb{R}^{N \times 3}$. Here $\theta$ are the shared backbone weights of a graph network over the object's particles or mesh nodes, $N$ counts node-timesteps in a short probing interaction, and $d$ is a small feature width (64 to 256). The head is solved as ridge regression:
$$W_\tau = (\Phi_\theta^\top \Phi_\theta + \lambda I)^{-1} \Phi_\theta^\top Y.$$
Here $\lambda$ is a regularization strength that we meta-learn. The solve costs one $d \times d$ system regardless of how many nodes the object has. We claim three things. First, for elastic and damping parameters this linear head loses little expressiveness, because those parameters enter the governing force equations linearly given strain and velocity features. That answers the usual objection that closed-form meta-learners only adapt a shallow linear head. Second, because the linear head reflects the physics, adaptation should extrapolate to stiffness values outside the training range better than a black-box context encoder. Third, training $\theta$ with diagonal Adam under a single learning rate is a measurable bottleneck in this setup, and it can be fixed by structured or blockwise preconditioning.
Two prior works come closest. Meta-learning with differentiable closed-form solvers (R2-D2) supplies the method: it differentiates through a ridge solve for few-shot image classification. It uses the Woodbury identity because its bottleneck is feature dimension. Our regime is the opposite: many nodes and few features. More importantly, R2-D2 has no reason to expect the head to be the right place to put task variation. We argue this from physics and test it. D-REX motivates the work. It shows that identifying physical parameters beats randomizing them, reaching 90% grasp success versus 40% for domain randomization on a 324g object. But it identifies only the mass of a rigid body, and it does so by backpropagating through simulation, which requires a differentiable simulator of the specific object at deployment. We identify continuum material behavior with a learned model and no simulator in the loop.
Research Program
Backbone and head. The backbone is a message-passing graph network over particles (DaXBench rope and cloth) or FEM mesh nodes (DefGraspSim). It outputs, for each node, a feature vector built from relative positions, rest-length strains, and velocities. The head is factorized so that each output channel is a sum of feature channels weighted by object-specific coefficients. This factorization mirrors the elastic force equations. We also build a generic unfactorized head of equal size as an ablation. Friction is not linear in its coefficient under Coulomb contact, so we keep friction variation as a separately reported stress test rather than claiming the head handles it.
Training. Each training episode samples an object and material parameters and splits a short interaction into a support segment and a query segment. The head is solved on the support segment. The backbone and $\lambda$ are then updated from the multi-step rollout error on the query segment. Gradients pass through the $d \times d$ solve by ordinary automatic differentiation, which is cheap. No inner optimization trajectory is unrolled, so memory does not grow with an adaptation horizon.
The Envelope Theorem argument in Closed-Form Last Layer Optimization lets the backbone gradient skip the matrix inverse only when the outer and inner losses coincide. In our meta-learning setup they do not coincide, because the outer loss is measured on held-out query data. We therefore do not rely on that shortcut, and we report the cost of differentiating through the solve directly.
Efficient Meta Learning via Minibatch Proximal Update offers an alternative way to avoid unrolling. It uses a proximal inner problem whose meta-gradient is analytic. But it still runs iterative inner steps with a hand-set uniform $\lambda$, and we include it as a baseline.
Optimizer arm. Before choosing optimizers, we measure how curvature differs across blocks of the graph network: encoder, message-passing layers, normalization, and head-feeding layer. Following The Sharpness Disparity Principle in Transformers, we use the empirical diagonal Fisher, which is cheap to estimate from gradients. That work found a stable sharpness ordering across Transformer blocks and set fixed learning-rate multipliers of 10, 8, 6, 4, 1. We do not copy its multipliers. We derive ours from the measured ordering in our network.
We then train the backbone three ways. The first is AdamW. The second is AdamW with these measured blockwise rates. The third is SOAP, a Shampoo-derived optimizer that preconditions in the eigenbasis of Kronecker-factored gradient covariances, as studied in Understanding and improving Shampoo and SOAP via Kullback-Leibler Minimization. Beyond Adam: SOAP and Muon gives a reason to expect SOAP to help graph networks on physical data: it reports 4.9 to 5.8 times faster convergence to target accuracy and stability under label scarcity on interatomic potentials.
Our specific hypothesis about the Adam clash is the following. Each episode's head is a fresh function of the backbone features, so gradient scale for the layers feeding the head swings from episode to episode. Adam's per-coordinate second-moment averages then misestimate curvature. A Kronecker factor built from the covariance of those layers' inputs tracks exactly the Gram matrix used in the ridge solve, so a structured optimizer should not suffer the same mismatch.
Baselines
The naive reference is a single-material dynamics model. It uses the same graph network trained with AdamW on the pooled material distribution and receives no adaptation signal at all. This tells us how much of the rollout error comes from material ambiguity. Domain randomization during policy learning is the corresponding control-level reference.
The strongest learned competitor is a history-conditioned dynamics model. It uses the same backbone plus a recurrent or attention encoder that reads the support segment and outputs a context vector, trained end to end with matched parameter count, data, and tuning budget. It is the strongest competitor because it is what practitioners actually do, and it can in principle learn any nonlinear material dependence. Beating it means lower query rollout error on held-out materials at equal support length, and a clear margin on the stiffness-extrapolation split. Matching it in-distribution while losing out-of-distribution would count against the proposal.
The second competitor is gradient-based adaptation of the whole model: FOMAML/Reptile style fine-tuning and the proximal inner loop of Meta-MinibatchProx. It is run with the number of test-time gradient steps chosen so that adaptation wall-clock matches our solve. It is also run with a generous step budget to show its ceiling. On miniImageNet 5-way 1-shot the file reports 48.51% for Meta-MinibatchProx, 47.07% for Reptile, and 46.21% for MAML, while R2-D2 reports about 51.8% and runs 10,000 episodes in about 1 minute 23 seconds versus over 6 minutes for MAML. These are the only reported comparisons between a closed-form solver and a gradient inner loop in the file. For material-adaptive deformable dynamics, no reported result found on Lacuna for any method.
The privileged reference is simulator-based system identification in the spirit of D-REX. It fits material parameters by gradient descent through the DaXBench differentiable simulator on the same support segment. This baseline has access to the true simulator family, so it is an upper bound on identification accuracy rather than a competitor we must beat. Our goal is to approach it at a fraction of the latency.
For downstream control on DaXBench, we compare model-predictive control with our adapted model against APG through the true simulator and against PPO. On Whip-Rope, DaXBench reports APG at 0.83 reward versus PPO at 0.25.
Two ablations isolate the key ingredients. The first swaps the physics-factorized head for a generic head of equal size, still solved in closed form. This tests whether the linear-in-material structure, rather than closed-form solving per se, drives extrapolation. The second fixes $\lambda$ instead of meta-learning it. The optimizer arm has its own controls, AdamW and blockwise AdamW, all with an equal tuning budget per optimizer.
Why not just…?
Why not just randomize material parameters during training? D-REX reports that domain randomization yields policies too weak for heavy objects and too forceful for light ones: 40% versus 90% success at 324g. Compliant objects add damage risk from over-gripping, as DefGraspSim documents. We still include randomization as the control-level floor, because on easy tasks it may be enough. If it matches adapted-model MPC on DaXBench Push-Rope, we will report that the benefit is confined to material-sensitive tasks.
Why not just condition on a history encoder? This is the real threat. The history encoder is more flexible and may win in-distribution. Our bet is specific: when material constants enter the forces linearly, a closed-form linear head extrapolates to unseen stiffness where a learned encoder interpolates poorly. The extrapolation split, which trains on mid-range Young's moduli from DefGraspSim's 10^4 to 10^9 Pa span and tests at the extremes, settles this directly. If the encoder wins there too, the physical-linearity argument fails and we would say so.
Why not just fine-tune the whole model with a few first-order steps? Fine-tuning adapts deep features and is not restricted to a linear head. It pays in latency and, from a few seconds of probing data, risks overfitting a model with many parameters. The matched-wall-clock and generous-budget runs show whether its ceiling justifies the cost. The friction stress test is where it should have its best chance, since friction is not linear in its coefficient.
Why not just tune AdamW harder? The Sharpness Disparity paper reports about 2 times speedup (1.92 times on LLaMA 1.1B) from blockwise rates over tuned AdamW, and Beyond Adam reports 4.9 to 5.8 times from SOAP. Neither result was obtained in a meta-learning setting with a solved head, so the gain here is an open question. The optimizer arm answers it with equal tuning budgets. A null result is informative: it would mean the Galashov incompatibility does not arise when the head is re-solved per episode rather than per minibatch.
Proposed Experiments and Decisive Checks
We generate interaction data in DaXBench for Push-Rope, Whip-Rope, and Fold-Cloth. For each object we sweep spring stiffness and damping, plus MPM Lamé parameters for the liquid and soft tasks. We use the DefGraspSim objects to supply FEM sag and deformation trajectories across its stiffness range. Probing interactions last one to three seconds.
The metrics are as follows. Query rollout error is the mean node position error at fixed horizons. Material recovery is measured as the correlation between solved head coefficients and true constants, which we can compute but never train on. Adaptation latency and training memory are recorded against support length. For control, we report DaXBench task reward with MPC on unseen materials and sag-angle prediction error on DefGraspSim objects, relative to that paper's 2 degree sim-to-real agreement.
Four checks decide the proposal. The first is extrapolation. The factorized closed-form head must beat the history encoder on out-of-range stiffness. It must also beat the generic closed-form head; otherwise the physics argument is not what drives the result. The second is cost. At matched adaptation wall-clock, it must match or beat whole-model fine-tuning, and training memory must stay flat as the support length grows while the unrolled baselines' memory grows. The third is optimizer. After the sharpness profile of the graph network is measured, SOAP or blockwise AdamW must reduce the gap between closed-form and gradient-adapted training that Galashov et al. observed under Adam. Failure here narrows the paper to its dynamics contribution. The fourth is control. MPC with the adapted model must close a meaningful fraction of the gap between PPO and simulator-privileged APG on Whip-Rope under unseen materials.
References
- Closed-form Last Layer Optimization
- Meta-learning with differentiable closed-form solvers
- D-REX: Differentiable Real-to-Sim-to-Real Engine for Learning Dexterous Grasping
- Efficient Meta Learning via Minibatch Proximal Update
- The Sharpness Disparity Principle in Transformers for Accelerating Language Model Pre-Training
- Understanding and improving Shampoo and SOAP via Kullback-Leibler Minimization
- Beyond Adam: SOAP and Muon for Faster, Label-Efficient Training of Machine Learning Interatomic Potentials