De meeste teams grijpen naar fine-tuning als het model steeds dezelfde dingen fout doet. Het deelt factuurvragen in bij technische support, schrijft in een toon die je merk nooit zou gebruiken, en mist de uitzonderingen die je experts toepassen zonder erbij na te denken. Wat ze willen, is bescheiden: een model dat antwoordt alsof het er al een jaar werkt.
De weg daarheen is een trainingsproject. Iemand verzamelt voorbeelden en schoont ze op, draait een sweep van trainingsjobs om de instellingen te vinden die werken, controleert het resultaat en brengt een nieuwe versie van het model uit. Het werkt, en het is een project, met een budget en een planning. Dan verandert er een beleid, of komt er een beter model uit, en begint het project opnieuw.
Duplex geeft je waar fine-tuning voor bedoeld is, uit het eigen werk van je team, en laat het model precies zoals het is. Elk resultaat dat je team bevestigt, leert Duplex iets, dus de aanpassing is actueel vanaf het volgende verzoek. En omdat het naast het model werkt in plaats van erin, gaat de aanpassing met je mee naar het volgende.
Een fine-tune herschrijft de gewichten, één model en één trainingsrun tegelijk.
Beter dan fine-tuning, zonder trainingsrun.
Fine-tuning verdient zijn plek. Het verandert de gewichten van het model, zodat het nieuwe gedrag bij elke aanroep meekomt, zonder lange prompt om mee te sturen, en voor een blijvende verandering aan één model is het een goede keuze.
De kosten zitten in alles rond de verandering. Elke aanpassing is een project op zich, en wat het model leerde, ligt vast op het moment dat de run eindigt. Een regel die op vrijdag verandert, wacht op de volgende run, en tot dan blijft het model de oude toepassen.
Waar teams voor fine-tunen, is meestal gedrag: de labels die ze gebruiken, de toon die ze willen, de beslissingen die hun experts elke keer op dezelfde manier nemen. Precies dat leert Duplex uit het werk zelf: een antwoord dat je team goedkeurde, een label dat iemand corrigeerde, een uitzondering die een manager bevestigde. Wie een fout ziet, corrigeert die, en de oplossing geldt vanaf het volgende verzoek, in plaats van in een map met voorbeelden te wachten op het volgende trainingsproject.
Duplex is gebouwd op ACI, Adaptive Continual Intelligence, dat tijdens runtime leert en handelt en de gewichten van je model met rust laat. Duplex heeft geen GPU nodig, dus er is geen trainingsrun om te plannen, te betalen of op te wachten, en geen nieuwe versie van het model om uit te brengen.
Rechtstreeks vergeleken met fine-tuning kwam Duplex er als winnaar uit. In zes tests, elk tegen een gefinetunede adapter die uit een sweep van trainingsruns was gekozen, paste het hetzelfde model aan, dat precies bleef zoals het was, en versloeg het de adapter elke keer, met gemiddeld 30.3 punten.
Zes tests: drie openbare datasets voor intentherkenning, elk getest op twee open modelfamilies.
Het gaat mee als jij van model wisselt.
Je AI is algemene intelligentie, langzaam geleerd, zoals de neocortex: hij leerde de wereld voordat jij er was, en je werk verandert hem niet. Duplex is runtime-intelligentie, snel, zoals de hippocampus: het leert van elk resultaat dat je team bevestigt. Fine-tuning vraagt de langzame leerder om het werk van de snelle te doen, en dat heeft twee kosten waar teams meestal pas later achter komen.
De eerste is corrigeren. Elk voorbeeld in een fine-tune wordt in de gewichten vermengd, het goede met het slechte, dus als er een fout blijkt, bijvoorbeeld een antwoord dat de korting van vorig jaar noemde, is er niets om aan te wijzen en eruit te halen. De weg terug is opnieuw trainen, zonder dat voorbeeld.
De tweede is overstappen. Een fine-tune hoort bij het model waarop hij getraind is, dus als er een beter model komt, blijft hij achter en begint het project van voren af aan: de sweep wordt opnieuw gedraaid, het resultaat opnieuw gecontroleerd, en tot die tijd weet het nieuwe model niets van je werk.
Wat Duplex leert, werkt naast het model, dus beide kosten vallen weg. Je ziet waar elke les vandaan kwam, en kunt die afzonderlijk corrigeren of verwijderen, terwijl al het andere blijft zoals het was. Wissel van model, en de aanpassing gaat met je mee: toen het werk naar een andere modelfamilie verhuisde, had Duplex geen hertraining nodig, terwijl de gefinetunede adapters in geen van de zes tests meegingen.
Één voorbeeld waarvan je model leerde, blijkt fout te zijn en moet eruit.
Als je wel wilt trainen, levert Duplex de data aan.
Sommige klussen vragen wel om training: een model dat iets moet kunnen wat het niet kan, of gewichten die zelfstandig moeten draaien, op een apparaat of in een product dat je uitbrengt. Voor die gevallen maakt Duplex de training beter.
Het moeilijkste deel van elk trainingsproject is de data: schone voorbeelden, gecontroleerd door mensen die het werk kennen. Precies die heeft je team al die tijd bevestigd, in de gewone loop van de dag. Duplex zet ze klaar voor je trainingsteam, elk met zijn herkomst erbij, en jij kiest wat erin gaat en wat erbuiten blijft.
Training vervangt ook niet wat Duplex leerde. Als het nieuwe model klaar is, werkt dat allemaal vanaf het eerste verzoek ernaast, blijft elk resultaat daarna Duplex iets leren, en gaat de aanpassing weer mee als het volgende model komt.
Aanpassen is niet langer een project met een budget en een planning, maar wordt deel van het werk. Je team corrigeert, bevestigt en beslist, zoals het elke dag doet, en je AI antwoordt alsof hij op dat alles getraind is. Het model blijft een keuze die je op elk moment kunt veranderen, en de aanpassing wordt iets wat je bezit.