Self-supervised learning: hoe modellen leren zonder gelabelde data

Elk machinelearningproject komt vroeg of laat op het punt dat je gelabelde data nodig hebt, en die labelen kost meer tijd en geld dan de meeste teams kunnen missen.

Een team inhuren om een miljoen afbeeldingen te taggen of een miljoen audiofragmenten te transcriberen kan in de tonnen lopen. Tegelijkertijd staat het internet vol met tekst, afbeeldingen, audio en video zonder labels. ML-teams hebben meer ruwe data dan ze ooit zullen gebruiken, maar bijna niets komt met de labels die nodig zijn om het model te trainen.

Self-supervised learning heeft die labelstap niet nodig. Het maakt van de eigen structuur van de data de trainingsinformatie. In plaats van mensen te betalen om te zeggen wat er op een afbeelding staat of wat een zin betekent, zet je een taak op die de data zelf al kan beantwoorden - zoals een woord verbergen en het model laten raden op basis van de woorden eromheen.

In dit artikel leg ik uit hoe self-supervised learning werkt, loop ik langs de belangrijkste technieken en laat ik zien hoe het zich verhoudt tot supervised, unsupervised en semi-supervised learning.

Wat is self-supervised learning?

Self-supervised learning is een manier om modellen te trainen zonder dat iemand de data eerst handmatig labelt.

In plaats van dat een persoon elk voorbeeld tagt, heeft de data z’n eigen antwoordsleutel. Het model bekijkt een deel van de input, verbergt een ander deel en leert door te proberen het gat op te vullen. Er is geen menselijke tussenkomst nodig.

Je kunt bijvoorbeeld een zin nemen, één woord verbergen en het model vragen het te raden aan de hand van de woorden eromheen. "The engineer pushed the ___ to the main branch" geeft het model genoeg context om "code" of "changes" te raden zonder dat iemand het juiste antwoord geeft. De zin zelf is het label.

Self-supervised learning zit in een vreemde positie tussen twee categorieën in. Het trainingsdoel lijkt op supervised learning - er is een duidelijke input, een duidelijk target en een verliesfunctie die meet hoe fout de gok was. Maar omdat geen mens die targets heeft gemaakt, wordt het meestal ingedeeld bij unsupervised learning, dat ook werkt op ruwe, ongetagde data. Self-supervised learning leent de mechaniek van de een en de databron van de ander.

Hoe werkt self-supervised learning?

Het proces volgt een herhaalbaar patroon, ongeacht met wat voor soort data je werkt. Dit zijn de stappen:

1. Begin met ongetagde data: Tekst, afbeeldingen, audio, video - het maakt niet uit, zolang je er maar veel van hebt.
2. Maak een leertask uit de data zelf: Dit heet een pretext task. Het is niet de taak waar je echt om geeft; het is een bedacht probleem dat het model dwingt iets nuttigs te leren. Een woord verbergen en het voorspellen is één voorbeeld.
3. Train het model om die taak op te lossen: Het model doet een gok, vergelijkt die met de echte waarde en past zich aan.
4. Leer bruikbare representaties: Terwijl het de pretext task oplost, bouwt het model een intern begrip op van de datastructuur, zoals grammatica, context, vormen en patronen.
5. Pas die representaties toe op downstream-taken: Zodra het model goede representaties heeft geleerd, richt je het op de taak die je eigenlijk wilde oplossen. Dit is de downstream-taak.

De pretext task is slechts een oefening. Niemand zet voor de lol een model in dat verborgen woorden voorspelt - de waarde zit in de representaties die het onderweg oppikt en die overdraagbaar zijn naar echte problemen.

Self-supervised learning versus andere leermethoden

De makkelijkste manier om self-supervised learning te begrijpen is te zien waar het overlapt met en verschilt van andere trainingsparadigma’s.

Self-supervised vs. supervised learning

Supervised learning heeft voor elke input een gelabeld voorbeeld nodig, zoals een afbeelding met het label "dog" of een review met het label "negative". Iemand moet die labels met de hand maken, wat kosten, tijd en een limiet betekent voor hoeveel data je realistisch kunt gebruiken.

Bij self-supervised learning krijgt het model nog steeds een target om te voorspellen, maar dat target komt uit de data zelf - een verborgen woord of het volgende token in een reeks. Er is geen menselijke annotatie nodig om het trainingssignaal te genereren.

Self-supervised vs. unsupervised learning

Beide methoden werken met ongetagde data, dus ze worden vaak verward. Het verschil zit in het doel.

Unsupervised learning zoekt naar structuur zonder een specifiek predictiedoel, zoals het clusteren van vergelijkbare klanten of het reduceren van de dimensies van een dataset. Self-supervised learning bouwt een expliciete predictietaak uit de data en traint het model om die op te lossen. Dat predictiedoel geeft self-supervised learning z’n supervised-achtige trainingslus, ook al zijn de labels zelf gegenereerd.

Self-supervised vs. semi-supervised learning

Semi-supervised learning mengt bewust een kleine gelabelde dataset met een grotere ongetagde, en gebruikt beide tegelijk om het model te verbeteren.

Self-supervised pretraining heeft helemaal geen labels nodig om te starten. Het kan volledig pretrainen op ongetagde data en later eventueel overgaan op een gelabelde dataset voor fine-tuning. Als labels al opduiken, is dat pas na de pretraining.

Self-supervised learning vergeleken met andere methoden

Typen self-supervised learning

Self-supervised methoden vallen in een paar brede families, elk rond een ander type pretext task gebouwd.

Contrastive learning

Contrastive learning traint een model om gerelateerde voorbeelden te onderscheiden van niet-gerelateerde. Het trekt de representaties van vergelijkbare voorbeelden naar elkaar toe en duwt niet-vergelijkbare uit elkaar, zonder ooit een handmatig label te gebruiken om "vergelijkbaar" te definiëren.

Twee geaugmenteerde versies van dezelfde afbeelding tellen als gerelateerd. Een afbeelding en het bijbehorende onderschrift ook. SimCLR past dit idee toe binnen één modaliteit, door verschillende crops of transformaties van dezelfde afbeelding te vergelijken. CLIP past het toe over modaliteiten heen, door afbeeldingen uit te lijnen met de tekst die ze beschrijft.

Masked modeling

Masked modeling verbergt een deel van de input en traint het model om die te reconstrueren. Het is hetzelfde idee als het invulvoorbeeld van eerder, maar dan breder toegepast.

In taal komt dit voor als masked language modeling, waarbij een handvol woorden in een zin wordt verborgen en voorspeld op basis van de rest. In vision komt het voor als masked image modeling, waarbij patches van een afbeelding worden verborgen en het model wordt gevraagd de ontbrekende pixels of hun onderliggende representatie te reconstrueren.

Autoregressief leren

Autoregressief leren voorspelt het volgende element in een reeks met alles wat eraan voorafging. Gegeven het begin van een zin voorspelt het model het volgende woord. Gegeven dat woord voorspelt het de volgende, enzovoort.

Dit is het doel achter de meeste moderne pretraining van taalmodellen. Het past van nature bij tekst, omdat taal al in een links-naar-rechts volgorde komt, en het schaalt netjes naar enorme tekstcorpora zonder extra setup.

Self-distillation

Self-distillation traint een model met z’n eigen voorspellingen als target, in plaats van een vast antwoord dat in de data verborgen zit.

Een veelvoorkomende opzet draait twee versies van hetzelfde netwerk - een "student" en een "teacher" - op verschillende views van dezelfde input. De student leert de output van de teacher te evenaren, en de teacher wordt bijgewerkt als een langzaam bewegend gemiddelde van de student. DINO en BYOL zijn representatieve benaderingen. Er zijn geen negatieve voorbeelden of gemaskeerde inputs nodig, omdat het model zijn eigen supervisie opbouwt uit consistentie over views.

Self-supervised learning in large language models

Self-supervision is de volledige pretrainingfase voor large language models. Elk groot LLM dat je gebruikt heeft taalstructuur, feiten en redeneerpatronen geleerd zonder één enkel door mensen geschreven label, puur door self-supervised pretext tasks op ruwe tekst op te lossen.

Next-token prediction

De meeste moderne LLM’s pretrainen op next-token prediction: gegeven een reeks tokens, voorspel welke daarna komt. Het model leest alles vóór een positie en raadt wat volgt, controleert zichzelf aan de hand van het daadwerkelijke volgende token en past zich aan.

Als je dat over triljoenen tokens van websites en coderepositories laat lopen, bouwt het model onderweg een werkend model van grammatica, feiten en zelfs redeneerpatronen op. Dit is hetzelfde autoregressieve doel als hierboven, maar dan op schaal toegepast.

Masked language modeling

Voordat autoregressieve pretraining de overhand kreeg, gebruikten modellen zoals BERT een andere pretext task. In plaats van te voorspellen wat erna komt, verbergt BERT willekeurige tokens door een zin en voorspelt die met context van beide kanten.

Die bidirectionele context maakt masked languagemodellen goed in begrijptaken zoals classificatie en vraagbeantwoording, ook al genereren ze geen tekst zoals next-token-modellen dat doen.

Leren uit grote tekstcorpora

Niets hiervan werkt zonder volume. Pretraining haalt data van webpagina’s, boeken, coderepositories en forums, gefilterd en gededupliceerd tot corpora met miljarden of biljoenen tokens. Hoe groter en gevarieerder het corpus, hoe algemener de resulterende representaties worden.

Pretraining is waar self-supervision z’n werk doet, maar het is niet de laatste fase. Fine-tunen op door mensen geschreven instructievoorbeelden leert het model instructies te volgen, en voorkeuroptimalisaties zoals RLHF of DPO gebruiken gerangschikte menselijke voorkeuren om de reacties te sturen. Beide latere fasen hebben gelabelde data nodig. Self-supervised pretraining is de enige fase die dat niet heeft.

Self-supervised learning in computer vision

Computer vision is hét domein waar niet genoeg gelabelde data is. Bounding boxes en segmentatiemaskers kosten veel meer tijd om te maken dan een enkele tag op een stuk tekst, wat self-supervised methoden hier extra waardevol maakt.

Contrastive beeldlearning past hetzelfde naar-elkaar-toetrekken, uit-elkaar-duwen idee toe dat eerder aan bod kwam, waaronder twee geaugmenteerde versies van dezelfde foto (een crop of een flip) nemen en het model trainen om ze als gerelateerd te herkennen, terwijl andere afbeeldingen in de batch als niet-gerelateerd worden behandeld. SimCLR is een bekend voorbeeld van deze aanpak voor afbeeldingen.

Masked image modeling neemt het invulidee uit taal en past het toe op pixels. Het idee is om patches van een afbeelding te verbergen en het model te trainen om de ontbrekende inhoud te reconstrueren, als ruwe pixels of als een geleerde featurerepresentatie. Dit is het doel achter MAE (Masked Autoencoders).

Afbeelding-tekstuitlijning traint een model om afbeeldingen te matchen met de onderschriften die ze beschrijven, waarbij overeenkomende paren bij elkaar in een gedeelde embeddingsruimte worden getrokken en niet-overeenkomende uit elkaar. CLIP is het bekendste voorbeeld en het is deels waarom modellen die zo getraind zijn zero-shot-classificatie ondersteunen - ze kunnen categorieën herkennen waarop ze nooit expliciet zijn getraind, simpelweg door een afbeelding te vergelijken met een tekstbeschrijving.

Self-supervised learning voorbij tekst en afbeeldingen

De pretext task volgt altijd de vorm van de data, dus overal waar je veel ongetagde data hebt, kun je er meestal een self-supervised taak omheen ontwerpen.

In spraak en audio voorspellen modellen gemaskeerde audiogedeelten of contrasteren ze verschillende clips op dezelfde manier als visionmodellen afbeeldingscrops contrasteren, waarbij ze representaties leren die handig zijn voor taken zoals spraakherkenning zonder vooraf getranscribeerde trainingsdata nodig te hebben.

In video kan de pretext task bestaan uit het voorspellen van toekomstige frames of het matchen van clips die uit dezelfde bronvideo komen, waardoor het model een gevoel voor beweging en temporele structuur krijgt dat een enkele afbeelding niet kan bieden.

Multimodale modellen combineren twee of meer van deze ideeën tegelijk en lijnen tekst, afbeeldingen, audio en video uit binnen een gedeelde representatieruimte, vergelijkbaar met hoe CLIP afbeeldingen en tekst uitlijnt, maar dan uitgebreid over meer datatypen.

Self-supervision duikt zelfs op in wetenschappelijke en sensordata - dingen zoals genomische sequenties of tijdreeks-sensormetingen - waar het maskeren of voorspellen van delen van het signaal een model structuur laat leren uit metingen die nooit bedoeld waren om in de eerste plaats "gelabeld" te worden.

Hoe self-supervised modellen downstream worden gebruikt

Pretraining levert een model op dat goed is in het oplossen van een pretext task. Daar zit niemand echt op te wachten; wat je daarna ermee doet, is wat telt.

Fine-tuning

Fine-tuning pakt het voorgetrainde model en traint al zijn gewichten verder, dit keer op gelabelde data voor de taak die je daadwerkelijk wilt. Omdat het model de structuur van het domein al begrijpt, heeft fine-tuning meestal veel minder gelabelde data nodig dan een model vanaf nul trainen.

Linear probing

Linear probing bevriest het voorgetrainde model volledig en traint alleen een enkele lineaire laag bovenop de output. Als een simpele lineaire classifier klassen kan scheiden met die bevroren features, dan vangen de voorgetrainde representaties echte structuur. Dit maakt linear probing een gangbare manier om de kwaliteit van representaties op zichzelf te testen, los van hoe goed het volledige model kan worden gefinetuned.

Feature-extractie

Feature-extractie werkt hetzelfde als linear probing, maar zonder het lineaire deel. Je neemt de bevroren representaties en voert ze aan elk downstream-algoritme dat je wilt. De enige taak van het voorgetrainde model is goede embeddings genereren; alles downstream daaraan is aan jou.

Zero-shot en few-shot gebruik

Sommige representaties zijn goed genoeg om helemaal zonder downstreamtraining te gebruiken. CLIP doet dit door een afbeelding en een set kandidaat-tekstlabels in dezelfde ruimte te embedden en vervolgens het label te kiezen dat het dichtst bij de afbeelding ligt. Few-shot learning pakt hetzelfde idee en voegt een klein aantal gelabelde voorbeelden toe, wat vaak genoeg is omdat de representaties al het grootste deel van de structuur dragen die een model nodig heeft.

Met self-supervised learning krijg je herbruikbare representaties. Je pretraint een keer en daarna kun je datzelfde kernmodel fine-tunen, proben, features uit extraheren of bevragen voor zoveel downstream-taken als je nodig hebt. Het meeste dure werk gebeurt één keer tijdens de pretraining, niet per taak.

Self-supervised learning in Python

Hier is een lichtgewicht voorbeeld met een voorgetraind model, geen self-supervised systeem vanaf de grond opgebouwd - puur om je een gevoel te geven voor de workflow.

all-MiniLM-L6-v2, beschikbaar via het pakket sentence-transformers, is voorgetraind met een masked language modeling-doel en daarna verder getraind met een contrastief doel op zinsparen. Dat is het self-supervised deel dat al voor je gedaan is - jij zet de resulterende representaties alleen aan het werk.

Zorg er om te beginnen voor dat je de dependencies installeert:

pip install sentence-transformers scikit-learn

Dan nu de code:

from sentence_transformers import SentenceTransformer
from sklearn.linear_model import LogisticRegression

# Create unlabeled data
support_tickets = [
    "My order arrived damaged and I need a replacement.",
    "The app crashes every time I try to upload a photo.",
    "I love how fast the checkout process is now.",
    "Can you tell me when my refund will be processed?",
    "The new dashboard layout is so much easier to use.",
    "I can't log in, it keeps saying my password is wrong.",
]

# Load a model pretrained with a self-supervised objective
model = SentenceTransformer("all-MiniLM-L6-v2")

# Obtain learned representations
embeddings = model.encode(support_tickets)
print(embeddings.shape)

Vorm van embeddings

De methode .encode() stuurt elk ticket door het voorgetrainde model en retourneert een dense vector die de betekenis weergeeft. Vanaf daar heeft een downstream-taak maar een handvol gelabelde voorbeelden nodig, omdat de embeddings het grootste deel van de structuur al meedragen:

# Use the representations for a downstream task, 1 = complaint, 0 = positive feedback
labels = [1, 1, 0, 1, 0, 1]

clf = LogisticRegression()
clf.fit(embeddings, labels)

new_ticket = ["The delivery was late and no one responded to my email."]
new_embedding = model.encode(new_ticket)
print(clf.predict(new_embedding))

Voorspelling van logistische regressie

Zes gelabelde tickets en een LogisticRegression-classifier zijn hier genoeg omdat de representaties, niet de classifier, het meeste werk doen.

Voordelen en beperkingen van self-supervised learning

Ik loop nu de voor- en nadelen van self-supervised learning langs.

Voordelen

1. Vermindert afhankelijkheid van handmatig gelabelde data: De pretext task genereert z’n eigen targets, dus labelbudgetten vormen niet langer een harde limiet voor hoeveel data je kunt trainen
2. Maakt gebruik van zeer grote datasets: Web-scale tekst- en audiocollecties worden bruikbaar voor training, niet alleen de kleine gelabelde subsets die teams zich konden veroorloven te annoteren
3. Levert overdraagbare representaties op: Eén voorgetraind model kan fine-tuning, linear probing, feature-extractie en zero-shot gebruik ondersteunen over een paar verschillende downstream-taken
4. Maakt grootschalige pretraining mogelijk: Dit is überhaupt de reden dat de foundationmodellen van vandaag mogelijk zijn.

Beperkingen

1. Aanzienlijke computevereisten: Pretraining op internet-schaal data vereist serieuze hardware en tijd, ver buiten bereik van de meeste individuele teams
2. Ontwerp van de pretext task is cruciaal: Een slecht gekozen pretext task levert representaties op die slecht overdragen, ongeacht hoeveel data je erin stopt
3. Geleerde representaties kunnen biases erven: Welke patronen, gaten of scheefheid in de trainingsdata zitten, duiken ook op in de representaties, want niets filtert ze tijdens de pretraining eruit
4. Sterke pretrainingprestaties garanderen geen downstream-succes: Een model dat z’n pretext task goed oplost kan nog steeds onderpresteren op een specifieke downstream-taak waarvoor het nooit direct is geoptimaliseerd

Waarom self-supervised learning belangrijk is voor moderne AI

Self-supervised learning is de reden dat foundationmodellen überhaupt mogelijk zijn.

Pretraining op de schaal die moderne modellen vereisen zou onhaalbaar zijn als het afhing van handmatige labels. Niemand labelt een biljoen tokens tekst of een miljard afbeeldingen met de hand. Self-supervision maakte het praktisch om te pretrainen op collecties op internet-schaal en dat ene model daarna te hergebruiken over een breed scala aan downstream-taken in plaats van voor elke taak een apart model te trainen.

Die verschuiving van veel taakspecifieke modellen naar één algemeen voorgetraind model dat voor veel toepassingen wordt aangepast, is de richting waarin het grootste deel van moderne AI is opgeschoven. Self-supervised learning is het mechanisme dat die stap mogelijk maakte.

Conclusie

Self-supervised learning genereert z’n eigen supervisie uit de structuur van ongetagde data in plaats van uit labels die een mens heeft geschreven. Het typische patroon is een woord verbergen of het volgende token voorspellen. De data beantwoordt z’n eigen vragen, en het model leert door te proberen die antwoorden goed te krijgen.

De belangrijkste benaderingen bouwen allemaal op datzelfde idee voort, elk op een andere manier. Contrastive learning trekt gerelateerde voorbeelden naar elkaar toe en duwt niet-gerelateerde uit elkaar. Masked modeling verbergt een deel van de input en traint het model om die te reconstrueren. Autoregressief leren voorspelt het volgende element in een reeks op basis van alles ervoor. De mechaniek verschilt, maar het onderliggende principe - de datastructuur zelf het trainingssignaal laten leveren - is hetzelfde.

Dat principe is waarom self-supervision achter de meeste taal-, visie- en multimodalemodellen zit die je al gebruikt. Next-token prediction pretraint de LLM’s van vandaag, contrastieve en gemaskeerde doelen pretrainen visionmodellen en afbeelding-tekstuitlijning pretraint de multimodale modellen die de twee verbinden.

Als je wilt leren een LLM from scratch te bouwen, schrijf je dan in voor onze Developing Large Language Models track om PyTorch, Hugging Face en de nieuwste NLP-technieken in actie te zien.