🤖 machine learning

Towards Migrating Neural Network Implementations

Dit artikel stelt een geautomatiseerde aanpak voor en valideert deze voor het migreren van neurale netwerkcijfer tussen deep learning-frameworks, zoals PyTorch en TensorFlow, door gebruik te maken van een pivotmodel om een abstractie te creëren die functionele equivalentie garandeert terwijl de uitdagingen van handmatige migratie worden overwonnen.

Oorspronkelijke auteurs: Nadia Daoudi, Ivan Alfonso, Jordi Cabot

Gepubliceerd 2026-05-19

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Nadia Daoudi, Ivan Alfonso, Jordi Cabot

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een prachtige, complexe machine (een Neuraal Netwerk) hebt gebouwd met een specifieke set blauwdrukken en gereedschappen uit één land (laten we zeggen, TensorFlow). Nu besluit je bedrijf om naar een nieuw land te verhuizen waar iedereen een andere set gereedschappen gebruikt en een iets andere taal spreekt (PyTorch).

Het probleem? Je kunt je machine niet zomaar oppakken en verplaatsen. De tandwielen passen niet, de instructies zijn in de verkeerde taal en de onderdelen hebben een andere vorm. Normaal gesproken zou je de hele machine moeten uit elkaar halen en met de hand van scratch moeten herbouwen, wat eeuwig duurt en vatbaar is voor fouten.

Dit artikel presenteert een robotische vertaler die deze herbouw voor jou automatisch uitvoert.

Hier is hoe hun "magische vertaler" werkt, opgesplitst in eenvoudige stappen:

1. De "Universele Vertaler" (Het Pivot-model)

In plaats van direct te vertalen van Taal A naar Taal B (wat rommelig is omdat ze zo verschillend zijn), hebben de auteurs een Universele Taal bedacht (de BESSER-NN Metamodel genoemd).

Denk hierbij aan een universele adapter voor elektrische stekkers.

Stap 1: Ze nemen je oorspronkelijke machine (TensorFlow-code) en breken deze op in zijn basisonderdelen (lagen, verbindingen, instellingen). Ze vertalen deze onderdelen naar de "Universele Taal".
Stap 2: Ze nemen die Universele Taal en vertalen deze naar de taal van het nieuwe land (PyTorch-code).

Dit zorgt ervoor dat, ongeacht waar je begint of waar je eindigt, de kern-"ziel" van de machine hetzelfde blijft.

2. Het Drie-Stappenproces

De auteurs beschrijven hun methode als een drie-fasen assemblagelijn:

Fase 1: De Röntgenfoto (AST-extractie): Ze gebruiken een tool om een "röntgenfoto" te maken van de oorspronkelijke code. Dit zet de rommelige tekstcode om in een helder, georganiseerd boomdiagram (een Abstracte Syntaxboom) dat precies laat zien hoe de machine is opgebouwd.
Fase 2: De Vertaling (Transformatie): Ze kijken naar dat boomdiagram en herschrijven het naar hun blauwdruk in de "Universele Taal". Hier behandelen ze de lastige delen, zoals ervoor zorgen dat de nieuwe machine weet hoe groot de invoergegevens zijn, zelfs als de oude code dit niet expliciet aangaf.
Fase 3: De Constructie (Codegeneratie): Tot slot gebruiken ze een templatesysteem (zoals een "invulformulier") om de nieuwe code in de doeltaal (PyTorch of TensorFlow) te schrijven, gebaseerd op die universele blauwdruk.

3. De Moeilijke Hindernissen (Uitdagingen)

Het artikel geeft toe dat dit niet eenvoudig was. Ze moesten drie specifieke puzzels oplossen:

De "Ontbrekend Stukje"-puzzel: In de oude taal (TensorFlow) berekenen sommige onderdelen van de machine hun grootte automatisch op basis van wat je ze invoert. In de nieuwe taal (PyTorch) moet je de grootte expliciet opschrijven. De robot van de auteurs moest detective-werk verrichten om die ontbrekende maten te "gissen" en in te vullen, zodat de nieuwe machine niet zou crashen.
De "Verborgen Instructie"-puzzel: Soms zit de activatiefunctie (een schakelaar die de machine aanzet) verborgen in een variabele-naam in plaats van duidelijk uitgeschreven te zijn. De robot moest slim genoeg zijn om die verborgen naam te vinden en te vervangen door de juiste, expliciete instructie voor de nieuwe taal.
De "Linkshandig vs. Rechtshandig"-puzzel: Stel je voor dat in het ene land dozen worden verpakt met het handvat aan de linkerkant, en in het andere land met het handvat aan de rechterkant. Als je de doos gewoon verplaatst, past hij niet op het plankje. TensorFlow en PyTorch organiseren gegevens anders (de ene plaatst de "kleurkanalen" aan het einde, de andere aan het begin). De auteurs voegden een "herordening"-stap toe om de gegevens om te draaien, zodat de nieuwe machine ze correct kan lezen zonder het daadwerkelijke beeld te veranderen.

4. Werkte Het? (De Resultaten)

De auteurs testten hun robot op vijf beroemde neuraal-netwerkontwerpen (zoals AlexNet en VGG16). Ze probeerden ze heen en weer te verplaatsen tussen TensorFlow en PyTorch.

Werkte het bouwen? Ja. De nieuwe code draaide zonder fouten.
Dacht het hetzelfde? Ja. Ze voerden exact dezelfde afbeeldingen en getallen in bij zowel de oude machine als de nieuwe machine. De resultaten waren bijna identiek (verschillend met minder dan één miljardste procent).
Leerde het hetzelfde? Ja. Toen ze beide machines trainden op real-world data (zoals het herkennen van katten versus honden of filmrecensies), behaalden ze bijna dezelfde nauwkeurigheidscores.

De Conclusie

Het artikel beweert dat ze een tool hebben gebouwd die neuraal-netwerkcode automatisch kan vertalen van één groot framework naar een ander. Dit bespaart ontwikkelaars de moeite om handmatig duizenden regels code te herschrijven, en zorgt ervoor dat de nieuwe versie precies werkt zoals de oude, alleen in een andere "taal".

Ze vermelden ook dat dit past in een groter systeem waar software is ontworpen met behulp van modellen, maar hun hoofdfocus ligt strikt op de codevertaling zelf, niet op hoe de AI wordt gebruikt in ziekenhuizen of andere specifieke real-world toepassingen.

Technische Samenvatting: Op Weg naar Migratie van Neuronale Netwerkimplementaties

Probleemstelling

De snelle vooruitgang van neuronale netwerken (NN's) heeft geleid tot een proliferatie van deep learning (DL)-frameworks (bijv. PyTorch, TensorFlow). Hoewel organisaties deze frameworks adopteren om gebruik te maken van specifieke functies, prestatiekenmerken of community-ondersteuning, staan ze vaak voor de noodzaak om bestaande NN-implementaties later in de levenscyclus te migreren naar een ander framework. Deze migratie wordt gedreven door factoren zoals dalende prestaties, evoluerende eisen of de afschaffing van ondersteuning voor specifieke frameworks (bijv. Hugging Face die TensorFlow-ondersteuning afschaft).

Momenteel is er een aanzienlijk gebrek aan geautomatiseerde benaderingen die specifiek zijn toegespitst op het migreren van NN-code. Bestaande literatuur richt zich voornamelijk op het converteren van getrainde, direct bruikbare modellen (artefacten) in plaats van de broncode zelf. Bijgevolg worden organisaties gedwongen om NN-code handmatig vanaf nul te herschrijven, een proces dat tijdrovend, foutgevoelig is en de flexibiliteit belemmert om nieuwe functies te adopteren terwijl bestaande logica wordt hergebruikt.

Methodologie

De auteurs stellen een Model-Driven Engineering (MDE)-benadering voor om NN-code automatisch te migreren tussen DL-frameworks. De kern van de methode rust op een pivot-model om de broncode te abstraheren voordat de doelcode wordt gegenereerd. Het proces bestaat uit drie hoofdstappen:

1. AST-extractie

Het proces begint met het parsen van de code van het bronframework (Python) om de Abstract Syntax Tree (AST) te extraheren. De auteurs maken gebruik van de ast-bibliotheek van Python om de code te representeren als een boom van knopen, waarbij knopen overeenkomen met NN-componenten zoals lagen, tensorbewerkingen en hyperparameters. Deze stap ondersteunt zowel Sequential- als Subclassing-architecturen die voorkomen in PyTorch en TensorFlow.

2. Transformatie (Model-naar-Model)

De geëxtraheerde AST wordt getransformeerd naar een framework-onafhankelijke representatie met behulp van het BESSER-NN metamodel. Dit metamodel, onderdeel van het BESSER low-code-platform, dient als het pivot-model.

Mapping: Knopen uit de bron-AST (bijv. een TensorFlow Dense-laag) worden gemapt naar hun equivalenten in het BESSER-NN-model (bijv. een Linear-laag).
Attributen: Hyperparameters, trainingsconfiguraties en datasetdefinities worden eveneens gemapt naar het pivot-model.
Omgaan met architecturale verschillen: De benadering maakt gebruik van vier verschillende transformatiemodules om de vier combinaties van bron/doel-architecturen af te handelen (PyTorch/TensorFlow $\times$ Subclassing/Sequential).
Symbolische Tracing: Een kritisch aspect van deze stap is het symbolisch traceren van de broncode om attributen af te leiden die niet expliciet in de AST zijn gedefinieerd (bijv. invoervormen in TensorFlow), zodat het pivot-model alle noodzakelijke informatie bevat voor het doelframework.

3. Codegeneratie (Model-naar-Text)

Zodra het BESSER-NN pivot-model is ingevuld, genereren codegeneratoren de uiteindelijke implementatie in het doelframework.

Preprocessing: Python-scripts verwerken het BESSER-NN-model om kruisverwijzingen en afhankelijkheden tussen lagen op te lossen.
Template Engine: De Jinja-template engine wordt gebruikt om de abstracte concepten in het pivot-model te mappen naar de specifieke syntaxis van het doelframework (PyTorch of TensorFlow).
Ondersteuning voor Architecturen: Er zijn vier codegeneratoren ontwikkeld om alle architectuurcombinaties te ondersteunen, zodat complexe ontwerpen (zoals het definiëren van een netwerk binnen een andere klasse) behouden blijven.

Belangrijkste Bijdragen en Technische Uitdagingen

Het artikel adresseert verschillende specifieke technische uitdagingen die inherent zijn aan migratie tussen frameworks:

Ontbrekende Attributen (Invoervormen): In TensorFlow worden invoervormen vaak automatisch afgeleid, terwijl PyTorch een expliciete definitie vereist. De auteurs hebben dit opgelost door een stap voor symbolische tracing toe te voegen tijdens de transformatiefase om ontbrekende invoervorm-attributen (bijv. in_features, in_channels) af te leiden en in het pivot-model in te vullen voordat PyTorch-code wordt gegenereerd.
Dynamische Activeringsfuncties: TensorFlow staat toe dat activeringsfuncties dynamisch aan variabelen worden toegewezen en aan lagen worden doorgegeven, terwijl PyTorch doorgaans expliciete laagdefinities verwacht. De migratiebenadering lost dit op door de waarde van de activeringsfunctie te verifiëren; als het een bekende string is, wordt een standaardlaag gegenereerd. Als het dynamisch is, creëert de generator een aangepaste functiedie de activering tijdens runtime oplost, waardoor de oorspronkelijke logica behouden blijft.
Kanaalvolgorde-conventies: TensorFlow gebruikt "channel-last"-volgorde, terwijl PyTorch "channel-first" gebruikt. Om functionele equivalentie te behouden zonder het formaat van de invoergegevens te wijzigen, voegt de benadering permute-tensorbewerkingen in. Deze bewerkingen herschikken de tensordimensies voor en na convolutielagen in de doelcode om te aligneren met de native conventie van het framework, terwijl de gegevensstroom consistent blijft met de bron.
Systeemintegratie: Het artikel toont aan hoe het BESSER-NN metamodel kan worden geïntegreerd met algemene softwaremodelleringstalen zoals UML. Dit stelt NN's in staat om te worden gedefinieerd als gedragsimplementaties binnen bredere systeemmodellen (bijv. als methoden in een toestandsmachine), wat de migratie van NN's als onderdeel van een grotere migratie van slimme systemen faciliteert.

Experimentele Evaluatie

De auteurs hebben de benadering geëvalueerd met behulp van vijf verschillende neurale netwerken uit de literatuur: AlexNet, VGG16, LSTM, CNN-RNN en TF-Tutorial. Deze netwerken bestrijken 12 verschillende laagtypes en een mix van Sequential- en Subclassing-architecturen.

De evaluatie adresseerde twee Onderzoeksvragen (RQ's):

RQ1 (Migratiesucces): De benadering heeft alle vijf de netwerken succesvol gemigreerd over alle ondersteunde scenario's (PyTorch $\leftrightarrow$ TensorFlow, Sequential $\leftrightarrow$ Subclassing). De gegenereerde code werd zonder structurele fouten uitgevoerd bij het aanvoeren van dummy-invoergegevens.
RQ2 (Functionele Behoud): De auteurs verifieerden dat de gemigreerde netwerken outputs produceren die functioneel equivalent zijn aan de originele.
- Willekeurige Invoeren: Met behulp van identieke gewichten en willekeurige invoeren was het Maximum Absolute Verschil (MAD) tussen bron- en doeloutputs verwaarloosbaar (tot $5.96 \times 10^{-8}$ ).
- Benchmarksdatasets: Netwerken werden getraind op CIFAR-10, SVHN, IMDB en SST-2. De voorspellingsnauwkeurigheid van de gemigreerde netwerken was zeer consistent met de bronnetwerken, waarbij het grootste waargenomen verschil 0,022 bedroeg (voor VGG16 op CIFAR-10).

Betekenis en Claims

Het artikel beweert dat de primaire betekenis ligt in het verschuiven van de focus van het migreren van getrainde modellen naar het migreren van broncode. In tegenstelling tot bestaande tools (zoals ONNX, MMdnn, CoreML) die statische, getrainde artefacten converteren, migreert deze benadering de definitie van het netwerk zelf.

Deze onderscheiding is significant omdat het:

Iteratief experimenteren mogelijk maakt, waardoor ontwikkelaars het model kunnen inspecteren, wijzigen en opnieuw trainen binnen het nieuwe framework.
Model-gedreven pipelines ondersteunt, waardoor NN's als volwaardige burgers kunnen worden behandeld binnen bredere software-engineering workflows.
De "black box"-karakteristiek van artefactconversie vermijdt, waardoor de mogelijkheid behouden blijft om gebruik te maken van nieuwe functies en best practices van het doelframework.

De auteurs concluderen dat hun benadering effectief de kloof tussen DL-frameworks overbrugt, de handmatige inspanning vereist voor modernisering vermindert en functionele equivalentie behoudt. Zij merken op dat toekomstig werk zal bestaan uit het uitbreiden van het metamodel om meer geavanceerde AI-concepten te ondersteunen (bijv. Transformers, Graph Neural Networks) en het ontwikkelen van refactor-transformaties om de NN-structuur te verbeteren.