Bouw een Fine-Tuning Dataset van het Web: URLs naar JSONL
Een goede fine-tune is 90% dataset. Dit is de pijplijn van ruwe URLs naar schone JSONL — grootschalige bronverzameling, deduplicatie, licentiefilters en het chatformaat dat trainers daadwerkelijk verwachten.
Een fine-tune is alleen zo goed als de data die je erin stopt, en het moeilijkste deel van fine-tuning is bijna nooit de trainingsrun — het is het bouwen van een schone dataset. Het web is de rijkste bron van die data, maar ruwe pagina's zijn rommelig, gedupliceerd, niet gelabeld en juridisch ongelijk. Deze gids is de pijplijn van URLs naar trainingsklare JSONL: hoeveel data je daadwerkelijk nodig hebt, hoe je het op grote schaal verzamelt, hoe je het schoonmaakt en dedupliceert, hoe je omgaat met licenties en hoe je het formatteert in de chatstructuur die trainers verwachten. Het gaat ervan uit dat je een instructie- of chat-fine-tune bouwt van openbare webinhoud.
Hoeveel data heb je eigenlijk nodig?
Begin met realistische doelen zodat je niet te veel of te weinig bouwt. De praktische ondergrens voor een fine-tune die redelijke resultaten oplevert is ongeveer 100 rijen; voor solide prestaties wil je over het algemeen meer dan 1.000. Meer helpt meestal, maar alleen als het schoon is — duizend goed gelabelde voorbeelden verslaan tienduizend rommelige. Ter referentie, de klassieke Alpaca dataset bestond uit 52.000 instructie/output paren, gegenereerd door een sterker model te vragen. En als je een groot model gebruikt om synthetische voorbeelden te genereren, zaai het dan met ten minste tien handgeschreven voorbeelden zodat het de exacte structuur en toon leert die je wilt voordat het meer produceert.
Bronverzameling: crawl naar schone markdown
Het doel in de bronverzamelingsfase is schone tekst, niet ruwe HTML. Een fine-tuning rij wil de essentie van een pagina — het artikel, de documentatie, de Q&A — zonder de navigatiebalken, cookie-banners en advertentie-opmaak die een naïeve scrape vervuilen. Dus crawlen je doelpagina's en zet ze om naar markdown bij het inlezen, wat boilerplate verwijdert terwijl het structuren zoals koppen en lijsten behoudt. Bij enig echt volume zul je tegen snelheidslimieten en IP-blokkeringen aanlopen, dus routeer de crawl door een roterende pool. Een Scraper API die direct markdown retourneert doet beide taken — schone output en blokweerstand — in één oproep, daarom behandelen we het in onze gids voor het voeden van LLMs met verse webdata.
# Sketch: crawl target URLs to clean markdown, ready for shaping into rows.
import requests
API = "https://api.quantumproxies.io/scrape" # returns markdown, handles rotation
def fetch_markdown(url):
r = requests.get(API, params={"url": url, "format": "markdown"},
headers={"Authorization": "Bearer YOUR_KEY"}, timeout=60)
return r.json()["markdown"]
docs = [fetch_markdown(u) for u in seed_urls] # clean text, no boilerplate
Het JSONL-formaat dat trainers verwachten
De meeste moderne fine-tuning tools standaardiseren naar een conversatie-JSONL-formaat: één JSON-object per regel, elk met een messages array van rol/inhoud paren, waarbij rollen system, user en assistant zijn en de user/assistant beurten elkaar afwisselen. Dat is het chatformaat dat Hugging Face en OpenAI-stijl trainers inlezen. Oudere instructiedatasets gebruiken een drie-velden structuur (instruction, input, output) — prima voor enkelvoudige supervisie-tuning — en multi-turn conversatieformaten bestaan ook, maar ze kunnen gemakkelijk worden omgezet naar het messages-formaat. Kies één doelformaat en standaardiseer alles daarop.
// One training example per line (.jsonl). Chat / messages format:
{"messages":[
{"role":"system","content":"You classify support tickets by urgency."},
{"role":"user","content":"My payment failed three times and the event is tomorrow."},
{"role":"assistant","content":"high"}
]}
{"messages":[
{"role":"system","content":"You classify support tickets by urgency."},
{"role":"user","content":"How do I change my avatar?"},
{"role":"assistant","content":"low"}
]}Stem het formaat af op het trainingsdoel: ruwe tekst voor voortgezette pretraining, instructie-plus-uitvoer of multi-turn chat voor gesuperviseerde fine-tuning, gerangschikte antwoorden voor voorkeur-gebaseerde methoden. Als je een redeneer-fine-tune bouwt, behoud de vraag en het antwoord maar herschrijf het antwoord om de gedachtegangstappen op te nemen die je wilt dat het model leert.
Schoonmaken: waar kwaliteit wordt gewonnen
Dit is de fase die je resultaat bepaalt, en het is meestal onopvallend filteren. Ga er nooit van uit dat web-gebaseerde of modelgegenereerde rijen correct zijn — inspecteer ze. De terugkerende faalmodi zijn specifiek en het is de moeite waard om ze bij naam te controleren:
- Label inconsistentie: dezelfde categorie geschreven als "Positief" in de ene rij en "positief" in een andere — normaliseer hoofdletters en spelling.
- Off-target antwoorden: de assistent geeft een zin of een vervolgvraag in plaats van het exacte label of formaat waarvoor je traint.
- Verkeerd gelabelde rijen: een dubbelzinnige invoer toegewezen aan de verkeerde uitvoer — het meest schadelijke soort ruis.
- Boilerplate residu: navigatietekst, cookie-meldingen of "lees meer" fragmenten die de markdown-conversie hebben overleefd.
- Duplicaten: identieke of bijna identieke voorbeelden die het aantal rijen opblazen en het model bevoordelen naar herhaalde inhoud.
Een goede gewoonte is om zowel de pre-schoon als de schoongemaakte JSONL te bewaren zodat je kunt meten wat je hebt verwijderd. En balanceer de set over categorieën — een oververtegenwoordigde klasse leert het model om het te overvoorspellen.
Deduplicatie en licenties
Webdata zit vol herhalingen — gesyndiceerde artikelen, gespiegelde documenten, boilerplate paragrafen — en duplicaten schaden stilletjes een fine-tune door overgewicht te geven aan wat herhaald wordt. Doe twee passes: exacte-match deduplicatie door de genormaliseerde tekst te hashen om identieke rijen te vangen, en dan near-duplicate detectie (een gelijkenis- of shingling-techniek zoals MinHash) om herschreven kopieën te vangen die een exacte hash mist. Wees op het gebied van licenties doelbewust: niet alles wat openbaar is, is vrij herbruikbaar. Houd de bron en licentie van elk document bij, filter inhoud uit waarvan de voorwaarden training gebruik verbieden, en geef de voorkeur aan bronnen met duidelijke hergebruiktoestemmingen. Het is veel goedkoper om herkomst te registreren terwijl je crawlt dan om het te reconstrueren nadat je alles hebt gemengd.
Combineren, kaart en splitsen
Wanneer je uit verschillende bronnen haalt, standaardiseer ze allemaal naar één formaat en voeg ze samen in een enkele uniforme dataset voordat je gaat trainen — één schone fine-tune op de gecombineerde set verslaat sequentieel fine-tunen op elke bron, wat de neiging heeft om te eroderen wat het model eerder heeft geleerd. Schrijf dan een datasetkaart: een kort verslag van waar de data vandaan kwam, hoe het is schoongemaakt, de grootte en labelverdeling, de licenties en eventuele bekende beperkingen. Het is wat de dataset reproduceerbaar en controleerbaar maakt maanden later. Houd ten slotte een evaluatiesplitsing achter die je nooit traint, zodat je de fine-tune eerlijk kunt meten in plaats van het te scoren op data die het heeft gememoriseerd. Als je een retrieval systeem voedt in plaats van een fine-tune, behandelt onze RAG pijplijngids de verfrissingskant van hetzelfde probleem.
Veelgestelde vragen
Hoeveel rijen heb ik nodig om een LLM te fine-tunen?
Ongeveer 100 rijen is het praktische minimum voor redelijke resultaten, en meer dan 1.000 is een goed doel voor solide prestaties. Meer helpt over het algemeen, maar alleen als de data schoon blijft — een kleinere, goed gelabelde set verslaat een grote rommelige. Voor synthetische generatie, zaai de generator met ten minste tien handgeschreven voorbeelden zodat het eerst jouw exacte formaat leert.
In welk formaat moet fine-tuning data zijn?
JSONL — één JSON-object per regel. De meeste moderne trainers standaardiseren naar een conversatieformaat met een messages array van systeem/user/assistant rol-inhoud paren. Oudere instructiedatasets gebruiken instructie/input/output velden. Kies één doelformaat op basis van je trainingsdoel en standaardiseer elke bron daarop voordat je gaat trainen.
Hoe maak ik een gescrapete dataset schoon voor fine-tuning?
Zet pagina's om naar markdown om boilerplate te strippen, filter dan handmatig voor de veelvoorkomende fouten: inconsistente labels, off-target antwoorden, verkeerd gelabelde rijen en overgebleven navigatie- of cookietekst. Deduplicateer met een exacte hash en een near-duplicate pass, balanceer de categorieën, en bewaar zowel de ruwe als schoongemaakte versies zodat je kunt meten wat je hebt verwijderd.
Kan ik elke webinhoud gebruiken om een model te trainen?
Niet automatisch — openbaar betekent niet vrij herbruikbaar. Sommige inhoud heeft voorwaarden die training gebruik verbieden, en persoonlijke data brengt zijn eigen regels mee. Houd de bron en licentie van elk document bij terwijl je het verzamelt, filter alles uit waarvan de voorwaarden training verbieden, en geef de voorkeur aan bronnen met duidelijke toestemmingen. Dit is algemene informatie, geen juridisch advies; raadpleeg een advocaat voor commerciële datasets.
Het bouwen van een fine-tuning dataset van het web is een filterpijplijn: bron schone markdown, vorm het naar het messages-formaat dat je trainer verwacht, dedupliceer en label-check meedogenloos, filter op licentie, en kaart het resultaat. Krijg ongeveer duizend schone rijen en houd een eerlijke evaluatiesplitsing achter, en je besteedt je trainingsbudget aan signaal in plaats van ruis.