Computing with continuous models
Research at the intersection of machine learning, dynamical systems and efficient computation.
How can a model learn the missing law, keep its promises, or preserve tomorrow’s questions in a tiny memory?
Explore all 42 articles ↓ · Browse the visual atlas ↗22 technical drafts · 12 flagship stories · Evidence and limitations throughout
The flagship collection
Scientific ML
A physical model should spend its learning capacity on what we do not know. We follow that idea from noisy sensors to evolving fields—and find the boundary between an exact equation and a trustworthy prediction.
Continual learning
What happens inside a model when its resolution increases? We follow a six-edge spline network through fitting, exact expansion, and continued learning—and separate a stable transition from a better final prediction.
Practical sensing
A speaker, a microphone, and an operator that recognizes a tone: exploring how tiny changes in reflected sound might reveal slow motion.
Scientific ML
Instead of asking a network to rediscover an entire dynamical system, learn the one response law the physics leaves unknown. A small model can then travel inside a much stronger solver.
Continual learning
What if a learning update came with a region where it could not change the model? Local spline supports make that guarantee possible—and reveal the cost of protecting too much.
ML systems
A spline edge may store hundreds of coefficients while needing only four for one prediction. Turning that locality into GPU speed requires choosing the right computation—not just counting fewer operations.
Learning algorithms
A model’s weights can stay fixed while its working context changes. In one arithmetic stream, keeping externally checked examples helped; keeping unfiltered generated examples hurt.
Compression & memory
A learner does not always need to remember its training stream. Sometimes it needs to remember the questions that stream can still answer—including a parameter choice made much later.
Physical systems
A tiny dynamics program can be dramatically cheaper than a neural ensemble without being more accurate. That tradeoff is worth measuring honestly.
Practical sensing
A voice is more than a waveform: excitation drives resonances that shape what we hear. That physical decomposition suggests a small model—and exposes what a genuine audio codec still has to transmit.
ML systems
A useful numerical component does not always need a GPU—or even a large runtime. The important question is what the complete service returns, at what accuracy, and with which costs included.
Learning algorithms
A system can perform better with memory without becoming progressively better as it accumulates memory. The distinction is the difference between a useful mechanism and an unsupported growth story.
Results, mechanisms, prototypes and informative failures
42 of 42 articles
No matching articles. Try another topic or clear the search.
Scientific ML
A physical model should spend its learning capacity on what we do not know. We follow that idea from noisy sensors to evolving fields—and find the boundary between an exact equation and a trustworthy prediction.
ML systems
A spline edge may store hundreds of coefficients while needing only four for one prediction. Turning that locality into GPU speed requires choosing the right computation—not just counting fewer operations.
ML systems
A neural response curve is continuous, even when training sees only samples. Its smoothness can sometimes be measured exactly over the whole domain—with one small structured matrix.
Continual learning
What happens inside a model when its resolution increases? We follow a six-edge spline network through fitting, exact expansion, and continued learning—and separate a stable transition from a better final prediction.
Scientific ML
A learned trajectory should not have to negotiate its starting position and velocity with a loss function. Some constraints can be part of the coordinates themselves.
Scientific ML
Instead of asking a network to rediscover an entire dynamical system, learn the one response law the physics leaves unknown. A small model can then travel inside a much stronger solver.
Scientific ML
Noisy measurements become especially troublesome when learning requires derivatives. A weak formulation changes the question: compare integrated physical effects instead of differentiating each imperfect sample.
Physical systems
A neural model can predict an aircraft’s vibration well. Compressing its weights is not necessarily the best way to preserve that ability.
Scientific ML
A model cannot learn information its inputs erase. Sometimes the decisive architectural change is to expose the right state, not add more parameters.
Physical systems
A tiny dynamics program can be dramatically cheaper than a neural ensemble without being more accurate. That tradeoff is worth measuring honestly.
Continual learning
A model can retain every contribution to its training objective and still get worse on an old example. That distinction changes what “memory without replay” can honestly promise.
Continual learning
What if a learning update came with a region where it could not change the model? Local spline supports make that guarantee possible—and reveal the cost of protecting too much.
Continual learning
A learned update need not overwrite the deployed model immediately. Propose it, test its permitted effect, and commit—or keep the previous state intact.
Continual learning
A good visual representation can make continual learning look surprisingly simple. The important question is what the small updating component actually learns—and what the frozen encoder already knows.
Learning algorithms
When evolution searches for a useful neural circuit, it need not also guess the best linear output weights. A conditional solve can change where the search spends its effort.
Learning algorithms
Detaching a layer’s activations changes a software graph. It does not necessarily change the learning algorithm. Following the error signal reveals the difference.
Neuromorphic ideas
A quiet interval can contain a great deal of computation—and very little new information. Known dynamics let a learning system integrate through it. The surprise was how well a simple numerical rival could do the same.
Neuromorphic ideas
Diagonalizing a memory system makes its dynamics simpler. Giving it fewer bits can make its answers worse. The coordinate system is part of the implementation—not just the notation.
Physical systems
A changed actuator may need a small model update. The useful unit of adaptation is a checked proposal, not an unconditional replacement of everything the system knows.
Physical systems
Prediction error is easy to measure. Useful action is harder—and can remain poor even when the actuator model is nearly right.
Scientific ML
An equation residual, a reconstructed field, and a downstream prediction are three different outputs. Improving one does not automatically improve the others.
Compression & memory
Discarding raw observations need not freeze the first reconstruction. But the future questions that remain answerable depend on exactly what was retained.
Inside a measured scanCompression & memory
A real measurement operator and a strong raw-data control changed the answer. Our compact spline messages were not the best way to preserve this scan.
Learning algorithms
Small agents can exchange programs flawlessly and still fail together. The hard part may be acquiring the distinctions that a future task needs.
Compression & memory
A learner does not always need to remember its training stream. Sometimes it needs to remember the questions that stream can still answer—including a parameter choice made much later.
Compression & memory
Distributed learning histories should combine without paying a new approximation penalty at every branch. Fixed parameter nodes give a surprisingly simple way to preserve that property.
Compression & memory
A sensor’s first calibration need not be its last. A compact scientific record can retain enough evidence to revise a physical interpretation—without pretending it preserves every possible interpretation.
Compression & memory
A compressed memory can return a highly accurate answer and still have to say: “I cannot guarantee the precision you asked for.” That refusal is part of a useful computational interface.
ML systems
A transformer does not remember its past in order to redraw a tensor. It remembers so that its next query can use that past. That distinction changes what a useful compression algorithm must preserve.
Numerical intelligence
A differential equation can be a computational building block—not just a penalty to minimize. In a layered pricing model, solving the local physics first makes the global problem much smaller.
Numerical intelligence
Nearly identical dynamics should produce nearly identical answers. A poorly chosen representation can instead turn them into enormous numbers that cancel.
ML systems
A useful numerical component does not always need a GPU—or even a large runtime. The important question is what the complete service returns, at what accuracy, and with which costs included.
Numerical intelligence
For a portfolio, the useful error bound is often the bound on the combined response—not the sum of pessimistic bounds on every leg.
Numerical intelligence
Finding a model-ambiguity warning can be expensive. Checking a concrete warning can be much smaller—and need not trust the optimizer.
Numerical intelligence
Two price curves can become indistinguishable while their local curvature remains different. The missing ingredient is the spatial scale of the question.
Numerical intelligence
The numerical engine worked. The market-admission procedure did not. Keeping those statements separate reveals where the application actually stopped.
Practical sensing
A voice is more than a waveform: excitation drives resonances that shape what we hear. That physical decomposition suggests a small model—and exposes what a genuine audio codec still has to transmit.
Practical sensing
A speaker, a microphone, and an operator that recognizes a tone: exploring how tiny changes in reflected sound might reveal slow motion.
Research perspectives
The most promising quantum connection may be a better physical interface—not a claim that a familiar function basis makes quantum algorithms free.
Research practice
More history improved the training fit. A later chronological test did not establish the transferable gain we had hoped for.
Learning algorithms
A model’s weights can stay fixed while its working context changes. In one arithmetic stream, keeping externally checked examples helped; keeping unfiltered generated examples hurt.
Learning algorithms
A system can perform better with memory without becoming progressively better as it accumulates memory. The distinction is the difference between a useful mechanism and an unsupported growth story.