SenseNova-Vision: il modello multimodale che unifica la computer vision

Summary

In Vision as Unified Multimodal Generation (arXiv:2607.06560) viene presentato SenseNova-Vision-7B-MoT, un unified multimodal model che riformula detection, OCR, keypoint detection, segmentation, depth estimation, surface normals e multi-view geometry come text, image o mixed text-image generation.

Partendo da Bagel-7B-MoT, SenseNova-Vision viene fine-tuned su un corpus multimodale costruito a partire da public datasets. Il modello non introduce task-specific prediction heads: sono instruction, serialization protocol e decoding convention a definire quale computer vision task eseguire.

I risultati mostrano un generalist competitivo con diversi specialist models, ma non un sostituto universalmente superiore. Il gap resta visibile soprattutto in segmentation e multi-view geometry, dove architecture e inductive bias specializzati conservano vantaggi misurabili.

• Code: GitHub - OpenSenseNova/SenseNova-Vision
• Paper: Vision as Unified Multimodal Generation
• Hugging Face: SenseNova-Vision-7B-MoT
• Dataset: SenseNova-Vision-Corpus-50M
• Benchmark: SenseNova-Vision-Benchmark
• Collection: SenseNova-Vision Collection
• Base model: BAGEL-7B-MoT

Research questions and answers

• È possibile unificare computer vision tasks molto diversi senza costruire un prediction head per ogni task? Sì, almeno per le quattro famiglie studiate: structured visual understanding, segmentation, dense geometry e multi-view geometry. SenseNova-Vision associa ogni task a uno dei native output spaces del modello: text per structured records, image per dense spatial maps e mixed text-image per output composizionali. Un decoder deterministico converte poi la generazione nel formato opportuno.

• Un unified multimodal model può competere con specialist models addestrati per un singolo visual task? In diversi casi sì, ma il paper non dimostra una superiorità universale. SenseNova-Vision raggiunge 56.6 F1@mIoU su COCO-Common, lo stesso risultato riportato per Grounding DINO-Swin-T, e ottiene risultati competitivi nella monocular geometry. In segmentation e multi-view reconstruction, specialist models come X-SAM, DepthAnything3 e VGGT mantengono vantaggi su vari benchmark.

• L'unified training permette di comporre capacità visuali in task non esplicitamente definiti nel training protocol? Il paper presenta evidenza qualitativa interessante. Il modello combina coordinate testuali e mask generation, segmenta istanze dello stesso tipo partendo da un visual reference e usa conoscenza OCR per generare text segmentation masks. Sono però qualitative probes, dichiaratamente imperfette: mancano benchmark quantitativi sufficienti per parlare di robust zero-shot task programmability.

Paper North Stars

Novelty - 8.5/10

La parte più interessante del paper non è il backbone. SenseNova-Vision parte esplicitamente da Bagel-7B-MoT e ne conserva la decoder-only multimodal architecture, il Mixture-of-Transformers e il visual generation path basato su VAE latent e rectified flow.

La novelty è nel modo in cui viene definito il problema.

Approcci precedenti hanno già unificato visual tasks come sequences, aggiunto MLLM a segmentation systems o generato dense maps come images. Il paper cita esplicitamente famiglie come Pix2Seq, Unified-IO, SAM, SegGPT, DICEPTION, Vision Banana e LISA.

SenseNova-Vision prova invece a usare contemporaneamente i native generative spaces di un UMM.

Un bounding box è text. Una depth map è image. Una semantic segmentation con region legend è text più image.

Il risultato è un'interfaccia molto più generale: invece di costringere tutto in una lunga sequenza di token, il modello può scegliere il formato più naturale per ogni compito (testo per strutture simboliche, immagini per mappe dense), rendendo più intuitivo e flessibile il modo in cui rappresenta le informazioni.

Il vero contributo, secondo me, è quindi il task representation protocol applicato su larga scala. Non un nuovo transformer block.

Il corpus da 50 milioni di esempi rende inoltre l'idea qualcosa di più di una architectural demo.

Pro: l'unificazione tra symbolic e dense prediction è pulita e sorprendentemente naturale.

Contro: molte componenti fondamentali - Bagel, MoT, rectified flow, normalized coordinate serialization e image-based dense prediction - esistevano già. La novelty nasce dalla loro composizione e dalla scala del data engineering.

Clarity - 8/10

Il paper è lungo 48 pagine, ben 22 figure. La struttura, però, è generalmente molto leggibile.

La divisione in structured visual understanding, dense geometry, segmentation e multi-view geometry aiuta a capire subito dove ogni task viene proiettato nell'output space.

Le appendici sono particolarmente utili.

Gli autori mostrano JSON schemas, special markers, pose serialization e conversion rules. Dettagli come la normalizzazione delle coordinate o il significato dei camera pose tokens sono documentati esplicitamente.

Il lato negativo è che alcune informazioni operative importanti restano vaghe.

Non vengono dichiarati il numero di training GPUs, il GPU model, le training hours o i GPU-hours totali. Anche la composizione esatta degli auxiliary VQA, text-to-image e image-to-image data usati per capability preservation non viene completamente enumerata.

C'è inoltre una discrepanza da segnalare.

Il testo principale del paper indica 83.3 come MMVP score di BAGEL, mentre la Hugging Face model card riporta 69.3 per la stessa baseline. SenseNova-Vision è indicato a 79.0 in entrambi i casi.

Non cambia il contributo tecnico del lavoro, ma è una differenza che gli autori dovrebbero chiarire.

Reproducibility - 7/10

Sul lato inference ed evaluation, la release è forte.

Sono pubblici model weights, inference code, evaluation scripts, training code, il benchmark e SenseNova-Vision-Corpus-50M. Il repository contiene direttamente componenti per FSDP training, unified pretraining, data loading e l'architecture derivata da BAGEL.

Il released corpus contiene circa 50 milioni di examples e occupa 8.74 TB sulla Hugging Face repository. Gli autori dichiarano 73 dataset-task entries distribuite su dieci task types.

C'è però una differenza importante tra reproducing inference e reproducing the training run.

Le original RGB images provenienti dai public source datasets non vengono duplicate nel corpus. Le JSONL annotations usano relative paths: bisogna scaricare e organizzare localmente i source datasets secondo la directory structure attesa.

Inoltre, il training hardware originale non è documentato.

La mia valutazione è quindi 8.5/10 per inference ed evaluation, ma circa 5.5/10 per una faithful training reproduction.

Affordability - 3.5/10 per il full training

Gli autori dichiarano 50.000 optimization steps, 500 warm-up steps, packing tra 32K e 36K tokens per rank e un maximum context di 32K per sample.

Il VAE visual encoder viene frozen, mentre gli altri modules e connectors vengono aggiornati. L'optimizer è AdamW con learning rate $2.5\times10^{-5}$, senza weight decay; viene mantenuta una EMA con decay 0.995.

Numero di training GPUs dichiarato: non specificato.

GPU model dichiarato: non specificato.

Training hours dichiarate: non specificate.

GPU-hours dichiarati: non specificati.

Training budget dichiarato: non specificato.

Per inference, il repository raccomanda 1x GPU da 80 GB per la full web demo. Per eseguire il complete benchmark viene raccomandata almeno una macchina con 8x GPU da 80 GB.

Mia stima del training cost

Questa è una stima editoriale, non un numero dichiarato dagli autori.

SenseNova-Vision parte da BAGEL-7B-MoT, un modello con circa 7B active parameters e 14B total parameters. Il MoT duplica gli expert parameters, pur evitando di eseguire entrambi gli experts su ogni token.

Considerando full-parameter SFT, 50K steps, high-resolution visual inputs fino a 980 pixel e multi-view samples fino a dieci views, ritengo plausibile un cluster nell'ordine di 64-128 A100/H100-class GPUs da 80 GB.

Con 4-10 giorni di training, l'ordine di grandezza sarebbe circa 6.000-31.000 GPU-hours.

A un cloud-equivalent cost molto variabile di 2.5-5 euro per GPU-hour, il compute-only budget potrebbe trovarsi grossolanamente nell'intervallo 20.000-150.000 euro.

La forbice è volutamente ampia. Senza throughput, cluster size e wall-clock time originali, una stima più precisa sarebbe falsa precision.

Non risultano dichiarati private raw datasets per il SenseNova-Vision Corpus: gli autori parlano di public images e rilasciano source lists e conversion rules. Vengono però usati data engines e pseudo-labeling pipelines per costruire parte dei targets.

Per un independent researcher, la reproduction fedele del training è poco affordable.

Riprodurre inference, task decoding o un fine-tuning ridotto su un subset è molto più realistico, ma non equivale a ripetere l'esperimento del paper.

Techniques

Computer vision come unified multimodal generation

La tesi del paper può essere descritta con una funzione molto semplice:

$$f_\theta(V, P, I) \rightarrow Y$$

dove:

• $V$ rappresenta uno o più visual inputs;
• $P$ rappresenta eventuali visual prompts;
• $I$ è la natural-language instruction;
• $Y$ è il generated response.

La differenza rispetto a un classico multi-task vision model è che $Y$ non deve appartenere a un singolo output space.

Possiamo scrivere:

$$Y \in \mathcal{T} \cup \mathcal{I} \cup (\mathcal{T}, \mathcal{I})$$

dove $\mathcal{T}$ è il text generation space e $\mathcal{I}$ l'image generation space.

Il task stabilisce quale spazio usare.

Uno pseudocode concettuale sarebbe:

def select_output_space(task: str) -> str:
    if task in {
        "detection",
        "ocr",
        "keypoints",
        "camera_pose",
    }:
        return "text"

    if task in {
        "depth",
        "surface_normals",
        "point_map",
        "binary_segmentation",
    }:
        return "image"

    if task in {
        "panoptic_segmentation",
        "generic_segmentation",
        "grounded_caption_segmentation",
    }:
        return "text+image"

    raise ValueError(f"Unknown task: {task}")

Questo non è il source code di SenseNova-Vision. È una rappresentazione semplificata della taxonomy descritta nel paper.

L'instruction comunica task intent, output schema e decoding convention.

Il modello non riceve quindi semplicemente "detect objects".

Il prompt stabilisce anche come la risposta dovrà essere interpretata.

È un dettaglio fondamentale: SenseNova-Vision non elimina il task protocol. Sposta il protocollo dall'architecture all'interfaccia generativa.

Structured visual understanding come text generation

Detection, referring, pointing, keypoints, OCR, document layout e GUI grounding vengono trasformati in text generation problems.

Le class labels e le OCR transcripts rimangono ordinary text.

Le spatial coordinates vengono normalizzate rispetto alla dimensione dell'immagine:

$$\hat{x} = \frac{x}{W}$$$$\hat{y} = \frac{y}{H}$$

con $W$ e $H$ rispettivamente image width e image height.

Le coordinate vengono rounded a tre decimal digits e clipped ai boundaries dell'immagine.

Per esempio, un bounding box:

$$(x_1,y_1,x_2,y_2)$$

diventa:

$$(\hat{x}_1,\hat{y}_1,\hat{x}_2,\hat{y}_2)$$

Uno serializer semplificato potrebbe essere:

def normalize_xy(x: float, y: float, width: int, height: int):
    nx = min(max(x / width, 0.0), 1.0)
    ny = min(max(y / height, 0.0), 1.0)

    return round(nx, 3), round(ny, 3)

def serialize_bbox(
    label: str,
    bbox: tuple[float, float, float, float],
    width: int,
    height: int,
) -> str:
    x1, y1, x2, y2 = bbox

    p1 = normalize_xy(x1, y1, width, height)
    p2 = normalize_xy(x2, y2, width, height)

    return (
        f"{label}"
        f"<bbox>"
        f"[{p1[0]}, {p1[1]}, {p2[0]}, {p2[1]}]"
        f"</bbox>"
    )

SenseNova-Vision utilizza reserved markers tra cui <p>, <bbox>, <point>, <kpt>, <ins> e <polygon> per rendere questi records decodificabili.

Il vantaggio è evidente.

Un LLM-like decoder sa già produrre sequences. Non serve aggiungere un DETR-style classification head più box regression head.

Il problema è che la detection diventa autoregressive serialization.

In una crowded image, il modello deve produrre correttamente una lunga sequenza di labels e coordinates. Il paper osserva infatti che dense detection è tra i tasks con convergenza più lenta.

Depth e surface normals come image generation

Una depth map è una dense prediction.

Serializzare ogni pixel come text sarebbe estremamente inefficiente e distruggerebbe la naturale struttura bidimensionale del target.

SenseNova-Vision usa quindi image generation.

Per depth estimation, i metric depth values validi vengono convertiti in inverse depth e normalizzati in una grayscale/RGB-compatible representation. Il training protocol considera una depth range tra 0.1 e 80 metri.

Concettualmente:

$$d^{-1}(u,v)=\frac{1}{\max(d(u,v),\epsilon)}$$

L'inverse depth può poi essere normalizzata:

$$g(u,v)=\frac{d^{-1}(u,v)-d^{-1}*{min}}{d^{-1}*{max}-d^{-1}_{min}}$$

con:

$$g(u,v)\in[0,1]$$

Una versione PyTorch semplificata:

import torch

def encode_inverse_depth(
    depth: torch.Tensor,
    min_depth: float = 0.1,
    max_depth: float = 80.0,
) -> torch.Tensor:
    valid = (depth >= min_depth) & (depth <= max_depth)

    safe_depth = depth.clamp(min=min_depth, max=max_depth)
    inverse = 1.0 / safe_depth

    inv_min = 1.0 / max_depth
    inv_max = 1.0 / min_depth

    encoded = (inverse - inv_min) / (inv_max - inv_min)
    encoded = encoded.clamp(0.0, 1.0)

    return torch.where(valid, encoded, torch.zeros_like(encoded))

È pseudocode pedagogico: per una reproduction esatta vanno usate le conversion utilities rilasciate dagli autori.

Per le surface normals, la situazione è ancora più naturale.

Una normal:

$$\mathbf{n}=(n_x,n_y,n_z)$$

ha tre components, generalmente comprese tra $[-1,1]$.

I tre values possono essere mappati sui canali RGB:

$$RGB = \frac{\mathbf{n}+1}{2}$$

Una conversione minimale:

def encode_normals(normals: torch.Tensor) -> torch.Tensor:
    # normals: [..., 3], values expected in [-1, 1]
    rgb = (normals + 1.0) / 2.0
    return rgb.clamp(0.0, 1.0)

Il paper codifica esplicitamente $(X,Y,Z)$ nelle RGB channels per le surface normals.

Qui emerge uno dei migliori inductive bias dell'approccio.

Depth maps e normal maps sono pixel-aligned con l'input image. La visual generation pathway del base model possiede già una forte familiarità con spatially aligned image transformations.

Gli autori osservano infatti che depth e surface normal estimation sono tra i task che convergono più velocemente.

Per densificare parte della geometry supervision, SenseNova-Vision utilizza pseudo labels prodotte attraverso MoGe-2 e applica validity filtering.

MoGe-2 è un monocular geometry model per metric-scale 3D point map prediction. Nel corpus SenseNova viene usato come uno dei data engines, non come inference module del modello finale.

Segmentation come binary mask o color-coded image

Per segmentation, SenseNova-Vision usa due protocolli principali.

Nel single-target setting, l'output è una binary mask image.

Questo include referring segmentation, reasoning segmentation e interactive segmentation.

Il target può essere concettualmente rappresentato come:

$$M(u,v)= \begin{cases} 1 & \text{foreground}\ 0 & \text{background} \end{cases}$$

Il modello genera direttamente l'immagine della mask.

Per interactive segmentation, il visual input può includere point, bounding box, scribble o mask prompts. Il protocollo usa markers come <point>, <box>, <mask> e <scribble>.

Il problema diventa più interessante nella generic semantic o panoptic segmentation.

Una color-coded mask da sola è ambigua.

Il colore rosso significa "car"? "person"? "road"?

SenseNova-Vision usa quindi un mixed text-image output.

La text response costruisce una legend:

road [R1, G1, B1] car [R2, G2, B2]

person [R3, G3, B3]

L'image response contiene la corrispondente color-coded segmentation mask.

Text e image svolgono due ruoli diversi.

Il text output definisce la semantic mapping tra classi e colori.

L'image output conserva la struttura spaziale densa della scena.

Questo schema evita una perdita di informazione: il modello non deve comprimere sia la semantica sia la geometria in un unico formato.

È probabilmente uno degli esempi più chiari di cosa significhi davvero unified multimodal generation nel contesto della computer vision.

Per evitare ambiguità tra colori simili, il protocollo costruisce una palette di colori ben separati nello spazio RGB.

Gli autori utilizzano una procedura di farthest-point sampling per selezionare colori il più possibile distanti tra loro.

Dato un insieme di colori già selezionati $S$, il prossimo colore viene scelto come:

$$c_k = \arg\max_{c \in \mathcal{C}} \min_{s \in S} |c - s|_2$$

In altre parole: ogni nuovo colore è quello più lontano dal colore già presente più vicino.

Uno pseudocode semplificato:

import torch

def farthest_color_palette(candidates: torch.Tensor, num_colors: int):
    selected = [candidates[0]]

    while len(selected) < num_colors:
        palette = torch.stack(selected)
        distances = torch.cdist(candidates.float(), palette.float())
        nearest = distances.min(dim=1).values
        next_idx = nearest.argmax()
        selected.append(candidates[next_idx])

    return torch.stack(selected)

Non è una nuova loss function, ma in SenseNova-Vision, il modo in cui rappresenti il target è parte integrante del metodo.

Point maps come images per la multi-view geometry

La multi-view geometry segue una logica simile.

Il modello riceve un insieme ordinato di immagini e un'istruzione che specifica il riferimento e il tipo di output richiesto.

Per ogni vista, SenseNova-Vision può generare una point map:

$$P_i(u,v) = (X, Y, Z)$$

Le coordinate 3D vengono codificate nei tre canali RGB:

• R → X
• G → Y
• B → Z

Le point maps sono allineate alla prima vista, che funge da reference frame.

Gli autori applicano anche normalizzazione e gestione degli invalid pixels, mappandoli verso regioni lontane (una sorta di sky box).

Durante il training vengono campionate fino a dieci viste per scena, per contenere il costo computazionale.

Ancora una volta, il modello non ha un head dedicato alla ricostruzione 3D: Genera immagini.

Ma il significato dei pixel cambia completamente in base al protocollo.

Camera pose come sequenza testuale quantizzata

La camera pose viene trattata come structured text.

Ogni frame contiene:

• rotazione (quaternion)
• direzione di traslazione
• scala della traslazione

Il formato è simile a:

I valori numerici vengono quantizzati e mappati su token discreti.

Il vocabolario include circa 2000 token numerici che rappresentano valori tra -1000 e 1000.

Una quantità reale $a \in [-1,1]$ viene trasformata in:

$$Q(a) = \text{round}(1000 \cdot a)$$

Questo permette al modello di generare pose come sequenze testuali, mantenendo una struttura facilmente parsabile.

È una scelta pragmatica: breve sequenza simbolica invece di una rappresentazione densa.

Mixture-of-Transformers: separare understanding e generation

SenseNova-Vision eredita da BAGEL il design Mixture-of-Transformers (MoT).

Due transformer experts distinti gestiscono modalità diverse:

• understanding expert → testo e visual tokens (ViT)
• generation expert → VAE tokens per image generation

Uno schema semplificato:

def route_token(token):
    if token.modality == "vae":
        return generation_expert(token)
    else:
        return understanding_expert(token)

Gli experts condividono il contesto, ma non i parametri.

Questo riduce la competizione tra obiettivi diversi: comprendere immagini e generare immagini non devono usare esattamente lo stesso spazio parametrico.

È una scelta importante per un modello che deve sia leggere che produrre contenuti multimodali complessi.

Training: text cross-entropy + rectified flow

Il training combina due obiettivi principali.

Per il testo:

$$\mathcal{L}*{text} = -\sum*{t} \log p_\theta(y_t | y_{<t}, x)$$

Per le immagini, viene utilizzato rectified flow nel latent space del VAE.

Una formulazione semplificata:

$$z_t = (1 - t) z_0 + t \epsilon$$

Il modello apprende la velocità:

$$v^* = \epsilon - z_0$$

con loss:

$$\mathcal{L}*{RF} = \mathbb{E}[|v*\theta(z_t, t, c) - (\epsilon - z_0)|^2]$$

Il training loop combina entrambe:

for batch in data:
    outputs = model(batch)

    loss = 0.0

    if batch.has_text:
        loss += cross_entropy(outputs.text, batch.text_targets)

    if batch.has_images:
        loss += rectified_flow(outputs.image, batch.image_targets)

    loss.backward()
    optimizer.step()

È una semplificazione, ma rende l'idea: un unico modello, due modalità di apprendimento.

Capability preservation

Un rischio evidente è il catastrophic forgetting.

Fine-tunare su task di percezione potrebbe degradare capacità generali come VQA o image generation.

Per evitarlo, SenseNova-Vision mescola:

• dati di computer vision
• VQA
• text-to-image
• image-to-image

Il dataset finale è quindi una combinazione:

$$D = D_{vision} \cup D_{VQA} \cup D_{T2I} \cup D_{I2I}$$

Questo aiuta a mantenere capacità generali, ma non elimina completamente il problema.

Alcuni benchmark mostrano infatti piccoli cali rispetto al modello base BAGEL.

SenseNova-Vision Q&A

Cos'è SenseNova-Vision-7B-MoT?

SenseNova-Vision sostituisce i modelli specialistici?

Qual è il principale contributo del paper?

È possibile eseguire SenseNova-Vision in locale?

Il modello è open source?