Software Dependencies 2.0: An Empirical Study of Reuse and Integration of Pre-Trained Models in Open-Source Projects
Deze studie onderzoekt hoe open-source-projecten pre-getrainde modellen als 'Software Dependencies 2.0' integreren en beheren door middel van een mixed-methods analyse van 401 GitHub-repositories.
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 softwareontwikkeling vroeger als het bouwen van een huis met Lego-blokjes was. Je kocht een doosje met specifieke blokken (bibliotheken), en je wist precies wat elk blokje deed: een raam, een deur, of een muur. Als je een ander blokje wilde, kon je dat makkelijk vervangen door een ander van hetzelfde formaat. Dit noemen de auteurs Software Dependencies 1.0.
Maar vandaag de dag is het bouwen van software veranderd. We gebruiken niet meer alleen simpele blokken, maar geavanceerde, zelflerende robots die we al vooraf hebben opgeleid. Dit zijn de Pre-Trained Models (PTMs). Denk aan deze robots als een superintelligente assistent die al miljoenen boeken heeft gelezen of miljoenen foto's heeft gezien voordat je hem ook maar hebt ingeschakeld.
Deze robots zijn zo krachtig dat ze nu een nieuw soort "bouwmaterialen" vormen. De auteurs noemen dit Software Dependencies 2.0.
Hier is wat het onderzoek vertelt over hoe developers met deze nieuwe "robots" omgaan, vertaald in alledaagse taal:
1. Het Grote Verwarringsprobleem (De "Vrijblijvende" Robots)
In het oude systeem (Lego) wist je precies welke blokjes je had en waar ze stonden. In het nieuwe systeem (Software 2.0) is het vaak een rommeltje.
- Het probleem: Ontwikkelaars gebruiken vaak meerdere van deze robots tegelijk. Soms zijn ze verwisselbaar (je kunt robot A vervangen door robot B omdat ze hetzelfde doen, net als twee verschillende merken koffiezetapparaat). Soms zijn ze aanvullend (robot A leest de tekst, robot B kijkt naar de foto, en samen maken ze een verhaal).
- De chaos: Het grootste probleem is dat niemand goed schrijft welke robots ze gebruiken. Vaak staat er alleen een hint in de code, of misschien een nootje in een document, maar vaak niet in een duidelijke lijst. Het is alsof je een huis bouwt met robots, maar niemand heeft opgeschreven welke robots er in de garage staan of welke versie van hun "brein" ze hebben. Dit maakt het heel moeilijk om te weten of je huis morgen nog veilig is als een robot-update uitkomt.
2. De Bouwplannen zijn anders (De "Aanpassings"-Fase)
Bij Lego volg je de instructies en klik je blokken op elkaar. Bij deze robots is het anders. Je haalt ze niet zomaar uit de doos en gebruikt ze direct.
- De aanpassing: De meeste ontwikkelaars moeten de robots aanpassen aan hun specifieke taak. Het is alsof je een robot die is getraind om auto's te herkennen, moet "omprogrammeren" om nu katten te herkennen.
- Drie soorten bouwstijlen: Het onderzoek vond drie hoofdmanieren waarop mensen deze robots gebruiken:
- De Verzamelaar: De robot haalt informatie uit een foto of tekst, en een andere, simpelere robot doet het echte werk (zoals een expert die een rapport schrijft op basis van de data van de eerste).
- De Schepper: De robot maakt iets nieuws, zoals een gedicht, een liedje of een afbeelding (denk aan AI-kunst).
- De Beslisser: De robot kijkt naar iets en zegt "ja" of "nee", of "dit is een hond, dat is een kat".
- Geen "Plug-and-Play": Het is zelden zo simpel als "insteeken en werken". Vaak moet je de robot een nieuwe "hoofd" geven (een extra laag toevoegen) of hem een beetje herscholen.
3. Het Grote Teamwerk (De "Robot-Feestjes")
Soms werken deze robots niet alleen, maar in een team.
- Het handover-systeem: Robot A pakt een idee en geeft het door aan Robot B.
- Het feedback-systeem: Robot A maakt iets, en Robot B kijkt erop en zegt: "Nee, dat is niet goed, probeer het nog eens." Robot B fungeert dan als een strenge leraar.
- De controleur: Robot A maakt iets, en Robot B kijkt alleen of het veilig is (bijvoorbeeld: "Is dit een gewelddadige afbeelding?").
- Het risico: Als Robot A verandert (bijvoorbeeld omdat de maker hem heeft bijgewerkt), kan Robot B in de war raken en het hele systeem laten crashen. Omdat ze zo nauw met elkaar verbonden zijn, is het moeilijk om te zien wie de schuldige is als er iets misgaat.
Waarom is dit belangrijk? (De Conclusie)
De auteurs zeggen: "We moeten stoppen met behandelen als deze robots gewoon nog een stukje code zijn."
Ze zijn anders. Ze zijn onvoorspelbaar (ze kunnen soms een foutje maken dat niet in de code staat), ze zijn afhankelijk van hun training (als de data verandert, verandert hun gedrag), en ze zijn moeilijk te traceren.
De boodschap voor de toekomst:
We hebben nieuwe gereedschappen nodig. Net zoals we in het verleden "verpakkingsbestanden" (zoals package.json) hebben uitgevonden om te weten welke Lego-blokjes we hebben, hebben we nu "model-verpakkingsbestanden" nodig. We moeten weten:
- Welke robot heb ik gebruikt?
- Welke versie van zijn brein?
- Hoe heb ik hem aangepast?
- Met welke andere robots werkt hij samen?
Zonder deze nieuwe regels en gereedschappen worden onze software-systemen steeds kwetsbaarder, net als een huis gebouwd met robots waarvan niemand weet wie ze zijn of wat ze precies doen. De auteurs noemen dit Software Dependencies 2.0: een nieuwe wereld waarin software niet alleen uit code bestaat, maar uit geleerd gedrag dat we moeten begrijpen en beheersen.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.