Cos'è LingBot-Vision?

LingBot-Vision è una famiglia di Vision Transformer self-supervised progettata per apprendere rappresentazioni spaziali dense.

Il teacher genera boundary, li valida e li usa per forzare il masking: In pratica, il modello è costretto a ricostruire proprio le parti più strutturate dell'immagine.

Parzialmente. I pesi sono pubblici, ma dataset e pipeline completa no.

Deep Learning

LingBot-Vision: imparare la geometria delle immagini dai boundary

LingBot-Vision trasforma i boundary in target self-supervised. Competitivo con Dinov3-7B.

14 luglio 2026

Summary

In Vision Pretraining for Dense Spatial Perception (arXiv:2607.05247) viene presentato LingBot-Vision, una famiglia di Vision Transformer self-supervised progettata per produrre dense visual features sensibili non soltanto alla semantica, ma anche alla struttura spaziale delle immagini.

La tecnica principale, chiamata masked boundary modeling, modifica il classico paradigma DINO/iBOT: il teacher scopre online i boundary dell'immagine, identifica i patch token attraversati da tali strutture e li forza nel masked set dello student.

Nascondere un boundary, però, non è sufficiente. LingBot-Vision aggiunge un secondo target geometrico basato su categorical boundary fields. Lo student deve quindi ricostruire sia la semantic representation del teacher sia la geometria sub-token del boundary nascosto.

Il risultato più interessante del paper non è un nuovo edge detector. I boundary diventano un pretraining signal per il backbone stesso.

Il ViT-g/16 da circa 1,1 miliardi di parametri raggiunge un RMSE di 0,296 su NYU-Depth v2 con un linear probe sui frozen features, contro 0,309 del DINOv3 da 7B parametri. La famiglia viene inoltre distillata in modelli ViT-L, ViT-B e ViT-S.

Code: https://github.com/robbyant/lingbot-vision
Paper: https://arxiv.org/abs/2607.05247
Dataset: /
HuggingFace: https://huggingface.co/collections/robbyant/lingbot-vision
Project page: https://technology.robbyant.com/lingbot-vision

Research questions and answers

È possibile imparare una rappresentazione visuale sensibile alla geometria senza boundary annotations, depth maps o external edge detectors? Sì. LingBot-Vision usa un EMA teacher per generare online un dense boundary field. Corner anchors, vote aggregation e a-contrario validation trasformano predizioni inizialmente rumorose in segmenti geometrici sufficientemente affidabili da diventare pseudo-target per lo student.
Aggiungere geometric supervision compromette la semantic representation imparata da DINO e iBOT? Non necessariamente. Nel proof of concept su ImageNet-1K, la configurazione completa migliora sia la k-NN accuracy sia il linear depth probing rispetto al baseline DINO+iBOT. A grande scala rimane comunque un trade-off: LingBot-Vision domina soprattutto sui dense task, mentre DINOv3 resta superiore nella pure image-level classification.
Il beneficio deriva dal nascondere i boundary oppure dal target usato per ricostruirli? Principalmente dal target geometrico. L'ablation più importante del paper mostra che boundary forcing con il solo semantic target ottiene risultati leggermente peggiori del baseline. Il vero active ingredient è la categorical boundary supervision; la scelta del mask determina dove affrontare la struttura, mentre il target geometrico determina cosa imparare.

Paper North Stars

Novelty - 9/10

La novità non consiste nell'inventare DINO, attraction fields, line segment detection o a-contrario theory. Tutti questi ingredienti hanno una storia precedente.

Il contributo originale è il modo in cui vengono collegati.

La computer vision classica tratta solitamente edge e boundary come output di un modello. Si addestra un backbone e, in seguito, una task-specific head prova a recuperare contour, segmentation masks o line segments.

LingBot-Vision inverte questa relazione: il boundary diventa un input al processo di apprendimento.

Il teacher decide autonomamente quali regioni contengono struttura geometrica. Queste regioni vengono nascoste allo student e trasformate nei problemi di ricostruzione più importanti.

Trovo particolarmente originale la categorical reparameterization del boundary field. Una quantità geometrica continua viene trasformata in una distribuzione su bins, rendendola compatibile con centering e sharpening tipici della self-distillation.

Anche il collegamento con la a-contrario theory è elegante: una distribuzione uniforme sulle orientation bins rappresenta direttamente l'ipotesi nulla di assenza di struttura.

Il paper non propone quindi un singolo nuovo layer.

Propone una diversa risposta alla domanda: quale informazione dovrebbe essere intenzionalmente difficile da ricostruire durante visual SSL?

Clarity - 8,5/10

Il paper ha una buona progressione narrativa.

Parte dal limite del random masking, introduce boundary forcing e mostra immediatamente una tensione: per mascherare i boundary bisogna prima sapere dove sono, ma il modello parte da random initialization.

La sezione sul bootstrapping affronta direttamente questo chicken-and-egg problem.

Le ablation sono particolarmente chiare. Il confronto tra categorical geometric target, dual supervision e "boundary forcing + semantic target only" consente di capire quale parte del metodo stia realmente funzionando.

La parte meno immediata riguarda il boundary field.

Per capire fino in fondo distance channel, orientation e endpoint angles è utile conoscere i lavori sugli attraction fields e sulla wireframe parsing. Il paper spiega l'intuizione, ma un lettore senza questo background probabilmente deve rallentare nella sezione 3.3.

Anche le systems optimizations sono distribuite tra metodo e implementation details. Sono importanti per capire la scalabilità, ma rendono la lettura leggermente più densa.

Reproducibility - 5/10

Pro: paper pubblico, inference code pubblico e weights pubblici.

Sono disponibili quattro backbone:

Modello	Backbone	Parametri
LingBot-Vision-Giant	ViT-g/16	1,1B
LingBot-Vision-Large	ViT-L/16	300M
LingBot-Vision-Base	ViT-B/16	86M
LingBot-Vision-Small	ViT-S/16	21M

Il repository permette di caricare i checkpoint, estrarre patch tokens e visualizzare le features con PCA.

Contro: il repository pubblico non contiene la training pipeline completa descritta nel paper.

I checkpoint sono esplicitamente backbone-only. Non includono optimizer state, DINO/iBOT projection heads o training-time boundary heads.

Non è inoltre pubblicata l'intera implementazione CUDA della online boundary target generation, inclusi corner-line pairing, vote aggregation, NFA validation e clean field re-rendering.

Il dataset di pretraining da 160,75M immagini non è pubblico.

La riproducibilità dei benchmark downstream usando i weights è quindi buona. La riproduzione end-to-end del pretraining flagship non lo è.

Affordability - 1/10 per il pretraining, 8/10 per usare i weights

Il flagship usa un ViT-g/16 da circa 1,1B parametri.

Il training principale è organizzato in tre fasi:

300.000 iterations di self-distillation pretraining
100.000 iterations di Gram anchoring
100.000 iterations di high-resolution adaptation

Il global batch size dichiarato è 3.072.

Moltiplicando iterations e global batch size, il programma principale corrisponde a circa 1,536 miliardi di sample slots elaborati:

500.000 \times 3.072 = 1.536.000.000

Questo significa semplicemente che il modello ha visto oltre un miliardo e mezzo di esempi (contando anche le ripetizioni), non che esistano così tante immagini uniche.

Gli autori confrontano questo budget con DINOv3, che usa 1M+100k+30k iterations con batch size 4.096. Sulla base dei schedule dichiarati, LingBot-Vision processa circa un terzo dei training samples.

Numero di GPU: non dichiarato Tipo di GPU: non dichiarato Training hours: non dichiarati

Estimated budget: non stimabile in modo credibile dai dati del paper.

Private datasets: sì. Il punto di partenza è un pool in-house di circa 2 miliardi di web images.

Per un independent researcher, riprodurre esattamente LingBot-Vision-Giant è quindi fuori portata.

Usare LingBot-Vision-Small, Base o Large come frozen backbone è invece molto più accessibile.

Techniques

Il punto di partenza: DINO e iBOT self-distillation

LingBot-Vision parte dalla teacher-student self-distillation.

Abbiamo uno student con parametri $\theta_s$ e un teacher con parametri $\theta_t$ .

Il teacher è aggiornato tramite EMA:

\theta_t \leftarrow m\theta_t + (1-m)\theta_s

Questa formula significa che i pesi del teacher non vengono aggiornati direttamente con il gradiente, ma sono una media pesata tra i vecchi pesi del teacher e quelli aggiornati dello student. Il parametro $m$ controlla quanto il teacher cambia lentamente nel tempo.

DINO usa distribuzioni:

p_t = \operatorname{softmax}\left(\frac{z_t-c}{\tau_t}\right)

Questa espressione indica che il teacher trasforma i suoi output $z_t$ in una distribuzione di probabilità, centrando i valori con $c$ e controllando la "sharpness" con la temperatura $\tau_t$ .

p_s = \operatorname{softmax}\left(\frac{z_s}{\tau_s}\right)

Allo stesso modo, lo student produce una distribuzione dai suoi output $z_s$ , ma con una temperatura diversa $\tau_s$ .

Loss:

\mathcal{L}_{DINO} = -\sum_k p_t^{(k)}\log p_s^{(k)}

Questa è una cross-entropy: lo student viene penalizzato quando la sua distribuzione è diversa da quella del teacher. In pratica, deve imitare il teacher.

iBOT estende ai patch:

\mathcal{L}*{iBOT} = \sum*{i\in M} H(p_t^{(i)}, p_s^{(i)})

Qui la stessa idea viene applicata ai singoli patch dell'immagine: per ogni patch mascherato, lo student deve ricostruire la distribuzione del teacher.

Boundary-forcing masking

Il set boundary:

B = { i : \operatorname{MaxPool}(E)_i > 0 }

Questa formula definisce quali patch contengono boundary: se almeno un pixel del patch appartiene a un bordo (dopo pooling), allora quel patch viene incluso in $B$ .

Masked set:

M^+ = M_{\text{rand}} \cup B

Il set finale dei patch mascherati è l'unione tra quelli scelti casualmente e quelli che contengono boundary. In questo modo i boundary vengono sempre nascosti allo student.

Geometry routing

i \in M^+ \Rightarrow \mathcal{L}_{iBOT}

Tutti i patch mascherati ricevono la loss standard iBOT.

i \in B \Rightarrow \mathcal{L}*{iBOT} + \mathcal{L}*{boundary}

Se il patch contiene un boundary, allora riceve anche una seconda loss geometrica. Questo significa che quei patch sono supervisionati più fortemente.

Boundary field

Segmenti:

\mathcal{S} = {s_1, s_2, \dots, s_n}

L'immagine viene rappresentata come un insieme di segmenti, cioè linee che descrivono i boundary.

Feature:

f(p) = (d, \theta, \alpha_1, \alpha_2)

Ogni pixel vicino a un boundary ha una rappresentazione geometrica: distanza dal segmento, direzione, e informazioni sugli endpoint.

Aggregazione:

\hat{s} = \operatorname{Aggregate}(\hat{s}*1, \dots, \hat{s}*{100})

Molti pixel propongono versioni rumorose dello stesso segmento; queste vengono aggregate per ottenere una stima più stabile.

Edge map

e(p) \in {0,1}

Una edge map classica assegna a ogni pixel un valore binario: 1 se è bordo, 0 altrimenti.

Bootstrapping

\theta_s \sim \text{random initialization}

All'inizio lo student è completamente casuale, quindi anche il teacher lo è. Il sistema deve quindi imparare gradualmente da segnali inizialmente rumorosi.

Categorical reparameterization

Bins:

c_1, c_2, \dots, c_K

Le quantità continue vengono discretizzate in $K$ intervalli (bins).

Distribuzione:

q_k(y) = \frac{\exp\left(-\frac{D(c_k,y)}{\tau_l}\right)}{\sum_j \exp\left(-\frac{D(c_j,y)}{\tau_l}\right)}

Questa formula costruisce una distribuzione morbida: invece di assegnare un solo bin, assegna probabilità più alte ai bin vicini al valore reale $y$ .

Distanza circolare:

D_{\text{arc}}(a,b) = \min(|a-b|, P-|a-b|)

Per angoli, la distanza tiene conto della periodicità: 0° e 360° sono vicini, non lontani.

Loss:

\mathcal{L}*{boundary} = -\sum*{p\in\Omega_B}\sum_c\sum_k q_{p,c,k}\log p^s_{p,c,k}

Questa è una cross-entropy tra la distribuzione target e quella predetta dallo student per ogni pixel e ogni canale geometrico.

Uniform distribution

p(\theta_k) = \frac{1}{K}

Una distribuzione uniforme significa che non c'è una direzione preferita: quindi non c'è un boundary significativo.

A-contrario

"A-contrario" è un approccio statistico usato per verificare se una struttura osservata (come un bordo o una linea in un'immagine) è significativa oppure potrebbe essere comparsa per puro caso.

L'idea di base è formulare un'ipotesi nulla (cioè "non c'è alcuna struttura reale, solo rumore") e poi calcolare quanto è improbabile osservare quella struttura sotto questa ipotesi. Se la probabilità è molto bassa, la struttura viene considerata significativa.

In pratica, invece di chiedersi "quanto è forte questo segnale?", l'approccio a-contrario chiede: "quanto sarebbe sorprendente vedere questo risultato se non ci fosse nulla di reale?".

P(X \ge k) = \sum_{j=k}^{n} {n \choose j} p^j (1-p)^{n-j}

Questa formula calcola la probabilità di osservare almeno $k$ pixel allineati per caso, assumendo che non ci sia struttura reale.

\operatorname{NFA} = N_{\text{tests}} \cdot P(X \ge k)

Il Number of False Alarms stima quante volte ci aspettiamo di vedere un evento simile per puro caso.

\operatorname{NFA} < 1

Se questo valore è minore di 1, il segmento è considerato significativo e non casuale.

Target pipeline

F_{\text{target}} = \operatorname{Render}(\operatorname{Validate}(\operatorname{Decode}(F_{\text{teacher}})))

Il campo finale usato come target viene ottenuto decodificando il teacher, filtrando i segmenti validi e poi ricostruendo una rappresentazione pulita.

Full objective

\mathcal{L} = \lambda_D \mathcal{L}*{DINO} + \lambda_I \mathcal{L}*{iBOT} + \lambda_B \mathcal{L}*{boundary} + \lambda_K \mathcal{L}*{KoLeo}

La loss totale è una combinazione pesata di quattro componenti: semantica globale (DINO), ricostruzione dei patch (iBOT), geometria dei boundary e regolarizzazione (KoLeo).

Dataset

Corpus finale:

160{,}75\text{M images}

Questo indica che il modello è stato addestrato su circa 160 milioni di immagini, curate da un pool molto più grande.