Implicit Neural Representation Facilitates Unified Universal Vision Encoding

Conference: ECCV 2026
Paper: ECCV 2026
Area: Self-Supervised Learning
Keywords: implicit neural representation, INR hyper-network, unified vision encoding, knowledge distillation, representation compression

TL;DR

The paper trains an image implicit neural representation (INR) hyper-network into a unified vision encoder, HUVR: a single ViT backbone emits standard tokens, compressed tokens (TinToks, up to 96x smaller), and per-patch INR modulation quantities, and is pretrained self-supervised with pixel reconstruction plus teacher distillation, making one representation usable simultaneously for classification, semantic segmentation, depth estimation, and image reconstruction.

Background & Motivation

Vision encoders today evolve along two largely disconnected tracks. The recognition track — image-level contrastive learning (CLIP, SigLIP 2), image-only self-distillation (DINO/DINOv2/DINOv3), and masked image modeling — produces embeddings that are strong for retrieval, classification, and semantic segmentation, but these models assume no responsibility for pixels themselves and cannot directly support generation. The generative track — variational autoencoders such as the Stable Diffusion VAE, trained with pixel reconstruction, perceptual, and adversarial losses — yields a latent space compatible with diffusion and autoregressive generation, yet its semantics are weak and it trails the former badly on classification and segmentation. Prior work mostly stitches the two tracks post-hoc: turning text-free diffusion models into discriminative encoders, or using a recognition model to guide a generative one (e.g., REPA). These results show a real synergy exists between the two pretraining families, but stitching is not native unification.

A natively unified encoder should carry high-level (classification), mid-level (segmentation), low-level (depth), and pixel-level (reconstruction) information out of the box. The difficulty is that the two objectives pull the latent in opposite directions: recognition wants to discard pixel detail irrelevant to the class in exchange for invariance, while reconstruction wants to retain that detail faithfully. There is also a second, easily overlooked sense of "unified" — tasks differ in the compute budget available to solve them, and retrieval-style tasks become dramatically harder as data scales, so shrinking the embedding brings massive savings. A genuinely unified model must therefore unify not only across tasks but also across token dimensions.

This paper's angle is that image INR hyper-networks are a natural candidate: they take an image and predict neural network weights, and those weights are themselves a pixel-level representation. Unlike convolutional VAEs, they are Transformer-based and can borrow patchification, patch size, and latent dimension directly from a ViT. The authors further observe that an INR hyper-network compresses along two axes for free — first by converting a specific image to latents, and second by learning one shared "base" INR that represents all possible images. Core idea: refactor the output side of the INR hyper-network into per-patch weight prediction (image tokens double as weight tokens, and a global token forms an outer product with patch tokens to yield the modulation matrices), insert a learnable down/up-sampling layer at the back end to obtain TinToks, and distill from a pretrained vision encoder to supply the high-level semantics an INR lacks natively — so that a single self-supervised pretraining supports recognition and generation at once.

Method

Overall Architecture

HUVR takes an image (pretraining resolution 256x256) and follows a standard ViT recipe up to the encoder: patchify, prepend a learnable global token, and feed it into a ViT encoder with RoPE. The divergence comes after the encoder, whose output splits three ways. The first is the standard tokens (d=768 for ViT-B, d=1024 for ViT-L), used directly for classification, semantic segmentation, depth estimation, and other recognition tasks. The second is the compressed tokens, TinToks: tokens are first projected by a linear layer down to a small dimension \(d_t\) (8/16/32 in the paper, up to 96x smaller than standard tokens), passed through a Transformer decoder, then linearly upsampled, serving the same recognition tasks and acting as the compressed representation. The third path exists only for reconstruction: every patch token is projected to the input dimension \(d_\text{in}\) of the base INR weights, the global token is projected to the output dimension \(d_\text{out}\), and their outer product gives a per-layer modulation matrix that multiplies elementwise onto the corresponding layer weights of the shared base INR. The modulated INR belongs to one specific patch: it takes pixel coordinates \((x,y)\) inside that patch and returns RGB values, and concatenating all patch predictions by spatial position reconstructs the full image. Training signals come in two kinds: the pixel difference between the reconstruction and the input, and distillation losses aligning the encoder and decoder outputs to the features of a pretrained vision encoder such as DINOv3 — the latter being what actually endows both the standard tokens and the TinToks with recognition semantics.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["input image"] --> B["ViT encoder<br/>patchify + global token"]
    B --> C["Patch-wise INR hyper-network<br/>image tokens double as weight tokens"]
    C --> D["Global-token outer-product modulation<br/>outer product gives per-layer matrices"]
    D --> E["TinToks compressed representation<br/>down-project → decoder → up-project"]
    E --> G["standard / compressed tokens<br/>classification · segmentation · depth"]
    E --> H["per-patch INR<br/>coords → RGB → reassemble image"]
    B -.-> F["distillation injects semantics<br/>L2 alignment to teacher features"]
    E -.-> F

Key Designs

1. Patch-wise INR hyper-network: image tokens double as weight tokens

A conventional INR hyper-network takes a set of learnable weight tokens as input and emits corresponding weight tokens, which an FC layer plus a repeat operation turns into modulation matrices; the output image tokens are simply discarded — they neither contribute to the loss nor serve inference. This has two consequences. First, the number of weight tokens must divide \(d_\text{in}\) or \(d_\text{out}\) of the base weights, which severely constrains the hyper-network and INR configurations. Second, the image information is crammed almost entirely into the weight tokens, which bear no clear correspondence to spatial locations in the input, so dense tasks such as semantic segmentation — which require knowing which token governs which region — are out of reach, while half the compute is wasted.

The paper changes the unit of prediction from one INR per image to one INR per patch: the encoder's patch tokens themselves serve as weight tokens, each predicting the small INR for its own patch, and each reconstruction covers only its own patch before the pieces are concatenated into the full image. Output tokens are no longer redundant, and a one-to-one token-to-patch correspondence appears, which is what makes dense tasks possible at all. The price is memory, since every patch instantiates an INR for the forward pass. The ablation in Table 8 shows this is by far the largest single contributor in the paper: on ImageNette, going from "modulate the second layer only" to patch-wise lifts PSNR from 27.15 to 51.96 and SSIM from 0.8000 to 0.9974.

2. Outer-product modulation from the global token: one token acting as both cls token and modulation source

Even after going patch-wise, a dimensional mismatch remains: output tokens have dimension \(d_\text{ViT}\) while the base weights \(W_i\) live in \(d_\text{in} \times d_\text{out}\). The naive fix used by prior work is to force \(d_\text{ViT} = d_\text{in}\) and copy the same token \(d_\text{out}\) times to form the modulation matrix, which empirically proves suboptimal; at the same time, the original INR hyper-network formulation has no class token at all, leaving recognition without a global summary.

A single learnable global token \(g\) solves both problems at once. The global token and each patch token \(p\) are linearly projected to \(\mathbb{R}^{d_\text{out}}\) and \(\mathbb{R}^{d_\text{in}}\) respectively, their outer product gives the per-layer modulation matrix, and that matrix modulates the base weights elementwise:

\[M_i = g_\text{proj}\, p_\text{proj}^{\top} \in \mathbb{R}^{d_\text{in} \times d_\text{out}}, \qquad \tilde{\omega} = \{W_i \odot M_i\}_{i=1}^{n}\]

The modulation matrix is therefore not a copied rank-one constant vector but something jointly determined by global semantics and the local patch, and the architecture now contains a cls token and patch tokens with nothing wasted. In Table 8, adding the global token raises ImageNette PSNR further from 51.96 to 53.36 with SSIM reaching 0.9985 — introduced for classification, it unexpectedly improves reconstruction too. The distillation study in Table 10 confirms the same token from the other side: distilling only into the global token is the most favorable setting for classification.

3. TinToks: learnable down- and up-sampling between the backbone and the INR prediction layers

Compute-constrained applications need representations far smaller than standard tokens, yet the standard ViT token dimension is tied to the base INR's \(d_\text{in}\)/\(d_\text{out}\) and cannot be set freely. Fitting a PCA transform on DINOv3 features is a workable alternative, but that transform is not trained for reconstruction or downstream tasks.

HUVR instead inserts an intermediate representation, the TinToks, between the Transformer backbone and the layers that produce the final INR prediction: a linear layer projects tokens from \(d_\text{ViT}\) down to \(d_t\), a Transformer decoder processes them (four layers by default; the experiments show the decoder materially helps reconstruction), another linear layer projects them back up, and final projections map them to \(d_\text{in}\) for patch tokens and \(d_\text{out}\) for the global token. The paper stresses that this involves compression along two axes — the image is first compressed into latents, and all images then share one base INR — and argues this is precisely why the latents preserve low-, mid-, and high-level information beyond the pixel level. Empirically the TinToks beat PCA and learnable autoencoder baselines on recognition and reconstruction simultaneously (ViT-B, 32 dims: ImageNet 76.7 vs 64.1/67.3, PSNR 27.83 vs 17.68), and the advantage grows with the compression ratio — at 8 dims, ImageNet accuracy is 57.1 against 16.1 for DINOv3 PCA.

4. Distillation injects semantics: supplying high-level semantics to a purely reconstructive objective

An INR hyper-network is trained only on pixel reconstruction; the latents it learns restore pixels well but are poor for classification and segmentation, and its token design makes patch-level information hard to recover in the first place. The paper therefore distills from a pretrained vision encoder (DINOv3 in most experiments): for the outputs of the student's last encoder block and last decoder block, a separate linear transformation is learned to align with the teacher features, and within each block the loss is further split by token type (global versus patch), yielding four L2 components each weighted by \(\lambda_{t,o}\):

\[\mathcal{L}_{\text{distill}} = \sum_{t \in \{g,\,p\}} \sum_{o \in \{\text{enc},\,\text{dec}\}} \lambda_{t,o} \left\| \phi_{t,o}(F_{t,o}) - F_{t,\text{teacher}} \right\|_2\]

Notably, the compressed tokens are never distilled directly: the authors find that once the encoder and decoder are distilled properly, the TinToks inherit semantics for free, which works better than aligning the compressed vectors themselves. Table 10 shows clear preferences in the choice of distillation target — distilling only the global token favors classification (82.9 at 768 dims, 71.3 at 32 dims), distilling only patch tokens favors segmentation (ADE20K mIoU 45.23), and distilling both gives the best overall classification (83.2) but noticeably degrades reconstruction (PSNR 25.33 against 28.42 with no distillation); the authors keep the both-token setting anyway and compensate with longer training and a larger teacher.

Loss & Training

The reconstruction term is the pixel mean-squared error between the input image and the concatenated per-patch predictions, optionally augmented with SSIM and LPIPS to improve visual quality; the semantic term is the four-component distillation loss above.

Pretraining uses a mix of DataComp (image-only) and ImageNet22k (without labels), with at least 10% of samples drawn from ImageNet22k following DINOv3, for the equivalent of 50 epochs on ImageNet22k; random resized cropping is the only augmentation. The backbone is a modern ViT with RoPE, focused on ViT-B/16 and ViT-L/16, with batch size and learning rate scaled linearly according to available resources. For teachers, a ViT-B student distills from a ViT-L teacher and a ViT-L student from a ViT-H teacher. Dense evaluation has a second training stage: since ADE20K segmentation is evaluated at 512x512 and NYUv2 depth at 480x480, after 256x256 pretraining the model is trained for three more epochs on a mix of 256x256 and 512x512 images from ImageNet22k only (again following DINOv3).

Key Experimental Results

Main Results

Evaluation spans four task families: recognition (ImageNet-1k with original and ReaL labels, ObjectNet, five fine-grained FGVC datasets, all linear probing with no fine-tuning), dense prediction (linear probes for ADE20K semantic segmentation and NYUv2 depth), reconstruction (PSNR/SSIM/LPIPS on the 50,000 ImageNet-1k validation images, never seen during training), and generation (class-conditional DiT-XL following the DiT protocol, reporting FID/IS/Precision/Recall).

The unified capability of the compressed tokens is the paper's central claim. The table below is the ViT-B, 32-dim setting, where the PCA and AE/L2B baselines are respectively a transform fitted on the ImageNet-1k training set and learnable autoencoders; the reconstruction baseline trains a decoder of roughly the same parameter count on frozen DINOv3 PCA features (AE and L2B do not report reconstruction):

Method (ViT-B, 32 dims)	ImageNet	ReaL	ObjectNet	PSNR	SSIM
DINOv3 + PCA	64.1	70.3	35.7	17.68	0.5398
DINOv3 + AE	53.8	59.9	32.7	-	-
DINOv3 + L2B	67.3	74.1	41.3	-	-
HUVR (ours)	76.7	83.2	49.4	27.83	0.7845

The standard tokens are competitive as well: at ViT-B/16 (d=768) the model reaches 85.0 on ImageNet against 84.6 for DINOv3.

Encoder (ViT-B/16, d=768)	ImageNet	ReaL	ObjectNet	Cars	CUB	DTD	Flowers	Food
C-RADIOv3	82.4	87.6	54.5	88.6	79.8	83.5	99.1	91.5
SigLIP 2	84.5	89.0	68.4	92.8	82.6	83.7	99.3	94.2
DINOv3	84.6	88.9	59.4	93.4	89.7	83.9	99.7	93.7
HUVR (ours)	85.0	89.2	62.0	93.1	89.4	84.3	99.7	94.3

On dense prediction the standard tokens edge out DINOv3 on ADE20K segmentation (ViT-B 52.0 vs 50.8 mIoU), while the 32-dim TinToks lead by a much wider margin (37.6 vs 29.7):

Setting	Method	ADE20K mIoU	mAcc	NYUv2 RMSE (lower is better)
ViT-B, d=768	DINOv3	50.8	62.6	0.3305
ViT-B, d=768	HUVR (ours)	52.0	63.4	0.3263
ViT-B, d=32	DINOv3 (PCA)	29.7	38.6	0.7056
ViT-B, d=32	HUVR (ours)	37.6	48.4	0.5440
ViT-L, d=1024	DINOv3	54.2	66.2	0.3235
ViT-L, d=1024	HUVR (ours)	53.5	65.2	0.3287
ViT-L, d=32	DINOv3 (PCA)	29.4	39.2	0.6685
ViT-L, d=32	HUVR (ours)	30.9	41.1	0.5726

As an INR hyper-network in its own right, HUVR also sets the reconstruction state of the art among comparable methods (PSNR, with training epochs in parentheses; the three dataset columns correspond to the ImageNette / LSUN / CelebA protocols):

Method	ImageNette	LSUN	CelebA
TransINR	29.01 (4000)	24.21 (12.67)	31.96 (300)
IPC	38.46 (4000)	-	35.93 (300)
LA-IPC	46.10 (4000)	-	50.74 (300)
ANR	-	28.30 (12.67)	-
HUVR (ours)	48.44 (400)	34.00 (12)	56.91 (100)

The generation side is reported far more honestly: training a class-conditional DiT-XL on HUVR's compressed latents still trails training on SD VAE latents (FID 24.72 / 24.53 vs 23.05); the authors call the result merely promising and note that raising the TinTok dimension from 16 to 256 helps generation.

Autoencoder Latent	FID (lower is better)	sFID (lower is better)	IS (higher is better)	Precision (higher is better)	Recall (higher is better)
SD VAE (32x32x4)	23.05	68.65	70.34	0.4318	0.4775
HUVR (16x16x16)	24.72	76.09	60.17	0.3850	0.4645
HUVR (16x256x256)	24.53	68.37	66.13	0.4307	0.4367

Ablation Study

Cumulative ablation of the hyper-network design (ImageNette; each row keeps all changes from the rows above, and the last row is the full method):

Config	PSNR (higher is better)	SSIM (higher is better)	LPIPS (lower is better)
TransINR + RoPE	23.78	0.7041	0.3866
+ modulate second layer only	27.15	0.8000	0.2424
+ patch-wise	51.96	0.9974	0.0026
+ global token	53.36	0.9985	0.0007
+ compression	48.58	0.9962	0.0019
+ decoder (full)	48.44	0.9954	0.0014

Ablation on the distillation target tokens (DINOv3 ViT-B teacher, only 5 ImageNet22k epochs; ⚠️ this table is interleaved with a neighbouring table in the PDF extraction, so the "both" row is aligned from context — refer to the original paper):

Distillation target	ImageNet d=768	ImageNet d=32	ADE20K mIoU	PSNR	SSIM
none	11.4	1.9	4.18	28.42	0.7973
global token only	82.9	71.3	39.29	26.42	0.7468
patch tokens only	81.9	65.5	45.23	26.95	0.7580
both (ours)	83.2	69.3	43.68	25.33	0.7133

Decoder design choices (again 5 ImageNet22k epochs):

Config	ImageNet d=768	ImageNet d=32	ADE20K mIoU	PSNR	SSIM
default	83.1	69.7	43.85	25.35	0.7135
tiny dim=768	83.1	69.1	44.00	25.65	0.7243
INR hidden 256→512	82.3	70.8	23.36 ⚠️	25.30	0.7119
INR layers 4→3	83.1	69.6	43.36	25.08	0.7015
INR layers 4→5	83.1	70.2	44.44	25.48	0.7188
decoder 4 layers→1	83.1	69.6	43.65	24.78	0.6962
decoder without attention	83.1	73.5	43.83	24.90	0.6943

The choice of distillation blocks (12 encoder blocks, 4 decoder blocks) is also a trade-off: (12, 1) gives the best standard-token classification and reconstruction (83.2 / PSNR 26.18), (11, 4) gives the best TinTok classification (72.6), and the paper settles on the middle ground (12, 4).

Key Findings

• Patch-wise prediction is the dominant contributor. On its own it lifts ImageNette PSNR from 27.15 to 51.96 in Table 8, with every other design adding marginal gains on top; the authors state plainly that the price is memory for the forward computation.
• Compression and the decoder are not required for reconstruction, but they are required for TinToks and for well-behaved distillation. Adding them slightly lowers reconstruction (PSNR 53.36 → 48.58 → 48.44), showing that unification has a cost that longer training must offset.
• Recognition and reconstruction can improve together, but not in step. Both improve with training time, with reconstruction saturating earlier (Figure 3). Teacher size exhibits a crossover: a larger teacher is initially worse and only wins after enough training, and while TinToks and reconstruction benefit from a large teacher almost immediately, standard-token classification needs roughly 40 ImageNet22k epochs and segmentation roughly 10-20 epochs to justify it (the paper states 10 epochs for segmentation while the first mIoU crossover in the table occurs at 20; ⚠️ refer to the original paper).
• Without distillation there is essentially no semantics. With no token distilled, 768-dim classification collapses to 11.4 and mIoU to 4.18, yet reconstruction is the best (PSNR 28.42). This directly shows that the native INR hyper-network objective contains no recognition semantics and that distillation is the only source of them.
• TinToks and standard tokens are complementary rather than a simple degradation. Figure 4 shows 8-dim TinToks can be more accurate than standard tokens on individual classes, while the t-SNE view exposes a looser feature structure with more easily confused classes.
• The positioning should be read honestly: at ViT-L scale recognition still slightly trails DINOv3 (86.9 vs 87.1), and generation FID does not beat the SD VAE — the authors themselves describe the generative results as promising rather than state of the art.

Highlights & Insights

• Treating the reconstruction objective as a carrier of semantics rather than its enemy. Pixel reconstruction is usually assumed to drag latents toward low-level detail and hurt semantics; this paper combines reconstruction with distillation so one latent serves both, with distillation supplying high-level semantics and reconstruction supplying pixel fidelity, and TinToks extending that coexistence to very small dimensions.
• Making output tokens double as weight tokens solves three problems at once. The change removes the redundant half of the tokens, relaxes the divisibility constraint between the number of weight tokens and \(d_\text{in}\)/\(d_\text{out}\), and establishes a token-to-patch spatial correspondence that makes dense tasks possible for the first time — a single design point with three payoffs, the paper's clearest "aha" moment.
• Outer-product modulation is more expressive than copied modulation. Taking the outer product of global semantics and a local patch yields a matrix carrying both "which kind of object" and "which part of the image," more flexible than repeating one token \(d_\text{out}\) times; and the global token, introduced for classification, also adds 1.4 PSNR to reconstruction.
• Compressed representations inherit semantics for free. The authors find they need not distill into the compressed tokens directly: once the encoder and decoder are distilled, the small intermediate tokens acquire semantics at no extra cost, which makes the compression branch nearly engineering-free to add.
• Transferable ideas: any "encoder plus reconstruction head" structure — say a multimodal encoder that must serve retrieval and reconstruction, or neural representations for video and 3D — can adopt the combination of patch-wise weight prediction, global-token outer-product modulation, and teacher distillation, especially when the target representation must be both small and semantically strong.

Limitations & Future Work

• The authors' admitted limitations are direct: pretraining does not operate at the scale or scope of prior image representation methods; generation is not end-to-end, and the model is currently positioned as a replacement for the VAE while not beating the SD VAE even in that slot; and applying it to VLMs would require text-aligned pretraining.
• The experimental scope is narrower than the word "universal" suggests: everything is images, with no video, 3D, or audio, so "universal" refers mainly to tasks (classification/segmentation/depth/reconstruction/generation) and token dimensions rather than modalities. All recognition evaluations are linear probes, leaving fine-tuning unverified.
• The ablations are statistically thin: the distillation studies (Tables 10, 11, 12, 13) train for only 5 ImageNet22k epochs, far short of the final models, and the authors themselves note that "ViT-L looking worse" is really a consequence of limited training time; such short runs should not be extrapolated to full training.
• In Table 13, the "INR hidden 256→512" row shows mIoU collapsing to 23.36, an order of magnitude below the other rows in the same column, which the paper does not explain and which should be read with caution (⚠️ refer to the original paper).
• Improvement directions: distilling from a mixture of teachers (the authors believe this is probably optimal but consider it out of scope); plugging TinToks into existing generative pipelines together with the "frozen pretrained encoder plus representation autoencoder" idea from concurrent work, which could close the generation gap; and extending to video and multiple modalities to earn the "universal" label.

Related Work & Insights

• vs DINOv3 / the DINO family: they are recognition specialists trained by self-distillation plus masked modeling, their representations contain no pixel-level information and cannot reconstruct; HUVR surpasses them at ViT-B scale for classification (85.0 vs 84.6) and leads slightly on dense tasks, still trailing at ViT-L scale, but additionally offers reconstruction and compression.
• vs unified representation methods (BigBiGAN / MAGE / Sorcen): these also span recognition and generation but cover narrower capability sets — BigBiGAN is generation + recognition only (ImageNet 56.6), MAGE 74.7/11.11, Sorcen 75.1/9.61 — whereas HUVR reaches 85.0 and is the only one offering dense prediction and extreme compression (TinToks) together.
• vs REPA: REPA trains a generative model with guidance from a recognition model, i.e., generation borrowing recognition features; this paper reverses the direction and trains a reconstruction model with guidance from a recognition model, and because the student is itself an encoder, recognition improves rather than degrades (ViT-B beats DINOv3), whereas the generative model REPA produces still has a clear recognition gap.
• vs prior INR hyper-networks (TransINR / IPC / LA-IPC / ANR): they predict a single INR per image, their output tokens are redundant and spatially ungrounded, and they can only reconstruct and compress; HUVR goes patch-wise, adds distillation, leads on reconstruction (ImageNette 48.44 vs LA-IPC 46.10, with 400 epochs instead of 4000) and, for the first time, lets this model family perform classification and segmentation.
• vs Latent-INR: it also pursues semantics-bearing INRs, but fits a per-video hyper-network and aligns a learnable latent to CLIP embeddings; HUVR learns a general hyper-network that handles inputs unseen during training.

Rating

• Novelty: ⭐⭐⭐⭐⭐ First to train an INR hyper-network as a general-purpose vision encoder; patch-wise weight prediction with global-token outer-product modulation is genuinely original and incidentally yields a usable 96x-compressed representation.
• Experimental Thoroughness: ⭐⭐⭐⭐ Covers five task families (classification/segmentation/depth/reconstruction/generation) across backbones and dimensions with a broad ablation grid, but the distillation ablations run only 5 epochs and pretraining scale lags contemporary representation learning methods.
• Writing Quality: ⭐⭐⭐⭐ Motivation and design rationale are clearly laid out, though a few headline numbers disagree slightly with the tables (e.g., +8.2 mIoU, +1.26 PSNR) and some tables need the original PDF because of column misalignment in extraction.
• Value: ⭐⭐⭐⭐ Offers a new route to unified vision encoding that passes through neither a VAE nor contrastive learning, and the compressed tokens and hyper-network design transfer to any setting needing small yet semantically strong representations; the generative side still needs follow-up work.

Related Papers

• [ICLR 2026] Adversarial Encoding Perturbation and Synthesis for Set Representation Auxiliary Learning
• [ECCV 2026] Vision-TTT: Efficient and Expressive Visual Representation Learning with Test-Time Training
• [NeurIPS 2025] Implicit Modeling for Transferability Estimation of Vision Foundation Models
• [CVPR 2026] Weight Space Representation Learning via Neural Field Adaptation
• [ICML 2026] How 'Neural' is a Neural Foundation Model?