MAS4SysML: Een multi-agent framework voor SysML v2-modelgeneratie vanuit natuurlijke taal

Summary

Dit protocol presenteert MAS4SysML, een multi-agent benadering die automatisch SysML v2-code genereert via gecoördineerde taakdeling, weinig reparatieiteraties vereist en de handmatige modelleringstijd aanzienlijk vermindert terwijl de efficiëntie van het systeemmodelleren verbetert.

Abstract

Het automatisch genereren van nauwkeurige SysML-modellen uit natuurtaalvereisten kan de adoptie van Model-Based Systems Engineering (MBSE) in complexe systeemontwikkeling aanzienlijk versnellen. Het gebruik van grote taalmodellen (LLM's) om modelcode te genereren voldoet echter vaak niet aan de strikte syntactische beperkingen van formele modelleringstalen, en het consequent waarborgen van semantische uitlijning tussen gegenereerde modellen en eisen blijft een uitdaging. Om deze uitdagingen aan te pakken, presenteert dit artikel MAS4SysML, een multi-agent samenwerkingsraamwerk voor SysML v2-codegeneratie dat syntactische correctheid en semantische consistentie verbetert onder een beperkt reparatiebudget. Het framework verdeelt een modelleertaak in hiërarchische subtaken, formaliseert deze als gestructureerde taakkaarten en genereert modelcode op een bottom-up manier. Tijdens de generatie wordt een officiële validatieomgeving gebruikt voor syntaxisdiagnostiek; Na voltooiing verifieert het framework de semantische consistentie tussen de code en de taakkaarten. Als syntaxis of semantische validatie faalt, herstelt en valideert het framework iteratief de code binnen een vooraf gedefinieerd reparatiebudget, geleid door diagnostische feedback, totdat aan de validatiecriteria is voldaan of het budget is uitgeput. Om de voorgestelde methode te evalueren, construeren we een SysML v2-dataset die vijf kerntaken omvat—eisen, gebruikssituaties, structuur, parametriek en toestandsmachines—en voeren we vergelijkende experimenten uit. Resultaten tonen aan dat MAS4SysML het gemiddelde foutpercentage in de syntaxis verlaagt tot 2,63, de semantische gelijkenis verhoogt tot 0,91 en in het algemeen beter presteert dan bestaande codegeneratiemethoden.

Introduction

MBSE is een belangrijke methodologie geworden voor eisenanalyse, systeemarchitectuurontwerp en verificatieplanning bij de ontwikkeling van complexe apparatuur in domeinen zoals luchtvaart en lucht- en ruimtevaart¹. Met behulp van unified modeling languages zoals SysML als de modelleringsruggengraat kan informatie—waaronder vereisten, structuur, gedrag en beperkingen—worden georganiseerd in een coherent modelraamwerk, waarmee de processtructuur en de efficiëntie van interdisciplinaire samenwerking wordt verbeterd². Echter, naarmate de systeemschaal blijft groeien, neemt het aantal modellen dat ontwikkeld moet worden dienovereenkomstig toe, wat leidt tot een aanhoudende toename van de werklast van handmatige SysML-modellering. Bovendien moeten modelleurs werken onder strikte syntactische en methodologische beperkingen, die aanzienlijke expertise en sterke abstractiemogelijkheden vereisen. Deze factoren zijn een belangrijke bottleneck geworden in de technische adoptie van MBSE³.

In de afgelopen jaren hebben LLM's sterke vaardigheden getoond in natuurlijke taalbegrip, gestructureerde informatierepresentatie en codegeneratie, wat nieuwe mogelijkheden biedt voor het automatiseren van MBSE-modellering van natuurlijke taal naar modelcode⁴. Eerdere studies hebben de directe generatie van SysML-modelcode onderzocht met behulp van LLMs⁵. Toch blijven er aanzienlijke uitdagingen bestaan. Syntactisch worden het typesysteem, de scopingmechanismen en referentiesemantiek van SysML beheerst door strikte formele beperkingen en zijn ze vaak ingewikkelder dan die van algemene programmeertalen⁶. Semantisch kunnen LLM's er niet in slagen gedragslogica, structurele relaties en cross-layer beperkingen volledig vast te leggen, wat resulteert in ontbrekende relaties, logische inconsistenties of onvolledige modellen⁷. Deze beperkingen belemmeren de betrouwbaarheid, beheersbaarheid en interpreteerbaarheid van directe generatie-benaderingen.

Om deze uitdagingen aan te pakken, presenteert dit artikel MAS4SysML, een SysML v2 codegeneratieframework met vier agentrollen. In plaats van direct te focussen op de eenmalige generatie van een volledig cross-view systeemmodel, richt deze studie zich op het genereren en iteratief repareren van meerdere representatieve SysML v2-modelleringstaken. Gedreven door taakontbinding en gestructureerde taakkaarten, en door codegeneratie, syntaxisdiagnostiek op toolniveau en verificatie van semantische consistentie, creëert MAS4SysML een gesloten loopproces van generatie, validatie en reparatie. Dit ontwerp verbetert de syntactische correctheid, semantische consistentie en structurele volledigheid van de gegenereerde code binnen een beperkt reparatiebudget.

De belangrijkste bijdragen worden als volgt samengevat: (1) MAS4SysML-raamwerk. Wij stellen MAS4SysML voor, een multi-agent, LLM-gedreven framework dat end-to-end generatie mogelijk maakt van natuurtaalvereisten tot uitvoerbare SysML v2-modelcode, en zo een praktische route biedt om de modelleringskosten te verlagen en de modelleringsefficiëntie te verbeteren. (2) Taakparsing en dubbele validatie. We introduceren een taakstructuur-boom-parsingsmechanisme en een duale validatieschema (syntaxis en semantiek). Bij taakparsing worden modelleerdoelstellingen hiërarchisch ontbonden en geformaliseerd in gestructureerde taakkaarten. Voor validatie maken syntaxisdiagnostiek gebruik van een officiële validatieomgeving⁸ om gegenereerde code te controleren en reparatiegerichte diagnostiek terug te geven, terwijl semantische validatie sleutelvelden in de taakkaarten gebruikt als referenties om de algehele consistentie tussen het gegenereerde model en de modelleringsdoelstellingen te beoordelen. (3) Experimentele evaluatie. We voeren vergelijkende experimenten uit waarbij syntaxisfoutpercentage en semantische consistentiescore als primaire metrieken worden gebruikt. De resultaten tonen aan dat MAS4SysML het gemiddelde foutpercentage in de syntaxis verlaagt tot 2,63 en de semantische gelijkenis verhoogt tot 0,91, waarmee het beter presteert dan baseline-methoden in generatienauwkeurigheid en automatisering.

Protocol

Het codegeneratieproces van het MAS4SysML-framework wordt samengevat in Supplementair Bestand 1. Het moet worden opgemerkt dat deze studie niet streeft naar het in één keer genereren van een compleet systeemmodel uit natuurlijke taal met strikte cross-view consistentie, inclusief vereisten, structuur, parametriek en gedrag. In plaats daarvan richt het protocol zich op het genereren van verschillende representatieve typen SysML v2 viewcode.

Fase I: Taakanalyse
De workflow begint met taakparsen. Het systeem levert de natuurlijk-taal modelleringsintentie aan de Task Structure Generation Agent, die een task-card set produceert. Om ervoor te zorgen dat volgende generaties uitvoerbaar en reproduceerbaar zijn, moet elke taakkaart minimaal (i) een taakidentificatie, (ii) afhankelijkheidsrelaties en (iii) belangrijke modelleringsinformatie voor validatie bevatten, zoals het modelleerdoel, beperkingen/randvoorwaarden, parameterslots en instantieatiewaarden, en de verwachte output. Deze fase levert task_card_set uit, die dient als de uniforme basis voor de daaropvolgende modelcodegeneratie.

Fase II: Iteratieve codegeneratie
Bij iteratieve generatie initialiseert het systeem de codecontext prev_code naar een lege toestand en genereert code voor elke taakkaart sequentieel volgens een volgorde bepaald door de afhankelijkheidsvelden. Voor elke taakkaart neemt de Code Generatieagent de huidige taakkaart en de contextuele code als invoer om candidate_code te produceren en roept vervolgens onmiddellijk de Syntax Validation Module aan voor controle. De module valideert de code met behulp van de officiële SysML v2 validatieomgeving en geeft diagnostische resultaten terug. Als validatie slaagt, wordt de candidate_code gebruikt om prev_code bij te werken en ondersteunt het de volgende generatie. Als validatie faalt, wordt de Code Repair Agent geactiveerd en voert hij minimale, gerichte bewerkingen uit die worden geleid door de teruggegeven diagnostiek, waarna de herstelde code opnieuw wordt ingediend voor hervalidatie. Deze reparatie-revalidatielus wordt begrensd door het maximale reparatiebudget K_max. Als validatie binnen het budget slaagt, wordt de passerende versie bijgewerkt prev_code; anders registreert het systeem na K_max-pogingen de storing en gaat verder met het genereren van de volgende taakkaart, waarbij de laatst gerepareerde versie als prev_code wordt gebruikt om te voorkomen dat de workflow wordt geblokkeerd en de contextuele continuïteit behouden blijft.

Fase III: Semantische validatie
Nadat de code voor alle taakkaarten is gegenereerd, gaat de workflow over naar semantische validatie. De Semantic Validation Agent beoordeelt de consistentie tussen de uiteindelijke code en de modeleringsintentie met behulp van sleutelvelden in task_card_set als referenties en geeft de resultaten van semantische validatie weer terug. Als validatie slaagt, wordt prev_code geaccepteerd als de definitieve SysML v2-modelcode. Anders genereert het systeem een Semantisch Deviatierapport dat onvervulde taakkaartvelden en de vereiste revisiescope identificeert. De Code Repair Agent herziet vervolgens de code en geeft de herziene modelcode als eindresultaat terug.

Modelarchitectuur en methodologie
Modelarchitectuur
Het MAS4SysML-raamwerk, geïllustreerd in Figuur 1, bestaat uit vier samenwerkingsagenten: de taakstructuurgeneratieagent, codegeneratieagent, codereparatieagent en semantische validatieagent. De bijbehorende prompttemplates worden weergegeven in Figuur 2.

De taakstructuurgeneratieagent voert semantische analyses uit van de intentie van de invoermodellering en genereert uitvoerbare, gestructureerde taakkaarten. Eerst past het een hiërarchisch taakontbindingsmechanisme toe (zie hiërarchisch taakontbindingsmechanisme) om het algemene modelleerdoel op te splitsen in taakknopen met goed gedefinieerde semantische grenzen en construeert vervolgens een gestructureerde taakkaart voor elke knoop. Vervolgens worden de taakkaarten geordend volgens hun modelleerafhankelijkheidsvelden om ervoor te zorgen dat de uitvoeringsvolgorde overeenkomt met de uiteindelijke codestructuur, waarmee de basis wordt gelegd voor bottom-up codegeneratie gedreven door het globale modelleringsdoel.

De code generatieagent genereert progressief SysML v2-conforme modelcode volgens de modelafhankelijkheden. Voortbouwend op de code-artefacten die door oudertaken worden geproduceerd, voert de agent de bijbehorende codegeneratiebewerkingen uit op basis van de vereisten die in elke taakkaart zijn gespecificeerd, waardoor een stapsgewijze constructie mogelijk wordt gemaakt—van lokale componenten tot het volledige model.

De code-reparatieagent corrigeert fouten in de gegenereerde code op basis van de resultaten van de syntaxisvalidatiemodule (zie syntaxisvalidatiemodule) en de semantische validatieresultaten. Voor syntactische reparatie maakt het gebruik van het fouttype, de positie en contextuele informatie die door de syntaxisvalidator worden teruggegeven om gerichte reparatiestrategieën te synthetiseren en gecorrigeerde code te genereren. Voor semantische reparatie past het structurele en logische relaties aan volgens de semantische validatieresultaten, waardoor semantische consistentie en structurele volledigheid in het uiteindelijke model worden gegarandeerd.

De semantische validatieagent beoordeelt de semantische consistentie tussen de volledig gegenereerde code en de taakkaarten met behulp van een speciaal semantisch validatiemechanisme (zie semantisch validatiemechanisme). Door kwantitatieve beoordeling wordt ervoor gezorgd dat de gegenereerde code de oorspronkelijke modelleerintentie nauwkeurig weerspiegelt, waardoor een precieze afstemming wordt bereikt tussen de modelcode en de gespecificeerde modelleringsvereisten.

Hiërarchisch taakontledingsmechanisme
Als formele modelleringstaal voor complexe systemen beschikt SysML v2 over strak gekoppelde syntaxis, diep geneste hiërarchische structuren en semantische beperkingen op verschillende niveaus. Een systeemstructuurblok kan bijvoorbeeld meerdere subonderdelen, attributen en poorten bevatten, terwijl tegelijkertijd prestatie- of gedragsvereisten worden uitgesproken via cross-layer beperkingen. Deze structuren en beperkingen creëren top-down structurele afhankelijkheden en bottom-up semantische feedbackrelaties. Met een vlakke, eenmalige generatiebenadering wordt het nauwkeurig in kaart brengen van dergelijke hiërarchische afhankelijkheden uitdagend, wat vaak resulteert in ontbrekende relaties, semantische inconsistenties of verlies van constraint-informatie.

Om deze uitdaging aan te pakken, ontwikkelen we een taakboomgebaseerde methode voor modellering van intentie-parsing die hiërarchisch de vereisten voor natuurlijke taalmodellering opsplitst. Zoals geïllustreerd in Figuur 3, worden complexe modelleerdoelen opgesplitst in gestructureerde en traceerbare taakknooppunten, waardoor het systeem modelleringssemantiek top-down kan interpreteren en afhankelijkheidsrelaties kan identificeren. Specifiek, wanneer de taakstructuurgeneratieagent de gebruikersinvoer ontvangt, maakt hij eerst gebruik van de semantische parsingmogelijkheden van LLM's om kernmodelleringsdoelstellingen, sleutelentiteiten en hun afhankelijkheden te identificeren. Vervolgens ontbindt het het topniveau doel recursief in semantisch onafhankelijke subtaken en verfijnt deze verder tot atomaire taken die direct kunnen worden gekoppeld aan SysML v2-modelleringsoperaties, waardoor uiteindelijk een complete taakstructuurboom ontstaat. Nadat de taakboom is opgebouwd, genereert de agent een gestructureerde taakkaart voor elke taakknoop op basis van een vooraf gedefinieerde template. Het formaat van de taakkaart wordt als volgt gedefinieerd:

TC = {id,O,N,K,P,V,C,D} (1)

Waarbij id de unieke identificatie van de taakknoop is, O het taakdoel, N de natuurtaalbeschrijving van de taak, K de kern SysML v2 semantische elementen aanduidt die bij de taak betrokken kunnen zijn, voornamelijk inclusief vereiste verdediging/vereiste, deel verdediging/deel, port verdediging/port, itemverdediging, attribuut verdediging/attribuut en toestand/transitie. Relaties tussen deze elementen worden voornamelijk uitgedrukt door verbinding (structurele verbindingen), invoer-/uitvoeritems op poorten (informatie-/materiaalstromen), en trigger/guard-condities van toestandsmachineovergangen (bijv. commando's, gezondheidsstatus en drempelbeperkingen), C als de semantische regels of randvoorwaarden, P als de parameteriseerbare slots binnen de taak zoals attribuutnamen, datatypes of samengestelde types, V als de geïnstantieerde waarden voor elke slot en D als de modeleringsafhankelijkheden tussen taken, waarbij depend_on de vereiste uitvoer van andere taken specificeert voordat de huidige taakcode wordt gegenereerd, geeft output aan die na voltooiing van de taak worden geproduceerd en consumes de externe invoer vertegenwoordigt die door de taak nodig zijn.

Syntaxisvalidatiemodule
Een syntaxisvalidatiemodule wordt opgebouwd op basis van de SysML v2 Pilot Implementation. Door zijn parser- en validatorinterfaces aan te roepen, parseert en verifieert de module de syntactische correctheid van de gegenereerde SysML v2-modelcode. De validatiecriteria van de module zijn voornamelijk afgeleid van de SysML v2-taalspecificatie, evenals de grammaticaregels, scope-resolutieregels en gerelateerde constraint-checkingmechanismen die zijn geïmplementeerd in de Pilot-tool. Specifiek onderzoekt de validatie of elementverklaringen goed gevormd zijn, of blokstructuren compleet zijn, of typeannotaties geldig zijn, of namen en referenties succesvol kunnen worden opgelost, en of modelleringsconstructies zoals poorten, verbindingen, toestanden en overgangen voldoen aan de eisen van de taal.

Nadat de codegeneratieagent het codefragment voor de huidige taak heeft geproduceerd, wordt de output doorgestuurd naar de syntaxisvalidatiemodule, waar het validatiescript de code analyseert en de resultaten teruggeeft in de vorm van gestructureerde diagnostische informatie. De validatieresultaten worden als volgt gerapporteerd:

e₁ = (type_i,pos i,msg _i) (2)

Waar e_i de lijst van gedetecteerde problemen voor de huidige modelleringstaak aanduidt, waarbij elke vermelding het fouttype _{type i}, foutlocatie pos_i en het diagnostische bericht msg_i bevat.

Als bijvoorbeeld de gegenereerde code een syntaxisfout bevat zoals "een attribuut wordt niet getypeerd door een attribuutdefinitie," geeft de validatiemodule het volgende diagnostische bericht terug:

'type' : 'error'
'message' : 'FOUT: Een attribuut moet worden getypeerd volgens attribuutdefinitie.' (3)
'positie' : 'regel 7 kolom: 3'

Wanneer het validatieresultaat e_{i 0} ≠ , wordt de verzamelde foutinformatie e_i doorgestuurd naar de code-reparatieagent voor verdere correctie. Daarom is het code-reparatieproces geen onbeperkte wijzigingsprocedure, maar een gerichte revisie, geleid door de expliciete diagnostische informatie die door de parser en validator wordt teruggegeven.

Semantisch validatiemechanisme
Het semantische validatiemechanisme gebruikt sleuteltaakkaartvelden die expliciete en traceerbare overeenkomsten met de modelcode hebben als semantische ankers. Het beoordeelt semantische consistentie op modelniveau en biedt daardoor expliciete, bruikbare criteria voor latere modelreparatie. Specifiek worden voor elke taakkaart TC_i de volgende velden gebruikt als belangrijke semantische referenties: (i) het modelleerdoel O_i, (ii) semantische beperkingen en randvoorwaarden C_i, (iii) geïnstantieerde parameterslotwaarden V_i, en (iv) verwachte uitvoer na taakvoltooiing D_i['lever']. Deze velden leggen complementaire semantische beperkingen op aan het gegenereerde model vanuit meerdere perspectieven: realisatie van modelintentie, voldoening aan beperkingen, consistentie van parameterinstantie en volledigheid van modeluitvoeren—waardoor een principiële beslissing mogelijk is of de modelcode aan de modelvereisten voldoet zonder extra aannames te vereisen.

Op basis van deze sleutelvelden definiëren we een meerveld-semantische consistentiebeslissingsfunctie:

(4)

waarbij I(·) een indicatorfunctie aanduidt die gelijk is aan 1 als alle subbeslissingsfuncties binnen de haakjes gelden, en 0 anders. Deze binaire beslissing maakt expliciet onderscheid tussen de toestanden van het voldoen aan de modeleringsvereisten en het vereisen van verdere reparatie, en biedt een deterministische triggervoorwaarde voor het daaropvolgende semantische reparatieproces. De algehele beslissing wordt gezamenlijk bepaald door de volgende vier subbeslissingsfuncties:

(1) Modellering van objectieve consistentie:

Φ₀ (TC_{i,c f}) = I(consist(c_{f,0 i})) (5)

waarbij Consist(c_{f,0 i}) aangeeft of de modelcode c_f semantisch consistent is met het modelleerdoel 0_i dat in de taakkaart is gespecificeerd.

(2) Semantische constraint satisfaction:

Φ_c (TC_{i,c f}) = I(Voldoet aan (c_{f,C i})) (6)

waarbij Satisfy(c_{f,C i}) aangeeft of de modelcode c_f voldoet aan de semantische beperkingen en randvoorwaarden C_i die in de taakkaart zijn gespecificeerd.

(3) Parameterconsistentie:

Φ_c (TC_{i,c f}) = I(Instant(c_{f,V i})) (7)

waarbij Instant(c_{f,V i}) aangeeft of de geïnstantieerde parameterwaarden V_i op de taakkaart consistent worden weergegeven in de modelcode.

(4) Outputconsistentie:

(8)

waarbij Artifacts(c_j) aangeeft of de door de taakkaart verwachte output aanwezig is in de uiteindelijke modelcode, en dient als maat voor de volledigheid van het gegenereerde resultaat.

Deze consistentieoordelen worden geïmplementeerd door de Semantic Validation Agent door gebruik te maken van de semantische begripscapaciteit van de LLM; Het interne redeneerproces van de agent verandert de formele definitie of het gebruik van de consistentiefunctie niet.

Door deze multi-veld semantische consistentiecontrole kan het gegenereerde model veld voor veld worden gevalideerd om te waarborgen dat elk modeldoel, beperkingsconditie, parameterconfiguratie en verwachte output voldoende wordt vervuld. Dit proces biedt niet alleen een expliciete trigger voor latere semantische reparatie, maar levert ook traceerbaar semantisch bewijs door de hele generatiepijplijn, waardoor de betrouwbaarheid en consistentie van het gegenereerde model verbetert.

Experimentele gegevens en evaluatie
Experimentele gegevens
SysML v2 modelcode is geen gewone softwarecode; de gegenereerde artefacten vertonen kenmerkende kenmerken van formele modellering. Verschillende opvattingen bevatten doorgaans verschillende categorieën van kernmodelleringselementen, zoals eisen, onderdelen, poorten, attributen, toestanden en overgangen, die aanzienlijk verschillen in hun verklaringsstijlen, organisatorische vormen en compositiestructuren. Daarnaast moet de modelcode aan meerdere beperkingen voldoen, waaronder typereferentie, hiërarchische genesing, verbindingsbeperkingen en semantisch hergebruik tussen elementen.

Om de prestaties van de voorgestelde methode onder verschillende modelleringscomplexiteiten volledig te evalueren, wordt een codedataset opgesteld die vijf representatieve modelweergavetypen omvat—eisen, use cases, structuur, parametriek en toestandsmachines. Deze modelweergaven komen respectievelijk overeen met vereistespecificatie, functionele interactie, structurele samenstelling, parametrische constraintrepresentatie en beschrijving van gedragslogica in systeemmodellering. Het afzonderlijk evalueren van het framework op verschillende modelweergavetypes maakt een fijnere analyse mogelijk van de toepasbaarheid onder diverse codestructuurkenmerken en modelbeperkingsvoorwaarden.

Elk modelweergavetype bevat 15 handmatig gemaakte modelinstanties, wat resulteert in een dataset van N = 75 SysML v2-modellen. De dataset beslaat meerdere engineeringdomeinen, waaronder lucht- en ruimtevaart, automotive, medische en slimme huissystemen, en alle modellen hebben met succes de officiële SysML v2-validatieomgeving doorstaan, wat strikte syntactische naleving garandeert.

Vervolgens genereerden we een bijbehorende natuurlijk-taal modelleerintentiebeschrijving voor elk model. Om de bouwefficiëntie te verbeteren, gebruikten we het prompttemplate dat in Supplementary File 2 wordt getoond en gebruikten we GPT-4o om de eerste beschrijvingen te produceren. GPT-4o werd geselecteerd vanwege zijn sterke semantische begrip en informatie-extractiecapaciteiten, waardoor het kernmodelelementen nauwkeurig kan vastleggen zonder hallucinaties en mensachtige modelintentiebeschrijvingen kan genereren⁹. Om nauwkeurigheid te waarborgen en ambiguïteit te elimineren, werden alle gegenereerde beschrijvingen handmatig beoordeeld en verfijnd door onderzoekers met een achtergrond in systeemengineering. Representatieve voorbeelden voor verschillende modeltypen zijn weergegeven in Tabel 1.

Evaluatiemetrieken
We gebruiken de volgende drie belangrijke metrics om de kwaliteit van de gegenereerde SysML v2-modelcode te evalueren:

Gemiddelde syntactische foutenkans (SER)
Deze metriek kwantificeert het aandeel syntactische fouten dat wordt gedetecteerd wanneer de gegenereerde modelcode wordt gevalideerd aan de hand van de officiële SysML v2-syntaxisregels. Het wordt berekend als:

(9)

waarbij E_i het aantal syntactische fouten aanduidt dat in het i-de gegenereerde model wordt geïdentificeerd. Deze metriek weerspiegelt in hoeverre de gegenereerde modelcode voldoet aan de formele SysML v2-syntaxisspecificatie.

Semantische consistentiescore (SCS)
Deze metriek evalueert hoe nauwkeurig en volledig de gegenereerde modelcode de semantische intentie vastlegt die in de natuurtaalmodelspecificaties wordt uitgedrukt. Specifiek extraheren we semantische eenheden uit de modelintentie—zoals systeementiteiten, deelnemende componenten, kernfuncties of gedragsscenario's, en sleutelvoorwaarden of beperkingen—en vergelijken deze met de semantische eenheden die aanwezig zijn in de gegenereerde modelcode. De semantische consistentie wordt berekend als:

(10)

waarbij U de verzameling semantische eenheden vertegenwoordigt die uit de modelintentie zijn geëxtraheerd, en de verzameling semantische eenheden die in de gegenereerde code zijn geïdentificeerd. geeft het aantal eenheden aan dat correct door de gegenereerde modelcode wordt vastgelegd. Een hogere SCS-waarde duidt op een sterkere semantische dekking en uitlijning.

Evaluatie van menselijke kwaliteit
Traditionele geautomatiseerde metrics zoals BLEU en CodeBLEU beoordelen voornamelijk oppervlakkige gelijkenis of code-uitvoerbaarheid, maar ze vangen niet vast of het model de bedoelde modelleringssemantiek echt begrijpt of correct uitdrukt. Deze metrics zijn beperkt in het evalueren van semantische consistentie, volledigheid van sleutelelementen en afstemming met de modelleerintentie¹⁰. Daarentegen kan menselijke evaluatie problemen zoals ontbrekende semantische elementen, logische inconsistenties, structurele redundantie of niet-ondersteunde hallucinaties nauwkeuriger identificeren, waardoor een betrouwbaardere^{beoordeling wordt} opgeleverd. Gemotiveerd door deze beperkingen ontwerpen we een menselijk evaluatiekader voor gegenereerde SysML v2-modellen, bestaande uit drie criteria: (1) Correctheid: het gegenereerde model moet de modelintentie nauwkeurig weerspiegelen, structurele en logische consistentie met de taakdoelstellingen behouden, en geen semantische ambiguïteit, ontbrekende elementen of foutieve uitbreidingen bevatten. (2) Leesbaarheid: de modelcode moet duidelijk en gemakkelijk te begrijpen zijn, met consistente naamgeving, een coherente structuur en een goed georganiseerde hiërarchie die inspectie en daaropvolgend onderhoud ondersteunt. (3) Integriteit: het model moet volledige structurele logica, consistente cross-element referenties en geen ongedefinieerde types of gebroken afhankelijkheidsketens vertonen, zodat het bruikbaar is voor downstream analyse en integratie. We nodigden onderzoekers met ervaring in SysML-modellering uit om elk gegenereerd model te scoren op een schaal van drie punten, waarbij 1 de laagste kwaliteit aanduidt en 3 de hoogste. Tijdens de evaluatie mochten beoordelaars de gegenereerde modelcode vergelijken met het grondwaarheidsmodel om een nauwkeurigere en meer uitgebreide beoordeling te garanderen.

Basislijn
We selecteerden meerdere evaluatiebaselines voor vergelijkend testen met de voorgestelde methode, waaronder:
CodeCoT¹²: Combineert chain-of-thought redeneren met een zelfcontrolemechanisme, waardoor het model expliciet kan redeneren tijdens het genereren en syntactische fouten zelf kan corrigeren, waardoor de codekwaliteit en semantische consistentie worden verbeterd.

Zelfplanning¹³: Introduceert een tweefasige codegeneratiepijplijn waarin het model eerst de oplossingsstappen plant en vervolgens code genereert volgens het plan, wat de logische samenhang en interpreteerbaarheid voor complexe taken effectief verbetert.

Zelfbewerking¹⁴: Hanteert een iteratief genereer- en bewerkparadigma dat de gegenereerde code uitvoert en automatisch fouten corrigeert op basis van runtime-feedback, waarbij de output continu wordt verfijnd.
CodeChain¹⁵: Gebruikt modulaire generatie en iteratieve revisie door complexe taken op te splitsen in onafhankelijke functionele modules en de structurele soliditeit en algehele kwaliteit te verbeteren via meerdere optimalisatierondes.

Zelf-debugging¹⁶: Geeft het model autonome debug- en uitlegmogelijkheden. Door een gesloten loopproces van generatie, uitvoering en debugging verbetert het de correctheid van complexe programmeertaken aanzienlijk zonder menselijke tussenkomst.

MapCoder¹⁷: Bouwt een meerfasig samenwerkingsraamwerk bestaande uit vier agenten—ophalen, plannen, coderen en debuggen—dat de workflow van menselijke programmering nauwgezet simuleert en gesloten-lus generatie mogelijk maakt van taakbegrip tot resultaatverificatie.

Zelfsamenwerking¹⁸: Organiseert het systeem als een virtueel programmeerteam met rollen als analist, programmeur en tester, waarbij de algehele prestaties bij complexe codegeneratie worden verbeterd door rolgebaseerde samenwerking en iteratieve feedback.

Experimentele opstelling
Om eerlijkheid en vergelijkbaarheid tussen experimenten te waarborgen, evalueerden we eerst verschillende gangbare LLM's met een directe codegeneratiebenadering om de basisprestaties vast te stellen. Op basis van deze eerste resultaten werd het best presterende LLM geselecteerd als het uniforme backbone-model voor alle daaropvolgende experimenten. Vervolgens hebben we het voorgestelde MAS4SysML-framework vergeleken met meerdere methoden voor representatieve codegeneratie. Alle LLM-interacties werden uitgevoerd met een vaste temperatuurinstelling (T = 0,2) om willekeur tijdens de generatie te minimaliseren. Voor elke modelleertaak werd het maximale aantal reparatieiteraties in MAS4SysML ingesteld op K_max = 3. Alle basismethoden werden uitgevoerd onder dezelfde experimentele configuratie als MAS4SysML om resultaatconsistentie en experimentele eerlijkheid te waarborgen. Het Python-script van de MAS4SysML-methode wordt geleverd als Supplementair Bestand 3.

Results

Evaluatie van het basismodel
We selecteerden eerst verschillende reguliere LLM's en voerden voorlopige prestatietests uit met directe model-naar-code generatie, waaronder CodeX(175B)¹⁹, CodeGen-Mono(16.1B)²⁰, PaLM Coder(62B)²¹, Alphacode(1.1B)²², Incoder(6.7B)²³ en code-davinci-002(175B)²⁴. Zoals weergegeven in Tabel 2...

Discussion

Wij stellen MAS4SysML voor, een multi-agent samenwerkingsraamwerk voor semi-geautomatiseerde SysML v2 modelcodegeneratie. Het raamwerk bestaat uit vier functioneel complementaire agenten. Tijdens de generatie ontbindt het (i) hiërarchisch de vereisten voor natuurlijke taalmodellering met behulp van een taakboom-gebaseerde structuur en formaliseert deze in gestructureerde taakkaarten, en (ii) genereert het SysML v2-modelcode op een bottom-up manier, geleid door de beperkingen en afhankeli...

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
LangChain	LangChain (open-source project)	v1.0.8; https://github.com/langchain-ai/langchain	Framework voor interactie met LLM en orkestratie van agenten
LangGraph	LangChain (open-source project)	v1.0.3; https://github.com/langchain-ai/langgraph	Framework voor uitvoering van workflows met meerdere agenten
Python	Python Software Foundation	3.10.x; https://www.python.org/downloads/release/python-3100/	Hoofdprogrammeertaal voor de implementatie van MAS4SysML
SysML v2 Pilot Implementation	Object Management Group (OMG)	(versie/tag release opgeven); https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation	Wordt gebruikt voor syntaxisvalidatie en modelparsing