Text2Weight: Bridging Natural Language and Neural Network Weight Spaces

Bowen Tian; Jiemin Wu; Songning Lai; Wenshuo Chen; Yutao Yue; Zexi Li

REVIEW 6 major objections 6 minor 39 references

Text2Weight: Bridging Natural Language and Neural Network Weight Spaces

T0 review · 6 major / 6 minor · reviewed 2026-08-05 · deepseek-v4-flash

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

Pith's one-line read The paper claims that T2W, a diffusion transformer conditioned on CLIP text embeddings, can generate neural network classifier weights directly from natural-language task descriptions, generalizing to unseen tasks and outperforming optimiza

desk verdict Plausible incremental method for text-conditioned weight generation, but the headline '>80% unseen accuracy' claim is contradicted by the paper's own Table 1. read the letter →

arxiv 2508.13633 v1 pith:XQDFIAFC submitted 2025-08-19 cs.LG

Bowen Tian , Wenshuo Chen , Zexi Li , Songning Lai , Jiemin Wu , Yutao Yue This is my paper

classification cs.LG

keywords Text2WeightweightspacegenerationdiffusiontransformerCLIPconditioningneuralnetworksynthesistext-guidedinitializationfusiongenerativemodels

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper tries to show that neural network weights can be treated as a generative data modality, synthesized on demand from a text prompt. It proposes T2W, a diffusion transformer that takes the CLIP embedding of a task description (a list of class names or natural-language class descriptions) and denoises a classifier head for that task. The headline result is that T2W produces high-accuracy weights for unseen tasks—the paper states over 80% average accuracy for TinyImageNet sub-tasks—and beats gradient-trained universal models and standard initializations. If true, this would let a user obtain a working classifier for a described task without collecting training images or training a model.

What carries the argument

The load-bearing object is the pooled condition vector $v_c \in \mathbb{R}^{512}$ produced by Algorithm 1: each class description is embedded with CLIP, the embeddings are averaged, and each embedding is re-weighted by its cosine similarity to that average before summation. This single vector is the only task information the diffusion transformer sees, injected through a prior attention mechanism into 576 chunked parameter tokens. Around this, the method adds a permutation-equivariance loss and a weight-space discriminator to keep generated weights on the valid weight manifold.

What would settle it

Construct two class subsets with identical fused text vectors $v_c$ (or nearly so) and different label sets, ask T2W to generate weights for each, and measure classification accuracy on both tasks. If one generated head fails while the other succeeds, the pooled-vector assumption is falsified. Alternatively, reproduce the reported TinyImageNet unseen-task accuracy: the text claims over 80%, while Table 1 reports 71.51%, so a reproduction run would settle which number is correct.

Watch

Extended reading notes

Core claim

The central claim is that a single text-conditioned diffusion model can learn the mapping from task semantics to classifier parameters and generalize past its training distribution. Concretely, T2W generates the weight matrices of a two-layer CLIP projection head ($W_1 \in \mathbb{R}^{512\times16}$, $W_2 \in \mathbb{R}^{16\times512}$) that maps frozen ResNet-18 image features into CLIP's text space, so the head classifies by dot-product similarity to per-class text embeddings. The conditioning signal is one pooled vector $v_c$: per-class CLIP embeddings are mean-aggregated and then recombined by cosine-similarity weights via Algorithm 1. The diffusion transformer denoises 576 chunked paramet

Load-bearing premise

The single pooled text vector $v_c$—a weighted average of per-class CLIP embeddings—carries all task information the generator receives, so if two different class subsets produce the same vector, T2W cannot tell them apart and the generated weights must be wrong for at least one of them.

Editorial extensions

If this is right

If T2W holds, a classifier for a described task can be generated without any images or gradient training on that task.
T2W-generated weights can initialize supervised training, reaching higher final accuracy with lower loss than Xavier, Kaiming, or random initialization.
Denoising an undertrained model's weights with T2W can boost accuracy, e.g., from 36.14% to 74.57% on a CIFAR-100 subtask.
Text-guided fusion of two separately trained models can outperform permutation-alignment fusion (Git Re-Basin), preserving each model's capabilities.
The released 36,000 text-weight pairs give other researchers a benchmark for text-conditioned weight generation.

Reading between the lines

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

The single pooled vector $v_c$ is a likely bottleneck: since the diffusion model conditions only on this one vector, two different class subsets that yield the same weighted average are indistinguishable; testing this would require analyzing collisions or conditioning on the full per-class embedding set.
Weight enhancement via denoising is intriguing because it suggests the diffusion model has learned a prior over the weight manifold that can pull partially trained heads back toward better solutions; a natural extension is to test how much denoising helps as a function of training progress.
The framework's generalization to unseen tasks is measured on subsets drawn from the same base datasets as training; a harder test would be generating weights for a completely novel class vocabulary (e.g., classes from a different dataset) and checking whether accuracy transfers.
If text-to-weight generation scales, it could turn model customization into a retrieval-style operation: instead of fine-tuning, one would describe the task and decode weights, which would change how personalized models are deployed.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Colleague,

The thing to know first: T2W does something real — it can generate a small CLIP adapter head from a text description of a classification task, and those heads achieve decent accuracy on held-out task subsets. The three downstream demos (initialization, enhancement, fusion) are inventive. But the paper's central quantitative claim, repeated in the abstract and Section 1, that Tiny-ImageNet unseen-task accuracy is 'over 80%', is contradicted by Table 1: the best variant gets 71.51%. That's an internal inconsistency, not a subtle modeling issue. Whoever fixes this needs to either correct the text or release code that reproduces the 80% number.

What's actually new is modest. This is an extension of the authors' own Text-to-Model (Li et al. 2024), acknowledged in Section 5. The additions — a weight-space discriminator, a permutation symmetry loss, flexible class counts, and downstream applications — are incremental engineering. No comparison against Li et al. is provided, so I can't tell whether the additions help. The open-source dataset of text-weight pairs is a useful resource.

The soft spots that matter:

1. The headline number. Already noted. You can't claim 80% when your own table says 71.5%.

2. The 'unseen task' setup is weaker than it sounds. Tasks are subsets of the same class pool, so individual classes overlap with the seen set. More importantly, the condition is a single pooled vector v_c, a cosine-similarity-weighted average of per-class CLIP embeddings (Algorithm 1). Two different subsets can produce nearly the same v_c, and the model has no way to distinguish them. The paper doesn't analyze this information loss at all.

3. No accuracy is reported for the normally trained target heads that define the weight-similarity target. The 'Loss' metric measures distance to those targets, so as a sanity check I'd want to know how good the targets themselves are.

4. The adversarial loss weight λ_2 is never reported. The ablation says removing it hurts, but I can't evaluate the magnitude.

The weight-enhancement and fusion results are interesting but based on very few samples (5 per dataset for enhancement, no error bars). They're suggestive, not conclusive.

Who's this for? People working on weight-space generation and text-conditioned models for small adapters. It's a plausible incremental step, but the evidence as presented doesn't support the strength of the claims.

My recommendation: send it to peer review. A referee can sort out whether the 80% claim is a typo or a real result, require the missing baselines, and push for analysis of the pooling bottleneck. As is, it's a conditional accept at best — the core idea appears real, but the paper oversells itself.

Referee Report

6 major / 6 minor

Summary. The paper proposes T2W, a diffusion-transformer framework that generates the weights of a low-rank CLIP projection head (W1∈R512×16, W2∈R16×512) from a natural-language description of a classification task. The method is trained on 36,000 text-weight pairs constructed from CIFAR-100, Caltech-256, and TinyImageNet, with the text condition computed as a cosine-similarity-weighted average of per-class CLIP embeddings. Experiments report seen/unseen task accuracy and weight MSE against trained target heads, ablation studies, and three applications: text-driven model fusion, parameter initialization, and weight enhancement. The paper's central claim is that T2W generalizes to unseen tasks, including a stated TinyImageNet unseen-task accuracy 'over 80%'.

Significance. If validated, text-conditioned generation of classifier heads would be a practical contribution to task-adaptive initialization, model editing, and weight-space manipulation. The paper introduces a dataset of text-weight pairs, a transformer-based architecture with permutation-symmetry and adversarial losses, and several downstream applications; these are useful ingredients. However, the headline generalization claim is not currently supported by the reported numbers: the TinyImageNet unseen-task accuracy in Table 1 is about 71.5%, the unseen-task split is not class-disjoint, and key controls (target-head accuracy, continued-training baseline, comparison to the authors' prior architecture) are missing. With careful re-evaluation and re-scoped claims, the approach could still be of interest; as it stands, the central conclusion is not established.

major comments (6)

[Section 1, Table 1] The paper states: 'The average classification accuracy of the classifiers generated for the TinyImageNet sub-dataset is over 80% in unseen tasks.' Table 1 reports for TinyImageNet unseen tasks 70.42% (T2W-CLIP) and 71.51% (T2W-NL); the three-dataset average is 73.55%. Table 4's 84.12% corresponds to 50 epochs of supervised training from a T2W initialization, not to generated weights. This internal contradiction affects the paper's strongest quantitative claim and must be corrected or reproduced before the generalization conclusion can stand.
[Section 4.1, Data Splits] The held-out 'unseen tasks' are random k-class subsets (k~U{8,32}) drawn from the same base class pool. With only 100/200/256 classes and 9,600 training tasks per dataset, every individual class and many class co-occurrences appear in training. Thus 'unseen task' does not mean unseen classes; the model has seen all the component classes, which greatly weakens the generalization claim. Table 1's slightly higher unseen than seen accuracy is consistent with this. Please report class-overlap statistics or, preferably, evaluate on held-out class sets that never appear in any training subtask.
[Section 4.1, Algorithm 1] The diffusion condition v_c is a single pooled vector formed by a cosine-similarity-weighted average of per-class CLIP embeddings. The target head must discriminate the classes in the task, but a pooled vector cannot in general distinguish different class subsets that yield similar averages; information about which classes are in the task and their inter-class structure may be lost. The paper provides no collision or information-loss analysis. If two tasks with different class sets map to nearly the same v_c, the model cannot condition on the difference. This is central to the generalization claim; please analyze the sufficiency of this representation or condition on the full per-class embedding matrix.
[Section 4.2, Table 1] The weight-similarity metric is MSE between generated weights and the per-task trained target weights, but the accuracy of those target weights is never reported. Without knowing how accurate the target heads are on their own test sets, the reader cannot judge whether a small MSE indicates high-quality generation or merely faithful reproduction of a weak target. Add a target-head accuracy column/row for each dataset and split, and report standard deviations across the three runs.
[Section 4.6] The weight-enhancement experiment compares an early-stopped model (25 epochs) before and after T2W denoising. There is no control that simply continues training for the remaining 25 epochs, so the reported gains (e.g., 36.14%→74.57% on CIFAR-100) may be due to additional optimization rather than to the T2W generative prior. Add a continued-training baseline and, if possible, an existing weight-denoising method as a baseline.
[Section 5] The method builds directly on Li et al. (2024), the authors' prior architecture, but no quantitative comparison is provided with that method or with other weight-generation baselines such as p-diff, DiffLoRA, or hyper-representation approaches. The claim that T2W advances generalization to unseen tasks relative to existing weight generation is therefore not yet established. Please add at least one comparison in a matched setting.

minor comments (6)

[Table 2] The column header 'T2M' appears to be a typo for 'T2W'.
[Section 4.1 and Appendix B.3] The text specifies hidden_dim=16 in Eq. (15), while Listing 1 uses hidden_dim=8. Also, Algorithm 2 states that only fc[-1] is unfrozen; clarify which of the two projection matrices are actually trained and generated.
[Abstract / Section 1] The paper says 'Our code is available on Github' but gives no repository URL, making the reproducibility claim unverifiable.
[Section 4.1] T2W-NL is said to use natural-language descriptions, but no examples of those descriptions or the generation protocol are provided. The training data uses template prompts 'A photo of class_i'; the mismatch between training and T2W-NL conditions should be clarified.
[Figure 6] The weight-enhancement results are based on five selected samples per dataset with no error bars. The claim that 'all samples dramatically improve' is only supported for these selected samples.
[Section 4.2] The Universal Model baseline is a single head trained on the full dataset rather than per-task target heads. The comparison is useful, but it is not a substitute for reporting the accuracy of the per-task target weights used in the MSE metric.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation; held-out image accuracy anchors the evaluation. Minor self-citation and a metric/claim inconsistency do not make the argument circular.

full rationale

The paper's derivation chain is not circular. The diffusion model is trained on a set of seen tasks (Eq. 9) and evaluated on held-out unseen tasks using test-set image accuracy (Table 1), which is an external benchmark not used in training. The text-conditioning vector v_c is constructed from CLIP embeddings (Algorithm 1) and the target W_head is trained with the same CLIP embeddings, but this is the intended paired-data setup rather than a self-fulfilling prediction. The only self-citation is Section 5's statement that the work extends Li et al. [13]; this is a related-work acknowledgement, and the reported gains over the Universal Model and initialization baselines are independently measured. Two non-circular concerns are flagged: (1) Section 1's claim that TinyImageNet unseen accuracy is 'over 80%' is contradicted by Table 1 (T2W-NL 71.51%, T2W-CLIP 70.42%), so the headline quantitative claim lacks support; (2) the 'Weight Similarity (Loss)' metric in Section 4.2 is the same MSE objective as the diffusion training loss, so on seen tasks low values are by construction and should not be treated as independent evidence. Neither concern makes the central generalization result circular, because the accuracy numbers on held-out test sets are independent. Overall circularity: low. Score 2.

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

The method relies on a trained diffusion model with many learned parameters, plus hand-chosen hyperparameters lambda_1 and lambda_2 (the latter unreported). The core modeling assumption is that a single pooled text vector preserves the task information needed to generate a good head. No new physical or conceptual entities are introduced.

free parameters (2)

lambda_1 = 0.1
Permutation symmetry loss weight, chosen by hand in Section 4.1.
lambda_2 = not specified
Adversarial loss weight defined in Section 3.5 but its value is never reported in the training setup.

assumptions (5)

standard math The diffusion forward process adds Gaussian noise with a predefined schedule and the reverse process learns to denoise.
Standard DDPM formulation in Section 3.2.
domain assumption The pooled text vector v_c from cosine-weighted averaging is a sufficient condition for the task-specific optimal head.
The whole pipeline feeds only v_c to the diffusion model; no per-class embeddings are provided. Section 4.1, Algorithm 1.
domain assumption CLIP text embeddings are sufficiently aligned with ResNet-18 image features after training the low-rank adapter so that dot-product logits yield meaningful classification.
Section 4.1 assumes the classification head operating in CLIP space is valid.
ad hoc to paper The denoising network applied to an under-trained model in the weight enhancement experiment can project the model onto the manifold of well-trained weights.
Weight enhancement (Section 4.6) applies T2W denoising to early-stopped models, which are outside the training distribution of noisy weights; no analysis is provided.
standard math The model has sufficient capacity to approximate permutation equivariance and the explicit symmetry loss improves sample quality.
Assumption 2 in Appendix A.2.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Text2Weight: Bridging Natural Language and Neural Network Weight Spaces." pith.science (2026). https://pith.science/paper/XQDFIAFC

@misc{pith2026250813633,
  author       = {Pith},
  title        = {Pith review of: Text2Weight: Bridging Natural Language and Neural Network Weight Spaces},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XQDFIAFC}},
  note         = {Machine review of arXiv:2508.13633}
}

read the original abstract

How far are we really from automatically generating neural networks? While neural network weight generation shows promise, current approaches struggle with generalization to unseen tasks and practical application exploration. To address this, we propose T2W, a diffusion transformer framework that generates task-specific weights conditioned on natural language descriptions. T2W hierarchically processes network parameters into uniform blocks, integrates text embeddings from CLIP via a prior attention mechanism, and employs adversarial training with weight-space augmentation to enhance generalization. Experiments on Cifar100, Caltech256, and TinyImageNet demonstrate T2W's ability to produce high-quality weights for unseen tasks, outperforming optimization-based initialization and enabling novel applications such as weight enhancement and text-guided model fusion. Our work bridges textual semantics with weight-space dynamics, supported by an open-source dataset of text-weight pairs, advancing the practicality of generative models in neural network parameter synthesis. Our code is available on Github.

Figures

Figures reproduced from arXiv: 2508.13633 by the authors.

**Figure 2.** An overview of the T2W framework [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

**Figure 3.** We have taken samples from the Unseen Task of each dataset for the visualization of denoising. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: We visualize a gradCAM plot of the generated model weights on the data for the target task during the denoising [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

**Figure 5.** Figure 5: Shape of the loss basin when training the model with different initialization methods. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

**Figure 6.** Figure 6: Experimental results of weight enhancement using T2W. [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

39 extracted references · 5 canonical work pages

[1]

Samuel K Ainsworth, Jonathan Hayase, and Siddhartha Srinivasa. 2022. Git re-basin: Merging models modulo permutation symmetries. arXiv preprint arXiv:2209.04836 (2022)

arXiv 2022
[2]

Zalán Borsos, Raphaël Marinier, Damien Vincent, Eugene Kharitonov, Olivier Pietquin, Matt Sharifi, Dominik Roblek, Olivier Teboul, David Grangier, Marco Tagliasacchi, et al . 2023. Audiolm: a language modeling approach to audio generation. IEEE/ACM transactions on audio, speech, and language processing 31 (2023), 2523–2533

2023
[3]

Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics . JMLR Workshop and Conference Proceedings, 249–256

2010
[4]

Yifan Gong, Zheng Zhan, Yanyu Li, Yerlan Idelbayev, Andrey Zharkov, Kfir Aberman, Sergey Tulyakov, Yanzhi Wang, and Jian Ren. 2024. Efficient Training with Denoised Neural Weights. In European Conference on Computer Vision . Springer, 18–34

2024
[5]

Gregory Griffin, Alex Holub, and Pietro Perona. 2007. Caltech-256 object category dataset. (2007)

2007
[6]

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2015. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision . 1026–1034

2015
[7]

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition . 770–778

2016
[8]

Gabriel Ilharco, Marco Tulio Ribeiro, Mitchell Wortsman, Suchin Gururangan, Ludwig Schmidt, Hannaneh Hajishirzi, and Ali Farhadi. 2022. Editing models with task arithmetic. arXiv preprint arXiv:2212.04089 (2022)

arXiv 2022

Show all 39 references

[9]

Xiaolong Jin, Kai Wang, Dongwen Tang, Wangbo Zhao, Yukun Zhou, Junshu Tang, and Yang You. 2024. Conditional lora parameter generation. arXiv preprint arXiv:2408.01415 (2024)

2024 arXiv
[10]

Felix Kreuk, Gabriel Synnaeve, Adam Polyak, Uriel Singer, Alexandre Défossez, Jade Copet, Devi Parikh, Yaniv Taigman, and Yossi Adi. 2022. Audiogen: Textually guided audio generation. arXiv preprint arXiv:2209.15352 (2022)

2022 arXiv
[11]

Alex Krizhevsky, Geoffrey Hinton, et al. 2009. Learning multiple layers of features from tiny images.(2009)

2009
[12]

Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. 2018. Visualizing the loss landscape of neural nets. Advances in neural information processing systems 31 (2018)

2018
[13]

Zexi Li, Lingzhi Gao, and Chao Wu. 2024. Text-to-model: Text-conditioned neural network diffusion for train-once-for-all personalization. arXiv preprint arXiv:2405.14132 (2024)

2024 arXiv
[14]

Derek Lim, Haggai Maron, Marc T Law, Jonathan Lorraine, and James Lucas
[15]

mnmoustafa and Mohammed Ali. 2017. Tiny ImageNet. https://kaggle.com/ competitions/tiny-imagenet. Kaggle

2017
[16]

Elvis Nava, Seijin Kobayashi, Yifei Yin, Robert K Katzschmann, and Benjamin F Grewe. 2022. Meta-learning via classifier (-free) diffusion guidance.arXiv preprint arXiv:2210.08942 (2022)

2022 arXiv
[17]

Aviv Navon, Aviv Shamsian, Idan Achituve, Ethan Fetaya, Gal Chechik, and Haggai Maron. 2023. Equivariant architectures for learning in deep weight spaces. In International Conference on Machine Learning . PMLR, 25790–25816

2023
[18]

William Peebles, Ilija Radosavovic, Tim Brooks, Alexei A Efros, and Jitendra Malik
[19]

William Peebles and Saining Xie. 2023. Scalable diffusion models with transform- ers. In Proceedings of the IEEE/CVF international conference on computer vision . 4195–4205

2023
[20]

Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. 2021. Learning transferable visual models from natural language supervision. In International conference on machine learni...

2021
[21]

Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. 2022. High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition . 10684–10695

2022
[22]

Konstantin Schürholt, Boris Knyazev, Xavier Giró-i Nieto, and Damian Borth
[23]

Konstantin Schürholt, Dimche Kostadinov, and Damian Borth. 2021. Self- supervised representation learning on neural network weights for model charac- teristic prediction. Advances in Neural Information Processing Systems 34 (2021), 16481–16493

2021
[24]

Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedan- tam, Devi Parikh, and Dhruv Batra. 2017. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE interna- tional conference on computer vision . 618–626

2017
[25]

Advances in Neural Information Processing Systems 35 (2022), 27906–27920

Hyper-representations as generative models: Sampling unseen neural network weights. Advances in Neural Information Processing Systems 35 (2022), 27906–27920

2022
[26]

Bowen Tian, Songning Lai, Lujundong Li, Zhihao Shuai, Runwei Guan, Tian Wu, and Yutao Yue. 2025. Pepl: Precision-enhanced pseudo-labeling for fine- grained image classification in semi-supervised learning. In ICASSP 2025-2025 IEEE International Conference on Acoustics, Speech ...

2025
[27]

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. Advances in neural information processing systems 30 (2017)

2017
[28]

Bedionita Soro, Bruno Andreis, Hayeon Lee, Wonyong Jeong, Song Chong, Frank Hutter, and Sung Ju Hwang. 2024. Diffusion-based neural network weights generation. arXiv preprint arXiv:2402.18153 (2024)

2024 arXiv
[29]

Yihang Wang, Bowen Tian, Yueyang Su, Yixing Fan, and Jiafeng Guo. 2025. MDPO: Customized Direct Preference Optimization with a Metric-based Sampler for Question and Answer Generation. In Proceedings of the 31st International Conference on Computational Linguistics . 10660–10671

2025
[30]

Yujia Wu, Yiming Shi, Jiwei Wei, Chengwei Sun, Yang Yang, and Heng Tao Shen. 2024. Difflora: Generating personalized low-rank adaptation weights with diffusion. arXiv preprint arXiv:2408.06740 (2024)

2024 arXiv
[31]

Athanasios Voulodimos, Nikolaos Doulamis, Anastasios Doulamis, and Efty- chios Protopapadakis. 2018. Deep learning for computer vision: A brief review. Computational intelligence and neuroscience 2018, 1 (2018), 7068349

2018
[32]

otter",

Allan Zhou, Kaien Yang, Kaylee Burns, Adriano Cardace, Yiding Jiang, Samuel Sokota, J Zico Kolter, and Chelsea Finn. 2023. Permutation equivariant neural functionals. Advances in neural information processing systems 36 (2023), 24966– 24992. MM ’25, October 27–31, 2025, Dublin...

2023
[34]

Mixue Xie, Shuang Li, Binhui Xie, Chi Liu, Jian Liang, Zixun Sun, Ke Feng, and Chengwei Zhu. 2024. Weight Diffusion for Future: Learn to Generalize in Non- Stationary Environments. Advances in Neural Information Processing Systems 37 (2024), 6367–6392

2024
[36]

Layer Selection: Focus on the second residual block’s final convolutional layer (ResNet’s layer2[-1].conv2) to capture mid-level features
[37]

Gradient Preservation: Enable gradients only for target layer through context management: 𝜕𝑦𝑐 𝜕𝐹(𝑙) 𝑘 (𝑖,𝑗) = TemporaryGradEnable(ℓtarget) | {z } selective gradient flow (32)
[38]

Denormalization: Recover original RGB values using dataset statistics: 𝑥denorm =𝑥⊗𝜎⊕𝜇, 𝜎 =  0.229 0.224 0.225  ,𝜇 =  0.485 0.456 0.406  (33)
[39]

Class Targeting: Compute gradients relative to ground-truth class throughClassifierOutputTarget wrapper
[2022]

arXiv preprint arXiv:2209.12892 (2022)

Learning to learn with generative models of neural network checkpoints. arXiv preprint arXiv:2209.12892 (2022)

2022 arXiv
[2023]

arXiv preprint arXiv:2312.04501 (2023)

Graph metanetworks for processing diverse neural architectures. arXiv preprint arXiv:2312.04501 (2023)

2023 arXiv

Pith tools

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

[1] [1]

Samuel K Ainsworth, Jonathan Hayase, and Siddhartha Srinivasa. 2022. Git re-basin: Merging models modulo permutation symmetries. arXiv preprint arXiv:2209.04836 (2022)

arXiv 2022

[2] [2]

Zalán Borsos, Raphaël Marinier, Damien Vincent, Eugene Kharitonov, Olivier Pietquin, Matt Sharifi, Dominik Roblek, Olivier Teboul, David Grangier, Marco Tagliasacchi, et al . 2023. Audiolm: a language modeling approach to audio generation. IEEE/ACM transactions on audio, speech, and language processing 31 (2023), 2523–2533

2023

[3] [3]

Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics . JMLR Workshop and Conference Proceedings, 249–256

2010

[4] [4]

Yifan Gong, Zheng Zhan, Yanyu Li, Yerlan Idelbayev, Andrey Zharkov, Kfir Aberman, Sergey Tulyakov, Yanzhi Wang, and Jian Ren. 2024. Efficient Training with Denoised Neural Weights. In European Conference on Computer Vision . Springer, 18–34

2024

[5] [5]

Gregory Griffin, Alex Holub, and Pietro Perona. 2007. Caltech-256 object category dataset. (2007)

2007

[6] [6]

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2015. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision . 1026–1034

2015

[7] [7]

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition . 770–778

2016

[8] [8]

Gabriel Ilharco, Marco Tulio Ribeiro, Mitchell Wortsman, Suchin Gururangan, Ludwig Schmidt, Hannaneh Hajishirzi, and Ali Farhadi. 2022. Editing models with task arithmetic. arXiv preprint arXiv:2212.04089 (2022)

arXiv 2022