Video · 2026-07-27 · 47m · 6 moments

Why Models Are AI’s Next Training Dataset | Damian Borth

✦ AI generated

timeline · colored by role

Claim◆

Trained neural network weights can be treated as an input modality for training another neural network to analyze and generate new weights, analogous to how language models learn from text and image models learn from pixels.

Borth introduces weight-space learning, arguing that trained model weights are not just the output of training but can be used as input data for a new class of neural networks that analyze and generate weights, just as language models process text or vision models process pixels.

transcript

Damian Borth: Exactly. So if you think about machine learning, machine learning has this idea of you have data and uh some output um in classical supervised machine learning data and some predictions and you train neural network uh in between to mimic uh the data set mimic the distribution of the data set and uh the outcome during this very expensive training procedure is a set of weights a configuration of parameters that define the neural network like the DNA of the neuronet network. um this is classical machine learning supervised unsupervised self-s supervised that fuels a lot of innovation over the last 10 years and with geni you know moved to next stage if you look at what happened over the last couple of years more and and more and more of those models have been published uh publicly are online accessible at you know repositories like hugging face or github. So we basically thought about this very simple idea. What happens actually if we take the weights of trained neuronet networks as the input to train a neural network to understand these weights that we have out there much much better. So to take another analogy you you know language models you take a big model you train this on every single sentence on the internet at the end you have a language model able to analyze language and to generate language. You can take the same idea for pixels. You take a big model, you train on all the pixels on the internet and you can analyze pixels and you can generate pixels. We do the same idea on all the weights of trained neural networks. So we can analyze weights of neuronet networks and we can generate weights of neuronet networks. um as straightforward as it is obviously there's a little bit more into the details but thinking about that you can treat the ways as a input modality gives you suddenly this opportunity of thinking about okay what would be language translation in with more like neural network models right what would be generation of you know words and tokens that are words in generation of tokens that are weights and can we be much much faster in creating new weights for particular the task or can we be much more precise in analyzing weights when somebody gives me a new network that I'm not knowledgeable about and I never saw before and then you know you have this new entire world this you know empty space of things you can do with weights um that you know you kind of carry into the community and hope that there's somebody listening and continuing and you know building up a community which happened over the last two three years which is very exciting because there are more people about that And yeah uh weights are exciting uh not only as the output of learning but as the input for learning.

explains mechanism · 1extends · 3gives example · 3provides context · 2rebuts · 1supports · 1

Data

An autoencoder trained on a homogeneous population of neural networks can predict the accuracy, generalization gap, and activation function of unseen models from their weights alone, without requiring test data.

Borth describes the first proof-of-concept for weight-space learning: an autoencoder compressed weight sequences from thousands of small models into a latent space, and a linear regression head on that space could predict accuracy and other properties of models never seen during training.

transcript

Damian Borth: we took you know an autoenccoder we have an encoder and decoder we learned the autoenccoder with or train the auto with reconstruction loss a contrastive loss in the middle and then we take we took only the encoder and unknown neural networks that we encoded into the latent space and this embeddings we put into a you know simple you know regression like a linear regression head to predict the accuracy. So you give me a neural network. I never saw this neural network and the idea was can I predict the accuracy of this neural network. Can I test the neural network without the use of test data? Right? Obviously this worked on this really small neural networks only in an homogeneous we call this a model zoo a population of models. So they were all trained on the same data, same architecture, first you know small steps towards this goal. But we could extract this information about the accuracy, the performance, the generalization gap, what kind of activation function was used. And if you would plot this latent spaces, you would see different initializations and how they evolve because we had, you know, 50 epo per model training and 10,000 models. So little trajectories were visible.

extends · 1gives example · 1

Mechanism

Mean squared error loss is fundamentally inadequate for generating functional neural network weights from a latent representation, because it reconstructs average weights well but loses the high-frequency information critical for network function.

Borth explains the 'blurry weights' problem: their autoencoder achieved very low reconstruction error, but when generated weights were loaded into a network, the network failed completely because MSE captures the average well but discards the precise high-frequency structure that makes a network functional.

transcript

Damian Borth: We we trained this out encoder. The mean split error was super low. We took the neural networks. We moved them in the forward pass. We reconstructed as said the loss is very low. We pluck the weights back to the neural network. Totally screwed up the entire new network. We're like [laughter] yeah it was like it was really like the mean spread is low and obviously now obviously right a mean square is an average. So we were very good at know reconstructing the average weights but the little things that make the difference of having this function working or not they were so important and there is analogy to pixels and images like when you had generative models for images the images were always blurry so people kind of tried hard and you know taming transformers for high resolution images changed the mean square error to perception laws and you know did some additional things on quantizing and the gun so we knew that reconstruction maybe a wrong loss and we tried to normalize and play around with the losses and you know thought about the behavior loss and then we were able to make those models little bit better but there's still a little bit of delta that is missing we kind of we generate at that time blurry weights right low frequency information high frequency information missing

provides context · 2rebuts · 1

Context

Weight-space learning can be scaled beyond homogeneous model zoos to train on diverse open-weight models from Hugging Face across different architectures, tasks, and modalities.

Borth describes scaling weight-space learning from controlled toy experiments to training on thousands of diverse models downloaded from Hugging Face, handling different architectures through specialized tokenization and normalization.

transcript

Damian Borth: So that the next step was can we get can we train on models that are out there and there's amazing work on analyzing how you know hugging face looks like the model atlas from Yahoo and Yetit and there is a lot of there are a lot of models so can we download those models and then independently of what kind of architecture they have what data set they trained use our machinery and it's a little bit tricky because you know different sequence lengths different types of neural network layer. So we have to put some information into it. But we were able to train like the first um you know weight space learning model that can do generation and analysis of weights. So discriminative and generative downstream dust on hugging face models. This was work by by D F which is really amazing. Um again we we thought it's much more challenging to do this but you know you have to scale you need the machinery and you need those little tricks how to handle those different you know the tokenizer needs to be adapted to arbitrary architectures that's that's the thing.

extends · 2

Example◆

Weight-space learning enables knowledge transfer across domains that generates domain-specific models with 20-30x less compute than training from scratch, demonstrated by generating remote sensing foundation models from an ImageNet-based encoder-decoder.

Borth presents the remote sensing case study where weight-space learning generated remote sensing foundation models using only 350 GPU hours, compared to 12,000 GPU hours for the state-of-the-art, by transferring knowledge from ImageNet-trained models across domains.

transcript

Damian Borth: um therefore we had this paper that we're going to publish soon in CVPR about remote sensing where we take an imageet vit use our machinery to generate remote sensing models or remote sensing foundation models then we have the domain change where our encoder decoder is providing knowledge transfer to generate models that are better than the ones that imageet fine-tuning would be able to reach. So here we have a true knowledge transfer which is really really great where we are able actually to outperform or be you know equally in performance with current models like TFM published at ICLR I think the auto claim they trained for 12,000 GPU hours and we are able to do this on 350 GPU hours that's a factor of I don't know 20 25 30 depending on how you count and this is suddenly interesting because you train from models and not from data. So if you think about right we're running out of data that's the reason why the scaling laws are a little bit you know considered differently and everybody is moving into test time adaptation [clears throat] test time training we're running out of data to train the large models but we are not using the weights of older models so why not using the weights all the knowledge that all the compute that people invested right

explains mechanism · 1gives example · 1provides context · 1

Prediction

Using dataset embeddings as prompts instead of model prompts enables privacy-preserving generation of neural network weights from sensitive data that cannot be shared, opening model generation to regulated industries.

Borth describes the vision of dataset prompting: instead of needing an existing model to anchor weight generation, a single embedding of a dataset could serve as the prompt, enabling financial and healthcare institutions to generate models from sensitive data without exposing the data itself.

transcript

Damian Borth: And if this could be done in a privacy preserving way, it would be even better, right? Because then suddenly people could use this without revealing individual members of this data set. So there's work that does something similar already and Kais you know um Zo and Andreas and others were working on that and we kind of moved this forward because we have model zoos right we have data sets and we have models so we have kind of images and we have models and why not trained and aligned space like clip did with text and images. Then we could use actually a kind of a data set encoder as a model prompt that could move into this space and point into this space instead of a model prompt. We use a data set prompt. So you you're a bank, you are a you know financial institution, healthcare provider, whatever. You don't reveal your data. You you have your data set of I don't know 100 samples, thousand samples. You create one data set embedding. So you cannot infer you know the individual members or samples. you give this embedding to us, we provide you the weights, we give you the weights, you're much faster in continuing training. So this would be this would be really interesting, right? Because that opens up to all the you know potential data sets that are not on hugging phase

provides context · 1

Highlight slides

Weights as Input Modality✦ from: Trained neural network weights can be treated as an input modality for training another neural network to analyze and generate new weights, analogous to how language models learn from text and image models learn from pixels.Analogy to Language and Vision Models✦ from: Trained neural network weights can be treated as an input modality for training another neural network to analyze and generate new weights, analogous to how language models learn from text and image models learn from pixels.Analyze and Generate Weights✦ from: Trained neural network weights can be treated as an input modality for training another neural network to analyze and generate new weights, analogous to how language models learn from text and image models learn from pixels.Weight-Space Learning Enables Cross-Domain Knowledge Transfer✦ from: Weight-space learning enables knowledge transfer across domains that generates domain-specific models with 20-30x less compute than training from scratch, demonstrated by generating remote sensing foundation models from an ImageNet-based encoder-decoder.20–30× Compute Savings vs. State-of-the-Art✦ from: Weight-space learning enables knowledge transfer across domains that generates domain-specific models with 20-30x less compute than training from scratch, demonstrated by generating remote sensing foundation models from an ImageNet-based encoder-decoder.Leveraging Prior Weights as a New Scaling Axis✦ from: Weight-space learning enables knowledge transfer across domains that generates domain-specific models with 20-30x less compute than training from scratch, demonstrated by generating remote sensing foundation models from an ImageNet-based encoder-decoder.

Related episodes

Video · The Cognitive Revolution

Intelligence on the Edge: Liquid AI's Ramin Hasani on the Search for Device-Native Foundation Models

→

Article · Simon Willison's Weblog

xai-org/grok-build, now open source

→

Article · Platformer

The case for making your own apps

→