Modele viziune–limbaj — tiparul ViT-MLP-LLM

Un encoder vizual transformă o imagine în tokenuri. Un proiector MLP mapează acele tokenuri în spațiul de reprezentare vectorială al LLM-ului. Un model de limbaj face restul. Acest tipar — ViT-MLP-LLM — este fiecare VLM de producție din 2026.

Tip: Învățați + utilizați Limbaje: Python Cerințe prealabile: Faza 4 Lecția 14 (ViT), Faza 4 Lecția 18 (CLIP), Faza 7 Lecția 02 (Auto-atenție) Timp: ~75 de minute

Obiective de învățare

• Enunțați arhitectura ViT-MLP-LLM și explicați contribuția fiecăreia dintre cele trei componente
• Comparați Qwen3-VL, InternVL3.5, LLaVA-Next și GLM-4.6V după numărul de parametri, lungimea contextului și performanța pe benchmarkuri
• Explicați DeepStack: de ce caracteristicile ViT de la mai multe niveluri strâng alinierea viziune–limbaj mai bine decât o singură caracteristică din ultimul strat
• Măsurați halucinația VLM în producție cu Cross-Modal Error Rate (CMER) și acționați după semnal

Problema

CLIP (Faza 4 Lecția 18) oferă un spațiu de reprezentare vectorială comun pentru imagini și text, suficient pentru clasificare zero-shot și regăsire. Nu poate răspunde la întrebarea „câte mașini roșii sunt în această imagine?”, deoarece CLIP nu generează text — doar evaluează similarități.

Modelele viziune–limbaj (vision-language models, VLM) — Qwen3-VL, InternVL3.5, LLaVA-Next, GLM-4.6V — atașează un encoder de imagine din familia CLIP la un model de limbaj complet. Modelul vede o imagine plus o întrebare și generează un răspuns. În 2026, VLM-urile open-source rivalizează sau depășesc GPT-5 și Gemini-2.5-Pro pe benchmarkuri multimodale (MMMU, MMBench, DocVQA, ChartQA, MathVista, OSWorld).

Triada de componente (ViT, proiector, LLM) este standardul. Diferențele dintre modele țin de ViT-ul ales, proiector, LLM, datele de antrenare și rețeta de aliniere. Odată ce înțelegeți tiparul, înlocuirea oricărei componente este mecanică.

Notă tehnică a traducerii: ViT–MLP–LLM este un tipar didactic util, nu arhitectura fiecărui VLM de producție: punțile pot fi MLP-uri, resamplere, cross-attention, Q-former sau integrare multimodală nativă, iar encoderele și integrarea tokenurilor diferă. Afirmațiile despre VLM-uri open-source față de GPT-5 sau Gemini-2.5-Pro sunt dependente de versiune, benchmark, prompt, protocol și dată; comparați numai rezultate publicate în condiții comparabile.

Conceptul

Arhitectura ViT-MLP-LLM

1. Encoder vizual — un ViT preantrenat (CLIP-L/14, SigLIP, DINOv3 sau o variantă ajustată fin). Produce tokenuri de patch-uri.
2. Proiector — un modul mic (MLP cu 2–4 straturi sau un Q-former) care mapează tokenurile vizuale în dimensiunea reprezentărilor vectoriale ale LLM-ului. Aici are loc cea mai mare parte a ajustării fine.
3. LLM — un model de limbaj doar-decoder (Qwen3, Llama, Mistral, GLM, InternLM). Citește tokenurile vizuale + textuale în secvență și generează text.

Toate cele trei componente pot fi, în principiu, antrenate. În practică, encoderul vizual și LLM-ul rămân în mare parte înghețate, în timp ce proiectorul se antrenează — câteva miliarde de parametri de semnal, ieftin.

Notă tehnică a traducerii: Un Q-former nu este pur și simplu un MLP cu 2–4 straturi: în BLIP-2 folosește tokenuri de interogare învățabile și mecanisme de atenție pentru a extrage un număr fix de reprezentări vizuale. De asemenea, ce module se îngheață sau se ajustează fin este o alegere de antrenare, nu o regulă universală; multe rețete actualizează selectiv encoderul, LLM-ul și/sau adaptorii.

DeepStack

Proiecția clasică folosește numai ultimul strat ViT. DeepStack (Qwen3-VL) eșantionează caracteristici de la mai multe adâncimi ViT și le suprapune. Straturile mai adânci poartă semantică de nivel înalt; straturile mai puțin adânci poartă informație spațială și texturală cu granulație fină. Alimentarea LLM-ului cu ambele reduce decalajul dintre „ce conține imaginea” (semantică) și „unde exact” (ancorare spațială).

Notă tehnică a traducerii: DeepStack și alinierea temporală descrise aici sunt contribuții ale familiei Qwen3-VL, raportate pentru arhitectura și evaluările acesteia. Caracteristicile provenite din mai multe straturi nu garantează îmbunătățiri pentru orice encoder, date sau sarcină; validați ablația în sistemul propriu.

Trei etape de antrenare

VLM-urile moderne se antrenează în etape:

1. Aliniere — înghețați ViT-ul și LLM-ul. Antrenați numai proiectorul pe perechi imagine–descriere. Aceasta îl învață să mapeze spațiul vizual în spațiul limbajului.
2. Preantrenare — dezghețați totul. Antrenați pe date imagine–text intercalate la scară mare (peste 500M de perechi). Aceasta construiește cunoașterea vizuală a modelului.
3. Ajustare pe instrucțiuni — efectuați ajustare fină pe triplete curatoriate (imagine, întrebare, răspuns). Aceasta predă comportamentul conversațional și formatele de sarcină. Ea transformă un „LM conștient de viziune” într-un asistent utilizabil.

Majoritatea ajustărilor fine LoRA vizează etapa 3 cu un set de date etichetat mic.

Notă tehnică a traducerii: Ordinea, datele, numărul de perechi și modulele dezghețate sunt specifice rețetei. Nu presupuneți că o preantrenare VLM actualizează toate ponderile sau că 500M de perechi, ori LoRA numai în etapa 3, sunt cerințe general valabile.

Comparația familiilor de modele (începutul lui 2026)

Model	Parametri	Encoder vizual	LLM	Context	Puncte forte
Qwen3-VL-235B-A22B (MoE)	235B (22B activi)	ViT personalizat + DeepStack	Qwen3	256K	SOTA general, agent GUI
Qwen3-VL-30B-A3B (MoE)	30B (3B activi)	ViT personalizat + DeepStack	Qwen3	256K	Alternativă MoE mai mică
Qwen3-VL-8B (dens)	8B	ViT personalizat	Qwen3	128K	Valoare implicită densă pentru producție
InternVL3.5-38B	38B	InternViT-6B	Qwen3 + GPT-OSS	128K	MMBench / MMVet solide
InternVL3.5-241B-A28B	241B (28B activi)	InternViT-6B	Qwen3	128K	Competitiv cu GPT-4o
LLaVA-Next 72B	72B	SigLIP	Llama-3	32K	Deschis, ușor de ajustat fin
GLM-4.6V	~70B	personalizat	GLM	64K	Open-source, OCR puternic
MiniCPM-V-2.6	8B	SigLIP	MiniCPM	32K	Potrivit pentru edge

Notă tehnică a traducerii: Acest tabel este un instantaneu al originalului, nu un catalog sau clasament actualizat. Dimensiunea, contextul, licența, disponibilitatea checkpointului și rezultatele depind de versiunea exactă; „SOTA”, „valoare implicită”, „competitiv” și „puternic” trebuie citite împreună cu benchmarkul, setarea de inferență, hardware-ul și data raportării. În particular, documentația curentă pentru Qwen3-VL afișează o variantă 8B cu aproximativ 9B parametri, context nativ de 256K și opțiuni de extindere; valoarea de 128K din tabel nu este o proprietate permanentă a tuturor implementărilor Qwen3-VL-8B.

Agenți vizuali

Qwen3-VL-235B atinge performanța globală de vârf pe OSWorld — un benchmark pentru agenți vizuali care operează GUI-uri (desktop, mobil, web). Modelul vede o captură de ecran, înțelege interfața UI și emite acțiuni (clic, tastare, derulare). Combinat cu instrumente, închide bucla pentru sarcini desktop obișnuite. Aceasta este baza pe care rulează majoritatea demonstrațiilor „AI PC” din 2026.

Notă tehnică a traducerii: OSWorld măsoară întregul ansamblu agentic în medii și protocoale definite — model vizual, politică ori planner, instrumente, stare de mediu, execuție și criteriu de oprire — nu numai VLM-ul care citește o captură de ecran. Un scor de vârf nu dovedește fiabilitate generală pe desktopurile utilizatorilor. Concluzia că „majoritatea” demonstrațiilor AI PC rulează acest stack nu este susținută aici de o sursă primară. Verificați performanța globală pentru versiunea agentului, setul de instrumente, prompt, timestampul leaderboardului și data evaluării.

Capabilități agentice + variante RoPE

VLM-urile trebuie să știe când apare un cadru într-un videoclip. Qwen3-VL a evoluat de la T-RoPE (reprezentări poziționale rotative temporale) la aliniere temporală bazată pe text — tokenuri textuale explicite de marcaj temporal intercalate cu cadre video. Modelul vede „<timestamp 00:32> cadru, prompt” și poate raționa despre relațiile temporale.

Problema alinierii

12% dintre perechile imagine–text dintr-un set de date colectat conțin descrieri care nu sunt complet ancorate în imagine. Un VLM antrenat pe acestea învață în tăcere să halucineze — să fabrice obiecte, să interpreteze greșit numere, să inventeze relații. În producție, acesta este modul de eșec dominant.

Skywork.ai a introdus Cross-Modal Error Rate (CMER) pentru a urmări acest lucru:

CMER = fracția ieșirilor în care încrederea în text este mare, dar similaritatea imagine–text (printr-un verificator din familia CLIP) este mică

Un CMER mare înseamnă că modelul afirmă cu încredere lucruri care nu sunt ancorate în imagine. Monitorizarea CMER și tratarea lui ca KPI de producție a redus rata halucinațiilor cu aproximativ 35% în implementarea lor. Trucul nu este „reparați modelul”, ci „rutați ieșirile cu CMER mare către revizuire umană”.

Notă tehnică a traducerii: În forma prezentată, CMER este o euristică operațională, nu o metrică VLM standardizată cu un protocol public universal. Originalul nu oferă o citare primară sau oficială care să verifice atribuirea către Skywork.ai ori procentele de 12% și ~35%; tratați-le ca afirmații neverificate, nu ca rezultate generalizabile. Similaritatea simplă de tip CLIP este utilă numai pentru reprezentări globale compatibile și calibrate; ea nu validează factualitatea sau halucinația fără date etichetate. Pragurile, verificatorul și ruta de escaladare trebuie calibrate pe distribuția proprie, cu precizie/recall măsurate pentru cazurile de risc.

Ajustare fină cu LoRA / QLoRA

Ajustarea fină completă a unui VLM de 70B este inaccesibilă pentru majoritatea echipelor. LoRA (rang 16–64) pe atenție + straturile proiectorului, sau QLoRA cu ponderi de bază pe 4 biți, încape pe un singur A100 / H100. Cost: 5.000–50.000 de exemple, 100–5.000 USD în calcul, 2–10 ore de antrenare.

Notă tehnică a traducerii: Memoria, costul și durata depind de dimensiunea reală a modelului, rezoluție, lungimea contextului, numărul de imagini, batch, optimizator, cuantizare, paralelism și prețul infrastructurii. Rangul LoRA, modulele-țintă și numărul de exemple sunt hiperparametri dependenți de sarcină, nu rețete implicite. Intervalele de 5.000–50.000 exemple, 100–5.000 USD și 2–10 ore sunt estimări ale originalului, nu un deviz universal. Un VLM de 70B nu este garantat să încapă pe un singur A100 sau H100 numai prin alegerea LoRA ori QLoRA; planificați cu estimarea de memorie și testați configurația concretă.

Raționarea spațială rămâne slabă

VLM-urile actuale obțin 50–60% pe benchmarkuri de raționare spațială (sus–jos, stânga–dreapta, numărare, distanță). Dacă cazul de utilizare depinde de „care obiect este deasupra celuilalt”, validați riguros — performanța VLM generică este sub nivelul uman. Alternative mai bune decât VLM pentru sarcini spațiale pure: un estimator specializat de puncte-cheie / poziție, un model de adâncime sau un model de detecție cu geometria casetelor postprocesată.

Notă tehnică a traducerii: Intervalul 50–60% și comparația cu oamenii nu sunt proprietăți ale tuturor VLM-urilor: ele depind de benchmark, limbă, rezoluție, prompt și protocol. Modelele specializate pot fi mai potrivite pentru o sub-sarcină geometrică, dar nu substituie automat raționarea semantică; evaluați end-to-end pe distribuția-țintă.

Construiți

Pasul 1: proiectorul

Partea pe care o veți antrena cel mai des. MLP cu 2–4 straturi și GELU.

import torch
import torch.nn as nn


class Projector(nn.Module):
    def __init__(self, vit_dim=768, llm_dim=4096, hidden=4096):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(vit_dim, hidden),
            nn.GELU(),
            nn.Linear(hidden, llm_dim),
        )

    def forward(self, x):
        return self.net(x)

Intrarea este un tensor de tokenuri (N_patches, d_vit). Ieșirea este (N_patches, d_llm). LLM-ul tratează fiecare rând de ieșire ca pe încă un token.

Pasul 2: asamblați ViT-MLP-LLM capăt la capăt

Schița trecerii directe pentru un VLM minimal. Codul real folosește transformers; acesta este aranjamentul conceptual.

class MinimalVLM(nn.Module):
    def __init__(self, vit, projector, llm, image_token_id):
        super().__init__()
        self.vit = vit
        self.projector = projector
        self.llm = llm
        self.image_token_id = image_token_id  # placeholder token in text prompt

    def forward(self, image, input_ids, attention_mask):
        # 1. vision features
        vision_tokens = self.vit(image)                     # (B, N_patches, d_vit)
        vision_embeds = self.projector(vision_tokens)       # (B, N_patches, d_llm)

        # 2. text embeddings
        text_embeds = self.llm.get_input_embeddings()(input_ids)  # (B, M, d_llm)

        # 3. replace image placeholder tokens with vision embeds
        merged = self._merge(text_embeds, vision_embeds, input_ids)

        # 4. run LLM
        return self.llm(inputs_embeds=merged, attention_mask=attention_mask)

    def _merge(self, text_embeds, vision_embeds, input_ids):
        out = text_embeds.clone()
        expected = vision_embeds.size(1)
        for b in range(input_ids.size(0)):
            positions = (input_ids[b] == self.image_token_id).nonzero(as_tuple=True)[0]
            if len(positions) != expected:
                raise ValueError(
                    f"batch item {b} has {len(positions)} image tokens but vision_embeds has {expected} patches."
                    " Every sample in the batch must be pre-padded to the same number of image placeholder tokens.")
            out[b, positions] = vision_embeds[b]
        return out

Tokenul substituent <image> din text este înlocuit cu reprezentări vectoriale reale ale imaginii — același tipar folosit de LLaVA, Qwen-VL și InternVL.

Notă tehnică a traducerii: Acesta este pseudocod conceptual. El presupune un token substituent pentru fiecare reprezentare vizuală proiectată; procesoarele reale pot extinde, comprima sau împacheta tokenurile de imagine diferit și trebuie să mențină măștile de atenție, pozițiile și paddingul coerente pentru fiecare eșantion. Numărul substituenților, expansiunea tokenurilor, pozițiile și fuziunea prin atenție sunt specifice checkpointului. Nu folosiți această implementare ca integrare directă a unui checkpoint.

Pasul 3: calculul CMER

O verificare ușoară la rulare.

import torch.nn.functional as F


def cross_modal_error_rate(image_emb, text_emb, text_confidence, sim_threshold=0.25, conf_threshold=0.8):
    """
    image_emb, text_emb: embeddings of image and generated text (normalised internally)
    text_confidence:     mean per-token probability in [0, 1]
    Returns:             fraction of high-confidence outputs with low image-text alignment
    """
    image_emb = F.normalize(image_emb, dim=-1)
    text_emb = F.normalize(text_emb, dim=-1)
    sim = (image_emb * text_emb).sum(dim=-1)        # cosine similarity
    high_conf_low_sim = (text_confidence > conf_threshold) & (sim < sim_threshold)
    return high_conf_low_sim.float().mean().item()

Tratați CMER ca pe un KPI de producție. Monitorizați-l pe endpoint, tip de prompt și client. Un CMER în creștere indică faptul că modelul începe să halucineze pe o anumită distribuție de intrări.

Notă tehnică a traducerii: Funcția este o implementare locală a euristicii: ea nu verifică factualitatea răspunsului și nici nu validează automat dimensiunea, alinierea sau calibrarea reprezentărilor. image_emb și text_emb trebuie să aibă aceeași ultimă dimensiune și să provină din același spațiu multimodal aliniat; altfel produsul scalar nu este interpretabil. Apelul .item() transformă rezultatul într-un scalar Python pentru jurnalizare și nu îl face potrivit ca pierdere diferențiabilă. Pragurile fixe 0.25 și 0.8 nu sunt universale; stabiliți-le și monitorizați-le cu date etichetate relevante pentru risc.

Pasul 4: clasificator VLM de jucărie (executabil)

Demonstrați că proiectorul se antrenează. Intră caracteristici „ViT” false; un token mic de tip LLM prezice o clasă.

class ToyVLM(nn.Module):
    def __init__(self, vit_dim=32, llm_dim=64, num_classes=5):
        super().__init__()
        self.projector = Projector(vit_dim, llm_dim, hidden=64)
        self.head = nn.Linear(llm_dim, num_classes)

    def forward(self, vision_tokens):
        projected = self.projector(vision_tokens)
        pooled = projected.mean(dim=1)
        return self.head(pooled)

Acest model poate fi ajustat pe perechi sintetice (caracteristică, clasă) în mai puțin de 200 de pași — suficient pentru a arăta că tiparul proiectorului funcționează.

Notă tehnică a traducerii: Blocul definește numai clasa; nu este un program complet de antrenare executabil de sine stătător. El presupune că Projector, importurile, datele sintetice, funcția de pierdere, optimizatorul și bucla de antrenare au fost definite anterior. Afirmația despre 200 de pași depinde de distribuția datelor și de hiperparametri.

Utilizați

Trei moduri în care echipele de producție folosesc VLM-uri în 2026:

• API găzduit — OpenAI Vision, Anthropic Claude Vision, Google Gemini Vision. Fără infrastructură proprie, risc de furnizor.
• Auto-găzduire open-source — Qwen3-VL sau InternVL3.5 prin transformers și vllm. Control complet, efort inițial mai mare.
• Ajustare fină pe domeniu — încărcați Qwen2.5-VL-7B sau LLaVA-1.6-7B, aplicați LoRA pe 5k–50k de exemple proprii, serviți cu vllm sau TGI.

from transformers import AutoProcessor, AutoModelForVision2Seq
import torch
from PIL import Image

model_id = "Qwen/Qwen3-VL-8B-Instruct"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForVision2Seq.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map="auto")

messages = [{
    "role": "user",
    "content": [
        {"type": "image", "image": Image.open("plot.png")},
        {"type": "text", "text": "What does this chart show?"},
    ],
}]
inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to("cuda")
generated = model.generate(**inputs, max_new_tokens=256)
answer = processor.decode(generated[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)

apply_chat_template ascunde tokenizarea substituentului <image>; modelul gestionează intern fuziunea.

Notă tehnică a traducerii: Exemplul este păstrat exact din original, dar API-urile VLM din transformers depind de versiune și checkpoint. Documentația curentă Qwen3-VL folosește Qwen3VLForConditionalGeneration (sau AutoModelForMultimodalLM în versiunile care expun această clasă), nu AutoModelForVision2Seq. Mutați intrările cu inputs.to(model.device), nu necondiționat la "cuda", și pentru un lot decodați separat fiecare continuare după lungimea propriilor input_ids; tăierea generated[0] este corectă doar pentru un singur exemplu. Verificați înainte de rulare exemplul oficial al modelului, dispozitivul și preprocesarea.

Livrați

Această lecție produce:

• outputs/prompt-vlm-selector.md — alege Qwen3-VL / InternVL3.5 / LLaVA-Next / API după acuratețe, latență, lungimea contextului și buget.
• outputs/skill-cmer-monitor.md — produce cod pentru instrumentarea unui endpoint VLM de producție cu rata de eroare cross-modală, tablouri de bord pe endpoint și praguri de alertare.

Exerciții

1. (Ușor) Rulați trei prompturi („ce este aceasta?”, „numărați obiectele”, „descrieți scena”) prin orice VLM deschis, pe cinci imagini. Evaluați fiecare răspuns manual ca corect / parțial corect / halucinat. Calculați o primă rată de tip CMER.
2. (Mediu) Ajustați fin Qwen2.5-VL-3B sau LLaVA-1.6-7B cu LoRA (rang 16) pe 500 de imagini dintr-un domeniu-țintă, cu descrieri. Comparați acuratețea zero-shot cu cea ajustată fin, în stil MMBench.
3. (Dificil) Înlocuiți encoderul de imagine al VLM-ului cu DINOv3 în locul SigLIP/CLIP implicit. Reantrenați numai proiectorul (LLM înghețat + DINOv3 înghețat). Măsurați dacă se îmbunătățesc sarcinile de predicție densă (numărare, raționare spațială).

Notă tehnică a traducerii: În exercițiul 2, 500 de imagini dintr-un domeniu nu constituie automat o evaluare „în stil MMBench”; definiți sarcina, împărțirile train/validare/test, prompturile, condițiile zero-shot și metoda de scor. La exercițiul 3, schimbarea encoderului schimbă preprocesarea, dimensiunea, numărul și geometria tokenurilor, precum și pozițiile și alinierea multimodală; proiectorul și procesarea imaginii trebuie adaptate. Antrenarea numai a proiectorului este o bază de comparație, nu o garanție că DINOv3 va îmbunătăți numărarea sau raționarea spațială.

Termeni-cheie

Termen	Ce spun oamenii	Ce înseamnă de fapt
ViT-MLP-LLM	„Tiparul VLM”	Encoder vizual + proiector + model de limbaj; fiecare VLM din 2026
Proiector	„Puntea”	MLP cu 2–4 straturi (sau Q-former) care mapează tokenurile vizuale în spațiul de reprezentare vectorială al LLM-ului
DeepStack	„Trucul de caracteristici Qwen3-VL”	Caracteristici ViT de la mai multe niveluri suprapuse în locul ultimului strat singur
Token de imagine	„Substituentul <image>”	Token special în fluxul textual, înlocuit cu reprezentări vizuale proiectate
CMER	„KPI pentru halucinație”	Cross-Modal Error Rate; mare când încrederea în text este mare, dar similaritatea imagine–text este mică
Agent vizual	„VLM care dă clic”	VLM care operează GUI-uri (OSWorld, mobil, web) cu apeluri de instrumente
Q-former	„Punte cu număr fix de tokenuri”	Proiector în stil BLIP-2 care produce un număr fix de tokenuri de interogare vizuală
Aliniere / preantrenare / ajustare pe instrucțiuni	„Trei etape”	Flux standard de antrenare VLM

Lecturi suplimentare

• Qwen3-VL Technical Report (arXiv 2511.21631)
• InternVL3.5 Advancing Open-Source Multimodal Models (arXiv 2508.18265)
• Seria LLaVA-Next
• BentoML: cele mai bune VLM-uri open-source din 2026
• MMMU: benchmark de înțelegere multimodală multidisciplinară
• VLM-uri în producție (Robotics Tomorrow, martie 2026)

Sursă: Originalul în limba engleză

Navigare: ← Lecția 04.24 — SAM 3 și segmentarea cu vocabular deschis · Faza 4 — Viziune computerizată · Lecția 04.26 — Adâncimea monoculară și estimarea geometriei → · Catalog complet