Do Large Language Models Understand Data Visualization Principles?

Deze studie presenteert de eerste systematische evaluatie van de capaciteit van grote taal- en visueel-taalmodellen om principes voor datavisualisatie te verifiëren en te corrigeren, waarbij wordt geconcludeerd dat hoewel deze modellen veelbelovende flexibele validators zijn, ze nog een kloof vertonen met symbolische oplossers en een opvallende asymmetrie tonen door beter te zijn in het herstellen dan in het detecteren van schendingen.

De kern

🎨 Kunnen AI's goed tekenen? Een test voor de "visuele grammatica"

Stel je voor dat Data Visualisatie (grafieken en diagrammen) een taal is. Net zoals we regels hebben voor grammatica en spelling in een zin, zijn er ook regels voor het maken van goede grafieken. Deze regels zorgen ervoor dat een grafiek eerlijk is en niet misleidend.

Vroeger hadden we alleen strenge, robotachtige regels (zoals een taalcontrole in Word die alleen kijkt naar spelling). Als je een grafiek maakte die tegen deze regels in ging, gaf de computer een foutmelding. Maar deze systemen waren stijf: als je iets nieuws probeerde, wisten ze het vaak niet te beoordelen.

Nu hebben we Grote Taalmodellen (LLMs): slimme AI's die alles lezen en begrijpen. De vraag in dit onderzoek is simpel: Begrijpen deze slimme AI's ook de "visuele grammatica"? Kunnen ze niet alleen een fout zien, maar ook zeggen: "Hé, die grafiek is raar, en hier is hoe je hem fixt"?

De onderzoekers hebben een grote test opgezet om dit uit te zoeken. Hier is hoe het werkt, in drie simpele stappen:

1. De Testset: De "Vervalsingstest" 🕵️‍♀️

De onderzoekers maakten twee soorten testmateriaal:

• De Kunstmatige Test (De "Simulatie"): Ze lieten een computer duizenden grafieken maken, waarbij ze expres fouten inbouwden. Denk aan een grafiek waar de kleuren verkeerd zijn gebruikt om volgorde aan te geven, of waar de as (de lijn onderaan) afgeknipt is om een trend groter te laten lijken dan hij is. Ze hadden precies de "antwoorden" (de grondwaarheid) om te zien of de AI het zag.
• De Echte Test (De "Straattest"): Ze pakten ook echte grafieken die mensen op internet (GitHub) hadden gemaakt. Dit is als het controleren van foto's van echte verkeersboetes in plaats van een simulatie.

2. De Proefpersonen: De AI's 🤖

Ze gaven deze grafieken (zowel de code als de afbeelding) aan verschillende AI's, van open-source modellen tot de duurste, slimste modellen van Google en OpenAI.

• Opdracht A (De Politie): "Kijk naar deze grafiek. Zie je fouten?"
• Opdracht B (De Architect): "Deze grafiek heeft een fout. Maak hem goed, maar verander niet te veel."

3. De Resultaten: Slim, maar niet perfect 🧠✨

Hier zijn de belangrijkste ontdekkingen, vertaald naar alledaagse termen:

• De "Oog-oor" Kwestie (Tekst vs. Beeld):
  Je zou denken dat een AI die zowel de code als het plaatje ziet, het beste zou scoren. Dat is waar, maar niet zo heel erg. Het is alsof je iemand vraagt een auto te beoordelen: het helpt om hem te zien, maar als je de technische specificaties (de code) al hebt, zie je de meeste fouten daar ook wel. De beeld-informatie gaf een klein beetje extra, maar de AI's konden de "visuele regels" niet volledig uit het plaatje halen zonder de tekst.

• De "Detectie vs. Reparatie" Paradox:
  Dit is het meest interessante stukje. De AI's waren vaak beter in het repareren dan in het vinden van fouten.

  • Analogie: Stel je voor dat je een kind vraagt: "Zie je dat die stoel scheef staat?" Het kind schudt twijfelend met zijn hoofd (fout: het ziet het niet). Maar als je zegt: "Zet die stoel recht," dan doet het dat perfect.
  • In de test konden de AI's soms een fout niet benoemen, maar als ze kregen: "Maak dit beter," maakten ze het vaak wel goed. Ze weten hoe het moet, maar ze zijn soms niet scherp genoeg om te zien dat het fout is.

• De "Moeilijke" Grafieken:
  De AI's waren goed in simpele staafdiagrammen (zoals een kind dat blokken bouwt), maar hadden het moeilijk met complexe cirkeldiagrammen of bochtige lijnen. Het is alsof ze goed kunnen tellen, maar moeite hebben met abstracte patronen.

• De "Echte Wereld" vs. De "Test":
  De AI's deden het beter op de echte grafieken van internet dan op de kunstmatige test. Waarom? Omdat ze die stijlen waarschijnlijk al eerder hebben gezien tijdens hun "schooltijd" (training). Ze herkenden de patronen, in plaats van echt te redeneren. Op de kunstmatige test, waar ze niets van hadden gezien, zagen ze hun beperkingen.

🏁 Conclusie: Waar staan we nu?

Deze AI's zijn als talentvolle stagiairs in een ontwerpbureau.

• Ze kunnen een ontwerp vaak opknappen als je ze vraagt om het te verbeteren (ze zijn goede "fixers").
• Maar ze zijn nog niet de meester-inspecteur die elke kleine fout direct ziet en kan uitleggen waarom het fout is (ze zijn nog geen perfecte "detectives").

De onderzoekers concluderen dat we deze AI's kunnen gebruiken om ons te helpen bij het maken van betere grafieken, maar we moeten ze nog niet blindelings vertrouwen om alles te controleren. Ze zijn een krachtige hulpmiddel, maar de menselijke expert is (nog) nodig om de laatste details te checken.

Kortom: De AI's begrijpen de regels, maar ze zijn soms wat traag om ze toe te passen en soms te zelfverzekerd. We moeten ze nog een beetje trainen om scherper te kijken.

Technische samenvatting

Probleemstelling

Datavisualisatieprincipes, afgeleid van decennia aan onderzoek in ontwerp en perceptie, zijn essentieel voor accurate communicatie. Bestaande systemen voor het valideren van visualisaties (zoals linters) maken gebruik van symbolische, op regels gebaseerde systemen (bijvoorbeeld Answer Set Programming of ASP) om principes als logische constraints te coderen. Hoewel deze systemen nauwkeurig zijn, vereisen ze gespecialiseerde expertise om de regels te definiëren en te onderhouden, wat hun schaalbaarheid en flexibiliteit beperkt.

Recente studies tonen aan dat Large Language Models (LLMs) en Vision-Language Models (VLMs) misleidende patronen in grafieken kunnen detecteren of vragen over visualisaties kunnen beantwoorden. Het blijft echter onduidelijk of deze modellen in staat zijn om direct te redeneren over en visualisatieprincipes af te dwingen binnen chart-specificaties (zoals Vega-Lite), zonder de tussenkomst van handmatig opgestelde symbolische regels. De kernvraag is: Begrijpen LLMs data-visualisatieprincipes voldoende om fouten te detecteren en te corrigeren?

Methodologie

De auteurs hebben een systematische evaluatie opgezet om de redeneercapaciteiten van LLMs en VLMs te testen. De aanpak omvatte drie hoofdfasen:

1. Dataset Constructie:

   • Synthetische Dataset: Er werd een gecontroleerde dataset gegenereerd van ongeveer 2.000 Vega-Lite specificaties. Deze werden gegenereerd door data uit diverse domeinen (financiën, gezondheid, demografie) te combineren met een randomisatie van chart-parameters (mark-type, encoding, schaal, etc.). Een Kullback-Leibler (KL) divergence filter werd gebruikt om een evenwichtige verdeling van 57 verschillende types principe-overtredingen te garanderen.
   • Real-world Dataset: Een verzameling van 307 menselijk geschreven Vega-Lite specificaties uit GitHub, die werden vertaald naar de Draco-grammatica voor analyse.
   • Ground Truth: Alle datasets werden geannoteerd met "ground truth" overtredingen, gegenereerd door een formele ASP-oplosser (Clingo) die de Vega-Lite specificaties controleerde op een subset van 57 constraints.

2. Evaluatie Opzet:
   De auteurs testten modellen op twee taken:

   • Detectie (Checking): Modellen kregen de Vega-Lite specificatie (en bij VLMs ook de gerenderde afbeelding) en een lijst met principes in natuurlijke taal. Ze moesten in een gestructureerd JSON-formaat aangeven welke principes werden geschonden.
   • Correctie (Fixing): Modellen kregen een specificatie met een bekende overtreding en kregen de opdracht om een gecorrigeerde Vega-Lite specificatie te genereren die aan het principe voldoet.

3. Modellen:
   Er werden zowel open-source modellen (bijv. LLaMA, Gemma, GPT-OSS) als gesloten bron-modellen (GPT-4o, Gemini-2.5-Flash) getest, zowel in tekst-only modus als multimodaal (tekst + afbeelding).

Belangrijkste Bijdragen

• Eerste Systematische Evaluatie: Dit is het eerste onderzoek dat LLMs en VLMs evalueert tegenover formeel gespecificeerde visualisatieprincipes (gebaseerd op ASP-constraints), in plaats van alleen op basis van menselijke beoordeling of vraag-antwoord taken.
• Gecreëerde Benchmark: De auteurs hebben een nieuwe benchmark gepubliceerd bestaande uit 2.000 synthetische en 300+ real-world Vega-Lite specificaties, geannoteerd met expliciete principe-overtredingen.
• Brug tussen Symbolisch en Taalgebaseerd Redeneren: Het paper vergelijkt de prestaties van LLMs direct met die van traditionele symbolische solvers, waardoor een brug wordt geslagen tussen formele verificatie en generatieve AI.

Resultaten

De resultaten tonen een gemengd beeld met duidelijke trends:

• Detectie (Checking):

  • Prestaties: De prestaties zijn gematigd. De beste gesloten bron-modellen (Gemini-2.5-Flash) behaalden een F1-score van 0,678 op de synthetische dataset (tekst-only) en 0,716 met multimodale input. Open-source modellen presteerden over het algemeen slechter (bijv. GPT-OSS-20B: 0,580).
  • Real-world vs. Synthetisch: Prestaties waren hoger op de real-world dataset (tot 0,778), maar dit wordt toegeschreven aan een smaller scala aan geteste principes en mogelijke "lekkage" van patronen uit de trainingsdata.
  • Zwakte bij Nuance: Modellen worstelen met subtielere perceptuele constraints (F1 < 0,10), vooral bij complexe mark-types zoals 'arc'.
  • Multimodaal: Het toevoegen van de gerenderde afbeelding leidde tot slechts marginale verbeteringen, wat suggereert dat modellen de visuele signalen niet optimaal benutten bovenop de tekstuele specificatie.

• Correctie (Fixing):

  • Asymmetrie: Er is een opvallende asymmetrie ontdekt: modellen zijn effectiever in het corrigeren van overtredingen dan in het betrouwbaar detecteren ervan.
  • Enforcement Rate: Gemini-2.5-Flash slaagde erin om de specifieke overtreding in 94,3% van de gevallen te verhelpen, terwijl de detectieprestatie lager was.
  • Kwaliteit: De gegenereerde specificaties waren bijna altijd syntactisch geldig (compilability > 99%) en leidden tot een netto-reductie van het totale aantal overtredingen (Compliance Ratio ~0,72). Echter, modellen maken vaak onbedoelde wijzigingen die andere principes schenden, wat aangeeft dat ze nog niet volledig "constraint-aware" zijn.

Betekenis en Conclusie

Het paper concludeert dat Large (Vision-)Language Models veelbelovende, flexibele validators en editors zijn voor data-visualisatie, maar dat ze nog niet de robuustheid van symbolische systemen hebben bereikt voor complexe perceptuele redenering.

• Praktische Impact: De resultaten onderstrepen het potentieel van LLMs als "co-pilots" in visualisatie-tools die auteurs kunnen helpen bij het identificeren en corrigeren van fouten, zelfs als ze niet perfect zijn in het detecteren van elke nuance.
• Toekomstige Richtingen: Er is nog ruimte voor verbetering, vooral in het beter benutten van multimodale input, het testen op een breder scala aan principes, en het ontwikkelen van protocollen die verder gaan dan macro-F1-scores om de kwaliteit van het redeneren te meten.

Samenvattend: LLMs begrijpen de logica van visualisatieprincipes redelijk goed om fouten te repareren, maar hun vermogen om deze principes consistent en nauwkeurig te detecteren in complexe scenario's blijft een uitdaging.