Detecting Semantic Alignments between Textual Specifications and Domain Models

Dit artikel presenteert een NLP-gedreven aanpak die gebruikmaakt van grote taalmodellen om de semantische uitlijning tussen tekstuele specificaties en domeinmodellen te detecteren, waarbij model-elementen met hoge precisie worden geclassificeerd als correct, incorrect of onbepaald.

De kern

🕵️‍♂️ De Taal- en Model-Detective: Hoe AI helpt bij het bouwen van software

Stel je voor dat je een recept hebt voor een prachtige taart (dit is de tekstuele specificatie). Op het papier staat precies wat erin moet: bloem, suiker, eieren, en hoe lang je moet bakken.

Nu probeer jij die taart te maken. Maar in plaats van dat je gewoon begint te bakken, maak je eerst een tekening van je taart (dit is het domeinmodel). Op die tekening teken je een kom met bloem, een bak met suiker, en een oven.

Het probleem:
Soms maak je een foutje. Misschien teken je op je tekening dat je zout in de taart doet, terwijl het recept alleen suiker zegt. Of je vergeet de oven helemaal. Als je pas aan het einde van het bakproces merkt dat je taart een zoute rommel is, is het te laat. Vooral voor beginners is het lastig om te zien of hun tekening (het model) wel klopt met het recept (de tekst).

🤖 De Oplossing: Een slimme AI-assistent

De auteurs van dit paper hebben een slimme tool bedacht die fungeert als een super-detective. Deze detective kijkt continu mee terwijl je aan je tekening werkt en zegt: "Hé, dit stukje van je tekening klopt met het recept!" of "Wacht even, hier staat iets anders dan in het recept!"

Hoe doet deze detective dat? Het proces ziet eruit als een vier-delige show:

1. De Vertaler (NLP Preprocessor)

Eerst neemt de detective het recept (de tekst) en leest het heel zorgvuldig door. Hij haalt de belangrijke woorden eruit, zoals "taart", "suiker" en "oven". Hij maakt een lijstje van wat er in de tekst staat.

• Vergelijking: Het is alsof je een boek in een samenvatting verandert, zodat je snel de hoofdlijnen ziet.

2. De Snijder (Model Slicer)

Vervolgens kijkt de detective naar jouw tekening. Hij neemt niet de hele tekening in één keer, maar knipt er stukjes uit. Hij pakt bijvoorbeeld alleen de 'kom met bloem' en kijkt daar naar.

• Vergelijking: Het is alsof je een grote puzzel in losse stukjes knipt om ze één voor één te controleren.

3. De Vertaler van Tekeningen (Sentence Generator)

Nu komt het slimme deel. De detective neemt dat losse stukje van je tekening (de 'kom met bloem') en schrijft er een zinnetje bij in mensentaal.

• Voorbeeld: Als je een lijn tekent tussen 'taart' en 'oven', schrijft de detective: "Een taart wordt gebakken in een oven."
• Vergelijking: Hij vertaalt je tekening terug naar een verhaal, zodat hij het kan vergelijken met het originele recept.

4. De Rechter (LLM - De Grote Brein)

Tot slot neemt de detective die twee verhalen:

1. Het originele zinnetje uit het recept.
2. Het zinnetje dat hij net bedacht over jouw tekening.

Hij vraagt een Super-Brein (een Large Language Model, zoals een slimme chatbot) om te oordelen:

• Kloppen ze? (Aligned) -> "Ja, in het recept staat ook dat je een oven gebruikt." ✅
• Strijden ze? (Misaligned) -> "Nee, in het recept staat 'suiker', maar jij hebt 'zout' getekend." ❌
• Weet ik het niet? (Unclassified) -> "Het recept is hier vaag, ik kan niet zeggen of het goed of fout is." 🤷‍♂️

🎯 Wat hebben ze ontdekt?

De onderzoekers hebben deze detective getest op 30 verschillende "recepten" (van een restaurantbeheersysteem tot een voetbalteam).

• Zeer betrouwbaar: Als de detective zegt dat iets goed is, dan is het bijna altijd goed (99% zekerheid). Hij maakt bijna nooit een fout door iets goeds als fout te bestempelen.
• Niet perfect: Hij mist soms wel een paar foutjes. Hij vindt ongeveer 78% van de fouten en de goede dingen.
• Snelheid: Het kost even (tussen 18 seconden en 1 minuut per stukje), maar dat is snel genoeg om het als een achtergrond-assistent te gebruiken terwijl je werkt.

💡 Waarom is dit belangrijk?

Stel je voor dat je een leerling bent die software bouwt. Normaal gesproken moet je wachten tot een leraar of senior collega jouw werk nakijkt. Dat duurt lang.

Met deze tool krijg je direct feedback:

• Je ziet een groen vinkje als je iets goed hebt gedaan (dat geeft zelfvertrouwen!).
• Je ziet een rood uitroepteken als je iets verkeerd hebt, inclusief de zin uit het recept die aangeeft waarom het fout is.

🚀 Conclusie

Dit onderzoek laat zien dat we AI kunnen gebruiken als een slimme, onuitputtelijke assistent voor mensen die software ontwerpen. Het helpt beginners om fouten te voorkomen en zorgt ervoor dat de tekening (het model) altijd trouw blijft aan het recept (de tekst).

Het is alsof je een receptchef hebt die over je schouder meekijkt en fluistert: "Zorg dat je de suiker gebruikt, niet het zout!" voordat je de taart in de oven schuift.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Detecting Semantic Alignments between Textual Specifications and Domain Models", geschreven in het Nederlands.

Probleemstelling

In de vroege fasen van software-engineering is het cruciaal om domeinmodellen (vaak visuele representaties zoals UML-class diagrams) te creëren die nauwkeurig overeenkomen met tekstuele specificaties (vereisten). Voor beginnende modelleerders is het echter een uitdagende taak om correcte domeinmodellen te bouwen en duidelijke, gestructureerde koppelingen (traces) tussen de tekst en de model-elementen tot stand te brengen.

Bestaande methoden voor semi-automatische generatie van domeinmodellen uit tekst vereisen nog steeds menselijke validatie voordat ze betrouwbaar zijn. Het ontbreekt vaak aan tools die modelleerders direct feedback kunnen geven over welke elementen correct zijn en welke fouten bevatten, inclusief de onderliggende redenatie. Het creëren van een dergelijke feedbacklus is complex omdat er voor een gegeven situatie niet altijd één enkel "correct" domeinmodel bestaat; modelleerders maken creatieve keuzes.

Methodologie

De auteurs stellen een geautomatiseerde aanpak voor om semantische uitlijning (alignment) en misuitlijning (misalignment) te detecteren tussen een tekstuele specificatie en een (deels) voltooid domeinmodel. De aanpak maakt gebruik van een hybride architectuur die traditionele NLP-technieken combineert met Large Language Models (LLMs).

Het proces bestaat uit vijf hoofdcomponenten (zie Figuur 3 in het paper):

1. NLP Specificatie Preprocessor (Component A):

   • Verwerkt de tekstuele specificatie met regelgebaseerde NLP (o.a. spaCy).
   • Voert co-referentie-oplossing uit (pronomen-resolutie).
   • Extrahert concepten (nouns) en relaties (verba/preposities) en koppelt deze aan de oorspronkelijke zinnen.

2. Model Slicer (Component B):

   • Doorloopt het domeinmodel en extrahert voor elk model-element (attribuut, associatie, erfgoed, enum, etc.) een "minimale model slice".
   • Deze slice bevat het element zelf en de noodzakelijke context (bijv. de klasse waar een attribuut toe behoort) om een geldig model te vormen.

3. Semantische Matcher (Component C):

   • Koppelt de geëxtraherde tekstconcepten en -relaties aan de model-elementen in de slices.
   • Gebruikt heuristieken op basis van syntactische woordgelijkenis en semantische gelijkenis om te bepalen welke zinnen uit de specificatie relevant zijn voor welk model-element.
   • Output: Een set van zinnen die matchen met een specifiek model-element.

4. Model Zin Generator (Component D):

   • Genereert voor elke model-slice een natuurlijke taalzin (bijv. "Een auto heeft een kentekenplaat") op basis van regelgebaseerde NLP.
   • Dit creëert een alternatieve beschrijving van het model-element die vergeleken kan worden met de originele tekst.

5. LLM-gebaseerde (Mis)uitlijning Detectie (Component E):

   • Dit is de kern van de intelligentie. Een LLM (GPT-4o) wordt gebruikt om de gegenereerde zin van het model te vergelijken met de gematchte zinnen uit de specificatie.
   • Er worden drie specifieke tests uitgevoerd via prompt engineering:
     • Equivalentie: Conveyen de zinnen dezelfde informatie?
     • Contradictie: Conveyen de zinnen tegenstrijdige informatie?
     • Inclusie: Is de betekenis van de gegenereerde zin opgenomen in de specificatiezin (ook als ze niet exact gelijk zijn)?
   • Beslissingslogica:
     • Als er equivalentie is -> Aligned (Correct).
     • Als er geen equivalentie is maar wel contradictie -> Misaligned (Incorrect).
     • Als er geen equivalentie is, maar inclusie wel -> Aligned (Correct, omdat specificaties vaak meer details bevatten dan het model).
     • Anders -> Unclassified (Onvoldoende bewijs).
   • Om de non-deterministische aard van LLMs te mitigeren, worden meerdere semantisch equivalente prompts gestuurd en wordt er gekozen op basis van meerderheidsstemming (voting).

Belangrijkste Bijdragen

• Hybride Architectuur: Een innovatieve combinatie van snelle, deterministische regelgebaseerde systemen voor preprocessing en slicing, met de semantische redeneercapaciteit van LLMs voor de daadwerkelijke validatie.
• Geautomatiseerde Validatie: Een methode die model-elementen classificeert als correct, incorrect of onbepaald, zonder dat er een referentiemodel (golden truth) nodig is; de tekstuele specificatie fungeert als de waarheid.
• Traceerbaarheid: Het systeem levert niet alleen een classificatie, maar ook de specifieke zinnen uit de specificatie die als bewijs dienen voor de beslissing.
• Evaluatieframework: Een uitgebreide evaluatie op een dataset van 30 domeinen met zowel correcte modellen als modellen met systematisch geïntroduceerde fouten (mutaties).

Resultaten

De aanpak is geëvalueerd op een dataset van 30 tekstuele specificaties uit diverse domeinen (restaurant, bankieren, games, etc.) en de bijbehorende domeinmodellen.

• Precisie (Correctheid): De precisie is uitzonderlijk hoog. Voor modellen zonder fouten is de precisie voor het detecteren van uitlijning 1.0 (alle voorspellingen waren correct). Voor het detecteren van misuitlijning in gemuteerde modellen was de precisie eveneens 1.0 (behalve in één geval met twee fouten). Dit betekent dat als het systeem een element als "fout" markeert, dit bijna zeker correct is.
• Recall (Volledigheid): De recall ligt rond de 77-78%. Dit betekent dat het systeem ongeveer 3 op de 4 model-elementen correct kan classificeren. De resterende elementen worden als "unclassified" gemarkeerd, vaak door ambiguïteit in de tekst of ontbrekende rollenamen in het model.
• F1-score: De gecombineerde F1-score ligt rond de 0.86 - 0.87.
• Performance: De verwerkingstijd varieert van 18 seconden tot 1 minuut per model-element (afhankelijk van de grootte van de specificatie en parallelisatie). De totale verwerkingstijd voor een model varieerde van 59 seconden tot ongeveer 13 minuten.
• Foutanalyse: De meeste fouten (misclassificaties) treden op bij associaties met multipliciteiten, vooral wanneer de tekst tijdsafhankelijke context bevat die de LLM als contradictie interpreteert, of wanneer er meerdere associaties tussen dezelfde klassen zijn.

Betekenis en Toepassing

De studie toont aan dat het mogelijk is om LLMs te gebruiken voor de semantische validatie van softwaremodellen met een zeer hoge betrouwbaarheid.

• Ondersteuning voor Modelleerders: De tool kan worden geïntegreerd in een modelleeromgeving (IDE) om modelleerders real-time feedback te geven. Elementen die als "aligned" worden gemarkeerd, kunnen als "geverifieerd" worden gemarkeerd, wat vertrouwen geeft. Elementen die als "misaligned" worden gemarkeerd, kunnen worden gewaarschuwd met de bijbehorende tekstuele contra-indicatie.
• Kwaliteitsborging: Het kan offline worden gebruikt voor kwaliteitsbeoordeling van bestaande modellen en het tot stand brengen van traceerbaarheidskoppelingen tussen eisen en modellen.
• Beperkingen: Het systeem detecteert momenteel geen ontbrekende elementen of overbodige elementen, alleen fouten in bestaande elementen. Ook is de huidige implementatie afhankelijk van externe LLM-API's, wat kosten en latentie met zich meebrengt, hoewel parallelisatie en lokale LLMs hierop een oplossing kunnen bieden.

Kortom, dit paper biedt een robuuste, geautomatiseerde oplossing voor het valideren van de semantische consistentie tussen tekstuele eisen en domeinmodellen, met name waardevol voor het opleiden van modelleerders en het verbeteren van de kwaliteit van model-gedreven ontwikkeling.