The money I can’t spend

I should start with something that will sound strange to most scientists: I have too much money. Not personally — personally, as I’ve written elsewhere, due to my lack of prioritization of bureaucracy and administration, I pay for my research tools out of my own pocket. But my group has funding that sits unspent. Not because there’s nothing to do with it, but because spending it responsibly would mean hiring more people, and hiring more people would most likely mean growing my group past the size where I can still understand what everyone is working on.

At the moment, I keep my group small on purpose, and even so it’s already hard. We just came back from a group retreat where I told everyone that I’m struggling to keep all our projects in my head, and that this means we’re not leveraging my strengths in the way we should. If I doubled the group, I’d gain output (more publications) but lose whatever grasp I still have. I’d become even more a manager, not a scientist. The funding system would be delighted — a larger group, more publications, more “impact.” But I would understand less about my own research, which is a trade I’m not willing to make.

I would happily give the money back if it meant removing the administrative apparatus that comes with having it. The reporting, the oversight, the hierarchy, the coordination overhead — all of it exists because the money exists. The money was supposed to enable the science. Instead, a growing share of it pays for the system that manages the money. I am sometimes not sure who is working for whom.

How we got here

None of this was built by villains. Science succeeded. It worked. Governments funded it, and the funding produced results, and the results justified more funding. The system grew — more researchers, more institutions, more publications, more money. Science is great, and we should all be grateful for having science.

But growth created coordination problems. When you have ten researchers at an institute, you can talk to each of them over lunch. When you have a thousand, you need an organizational chart, a procurement office, a grants administration team, an HR department, a compliance unit. Each layer solves a real problem. Each layer also costs money, takes time, and adds friction. And each layer, once established, develops its own logic, its own incentives, its own instinct for self-preservation.

The funding also required a story. To justify public investment at this scale, science needed to promise something large. The story it told was: we produce truth. Give us money, and we will deliver facts about the world that are reliable, verified, and objective. This is my speculation — I haven’t dug into the historical evidence for this reading, and I would be curious to see it tested (reach out to me!). Metrics also come from a different pressure — science consumes resources that could go to other things society values and needs, and there is an urge to justify that expense. So you build metrics, and metrics need oversight, and oversight needs administrators. And so the system grows — not to produce more understanding, but to demonstrate that it’s delivering on its promises.

Science doesn’t produce truth. It produces better working hypotheses. That’s a different thing, and it might imply a different kind of institution. A hypothesis is provisional. It’s meant to be revised. It’s useful precisely because it might be wrong. An institution built around truth needs to verify and control. An institution built around hypotheses needs to explore and tolerate uncertainty. We built the first kind and are now surprised that it doesn’t feel like the second.

We also just got ICML reviews back

I am writing this shortly after getting reviews back on our ICML papers, so I should be transparent that the timing is not a coincidence. Many of the reviews ask for more benchmarks, more models, more ablations. I don’t see when this actually stops, and I don’t see when adding this form of “more” adds to more insight.

But I notice the same thing in myself when I review. The form has a field for strengths and a field for weaknesses. The weaknesses field is empty, and it’s waiting for me to fill it. I have noticed that this field, by existing, changes what I do. Even when a paper is good — when I read it and think, yes, this is interesting, this advances understanding — I find myself (subconsciously) scanning for something to put in the weaknesses box. There is always another benchmark the authors didn’t run, another model they didn’t compare against, another dataset they didn’t test on. These are technically valid criticisms. They are also, in most cases, beside the point. The paper taught me something. The missing benchmark would not have taught me more.

The form asks for weaknesses, so I supply them. The authors write a rebuttal, addressing each weakness with more experiments, more comparisons, more pages. The paper gets longer. I’m not sure it gets better. The cycle consumes weeks of work on both sides, and the decision at the end — accept or reject — is, as multiple studies have shown, sometimes barely more reliable than random assignment. We all know this. We do it anyway.

The request for “more” is the easiest criticism to make because it’s unfalsifiable. There will always be another experiment you didn’t run. If we require proof that something works on everything, we will never be done with anything, and we can stop the business of doing research in the first place.

And now we have AI reviews. Researchers submit papers, and on the other end, an LLM fills in the same form — strengths, weaknesses, questions for the authors — producing the shape of evaluation without necessarily having any understanding behind it. Whatever relationship LLM-generated text has to semantic content and truth is always accidental or incidental. The conferences respond with detection policies, new rules, more oversight. The system treats the symptom by growing the apparatus. Kevin Baker, put it well “Systems can persist in dysfunction indefinitely, and absurdity is not self-correcting.”

I sometimes think about what peer review was before it scaled. When a field was small enough, a program committee sat in a room and discussed each paper. They argued, they disagreed, they changed their minds. The process was biased, clubby, and imperfect. But it happened at a human scale, which meant that understanding was at least possible. At the current scale, it’s not. No committee can discuss thousands of submissions. So we distribute the work to anonymous individuals, give them forms, aggregate their scores, and pretend the numbers mean something. We scaled the process and lost the thing that made it work.

Science is human

I think the thing I keep circling around is that science is a human activity. Understanding — the actual thing science is for — happens inside a human mind. A person reads a paper, thinks about it, connects it to what they already know, and updates their picture of how something works. That process doesn’t scale. You can’t make it faster by adding metrics. You can’t outsource it to an AI and call the output “understanding.” You can produce more papers, more data, more benchmarks, but understanding is still bounded by the pace at which a person can absorb and integrate ideas.

Hartmut Rosa has written about this as a dissonance between the pace of production and the pace of comprehension. We publish more than anyone can read — and perhaps I am also producing blog posts at a higher pace than anyone cares to read. We produce data faster than anyone can analyze. We run experiments faster than anyone can think about what they mean. The institution optimizes for production. Understanding happens on its own schedule, and that schedule has not gotten faster. I honestly don’t see how it can, unless we upgrade the human hardware — and the evidence from recent studies suggests that measured intelligence is maybe even declining.

And the questions we choose to ask in science are, in the end, value judgments. What’s worth studying? What matters? These are human decisions, rooted in human experience and human priorities. I think, on a societal level, we shouldn’t leave these to an AI scientist or an optimization algorithm or a metric that rewards citation counts. The selection of questions is where human judgment matters most, and it’s exactly the part of the process that gets squeezed when the system demands more output.

If we’re honest about this fact that science is irreducibly human — then we can start questioning the institutions we’ve built. Because many of them are, in a meaningful sense, inhuman. They operate at scales where no individual can comprehend the whole. They substitute measurement for judgment and volume for depth. They were built to manage a system too large for humans to manage, and in doing so they created an environment that is increasingly difficult for humans to do good work inside.

A German asking for austerity

And now I am here: The German asking for austerity. But I think the answer, for at least parts of the system, is to want less. Not because cutting budgets is virtuous — I have lived through enough austerity discourse to know it isn’t — but because some things that matter in science only survive at a scale where humans can still be fully present.

Smaller groups where a PI understands every project. Peer review at a scale where people can discuss papers rather than fill in forms. Less pressure to produce more, and more room to understand what’s already been produced. Fewer metrics, more trust. And I mean trust in the full human sense — I crave it, almost, from my institution. The feeling that they trust me to spend wisely the money I brought in through third-party funding. That they trust my judgment about whom I talk to, what I work on, how I run my group. The word “enough” as a legitimate answer to “how much?”

Is more even better? More papers, more citations, more funding, more people, more benchmarks, more administration to manage all of the above? The system says yes. My experience says: past a certain point, more produces more of everything except the thing science is actually for.

I would give back money to have less overhead. I would accept fewer publications to have deeper ones. In my group, we have already started saying no — to new projects, to quick workshop papers, to collaborations that would spread us thinner. At the retreat, we discussed doing even more of that. These are not popular positions in a system that equates growth with success. But I think they might be correct. And I also realize that this cannot be the universal prescription. We have important questions to answer and we need science to answer them. And I also recognize that a lot of great science happens in large groups and that humanity benefitted a lot from the growth of science. But I think we can also recognize that there are some things that only happen in small groups, and that we should be careful not to lose those things in the rush to produce more.

A caveat

There is frustration in all of this, and frustration is not always a reliable guide to systemic problems. Maybe some of what bothers me is just the normal friction of working inside any institution. Maybe I could solve some of it by being more patient, more organized, better at administration. Maybe I am a person with a higher desire for freedom and trust than is usual, and maybe I am coupling some personal frustrations into what I’m presenting as a systemic critique. I don’t claim to have perfectly separated the two. And I don’t claim that any of what I describe is universally true or can be used as an answer for systemtic problems.

This blog post is itself a symptom. I am a researcher, procrastinating on my research, writing about why the system makes it hard to do research. In a system that worked, the frustration wouldn’t accumulate to the point where it demands an essay. It should just be smoother from the start.

Where, if not in academia, should we be willing to dream about what the thing could be? Where, if not among people whose job is to ask hard questions, should we ask whether our own institutions are the right ones? Maybe this is utopian. But we are in the business of ideas that sound unrealistic until someone tests them. The least we can do is extend that courtesy to ourselves.

The gap

My university has a straightforward mechanism for paying research costs. I hand in an invoice, and if it is under €7,000, the finance office processes it. This works for lab equipment, conference fees, even computers — anything sold by a vendor who issues a proper invoice.

Cloud providers and AI companies do not issue invoices to individual researchers. They charge credit cards. My university can process an invoice. OpenAI can charge a credit card. Between those two facts lies an administrative gap that no one is responsible for closing.

Earlier this year, I sent my partner a photo of myself carrying a stack of new MacBooks for my research group. Tens of thousands of euros worth of hardware, purchased by the university without issue, because the third-party reseller sends invoices. She saw that photo. Weeks later, we had the fight about money, because the code running on those MacBooks makes API requests that cost fractions of a cent each, and those come out of my personal credit card. The hardware cost a hundred times more than the software. The expensive purchase was easy. The cheap one was impossible. Not because anyone decided that MacBooks matter more than API calls, but because one product comes with an invoice and the other requires a credit card.

This mismatch was invisible ten years ago. Most research costs were physical goods sold through conventional procurement channels. But the tools that computational researchers depend on are now overwhelmingly digital, subscription-based, and billed to credit cards. Research might also have been slower. The gap between what researchers need to buy and what universities can pay for widens every month.

The result is a hidden tax on digital research, and it gets paid in three currencies: your own money, your own time, or the research you quietly decide not to attempt because the overhead isn’t worth it. That last one is the real cost. You don’t spin up GPU instances, when you are rushing for a deadline. You don’t try the new model. You stick with whatever is already approved, even when better options exist. The procurement system shapes which research gets attempted.

And it fails on its own terms. The purpose of all this bureaucracy is financial oversight — knowing what was spent, on what, by whom. But when researchers pay personally and file reimbursements months later (or never), the university has no accurate record of research costs. My several thousand euros of unfiled claims are not in anyone’s books. The system designed for accountability produces worse accounting than the alternative.

Why nobody fixes it

The bottleneck persists because it sits in a crack between institutions. Cloud providers sell to consumers and enterprises. Universities buy from vendors through invoices. Individual researchers fit neither category. Some providers do offer invoicing — I asked Anthropic, and the mechanism exists — but only for customers large enough to justify the setup. A single researcher spending a few hundred euros a month does not qualify. The providers won’t adapt their billing for one lab. The universities won’t adapt their procurement for one new category of expense. Researchers lack the leverage to change either side. So the gap persists, and researchers absorb the cost.

Underneath this lies a design error worth naming. University procurement optimizes for a world where the optimal amount of misuse is zero — every transaction verified, pre-approved, matched to documentation. But in any system, the optimal amount of fraud is non-zero. The cost of preventing the last fraction of misuse exceeds the cost of the misuse itself. Universities spend hundreds of euros in administrative overhead to control the possibility of someone misspending twenty euros on API tokens. They turn publicly funded researchers into part-time bookkeepers. The control system costs more than what it controls.

My university already accepts bounded trust for invoice-based purchases — hand in an invoice under €7,000, no (or at least few) questions asked. It just hasn’t extended that trust to the new category of costs that researchers actually face.

The proposal

Several colleagues have independently given me the same advice: just start a nonprofit to handle your invoicing. When founding a legal entity feels like the path of least resistance for paying a monthly software bill, something has gone wrong at the systems level. But the advice points toward a real solution — not one nonprofit for me, but one that serves researchers like me across institutions.

The idea is a thin intermediary that does one thing: it pays the credit card, and it sends the university the invoice.

The intermediary holds accounts with major cloud and AI providers. Each participating researcher gets a virtual account with spending limits tied to their grant or institutional budget. The intermediary tracks usage, handles currency conversion, and generates one consolidated quarterly invoice per researcher, formatted for each university’s procurement system. From the university’s side, it looks like any other vendor. From the researcher’s side, the credit card disappears.

This works because the invoicing infrastructure already exists on the provider side — it is gated by scale, not by technical barriers. An organization that aggregates demand from dozens of researchers becomes the kind of customer that qualifies for invoiced billing. The bridge can be built. No individual researcher is heavy enough to justify building it for themselves alone.

Universities would change nothing. Their finance offices process the intermediary’s invoice the way they process every other vendor invoice. They would, in fact, gain better visibility into research spending than they have now, because one clean quarterly report replaces the current mess of scattered personal reimbursements and unfiled claims.

The experiment

A credible pilot could be following: 15 to 30 researchers across three to five institutions, six months, umbrella accounts with a handful of major providers. The intermediary generates quarterly invoices and submits them through each university’s standard procurement process.

Four things to measure. Do the invoices get processed without friction — will universities accept the intermediary as a normal vendor? Do researchers increase their use of cloud and digital tools? Do researchers attempt work they previously avoided? And the financial picture: administrative time saved, reimbursement backlogs cleared, savings from volume pricing.

Setup costs are small. The intermediary needs a legal entity, a bookkeeping system, and credit card accounts with a few providers. If the pilot fails — if universities reject the invoices or researchers don’t change their behavior — that is informative. It tells us the barrier is not administrative plumbing but something deeper, something no intermediary can fix. I doubt it, but the experiment would show it.

If it works, it scales without institutional reform. Each new university adds one vendor to its approved list. Each new provider adds one billing relationship. The thing grows by making a previously painful resource accessible through a shared layer of infrastructure.

I am aware that I have spent a considerable number of words on invoicing. That is, in a way, the point. The bottleneck holding back a growing share of digital research is not a scientific problem, not a technical limitation, not a lack of ideas. It is a missing invoice. The fix is comically mundane, which is perhaps why no one has built it. It falls below the threshold of what feels like a problem worth solving. But for researchers paying out of their own pockets, fighting with their partners about shared finances, and quietly deciding which experiments are not worth the administrative pain — it is the problem.

The Setup

Still, I am a bit conservative. I set everything up on a somewhat hardened Hetzner VPS — the cheapest one possible. I did not give it full access to my accounts. OpenClaw runs as a non-root account. I was inspired by the advice here.

1. Create cheapest possible Hetzner VPS, add SSH key
2. Install OpenClaw via the Ansible playbook
3. sudo su - openclaw, then openclaw onboard --install-daemon
4. Manual onboarding, local gateway with loopback
5. OpenAI as model provider (Peter Steinberger seems to like it more)
6. Telegram as chat connection with pairing

I was naïve and did some of this on the train. Not in tmux.

Giving It a Soul

I started giving it a soul by complaining about what I always portray as the source of my problems: that my employer does not fund a personal assistant. I prompted it to be a critical personal board of advisors, taking in viewpoints from people I specifically mentioned — with diverse but valuable perspectives. I gave it instructions about my long-term high-level research direction, and a dump of my tasks that currently came to mind. The tasks for which I never managed to really consistently stick to any task management system.

What Happened

In my first attempt, I hardened the thing so hard that I locked myself out. The todo list was not even transferred completely.

I told it I would like to finish every day with reflection and start every day with an agenda. But right now, I said, I just want a five-minute thing to tick something off. It responded:

Create a note titled “Corral — Coherent Plan v1” and write exactly 3 bullets:

1. Core question: what decision this project must answer
2. Current evidence: what results already support/contradict
3. Next experiment: single highest-value next step

I cannot do that in five minutes. I cannot do deep thinking in five minutes. That is the whole reason I came to this tool — I am drowning in small tasks and cannot find the space to think. I asked for the smallest possible win. And it told me to produce a coherent strategic plan.

My attempt at moving fast gave me something that wanted me to be even more superhuman than I already cannot be.

Back to Basics

I am now back to using Things 3. Perhaps I will even go back to paper.

I still have the struggle that I strive for freedom to think deeply and creatively, but that I also have just too many small admin things to do. I still did not find a way to balance them. OpenClaw certainly did not help me. Perhaps I did not invest enough. Perhaps I am also back to admitting that I have no chance — that I reached for yet another productivity trick, hoping it would finally make the difference. Perhaps I have to learn the lesson I always tell others: there is no shortcut.

The Puzzle of Too Many Parameters

Monthly airline passengers from 1949 to 1960. You want to forecast the next few years. A linear model has 2 parameters. A cubic polynomial has 4. A degree-20 polynomial has 21.¹

Classical statistics warns against the high-parameter option. More parameters, more opportunities to chase noise instead of signal. The cubic should suffice.

Yet modern deep learning uses models with billions of parameters trained on datasets that cover a vanishing fraction of possible inputs. By classical logic, these models should memorize their training data and fail on anything new. Still, they seem to ace very difficult benchmarks.

The Arithmetic of Impossibility

A language model predicts the next token given all previous tokens:

With vocabulary and context length , the input space contains:

possible sequences. Training corpora contain perhaps tokens. The ratio of observed to possible:

If every atom in the observable universe were a training example, we’d still have seen essentially nothing. The model encounters novel inputs on every forward pass, yet produces sensible outputs.

The arithmetic says learning is impossible. The models work anyway. One of these must be wrong.

Real Data Is Not Random Data

Sample an image uniformly at random from the space of all 256×256 RGB images. You get noise. Sample a million. Still noise. The space of natural images—photographs, paintings, anything a human would recognize—occupies a measure-zero subset of pixel space.

A striking way to see this: take two random points in pixel space and walk linearly between them. Every step is noise. Now take two real images and walk between them along the data manifold (as a generative model learns to do). The intermediate points look like images—blurry perhaps, but recognizably structured.

Code

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)

fig, axes = plt.subplots(2, 6, figsize=(12, 4.5))

# Top row: random walk in pixel space
start_random = np.random.rand(32, 32, 3)
end_random = np.random.rand(32, 32, 3)

for i, alpha in enumerate(np.linspace(0, 1, 6)):
    interp = (1 - alpha) * start_random + alpha * end_random
    axes[0, i].imshow(interp)
    axes[0, i].axis('off')
    axes[0, i].set_title(f'α={alpha:.1f}', fontsize=10)

axes[0, 0].set_ylabel('Random\ninterpolation', fontsize=11, rotation=0, ha='right', va='center')

# Bottom row: "manifold" interpolation (simulated with smooth structure)
for i, alpha in enumerate(np.linspace(0, 1, 6)):
    freq_blend = 1.5 + alpha
    x = np.linspace(-2, 2, 32)
    y = np.linspace(-2, 2, 32)
    X, Y = np.meshgrid(x, y)
    
    img = np.zeros((32, 32, 3))
    base = 0.5 + 0.25 * np.sin(freq_blend * X + alpha * 2) * np.cos(freq_blend * Y - alpha)
    img[:,:,0] = base + 0.15 * np.sin(X * 2 + alpha * 3)
    img[:,:,1] = base + 0.1 * np.cos(Y * 3 - alpha * 2)
    img[:,:,2] = base + 0.12 * np.sin((X - Y) * 2 + alpha)
    img = np.clip(img, 0, 1)
    
    axes[1, i].imshow(img)
    axes[1, i].axis('off')

axes[1, 0].set_ylabel('Manifold\ninterpolation', fontsize=11, rotation=0, ha='right', va='center')

plt.tight_layout()
plt.show()

The same holds for text. Random token sequences are gibberish. Coherent sentences, paragraphs, arguments—these live on a thin subspace of token-sequence space, constrained by grammar, semantics, and the structure of ideas worth expressing.

This resolves the arithmetic paradox. The impossibility proof assumes you need to cover the full input space. But the data we care about concentrates on a low-dimensional structure, and coverage of that structure is tractable.

The Manifold Hypothesis

The standard formalization: data lies on or near a -dimensional manifold embedded in the ambient space , where .

Covering a -dimensional manifold requires samples scaling as , not . If images live on a manifold of dimension 1,000 rather than filling a space of dimension 200,000, the sample complexity drops from astronomical to merely large.

Pope et al. (2021) measured intrinsic dimensions of standard image datasets and found values in the hundreds to low thousands—far below ambient dimension, though not trivially small.

The Geometry of Piecewise Linear Functions

ReLU networks compute piecewise linear functions. Not approximately linear. Exactly linear, within each piece.

The ReLU activation is piecewise linear with two pieces. Compositions of affine transformations and coordinate-wise ReLUs yield piecewise linear functions on convex polytopes. Within each polytope, the network computes for some and specific to that region.

Code

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)
n_units = 8

w1 = np.random.randn(n_units, 2)
b1 = np.random.randn(n_units) * 0.5
w2 = np.random.randn(n_units) / np.sqrt(n_units)
b2 = np.random.randn() * 0.2

def forward(x, y):
    inp = np.stack([x.flatten(), y.flatten()], axis=1)
    hidden = np.maximum(0, inp @ w1.T + b1)
    return (hidden @ w2 + b2).reshape(x.shape)

g = 100
xs = np.linspace(-2, 2, g)
ys = np.linspace(-2, 2, g)
X, Y = np.meshgrid(xs, ys)
Z = forward(X, Y)

fig, ax = plt.subplots(figsize=(7, 6))
contour = ax.contourf(X, Y, Z, levels=30, cmap='RdBu')
plt.colorbar(contour, ax=ax, label='f(x)')

for i in range(n_units):
    a, b = w1[i]
    c = b1[i]
    if abs(b) > 0.01:
        line_x = np.array([-2, 2])
        line_y = -(a * line_x + c) / b
        if any(abs(line_y) < 2.5):
            ax.plot(line_x, np.clip(line_y, -2, 2), 'k-', linewidth=0.8, alpha=0.5)
    elif abs(a) > 0.01:
        xi = -c / a
        if abs(xi) < 2:
            ax.axvline(xi, color='k', linewidth=0.8, alpha=0.5)

ax.set_xlim(-2, 2)
ax.set_ylim(-2, 2)
ax.set_xlabel('$x_1$')
ax.set_ylabel('$x_2$')
ax.set_aspect('equal')
plt.tight_layout()
plt.show()

/var/folders/gk/s1v9_48163q2rxpc1x2gq21m0000gn/T/ipykernel_49826/3517710329.py:14: RuntimeWarning:

divide by zero encountered in matmul

/var/folders/gk/s1v9_48163q2rxpc1x2gq21m0000gn/T/ipykernel_49826/3517710329.py:14: RuntimeWarning:

overflow encountered in matmul

/var/folders/gk/s1v9_48163q2rxpc1x2gq21m0000gn/T/ipykernel_49826/3517710329.py:14: RuntimeWarning:

invalid value encountered in matmul

/var/folders/gk/s1v9_48163q2rxpc1x2gq21m0000gn/T/ipykernel_49826/3517710329.py:15: RuntimeWarning:

divide by zero encountered in matmul

/var/folders/gk/s1v9_48163q2rxpc1x2gq21m0000gn/T/ipykernel_49826/3517710329.py:15: RuntimeWarning:

overflow encountered in matmul

/var/folders/gk/s1v9_48163q2rxpc1x2gq21m0000gn/T/ipykernel_49826/3517710329.py:15: RuntimeWarning:

invalid value encountered in matmul

There’s a topological way to think about this. A neural network progressively transforms the input space, stretching and folding it until the data becomes linearly separable.² The network learns a coordinate system in which the problem is simple.

The number of linear regions grows exponentially with depth. A network can have far more regions than training points. Most regions contain no data at all.

What Training Determines

Consider a single linear region containing training points in -dimensional space. The network computes throughout this region. Training enforces:

These are constraints on a gradient with components. When —the typical case in high dimensions—infinitely many gradients satisfy the constraints.

The training points span at most an -dimensional subspace. Along directions in this subspace, the gradient is pinned down. Along orthogonal directions, it’s arbitrary.

This connects to a classical result in learning theory. The representer theorem says that in kernel methods, the optimal solution can be written as a linear combination of kernel evaluations at the training points—only the training data matters, and only along the directions it spans. The geometry here is analogous: training constrains the function along directions spanned by the data and nowhere else.

If training data lies on a low-dimensional manifold, the constrained directions align with the manifold’s tangent space. Normal directions—perpendicular to the manifold—remain free. Training pins down the function on the manifold but leaves it underdetermined elsewhere.

Pretraining as Learning the Manifold

Large-scale pretraining can be understood as learning the data manifold itself. When a language model predicts the next token on a massive text corpus, it learns the structure of “valid text space”—which sequences are probable, which transitions are natural, what the local geometry of text looks like.

This perspective is supported by work showing that deep networks learn representations capturing manifold structure (Bengio, Courville, and Vincent 2013). The hidden layers build a coordinate system aligned with the data manifold, making downstream tasks easier by providing a representation where relevant variation is explicit.

This explains why pretraining helps so much. A randomly initialized network must simultaneously learn manifold structure and the task-specific function. A pretrained network already knows the manifold; fine-tuning only needs to learn the function on it.

Why the Underdetermined Directions Don’t (Usually) Matter

Three factors make underdetermination benign in practice.

The data manifold is where queries live. If test data comes from the same distribution as training, test points lie on or near the same manifold. The underdetermined normal directions are never queried.

Neural networks prefer simple functions. Not all functions consistent with training data are equally likely to emerge. Networks exhibit a bias toward low-complexity functions, formalizable via Kolmogorov complexity (Valle-Perez, Camargo, and Louis 2019; Goldblum et al. 2023). The functions networks actually learn tend to be simple.

Real data is generated by simple processes. Biological structures reflect evolutionary compression. Human artifacts encode low-dimensional intentions. The data we care about is often output of structured processes.

The match between neural networks’ simplicity bias and the simplicity of real-world data may be the deeper reason deep learning works. The manifold hypothesis is a geometric consequence of this match, not the fundamental explanation.

An Unexpected Success: Language Models for Chemistry

In Jablonka et al. (2024), we fine-tuned large language models to predict chemical properties: bandgaps, photoswitching wavelengths, toxicity. Language models are trained on text, not molecules. The transfer seems absurd.

Yet it works. Fine-tuned LLMs achieve competitive performance, sometimes matching purpose-built molecular models.

The geometric interpretation: LLMs have learned inductive biases—preferences for compositional, hierarchical, smoothly-varying functions—that transfer across domains. Chemistry and language are (sometimes?) both structured.

When Deep Learning Fails

The geometric picture predicts specific failure modes, all involving queries that leave the training manifold.

Distribution shift. Zech et al. (2018) analyzed a deep learning model for detecting pneumonia in chest X-rays. The model achieved high accuracy—but partly by detecting which hospital the X-ray came from, using equipment artifacts like metal tokens. At a new hospital with different equipment, performance collapsed. The test manifold diverged from training.

Code

import numpy as np
import matplotlib.pyplot as plt

train_x = np.linspace(-2, 1, 40)
train_y = np.sin(train_x * 2) * 0.8
test_x = np.linspace(0.5, 2.5, 25)
test_y = np.sin(test_x * 2) * 0.8

model_x = np.linspace(-2.5, 3, 200)
slope = (train_y[-1] - train_y[-5]) / (train_x[-1] - train_x[-5])
model_y = np.where(model_x <= 1, np.sin(model_x * 2) * 0.8, train_y[-1] + (model_x - 1) * slope)

fig, ax = plt.subplots(figsize=(8, 4))
ax.axvspan(1, 3, alpha=0.1, color='red')
ax.plot(model_x, model_y, 'k-', linewidth=2, label='Model')
ax.scatter(train_x, train_y, c='#3b82f6', s=30, label='Training', zorder=5)
ax.scatter(test_x, test_y, c='#dc2626', s=30, marker='x', label='Test (shifted)', zorder=5)
ax.axvline(1, color='gray', linestyle=':', linewidth=1)
ax.set_xlabel('x')
ax.set_ylabel('f(x)')
ax.set_xlim(-2.5, 3)
ax.set_ylim(-1.5, 1.5)
ax.legend(loc='upper right')
plt.tight_layout()
plt.show()

Adversarial examples. Small perturbations orthogonal to the data manifold move inputs into regions where the function is underdetermined. The output changes dramatically because the gradient in that direction was never constrained.

Extrapolation. ReLU networks extend linearly beyond the convex hull of training data. If the true function curves, the linear extrapolation diverges.

High intrinsic dimension. If data doesn’t concentrate on a low-dimensional manifold, most directions are unconstrained and generalization fails.

The Problem of Missing Negative Examples

A subtler failure mode matters enormously in practice: the model can only learn the manifold from data it sees.

Consider predicting which chemical reactions succeed. Published literature overwhelmingly reports reactions that worked. Failed reactions—attempts producing no product, conditions causing decomposition—are rarely published. The model sees only one side of the decision boundary.

This creates a systematic blind spot. The model learns what successful reactions look like but has no information about the landscape of failures. It can’t distinguish “this will work” from “this is unlike anything I’ve seen.” Both map to the same uncertainty—off the manifold of observed successes.

To learn a manifold’s boundary, you need to see both sides. Without negative examples, the learned manifold may be far too permissive.

The Limits of the Framework

The “real data is simple” argument works for perception, language, games—domains with abundant data from stable distributions. Scientific discovery is different. It seeks patterns in domains where structure is unknown (or questioning the structure is the point).

The domains where machine learning would be most valuable—genuine discovery, not pattern-matching on known distributions—are exactly where the assumptions might not hold.

Conclusions

The counting argument was correct: learning an arbitrary function in dimensions is impossible with samples. But the functions we care about aren’t arbitrary. They’re generated by structured processes—physics, biology, human intention—that produce structured outputs.

Neural networks work because they share this preference for structure. They’re biased toward simple, compositional functions, and real data happens to be simple and compositional. The manifold hypothesis is a symptom of this alignment, not the cause.

Understanding the geometry clarifies both successes and failures. Successes come from fitting smooth functions to structured data on low-dimensional manifolds. Failures come from queries leaving the manifold, shifting distributions, or domains where structure assumptions don’t hold.

For perception and pattern-matching, the framework suggests continued progress. For scientific discovery—finding patterns where structure is unknown—it counsels caution. The assumptions making deep learning work are precisely those we can’t verify in genuinely novel domains.

This post draws on work by Andrew Gordon Wilson on inductive bias and Bayesian deep learning, Ben Recht on what machine learning can and cannot do, and Mikhail Belkin on interpolation and generalization. The geometric intuitions build on Chris Olah’s writing on topology and Riley Goodside’s essays. Errors are my own.

References

The Working Memory Problem

I can only hold about 4 things in working memory at once. When I’m juggling 15 design decisions and vague intuitions about what might work, most of it is slipping away. I need concrete signals.

Writing and sketching force me to make things concrete. Writing is thinking. When I try to draft a results section for experiments I haven’t run yet, I immediately hit questions: “Wait, what’s the y-axis here? How would I actually measure this?” Those questions become my experimental plan.

Similarly, when I integrate code modules before they’re polished, the failures tell me what actually matters. Often the “polish” I was planning turns out to be unnecessary. And the failures tell me what actually matters.

What I Actually Do

• I start writing paper drafts at the first signs of life. Playing with different introductions helps me figure out which story actually makes sense. Sketching figure layouts exposes which experiments I’m missing.
• I wire together code modules when they’re partially done. The integration failures are informative.
• I run simplified experiments first—1000 examples instead of 1M, 2 layers instead of 12. I can add complexity once I know the direction has promise. This is to maximize research velocity.
• I submit to workshops before papers feel “fully baked.” The writing process and feedback catch blind spots.
• I share half-baked ideas. A conversation can save months of heading the wrong direction.

Pride vs. Progress

These practices aren’t technically hard. What makes them difficult is the discomfort of showing work that isn’t impressive yet, of risking visible mistakes, of accepting that my initial intuitions might be wrong.

But I’ve noticed that waiting for things to feel “ready” often means operating in the dark for too long. The cost of being wrong in private—spending months on the wrong path—tends to be much higher than the awkwardness of being wrong in public. And if we talk about spending public research money, we should minimize this cost.

How Fast Is Too Fast?

There is a limit, of course. If I’m moving so fast that I can’t reproduce last week’s experiments or I’ve lost track of what I’ve tried, I’ve gone too far. Clean experiments matter even when iterating quickly.

But I find I’m rarely limited by going too fast. More often, I’m limited by waiting too long—by postponing the test that would have given me signal.

So now when I catch myself thinking “this isn’t ready yet,” I try to ask: ready for what? Often the answer is: ready to learn something from. And that bar is much lower than I think.

You’re Going to Forget Which Game You’re Playing

Here’s what’s going to happen: You’ll get so caught up in what James Carse calls the “finite game” (Carse 1986) that you’ll forget about the infinite game entirely.

The finite game is winning the ERC. The infinite game? That’s the research itself—the questions that genuinely excite you, the work you’d want to do regardless of whether anyone gives you money for it.

Carse distinguishes between games we play to win (finite) and games we play to keep playing (infinite). Your proposal will be full of research you find genuinely important, exciting, and novel. But somewhere along the way, the narrative will become “winning the ERC is the only way to do this exciting work.”

That’s not true. You know that’s not true. But you’re going to forget it anyway.

And look—I know you’re hungry for a win right now. After the losses you’ve experienced recently (and we both know what I’m talking about), you need this. I get it. But being thirsty for a win makes it almost impossible to stay in the infinite game mindset.

Try anyway.

Someone Will Tell You You’re Late (You’re Not)

An advisor is going to tell you you’re late. This will happen when you have a 17-page draft completed, 1.5 months before the deadline.

You’re not late.

But their anxiety will become your anxiety, and you’ll carry that weight through the rest of the process. I wish I could tell you how to avoid internalizing this, but I can’t. Just… know that it’s happening. Maybe that awareness will help a little.

You’re Writing for Everyone, Which Means No One

You’re going to write a transdisciplinary proposal that fits into multiple panels. This will feel strategic. It’s actually a trap.

You can’t assume background knowledge in anything. Every discipline has its own language, its own implicit assumptions, its own way of framing problems. How do you write for everyone without writing for no one? How do you balance depth and accessibility when your readers might come from entirely different fields?

Maybe the answer is simpler than you think: assume less in general, but write it in an interesting way. Don’t dumb it down—just explain more. Make your enthusiasm for the ideas carry the reader through the explanations they need.

I still don’t know if you solved this problem. I hope the reviewers will tell us.

The Structure You Think You Have

You think you have good structure. You don’t.

What you need: the same subheadings for each Work Package. Visual emphasis—color, even. Clear blocks for deliverables and contingency planning. Make it obvious what you’ll produce and what you’ll do when (not if) things don’t go according to plan.

Here’s what structure is really about: convincing reviewers that you have a plan and that you’re worth the money. Every Work Package should make it crystal clear what you’re going to deliver, when you’re going to deliver it, and what could go wrong.

Also, try to write it so readers don’t need to read everything linearly. Each section should stand somewhat independently. Reviewers are busy. Give them permission to jump to what matters to them. They should be able to skip around and still understand that you know what you’re doing and that funding you makes sense.

You won’t get this right on the first try. Or the second. Keep iterating.

On Intensity and Timing

You’re going to wonder if you should start earlier. Don’t.

Work in waves. One full day exclusively on the proposal, then wait for new feedback or inspiration before opening the document again. This rhythm keeps the intensity without burning you out.

And yes, the intensity is necessary. Some things can’t be done slowly.

Lead with the Answer

You’re going to slowly—too slowly—move toward using what’s called the McKinsey Pyramid Principle (Minto 2009). Stop resisting this. Just do it from the start.

Here’s the deal: Instead of building up to your point (how you naturally think), start with the answer and then provide supporting arguments and evidence. Barbara Minto developed this approach at McKinsey for communicating with busy executives—which is basically what grant reviewers are.

Why? Because reviewers are busy. They need to grasp your core contribution immediately. Lead with the answer. Tell them what you’re going to do and why it matters. Then—and only then—show them the supporting details.

You’re going to resist this because it feels unnatural, like you’re giving away the ending. Do it anyway.

AI Is Helpful But Forgetful

You’re going to use AI extensively:

• Prompting it to act as reviewers from various disciplines
• Using Deep Research and platforms like FutureHouse for literature review
• Getting help finding effective examples

But here’s what you need to know: AI forgets things across long documents.

When you’re working on a 15-20 page proposal, edits in one section require changes elsewhere. The introduction needs updating after you rework the objectives. A change in methodology impacts your timeline. Your risk mitigation needs to align with your deliverables.

AI doesn’t naturally track these dependencies. You become the keeper of the narrative arc, the one who remembers what you said ten pages ago. The iterative process of checking for consistency, updating multiple sections, ensuring coherence—that’s all you.

Is it worth using AI? Yes. But it’s not magic. It’s a tool that requires active management.

Give Yourself Permission to Write Badly

Anne Lamott writes in Bird by Bird that perfectionism is “the voice of the oppressor” and “the main obstacle between you and a shitty first draft.” (Lamott 1994)

Listen to her.

Don’t start in the official ERC template. Write one long messy document first. Give yourself permission to write badly, to explore, to ramble. When you share it for feedback, you can say: “This is not yet the ERC proposal.” That distinction matters. It gives both you and your readers permission to focus on the ideas rather than the polish.

Then, after feedback, move it to the template. Write Part B1 first, then B2. Share both. Iterate. Rewrite. Iterate again.

The messiness is part of the process, not a sign that you’re doing it wrong.

That Harsh Feedback? You Need It

Someone is going to destroy your Part B2. Just absolutely tear it apart.

It’s going to hurt. And then, surprisingly, it’s going to help enormously.

The harsh feedback will give you the push you need to attempt another complete rewrite when you’re feeling unmotivated and lacking confidence. Sometimes the feedback that stings the most is exactly what you need to hear.

Try to remember that when you’re in the moment of pain.

What You’d Change (And What You Wouldn’t)

You’re going to wish you’d converged earlier on which panel to target. But the story develops in the process of writing it. How can you know which panel you’re targeting before you know what story you’re telling? Maybe this is one of those things that can’t be optimized.

You’re also going to almost miss formal requirements—confirming your PhD defense date, for instance. Without institutional support, you would have completely overlooked these. Next time, make a checklist of procedural matters from the start.

But starting earlier? No. The intensity of the compressed timeline is necessary, not just stressful.

What This Is Really About

Here’s what you need to understand: Grant writing is as much about managing yourself—your anxiety, your relationship with success and failure, your writing process—as it is about the research.

Are you playing the finite game or the infinite game? Are you optimizing for winning, or for continuing to play?

The proposal you’re about to write is valuable beyond its immediate outcome. It’s a crystallization of your thinking, a test of your communication, a forcing function for clarity. Whether you win this particular finite game or not, the infinite game—your research, your contribution to the field, the questions that genuinely excite you—continues.

Writing the proposal will help you crystallize ideas. It will help you find people who are good sounding boards. It will give you clear signals that your writing still isn’t as clear as you think it is.

These things are valuable regardless of the outcome.

A Final Note

I don’t know yet what the outcome will be. I’m still skeptical about whether this proposal will “fly”—some ideas may require too much shared background knowledge that reviewers won’t have.

But I’m excited about the ideas regardless. We’ll find ways to pursue them no matter what happens.

Remember which game you’re really playing.

And now, I suppose, back to those revisions.

With solidarity and hope,
Your slightly-less-young self

Context Shapes Everything

Theodore Roszak constructed a thought experiment that illustrates this perfectly (Roszak 1992):

Imagine watching a skilled psychiatrist at work. His waiting room overflows with patients suffering various emotional and mental disorders—some nearly hysterical, others plagued by suicidal thoughts, hallucinations, nightmares, or paranoid delusions about being watched by people who will hurt them.

The psychiatrist listens attentively and tries his best to help, but without success. His patients worsen despite heroic efforts.

Now Roszak asks us to consider the larger context: The psychiatrist’s office sits in a building. The building sits in a place. That place is Buchenwald, and the patients are concentration camp prisoners.

Context changes everything.

This principle extends beyond clinical settings. We experience this daily in human interactions—we can only meaningfully connect with others when we understand their full context: their background, experiences, current circumstances, and unspoken assumptions. Without this context, even well-intentioned communication fails.

The Systems Science Perspective

Systems science teaches us that emergent properties arise from interactions between components, not from components themselves (Meadows 2008). A material’s performance emerges from atomic structure within its manufacturing context, operating environment, and lifecycle constraints.

Yet current AI for science systems remain myopically focused on small subsets, failing to integrate broader contextual factors. We optimize binding energies while ignoring synthesis routes. We predict properties while ignoring cost, scalability, or environmental impact.

Kenneth Stanley and Jeff Clune argue in “Greatness Cannot Be Planned” that optimizing for ambitious goals fails because the stepping stones to greatness are deceptive (Stanley and Clune 2015).

In practice, designing materials with single goals that might seem sensible (e.g., optimize CO₂ binding energy) proves deceptive. Materials exist within complex systems, and myopically optimizing one metric prevents success.

Consider a battery material with perfect energy density that degrades after ten cycles, costs $10,000 per gram, or requires mining rare elements from conflict zones. The system context reveals why single-metric optimization fails.

The Tacit Knowledge Gap

This context problem connects to missing tacit knowledge in our AI systems.

Philosopher-chemist Michael Polanyi famously observed: “We know more than we can tell” (Polanyi 1966). Much of this unverbalized knowledge drives scientific greatness.

Tacit knowledge helps scientists prune search spaces and recognize when experiments or spectra “don’t look right.” This intuition emerges from years of contextual experience—understanding how synthesis conditions affect structure, how processing history influences properties, how real-world operating conditions differ from laboratory ideals.

Current AI systems lack this systems-level understanding, focusing instead on isolated predictions divorced from broader context.

Moving Forward

Building AI systems that understand context requires integrating knowledge across scales, disciplines, and domains. We need systems that consider not just atomic structure but also synthesis pathways, processing conditions, operating environments, economic constraints, and sustainability impacts. They need to be able to gather this context by experiencing it.

The best materials aren’t just optimized—they’re appropriate for their contexts: manufacturability, cost, environmental impact, supply chains, regulatory approval, and real-world operating conditions.

Context engineering isn’t just another AI technique—it’s the foundation of intelligent systems that work in the real world.

Just as meaningful human connection requires understanding full context, breakthrough AI for science demands systems-level thinking that integrates the complex, interconnected reality in which materials actually exist and function.

References

On Value Lock-In and Scientific Monocultures

Value lock-in describes what happens when systems become so entrenched that they perpetuate specific ways of thinking, making alternatives prohibitively difficult to pursue.¹

Science faces an analogous risk. Once AI scientists become the dominant research paradigm—and given their speed and cost advantages, this seems likely—they won’t simply reflect current scientific values. They’ll crystallize them. What appears today as one approach among many could become the only viable approach, not through conscious choice but through path dependence.

The concern isn’t that AI scientists will be poorly designed, but rather that they’ll be too successful at optimizing for current definitions of scientific progress. This creates the “lock-in effect”: the more we invest in AI-driven research infrastructure, the harder it becomes to pursue alternatives, regardless of their potential merit.

The Myth of Value-Neutral Science

Science has never been value-neutral, though we often pretend otherwise. Every research program embeds choices about what questions matter, what methods are legitimate, what constitutes adequate evidence (Huff 2017; Bronowski 1961).

Take computer vision’s relationship with ImageNet. This single benchmark, created by a particular research community with specific assumptions about visual recognition, shaped an entire field for over a decade. It privileged approaches that performed well on a large, static, pre-labeled photographs (Dotan and Milli 2019).

These kind of value-laden choices are the along the entire chain of (AI) research (Dehghani et al. 2021; Hooker 2020; Alampara, Schilling-Wilhelmi, and Jablonka 2025).

Concentration and Its Discontents

Contemporary AI scientists emerge from a remarkably homogeneous ecosystem: similar academic backgrounds, shared technical assumptions, a handful of dominant companies providing the underlying infrastructure. This concentration creates troubling dynamics (Paul 2019; Crawford 2021).

First, epistemic monoculture becomes increasingly likely. When AI systems trained on similar data with comparable objectives dominate research, they’ll systematically favor certain types of questions. Approaches that don’t translate well into current AI paradigms—perhaps because they rely on tacit knowledge, or require forms of reasoning that resist formalization—risk being dismissed as unscientific rather than simply incompatible with our current tools.

Second, we face the prospect of algorithmic gatekeeping. As AI scientists become more productive, human researchers will encounter mounting pressure to adopt these tools or become irrelevant (and performing “current science” as a form of “art”). A small number of AI platforms could effectively determine which ideas get explored and which get ignored—not through explicit censorship, but through the subtler mechanism of making alternatives economically unviable: Power tends to concentrate, and scientific institutions aren’t immune to this tendency.

Normal Science and Revolutionary Potential

According to Thomas Kuhn’s philosophy of science, science alternates between periods of “normal science”—where researchers work productively within established paradigms—and revolutionary episodes that fundamentally reframe entire fields (Kuhn 1962). Crucially, Kuhn observed that normal science “often suppresses fundamental novelties because those novelties are necessarily subversive of its basic commitments.”

AI scientists, optimized on existing scientific literature, might end up being just sophisticated normal science machines. They could excel at incremental advances within current paradigms but struggle with the radical reconceptualization that drives scientific revolutions. This is because current paradigms of machine learning systems easily question their foundational assumptions because those assumptions are embedded in their training data and optimization targets . It’s an inevitable consequence of how these systems work: They are trained to maximize the likelihood of the training data. But it suggests that a science dominated by AI scientists might become extraordinarily good at certain kinds of progress while systematically failing at others.

Toward Epistemic Pluralism

None of this constitutes an argument against AI in science, which would be both futile and counterproductive. Rather, it’s a case for what we might call epistemic pluralism: the deliberate maintenance of diverse approaches to scientific inquiry.

We need something like a portfolio approach to scientific methodology. Some research should leverage AI scientists for their remarkable speed and scale. Other investigations should preserve space for human-led inquiry. Still other work should explore hybrid approaches that combine artificial and human intelligence in novel configurations.

Monocultures are efficient under stable conditions but catastrophically vulnerable to unexpected challenges. Diverse ecosystems sacrifice some efficiency for resilience. Given the stakes involved in scientific knowledge production, resilience seems worth prioritizing.

The robustness of scientific knowledge depends not on any single approach, however sophisticated, but on the productive tension between multiple ways of understanding the world. Preserving that tension, even as AI transforms scientific practice, may be one of the most important challenges facing the scientific community today.

References

A Fraud‑Inspired Analogy

In credit‑card fraud, businesses calculate an acceptable fraud rate—say, 0.5% of transactions—because the cost of preventing every single fraudulent swipe would choke off legitimate commerce. They bake that “waste” into budgets, balancing losses against user friction. Too little fraud tolerance, and customers face endless identity checks; too much, and bad actors thrive.

Similarly, Europe’s research ecosystem must decide its fraud‑rate equivalent: how many dead‑end experiments, unused datasets or stalled hires do we permit to enable the rest to flourish? The answer is not zero.

Building the Right Ecosystem

• New Data Organizations. Establish mission‑driven entities whose sole purpose is to create and share scientific data at minimal cost per replicable datapoint. Fund them to accept researcher proposals, execute experiments—robotic or computational—and retain public rights so that every dataset becomes a reusable building block. Those organizations would also be best place to organize competitions such as CASP to measure real-world impact of AI innovations.

• Data as Public Good. Complement these organizations with micro‑grants for labs and individual researchers to curate and submit annotated datasets—including negative results—to a pan‑European repository. .

• Engineering Partnerships and Product Teams. Embed research software engineers and product managers in academic groups to build, maintain and ship AI tools, applications and data products. Treat code libraries and computational platforms as first‑class research outputs, fostering shared solutions rather than isolated prototypes.

Catalyzing Real‑World Impact

Only by stepping beyond the lab walls—talking with clinicians, industry users, policy makers and citizens—can AI4Science tackle system‑level problems and rediscover its path toward truth. As Daniel Sarewitz argues (Sarewitz 2016), science must shed its ivory‑tower aloofness, embrace accountability, and co‑create solutions with the communities it aims to serve.

Imagine an “Academic Free Zone” pilot in which select institutions are empowered to hire swiftly, manage their own budgets, and report not on form‑counts but on real societal outcomes. Such “bubbles of exploration”-intensive zones where shared optimism, dedicated infrastructure and a tolerable failure rate yield transformative breakthroughs might reflect the best of positive bubble dynamics (Sargeant 2025).

Rather than endless approvals, researchers would report toward tangible public benefits. In this way, we treat researchers as accountable professionals and align incentives with Europe’s mission: ensuring that AI4Science delivers societal value, not just publication counts.

Personal Reflections

I often ask myself: “where can my AI4Science efforts matter most?”. I want that a skill set as mine remains in public service: I worry about centralization of power in AI (Harari 2018). Yet I share colleagues’ frustration at bureaucratic inertia: a promising algorithm may sit unused for years behind grant cycles and compliance checks. If Europe is serious about impact, we must dismantle these barriers.

The Digital Archaeologist’s Toolkit

In our metaphor, an autoencoder is like a three-phase archaeological expedition.

class ExcavationBrush(nn.Module):
    def __init__(self, spectral_channels=1000, artifact_dimensions=32):
        super().__init__()

        self.compressor = nn.Sequential(
            nn.Linear(spectral_channels, 512),
            nn.ReLU(),
            nn.BatchNorm1d(512),
            nn.Dropout(0.2),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.BatchNorm1d(256),
            nn.Linear(256, artifact_dimensions)
        )

    def forward(self, buried_spectrum):
        return self.compressor(buried_spectrum)

# In our latent space, each spectrum becomes coordinates on an ancient map
# It's like Google Maps, but for molecules
def encode_spectrum(encoder, noisy_spectrum):
    latent_artifacts = encoder(noisy_spectrum)  # Returns a point in hyperspace
    return latent_artifacts

class Reconstructor(nn.Module):
    def __init__(self, artifact_dimensions=32, spectral_channels=1000):
        super().__init__()
        
        self.reconstruction_process = nn.Sequential(
            nn.Linear(artifact_dimensions, 256),
            nn.ReLU(),
            nn.BatchNorm1d(256),
            
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.BatchNorm1d(512),
            
            nn.Linear(512, spectral_channels),
            nn.Sigmoid() 
        )
    
    def forward(self, artifact_description):
        return self.reconstruction_process(artifact_description)

The Mathematics of Archaeological Documentation

Just as physical conservation laws govern the preservation of matter and energy (thanks, Emmy Noether!), information theory dictates how we can compress and reconstruct data without turning it into digital gibberish.

The fundamental equation governing our autoencoder is the reconstruction loss:

Where is our original spectrum (the truth, the whole truth, and nothing but the truth) and is our reconstruction.

But we can be fancier with a composite loss function:

Each term has a job:

• Fidelity term: “Make it look like the original”
• Gradient penalty: “Keep it smooth, no sudden jumps”
• Feature preservation: “Those peaks are important, don’t lose them!”
• Regularization: “Stay humble, don’t overfit”

The Manifold Hypothesis: Why This Archaeological Dig Makes Sense At All

Let’s address a fundamental question: why should this even work? Shouldn’t compressing our beautiful high-dimensional spectrum lose valuable information? Welcome to the manifold hypothesis, the reason dimensionality reduction isn’t just mathematical vandalism.

The manifold hypothesis suggests that high-dimensional data (like our spectroscopic signals) aren’t actually using all those dimensions effectively. Instead, the data lies on or near a lower-dimensional surface (a manifold) embedded in that high-dimensional space. It’s like discovering that what looks like a complex 3D sculpture is actually just a cleverly folded 2D sheet of paper.

To visualize this, imagine our spectra are actually faces of ancient masks (stay with me here). Each mask has thousands of pixels (dimensions), but you could describe any mask with far fewer parameters: eye size, mouth width, nose shape, etc. That’s your manifold! Autoencoders discover these “facial features” of spectra automatically. ![You might be familiar with eigenfaces, which are “basis vectors” of human faces one can derive with PCA.]

From Classical to Neural: The Connection Between PCA and Linear Autoencoders

Long before neural networks were cool, archaeologists (well, statisticians) had their own dimensionality reduction technique: Principal Component Analysis, or PCA.

A Practical Example: Finding the Redundant Dimension

Let’s make this concrete with an example. Imagine we have a spectrum where two neighboring wavelengths always vary together—perhaps due to a broad absorption band or some instrumental correlation.

# Create a dataset with a redundant dimension
def create_redundant_spectrum(num_samples=1000):
    # Independent features
    independent_features = np.random.randn(num_samples, 3)
    
    # Create a 5D spectrum where dimensions 2 and 3 are correlated
    spectra = np.zeros((num_samples, 5))
    spectra[:, 0] = independent_features[:, 0]  # Independent
    spectra[:, 1] = independent_features[:, 1]  # Independent
    spectra[:, 2] = independent_features[:, 2]  # Independent
    spectra[:, 3] = 0.95 * independent_features[:, 2] + 0.05 * np.random.randn(num_samples)  # Correlated with dim 2
    spectra[:, 4] = independent_features[:, 0] - independent_features[:, 1]  # Another linear combination
    
    return spectra

# Create a linear autoencoder
class LinearAutoencoder(nn.Module):
    def __init__(self, input_dim=5, latent_dim=3):
        super().__init__()
        self.encoder = nn.Linear(input_dim, latent_dim, bias=False)  # No bias
        self.decoder = nn.Linear(latent_dim, input_dim, bias=False)  # No bias
    
    def forward(self, x):
        latent = self.encoder(x)
        return self.decoder(latent)
    
    def tie_weights(self):
        # This enforces W_2 = W_1^T 
        self.decoder.weight.data = self.encoder.weight.data.t()

When we train this model, it should learn to identify dimension 3 as redundant (since it’s nearly identical to dimension 2). Also dimension 4 is only a linear combination of other dimensions. A 3-dimensional latent space will capture all the variance in the 5-dimensional input.

Code

# Generate redundant spectrum
spectra = create_redundant_spectrum()

# Apply PCA
pca = PCA(n_components=5)  # Get all components to see variance
spectra_reduced = pca.fit_transform(spectra)

pca_three = PCA(n_components=3)
spectra_reduced_three = pca_three.fit_transform(spectra)
spectra_reconstructed = pca_three.inverse_transform(spectra_reduced_three)

# Calculate reconstruction error
reconstruction_error = np.mean((spectra - spectra_reconstructed) ** 2)

# Plot the explained variance
plt.figure(figsize=(10, 5))
plt.bar(range(1, 6), pca.explained_variance_ratio_)
plt.xlabel("Principal Component")
plt.ylabel("Explained Variance Ratio")
plt.title(f"PCA Explained Variance (Reconstruction Error: {reconstruction_error:.6f})")
plt.xticks(range(1, 6))
plt.ylim(0, 0.5)
plt.tight_layout()
plt.show()

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:152: RuntimeWarning:

divide by zero encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:152: RuntimeWarning:

overflow encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:152: RuntimeWarning:

invalid value encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:152: RuntimeWarning:

divide by zero encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:152: RuntimeWarning:

overflow encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:152: RuntimeWarning:

invalid value encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:205: RuntimeWarning:

divide by zero encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:205: RuntimeWarning:

overflow encountered in matmul

/opt/miniconda3/lib/python3.13/site-packages/sklearn/decomposition/_base.py:205: RuntimeWarning:

invalid value encountered in matmul

In the real world, spectroscopic data often has many such redundancies. Neighboring wavelengths are correlated, certain patterns of peaks occur together, and baseline effects introduce further correlations. These redundancies are exactly what autoencoders exploit—the manifold structure of our data.

The difference is that nonlinear autoencoders can capture more complex manifolds that PCA misses. It’s like upgrading from a 2D map to a 3D hologram of your archaeological site.

Beyond Linear Maps: Where Neural Networks Actually Shine

Now we’ve seen that linear autoencoders are just PCA in disguise, let’s talk about why we still bother with neural networks.

The magic happens when we add nonlinearities: those lovely activation functions like ReLU, sigmoid, or tanh. These allow autoencoders to learn complex, curved manifolds that PCA could never dream of capturing.

class NonlinearArchaeologist(nn.Module):
    def __init__(self, input_dim=1000, latent_dim=32):
        super().__init__()
        
        # Now with extra nonlinear goodness!
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.ReLU(),  # This is where the magic happens
            nn.Linear(512, 256),
            nn.ReLU(),  # More magic!
            nn.Linear(256, latent_dim)
        )
        
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, input_dim)
        )

The Probabilistic Excavation: Variational Autoencoders

What if our archaeologist isn’t completely certain about what they’ve found? Enter the Variational Autoencoder (VAE)—the probabilistic archaeologist who deals in uncertainties rather than absolutes.

class ProbabilisticArchaeologist(nn.Module):
    def __init__(self, input_dim=1000, latent_dim=32):
        super().__init__()
        
        # Encoder produces distribution parameters
        self.encoder_base = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU()
        )
        
        # Two outputs: mean and log-variance
        self.fc_mu = nn.Linear(256, latent_dim)
        self.fc_logvar = nn.Linear(256, latent_dim)
        
        # Decoder reconstructs from samples
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, input_dim)
        )
    
    def encode(self, x):
        h = self.encoder_base(x)
        mu = self.fc_mu(h)         # "I think the artifact is here"
        logvar = self.fc_logvar(h)  # "But I could be wrong by this much"
        return mu, logvar
    
    def reparameterize(self, mu, logvar):
        # The famous reparameterization trick
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        return self.decoder(z), mu, logvar

def vae_loss(reconstruction, x, mu, logvar, beta=1.0):
    """Calculate the VAE loss with reconstruction and KL terms"""
    # Reconstruction loss (how well does the output match the input?)
    recon_loss = F.mse_loss(reconstruction, x, reduction='sum')
    
    # KL divergence (how much does our distribution differ from the prior?)
    # For the standard normal prior, this has a nice closed form
    kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    
    # Total loss with β weighting
    return recon_loss + beta * kl_loss

Conclusion: The Journey Continues

Our archaeological expedition through the world of autoencoders has revealed powerful tools for uncovering the hidden structure in spectroscopic data. We’ve seen how:

1. Linear autoencoders connect to classical methods like PCA
2. Nonlinear autoencoders can capture complex manifold structures
3. Variational autoencoders add a probabilistic perspective that enables generation and interpolation

Just as archaeologists piece together ancient civilizations from fragments, we can piece together the underlying molecular and material properties from noisy, complex spectral data.

And just like archaeology, the field continues to evolve with new techniques and approaches. From graph neural networks to attention mechanisms to diffusion models, the tools for spectroscopic data analysis keep getting more sophisticated - allowing us to uncover ever more subtle patterns and relationships in our molecular artifacts.

So grab your digital trowel and start digging!

You can find a short lecture on this on YouTube.

Impact Neutrality

I rarely suggest rejection. This comes from my attempt to be “impact neutral” in reviewing, an approach I’ve found useful after reading Jan Jensen’s thoughts and seeing the PLoS ONE model in action.

By “relatively impact neutral,” I mean I focus primarily on scientific soundness. I’ll still praise work I find particularly important and note when novelty seems lacking, but these observations inform rather than dictate my recommendations. I try to keep acceptance/rejection opinions out of my review’s main body. If there are forms, I do not fill them if I do not have to: knowledge work is notoriously difficult to measure (Drucker 1999), and the stepping stones that lead to discoveries often cannot be anticipated (Stanley and Lehman 2015).

Looking for Value

Even in papers I initially find underwhelming, I deliberately search for strengths. What makes this work add to our existing knowledge? How could the authors better emphasize these aspects?

This isn’t just kindness—it’s also practical. By focusing on what works, I can help authors build on their strengths and often discover value I initially missed.

Making Feedback Actionable

Vague criticism helps no one. I try to make every comment actionable by offering specific suggestions and quoting the relevant text.

Maintaining an Objective Tone

Throughout my reviews, I write in an objective, non-judgmental tone. Critical analysis doesn’t require harsh language. Scientific evaluation can be thorough and rigorous while remaining respectful of the authors’ efforts and expertise.

My Review Structure

My reviews typically include:

1. Summary: My understanding of the work, which helps authors see if I’ve missed something crucial.
2. Major Points: Critical flaws in design, analysis, or unsupported claims.
3. Minor Points: Suggestions that don’t affect the core message but would strengthen the paper.
4. Reproducibility: Assessment of code and data availability.
5. Limitations of Expertise: Areas where my knowledge is limited, particularly important for interdisciplinary work.

My Process

Good reviews take time. My typical approach:

1. Read the manuscript thoroughly first.
2. Do a quick literature check using tools like PaperQA or Ai2 ScholarQA.
3. Take a few days away to let thoughts settle.
4. Write the review.
5. Get feedback from a local LLM to check if I’ve followed my own guidelines.

I’ve found acknowledging my own biases helps me compensate for them. We all bring preferences to reviews—naming them doesn’t eliminate them but makes them visible.

I don’t review for publishers I consider predatory, such as MDPI.

The Case for Kindness and Diversity

Our field would benefit from more kindness in the review process. The harsh, dismissive tone of some reviews doesn’t improve science—it discourages innovative thinking and disproportionately impacts early-career researchers and those from underrepresented groups.

Similarly, greater diversity of thought would strengthen our collective work. When reviewers from varied backgrounds, methodological traditions, and theoretical perspectives evaluate research, we catch blind spots and identify new possibilities. Homogeneous reviewing leads to homogeneous science.

Both kindness and diversity ultimately serve the same goal: creating an environment where the best ideas can emerge, regardless of their source or how they challenge conventional thinking.

Open Questions

• I’m also interested in how the community might evolve publication models. Could approaches like Bengio’s proposal of submitting to journals and conference chairs picking “interesting articles” or rolling reviews address some current frustrations?
• In an era of information overload, might versioned, updateable articles serve science better than our current static approach?

Building a Collective Scientific Intelligence

One of the most tragic inefficiencies in science is how poorly we transfer experience. A PhD student spends 4-5 years developing deep experimental intuition about a specific material system or characterization technique. When they leave, most of that knowledge leaves with them.

A large opportunity lies in general-purpose models and alignment approaches that can:

• Learn from unstructured experimental data across different modalities
• Bridge the gap between synthesis conditions and material properties
• Surface non-obvious connections between seemingly unrelated research areas

The technical breakthrough enabling this is our ability to simultaneously handle:

1. Synthesis protocols (as structured text and process graphs)
2. Characterization data (spectroscopy, microscopy, diffraction)
3. Property measurements (electronic, mechanical, optical)
4. Theoretical calculations (DFT, molecular dynamics)

Expert Councils: Beyond Single Models

We do not only want to have the average representation of materials data - we need specialized expertise for various topics and the ability to let these experts interact. This mirrors how human experts work together, bringing different perspectives and expertise to complex problems.

The key is bootstrapping specialized models using:

• Integration with physics-based simulations
• Iterative refinement through experimental feedback
• Domain-specific inductive biases that constrain the solution space
• Validation through robust tools and theoretical frameworks

For example, we can: - Generate feedback through simulations and experiments - Use iterative training approaches similar to Beyond A* - Constrain function spaces using inductive biases - Hand over specific predictive tasks to specialized architectures

The specialized models can be bootstrapped with information from general-purpose models, making them more data-efficient while maintaining domain expertise.

Guiding Discovery Through “Interestingness”

Optimizations - or searches through materials space - are often compared with finding a needle in a haystack. Some try to design ML approaches as a “magnet” or “filter” to more efficiently find the needle. This could not be more misguided for two reasons:

1. We often don’t even know what we’re looking for (we often cannot define what metrics would be important before we have the solution)
2. Looking for a needle in a haystack suggests searching through an unstructured space, but materials space has rich patterns we can exploit

Instead, we’re developing ways to identify scientifically promising directions through:

• Novelty detection that can spot meaningful deviations from known patterns
• Uncertainty quantification that highlights areas where models disagree
• Causal reasoning that can extract mechanistic insights

Implications for Model Choice

Our analysis of data spaces reveals a nuanced framework for choosing modeling approaches, one that goes beyond simple metrics to consider the fundamental nature of structure in each domain.

Conclusions

This analysis, while admittedly preliminary, provides a framework for understanding when to apply specialized versus general-purpose models in scientific domains. The choice appears guided by three key factors:

1. The type of structure present (physical, human-created, or mixed)
2. The structure-to-noise ratio
3. The presence and nature of hidden variables

In domains with physical structure and few hidden variables, specialized architectures can effectively leverage domain knowledge. However, in domains with human-created structure or many hidden variables, general-purpose models may be more appropriate. This explains why our group remains optimistic about applying LLMs to chemistry - the complexity and hidden variables in chemical experiments might make them particularly suitable for statistical pattern recognition through large language models.