Hoe gegevens te creëren voor het fijn afstemmen van LLM's

Het fijn afstemmen van een groot taalmodel (LLM) is slechts zo goed als de gegevens waarop het is getraind. Hoogwaardige, goed gestructureerde datasets bepalen rechtstreeks hoe goed het model instructies opvolgt, vragen beantwoordt en zich gedraagt in productie.

Deze gids behandelt het volledige proces van gegevensvoorbereiding voor LLM-fijnafstemming, van ruwe tekst tot een productieklaar dataset.

Belangrijkste punten

• Hoge kwaliteit data is belangrijker dan grote hoeveelheden bij het fijn afstemmen van LLM's. Schone, goed gestructureerde en taakgerichte datasets presteren consequent beter dan luidruchtige, te grote datasets.
• Begin met een duidelijk gedefinieerd doel voordat je gegevens verzamelt. Weten of je aan het verfijnen bent voor instructievolging, domeinspecialisatie of conversatiegedrag, bepaalt elke beslissing over de gegevens.
• Instructie–antwoordparen vormen de basis van effectieve fijnafstemming. Goed geschreven prompts met nauwkeurige, beknopte antwoorden helpen modellen om gewenste gedragingen sneller te leren.
• Een correcte gegevensindeling is van cruciaal belang. Het afstemmen van je dataset op het doelkader (JSON, JSONL of chatformaat) voorkomt fouten tijdens het trainen en verbetert de efficiëntie van het leren.
• Continue evaluatie en iteratie zijn noodzakelijk. Fijn afstemmen is een iteratief proces: resultaten monitoren, gegevens verfijnen en opnieuw trainen om optimale prestaties te bereiken.

Begrip van de gegevensvereisten voor LLM-fine-tuning

Fijn afstemmingsgegevens zijn geen ruwe tekst die van het internet is gehaald. In tegenstelling tot pretraining, waarbij modellen taalpatronen leren van een enorme corpus, leert fijn afstemmen een model hoe het zich moet gedragen. Het doel is om reacties vorm te geven zodat het model instructies opvolgt, vragen nauwkeurig beantwoordt en een consistente persoonlijkheid aanneemt.

In de praktijk betekent dit het omzetten van kennis in gestructureerde voorbeelden die een gebruikersintentie koppelen aan een ideaal antwoord. Elk gegeven punt laat het model expliciet zien hoe een goed antwoord eruitziet voor een bepaalde prompt. Na verloop van tijd internaliseert het model deze patronen en begint het ze te generaliseren naar ongeziene inputs.

De meeste moderne fine-tuning-pijplijnen zijn afhankelijk van ofwel instructiestijldata ofwel chatstijldata. Instructiestijldatasets bestaan uit een instructie, een optionele invoer en een uitvoer. Chatstijldatasets gebruiken rolgebaseerde berichten zoals systeem, gebruiker en assistent. Beide benaderingen hebben hetzelfde doel; de keuze hangt meestal af van het doelmodel en het trainingskader.

Gegevensindelingen voor LLM-finetuning

Voordat je een dataset aanmaakt of exporteert, is het cruciaal om de verschillende dataformaten die worden gebruikt voor LLM-fijnstelling te begrijpen. Het formaat dat we kiezen beïnvloedt direct hoe het model instructies interpreteert, het verloop van gesprekken leert en generaliseert naar het gebruik in de praktijk. Hoewel de meeste moderne trainingsframeworks meerdere formaten ondersteunen, dient elk formaat een iets ander doel en is het geschikt voor verschillende fijnstelingsdoelen.

Hier zijn een paar van de meest gebruikte dataformaten voor het verfijnen van modellen.

Voltooiingsstijl Formaat

Completion-stijl datasets zijn de eenvoudigste en meest traditionele vorm van fine-tuninggegevens. In dit formaat wordt het model een prompt getoond en getraind om de voortzetting te voorspellen. Dit formaat werd vaak gebruikt bij vroege GPT-stijl fine-tuning en wordt nog steeds ondersteund door veel API's.

Een voorbeeld in voltooiingsstijl ziet er meestal zo uit:

{
"prompt": "What is a Linux-Console.net GPU Droplet?
Answer:",
"completion": " A GPU Droplet is a virtual machine on Linux-Console.net that includes NVIDIA GPUs for AI, machine learning, and high-performance computing workloads."
}

In deze opzet leert het model tekst te blijven genereren na de prompt. Hoewel deze benadering eenvoudig is, heeft het beperkingen. Omdat de structuur impliciet is, kan het model moeite hebben met complexe instructies of gesprekken van meerdere beurten. Fijnslijning in completion-stijl is het meest geschikt voor taken met een beperkte reikwijdte, zoals korte antwoorden, classificatie of gecontroleerde tekstgeneratie.

Instructiestijl Formaat

Instructie-stijl fine-tuning maakt het leerdoel expliciet door de instructie duidelijk te scheiden van de verwachte output. Dit formaat is de facto de standaard geworden voor het aanpassen van open-source LLM's omdat het het opvolgen van instructies verbetert en ambiguïteit vermindert.

Een voorbeeld in instructiestijl bevat meestal drie velden: een instructie, een optionele invoer en een uitvoer. De instructie beschrijft de taak, de invoer biedt indien nodig aanvullende context en de uitvoer vertegenwoordigt de ideale reactie.

{
"instruction": "Explain what a GPU Droplet is in Linux-Console.net",
"input": "",
"output": "A GPU Droplet is a virtual machine provided by Linux-Console.net that comes with NVIDIA GPUs and is designed for AI, machine learning, deep learning, and high-performance computing workloads."
}

Dit formaat is zeer goed leesbaar en gemakkelijk te debuggen. Dit maakt het mogelijk om verschillende taaktypes te combineren, zoals uitleg, samenvattingen en probleemoplossing, binnen dezelfde dataset. Gegevens in instructiestijl zijn ideaal wanneer het doel is om een model te leren hoe het opdrachten betrouwbaar kan volgen en consistente, domeinspecifieke reacties kan produceren.

Chatstijl Formaat

Chat-stijl datasets zijn ontworpen om echte gesprekssituaties te weerspiegelen. Elk trainingsvoorbeeld bestaat uit een reeks berichten, waarbij elk bericht is gekoppeld aan een rol zoals systeem, gebruiker of assistent. Dit formaat sluit nauw aan bij hoe op chat gebaseerde LLM's in de praktijk worden gebruikt.

Een voorbeeld in chatstijl ziet er meestal zo uit:

{
"messages": [
{"role": "system", "content": "You are a helpful Linux-Console.net support assistant."},
{"role": "user", "content": "What is a GPU Droplet?"},
{"role": "assistant", "content": "A GPU Droplet is a virtual machine on Linux-Console.net equipped with NVIDIA GPUs, designed for AI, machine learning, and high-performance computing workloads."}
]
}

Het systeembericht definieert het gedrag en de toon van het model, terwijl de berichten van de gebruiker en de assistent de gespreksflow aanleren. Dit formaat is bijzonder effectief voor chatbots, klantenservicemedewerkers en assistenten die meerdere beurten ondersteunen.

Chat-achtige datasets zijn echter omslachtiger en iets complexer om samen te stellen. Ze zijn het meest geschikt wanneer de uiteindelijke toepassing conversatief en contextafhankelijk is.

Voordat we beslissen over het geschikte formaat voor het trainen van het model, moeten we eerst de specifieke taak die we willen bereiken verduidelijken.

Als we een model aanpassen voor eenvoudige prompt–response taken, kan completion-stijl data voldoende zijn. Voor de meeste domeinadaptatie- en instructie-volguse gevallen bieden instructie-stijl datasets de beste balans tussen duidelijkheid en flexibiliteit. Bij het bouwen van conversatieagents of assistenten die context en persoonlijkheid moeten behouden, zijn chat-stijl datasets de meest natuurlijke keuze. Wat het meest belangrijk is, is consistentie. Een goed gestructureerde, schone dataset in een van deze formaten zal beter presteren dan een grotere maar slecht ontworpen dataset.

Waar fijn-afstemmingsgegevens vandaan komen

Datasets van hoge kwaliteit voor fijn afstellen worden bijna altijd afgeleid van gezaghebbende bronnen. Deze omvatten productdocumentatie, API-referenties, interne supporttickets, artikelen in het helpcentrum en zorgvuldig samengestelde uitleg van experts. In veel systemen in de praktijk maken teams ook synthetische voorbeelden om randgevallen of ondervertegenwoordigde vragen te dekken.

Het is altijd nodig om betrouwbare bronnen te identificeren die de kennis en het gedrag weerspiegelen die we willen dat het model leert. Voor domeinspecifieke fijn-afstemming omvat dit vaak officiële documentatie, interne kennisdatabases, supporttickets, veelgestelde vragen en door experts geschreven handleidingen. Hoe dichter de gegevens bij echte gebruikersvragen en gezaghebbende antwoorden liggen, hoe effectiever het fijn-afgestelde model zal zijn. Soms kan er ook de noodzaak zijn om ethisch verantwoord webscraping uit te voeren om betrouwbare gegevens te genereren voor bepaalde domeinspecifieke chatbots.

In de praktijk vertrouwen veel teams op een combinatie van propriëtaire gegevens en open datasets. Platforms zoals Hugging Face spelen een centrale rol in dit proces. Hugging Face biedt duizenden openbaar beschikbare datasets die onderwerpen bestrijken zoals instructietuning, vraag-antwoord systemen, samenvatting en conversatietaken. Deze datasets kunnen direct worden gebruikt, worden aangepast aan een nieuw domein, of dienen als sjablonen voor het maken van aangepaste gegevens. Hugging Face Datasets bieden ook gestandaardiseerde tools voor laden, versiebeheer en streaming, waardoor grootschalige gegevensverzameling en -voorbewerking aanzienlijk eenvoudiger wordt.

LLM-gegenereerde gegevens en creatie van synthetische datasets

Een van de moderne methoden bij het fijn afstemmen van LLM's is het genereren van trainingsgegevens met behulp van een bestaande grote taalmodel. Deze aanpak, vaak aangeduid als synthetische datageneratie of door LLM gegenereerde data, is steeds populairder geworden omdat het de tijd en kosten die nodig zijn om hoogwaardige datasets op te bouwen aanzienlijk vermindert.

In deze workflow wordt een sterk basismodel aangestuurd om instructie–antwoordparen, vraag–antwoordvoorbeelden of gesprekken met meerdere beurten te genereren op basis van een vooraf gedefinieerd schema. De gegenereerde output wordt vervolgens beoordeeld, gefilterd en verfijnd voordat deze aan de dataset voor fine-tuning wordt toegevoegd. Wanneer dit zorgvuldig wordt gedaan, kan deze techniek gegevens opleveren die sterk lijken op echte gebruikersinteracties.

Door LLM gegenereerde gegevens zijn vooral nuttig wanneer er weinig door mensen geschreven voorbeelden beschikbaar zijn, bij het behandelen van randgevallen, of bij het uitbreiden van een bestaande dataset om dekking en diversiteit te verbeteren. Bijvoorbeeld, zodra we een kleine set vertrouwde Linux-Console.net-feiten hebben gedefinieerd, kan een LLM tientallen semantisch verschillende vragen en hoogwaardige antwoorden genereren, terwijl de consistentie met de oorspronkelijke kennis behouden blijft.

Echter, synthetische gegevens moeten met voorzichtigheid worden gebruikt. Modellen hebben de neiging om hun eigen vooroordelen en formuleringen te versterken, wat kan leiden tot overfitting of verminderde taalkundige diversiteit als de dataset volledig synthetisch is. Om deze reden werkt door LLM gegenereerde data het beste wanneer het wordt gecombineerd met door mensen samengestelde of gezaghebbende brongegevens. Menselijke controle, automatische validatiecontroles en deduplicatie zijn essentiële stappen in dit proces.

In productielijnen volgen teams vaak een hybride aanpak. Door mensen geschreven gegevens zorgen voor juistheid en toon, terwijl door LLM gegenereerde gegevens de dataset opschalen en hiaten opvullen. Deze balans stelt teams in staat sterke resultaten bij fijn afstellen te behalen zonder concessies te doen aan nauwkeurigheid of betrouwbaarheid.

Het Voorbereiden van Hugging Face Datasets voor LLM Fine-Tuning

Nu heeft Hugging Face een groot aantal open-source datasets die kunnen worden gebruikt om hoogwaardige fine-tuning data te creëren. Veel van deze datasets bevatten al instructie–reactieparen, maar moeten nog worden geformatteerd in een consistente promptstructuur voordat ze voor training worden gebruikt.

Voorbeeld_1:

from datasets import load_dataset
from itertools import islice

# Load Dolly dataset (non-streaming; small enough)
dataset = load_dataset("databricks/databricks-dolly-15k", split="train")

# Take first 1000 samples
samples = list(islice(dataset, 1000))

print("Dolly sample structure:")
print(samples[0])

# Format for instruction fine-tuning
def format_dolly(example):
   instruction = example["instruction"]
   context = example.get("context", "")
   response = example["response"]

   prompt_parts = [
       f"### Instruction:\n{instruction}"
   ]

   if context.strip():
       prompt_parts.append(f"### Input:\n{context}")

   prompt_parts.append(f"### Response:\n{response}")

   return {"text": "\n".join(prompt_parts)}

# Apply formatting
formatted_samples = [format_dolly(sample) for sample in samples]

Dolly sample structure:
{'instruction': 'When did Virgin Australia start operating?', 'context': "Virgin Australia, the trading name of Virgin Australia Airlines Pty Ltd, is an Australian-based airline. It is the largest airline by fleet size to use the Virgin brand. It commenced services on 31 August 2000 as Virgin Blue, with two aircraft on a single route. It suddenly found itself as a major airline in Australia's domestic market after the collapse of Ansett Australia in September 2001. The airline has since grown to directly serve 32 cities in Australia, from hubs in Brisbane, Melbourne and Sydney.", 'response': 'Virgin Australia commenced services on 31 August 2000 as Virgin Blue, with two aircraft on a single route.', 'category': 'closed_qa'}

Voorbeeld_2:

from datasets import load_dataset
from itertools import islice

dataset = load_dataset(
   "Open-Orca/OpenOrca",
   split="train",
   streaming=True
)

samples = list(islice(dataset, 1000))

def format_openorca(example):
   system = example.get("system_prompt", "You are a helpful assistant.")
   question = example["question"]
   answer = example["response"]

   text = (
       f"### System:\n{system}\n"
       f"### Instruction:\n{question}\n"
       f"### Response:\n{answer}"
   )

   return {"text": text}

formatted_samples = [format_openorca(s) for s in samples]

{   'text': '### System:\n'
            '\n'
            '### Instruction:\n'
            'You will be given a definition of a task first, then some input '
            'of the task.\n'
            'This task is about using the specified sentence and converting '
            'the sentence to Resource Description Framework (RDF) triplets of '
            'the form (subject, predicate object). The RDF triplets generated '
            'must be such that the triplets accurately capture the structure '
            'and semantics of the input sentence. The input is a sentence and '
            'the output is a list of triplets of the form [subject, predicate, '
            'object] that capture the relationships present in the sentence. '
            'When a sentence has more than 1 RDF triplet possible, the output '
            'must contain all of them.\n'
            '\n'
            "AFC Ajax (amateurs)'s ground is Sportpark De Toekomst where Ajax "
            'Youth Academy also play.\n'
            'Output:\n'
            '### Response:\n'
            '[\n'
            '  ["AFC Ajax (amateurs)", "has ground", "Sportpark De '
            'Toekomst"],\n'
            '  ["Ajax Youth Academy", "plays at", "Sportpark De Toekomst"]\n'
            ']'}

• Zorgt voor een consistente promptstructuur in alle voorbeelden,
• Gaat op een nette manier om met optionele invoer,
• Genereert een enkel "text"-veld dat naadloos werkt met tokenizers,
• Compatibel met LoRA, QLoRA en volledige fine-tuning-pijplijnen.

Zodra dit dataset is opgemaakt, kan het rechtstreeks worden getokeniseerd en doorgegeven aan een trainingslus met behulp van Hugging Face Trainer, SFTTrainer of aangepaste PyTorch-code. Tip:
Bekijk altijd een paar opgemaakte voorbeelden voordat je begint met trainen. Kleine inconsistenties in de opmaak kunnen het gedrag van het model tijdens fine-tuning aanzienlijk beïnvloeden.

Gegevens creëren voor domeinspecifieke LLM-fijnafstemming

Om een groot taalmodel fijn af te stemmen op een specifiek domein, zoals gezondheidszorg, juridisch, financiën of onderwijs, is het nodig om ruwe gegevens te verzamelen.

Deze sectie schetst een gestructureerde aanpak voor het creëren van hoogwaardige, domeinspecifieke fine-tuninggegevens. Definieer de Domeinreikwijdte en Doeltaken: Begin met het duidelijk definiëren van wat het model moet leren en hoe het zal worden gebruikt. Domeinspecifieke fine-tuning is het meest effectief wanneer de reikwijdte beperkt en taakgericht is.

Belangrijke vragen om te beantwoorden:

• In welke domeinkennis moet het model gespecialiseerd zijn?
• Welke taken zullen gebruikers uitvoeren met het model?
• Welk niveau van deskundigheid moeten de antwoorden weerspiegelen?

Voorbeelden:

• Gezondheidszorg: samenvatting van klinische aantekeningen, uitleg van medische concepten
• Financiën: interpretatie van financiële maatstaven, winstanalyses
• DevOps: loganalyse, probleemoplossing bij incidenten

Een goed gedefinieerde scope voorkomt dat lawaaierige of irrelevante gegevens de prestaties van het model verminderen. Verzamel hoogwaardige domeingegevens: Domeinspecifieke datasets moeten worden verkregen uit betrouwbare en gezaghebbende bronnen.

Veelvoorkomende gegevensbronnen zijn:

• Interne documentatie en kennisbanken
• Branche whitepapers en onderzoekspublicaties
• Technische handleidingen en productdocumentatie
• Ondersteuningstickets, veelgestelde vragen en klantinteracties
• Transcripties of aantekeningen van deskundigen

Zorg ervoor dat alle gegevensverzameling voldoet aan de privacy-, beveiligings- en licentievereisten.

Transformeer ruwe inhoud naar instructie–antwoordparen: Ruwe domeinteksten moeten worden omgezet in voorbeelden voor begeleid leren die het model leren hoe te reageren op domeinspecifieke vragen.

Elke sample zou een realistische taak moeten vertegenwoordigen die van het model wordt verwacht uit te voeren.

Voorbeeld (Financiën):

• Instructie: Leg EBITDA uit en de rol ervan bij de waardering van een bedrijf.
• Reactie: EBITDA staat voor winst vóór rente, belastingen, afschrijvingen en amortisatie, en wordt vaak gebruikt om de operationele prestaties van een bedrijf te beoordelen.

Deze transformatie kan handmatig worden gedaan, semi-automatisch met behulp van LLM-assistentie, of volledig programmatisch met validatie. Gebruik een Consistente Promptstructuur: Consistentie in de opmaak is cruciaal voor stabiele fijnafstemming. Een gestandaardiseerd prompt-sjabloon helpt het model om de grenzen van de taak en de verwachtingen van de respons te leren.

Aangeraden instructie-afstemmingsformaat:

### Instruction:
<Task description>

### Input:
<Optional domain context>

### Response:
<Expected output>

Deze structuur is breed compatibel met Alpaca-stijl, Dolly-stijl en LLaMA-gebaseerde fijnafstemmingspijplijnen.

Formatteer domeingegevens programmatisch: Zodra instructie–antwoordparen zijn gedefinieerd, kunnen ze worden omgezet in trainingsklare tekstvoorbeelden.

def format_domain_example(example):
    instruction = example["instruction"]
    context = example.get("context", "")
    response = example["response"]

    sections = [f"### Instruction:\n{instruction}"]

    if context.strip():
        sections.append(f"### Input:\n{context}")

    sections.append(f"### Response:\n{response}")

    return {"text": "\n".join(sections)}

Het resulterende „tekst”-veld kan direct worden getokeniseerd en doorgegeven aan workflows voor gesuperviseerd fine-tunen. Valideer de gegevenskwaliteit voordat u begint met fine-tunen: Controleer voordat het trainen begint handmatig een subset van de voorbeelden om te zorgen dat de gegevens feitelijk correct zijn, de instructies juist en eenduidig zijn, en dat het kwalitatief goede antwoorden zijn.

Slechte data, zelfs in kleine hoeveelheden, kan het gedrag van een model na fine-tuning aanzienlijk beïnvloeden. Voor meer informatie over dit onderwerp kun je de gedetailleerde blog over LLM-verontreiniging bekijken.

Kies een geschikte fine-tuningstrategie: Voor de meeste domeinspecifieke toepassingen:

• LoRA/QLoRA bieden snelle, kosteneffectieve aanpassing
• Volledige fijnafstemming biedt maximale prestaties tegen hogere kosten

De meeste teams behalen sterke resultaten door het gebruik van LoRA-gebaseerde supervisie-finetuning met goed samengestelde gegevens. We hebben al een stapsgewijze handleiding gemaakt die laat zien hoe je LoRA kunt gebruiken voor modelfinetuning met een aangepaste dataset. Kijk gerust in de sectie met bronnen voor meer informatie.

Het genereren van domeinspecifieke fine-tuninggegevens via webscraping

Webscraping is een praktische manier om domeinspecifieke inhoud te verzamelen uit openbare documentatie, blogs of kennisbanken. Eenmaal gescraped, kan deze ruwe tekst worden omgezet in instructie–antwoordparen voor gesuperviseerde fine-tuning.

Waarschuwing: Zorg er altijd voor dat de website scraping toestaat en dat dit op een ethische manier gebeurt.

Stap 1: Vereiste bibliotheken installeren

Gebruik pip om de benodigde bibliotheken te installeren.

pip install requests beautifulsoup4

Stap 2: Haal de inhoud op met Beautiful Soup

In dit voorbeeld halen we koppen en paragrafen van een technische documentatiepagina.

import requests
from bs4 import BeautifulSoup

def scrape_page(url):
    response = requests.get(url, timeout=10)
    response.raise_for_status()

    soup = BeautifulSoup(response.text, "html.parser")

    title = soup.find("h1")
    paragraphs = soup.find_all("p")

    content = {
        "title": title.get_text(strip=True) if title else "",
        "paragraphs": [
            p.get_text(strip=True)
            for p in paragraphs
            if len(p.get_text(strip=True)) > 100
        ]
    }

    return content

Stap 3: Zet gescrapete inhoud om in instructie–antwoordparen

Na het scrapen zetten we de ruwe tekst om in trainingsvoorbeelden die geschikt zijn voor instructie-afstemming.

def create_instruction_data(scraped_content):
    instruction = (
        f"Explain the following topic in a clear and concise manner: "
        f"{scraped_content['title']}"
    )

    response = " ".join(scraped_content["paragraphs"])

    return {
        "instruction": instruction,
        "response": response
    }

Stap 4: GegevensFormatting voor LLM Fine-Tuning

Formatteer tot slot de instructie–reactieparen in één enkele promptveld.

def format_for_finetuning(example):
    text = (
        f"### Instruction:\n{example['instruction']}\n\n"
        f"### Response:\n{example['response']}"
    )
    return {"text": text}

Stap 5: End-to-End Voorbeeld

url = "https://linux-console.net/community/tutorials/deploy-coreflux-mqtt-mongodb
"
scraped = scrape_page(url)

instruction_data = create_instruction_data(scraped)
formatted_sample = format_for_finetuning(instruction_data)

print(formatted_sample["text"][:500])

### Instruction:
Explain the following topic in a clear and concise manner: Deploy Coreflux MQTT Broker with MongoDB on Linux-Console.net

### Response:
MQTT brokersare essential for modernIoTinfrastructure andautomationsystems, where the need for a centralized, unified, and fast data hub is the key part for system interoperability and data exchange.Corefluxis a powerful,low codeMQTT broker that expands the traditional MQTT broker to a system that provides advanced features forreal-time dataprocessin

Het genereren van synthetische data met LLM's (zonder betaalde API's)

Het verzamelen en handmatig annoteren van domeinspecifieke gegevens is vaak duur en tijdrovend. Een praktisch alternatief is het genereren van synthetische gegevens met behulp van LLM's, waarbij een LLM wordt gebruikt om realistische instructie–antwoordparen op grote schaal te creëren. Vaak kunnen we een GROQ API-sleutel of andere betaalde diensten gebruiken om de LLM synthetische gegevens te laten genereren, maar in deze datastroom laten we zien hoe je synthetische klantenondersteuningsgegevens kunt genereren met een gratis, lokaal draaiende LLM van Hugging Face, waarbij geen API-sleutels of betaalde diensten nodig zijn.

Voorbeeld: Synthetische Klantenservice Data Generator

Het volgende voorbeeld gebruikt de Hugging Face transformers bibliotheek met een lichtgewicht open-source model (flan-t5-base) om instructie–antwoordparen te genereren voor klantenservice-scenario's.

Installeer afhankelijkheden

pip install transformers torch

Python-code: Genereren van synthetische gegevens met een lokaal LLM

import random
import json
from transformers import pipeline

class FreeSyntheticDataGenerator:
    def __init__(self):
        # Instruction-tuned model
        self.generator = pipeline(
            "text2text-generation",
            model="google/flan-t5-base"
        )

        self.templates = {
            "order_inquiry": [
                "Where is my order #{order_id}?",
                "Can you track order #{order_id}?",
                "What is the status of order #{order_id}?"
            ],
            "return_request": [
                "I want to return my {product}",
                "How do I get a refund for {product}?"
            ],
            "technical_support": [
                "My {device} is not turning on.",
                "I am facing error code {error_code} on {software}"
            ]
        }

        self.variables = {
            "order_id": ["12345", "67890", "ABC999"],
            "product": ["laptop", "phone", "headphones"],
            "device": ["laptop", "router", "tablet"],
            "software": ["Windows", "Android", "website"],
            "error_code": ["404", "E-001"]
        }

    def generate_examples(self, category, count=5):
        dataset = []

        for _ in range(count):
            instruction = random.choice(self.templates[category])

            for var, values in self.variables.items():
                instruction = instruction.replace(
                    f"{{{var}}}", random.choice(values)
                )

            prompt = f"""
You are a professional customer support agent.
Respond clearly and concisely.
Customer query: {instruction}
"""

            response = self.generator(
                prompt,
                max_length=150,
                do_sample=False
            )[0]["generated_text"]

            dataset.append({
                "instruction": instruction,
                "output": response.strip(),
                "category": category
            })

        return dataset


if __name__ == "__main__":
    generator = FreeSyntheticDataGenerator()
    samples = generator.generate_examples("order_inquiry", 3)
    print(json.dumps(samples, indent=2))

Uitvoerformaat voor fijnafstemming

Elk gegenereerd voorbeeld volgt een instructie-afstemmingsformaat, waardoor het geschikt is voor gesuperviseerde fijnafstemming (SFT):

[
  {
    "instruction": "What is the status of order #12345?",
    "output": "Order #12345 has been placed.",
    "category": "order_inquiry"
  },
  {
    "instruction": "What is the status of order #12345?",
    "output": "Your order is currently being processed and is expected to be delivered within the estimated delivery timeline.",
    "category": "order_inquiry"
  },
  {
    "instruction": "Where is my order #12345?",
    "output": "Where is your order #12345?",
    "category": "order_inquiry"
  }
]

Voel je vrij om ook andere gratis opties te verkennen; echter, als je betaalde API-opties gebruikt, kun je deze gebruiken voor het genereren van kwalitatieve synthetische data (en meer). Hier zijn enkele voorbeelden:

Betaalde API's zijn echter soms beter voor het genereren van synthetische gegevens, omdat ze gebruikmaken van grote, instructie-getrainde modellen die specifiek zijn getraind om aanwijzingen nauwkeurig te volgen en gestructureerde, hoogwaardige antwoorden te produceren.

In tegenstelling tot gratis of basismodellen, begrijpen betaalde API's intenties, rolinstructies en formatvereisten, wat resulteert in outputs die samenhangend, relevant en consistent zijn over duizenden voorbeelden. Dit vermindert aanzienlijk hallucinaties, herhaling en off-topic tekst, wat betekent dat de gegenereerde data veel minder handmatige schoonmaak vereist voordat het kan worden gebruikt voor fine-tuning.

Bovendien beheren betaalde API's schaalbaarheid, betrouwbaarheid en prestaties automatisch, waardoor teams snel grote hoeveelheden synthetische gegevens kunnen genereren en ze een efficiëntere en gemakkelijkere keuze maken voor datasets van productieniveau.

Waarom de kwaliteit van gegevens belangrijker is dan de hoeveelheid gegevens

Een van de meest voorkomende fouten bij het fijn afstemmen is het prioriteren van de grootte van de dataset boven de kwaliteit van de dataset. Grote hoeveelheden lawaaierige, repetitieve of dubbelzinnige voorbeelden kunnen de prestaties van het model juist schaden. Daarentegen levert een kleinere dataset met duidelijke instructies en precieze antwoorden vaak veel betere resultaten op.

Hoogwaardige fine-tuninggegevens hebben een paar kenmerkende eigenschappen. Elk voorbeeld richt zich op één enkele intentie, het antwoord is volledig maar beknopt, de toon is consistent in de hele dataset en er zijn geen tegenstrijdigheden of gefantaseerde feiten. Dubbele of bijna-dubbele voorbeelden moeten worden vermeden, tenzij herhaling bedoeld is voor versterking.

Als algemene regel geldt dat duizenden zorgvuldig samengestelde voorbeelden meestal voldoende zijn voor domeinaanpassing en gedragsvorming. We hebben pas tienduizenden voorbeelden nodig als we streven naar diepe specialisatie of een zeer breed scala aan taken willen bestrijken.

Veelgestelde vragen

Hoeveel gegevens zijn nodig om een LLM bij te stellen?

De hoeveelheid data die nodig is, hangt af van de fijn-afstemmingsmethode en de taak. Voor parameter-efficiënte fijn-afstemmingsmethoden zoals LoRA of QLoRA kunnen vaak hoge kwaliteit resultaten worden behaald met slechts 500 tot 5.000 instructie–reactie-paren. Volledige modelfijn-afstemming vereist doorgaans veel grotere datasets, vaak tientallen of honderden duizenden voorbeelden. In de meeste gevallen zijn de kwaliteit en relevantie van de data belangrijker dan de hoeveelheid.

Kan ik een LLM alleen met synthetische gegevens verfijnen?

Ja, LLM's kunnen worden bijgeschaafd met alleen synthetische gegevens, vooral voor goed gedefinieerde taken zoals klantenservice, samenvatting of domeinspecifieke vragen en antwoorden. Synthetische gegevens werken het beste wanneer ze worden gegenereerd met instructie-afgestelde modellen en worden geverifieerd via geautomatiseerde controles en menselijke toetsing. Veel productiesystemen gebruiken een mix van synthetische en echte gegevens, maar hoogwaardige synthetische gegevens alleen kunnen nog steeds sterke prestaties leveren.

Wat is het beste dataformaat voor LLM-fijnafstemming?

Het meest gebruikte en aanbevolen formaat is JSONL (JSON Lines), waarbij elke regel één trainingsvoorbeeld vertegenwoordigt. Voor instructieafstemming omvat dit meestal velden zoals instruction en output. JSONL wordt breed ondersteund door Hugging Face, PEFT (LoRA/QLoRA) en de meeste fine-tuning pipelines, waardoor het eenvoudig is om te streamen en op te schalen tijdens het trainen.

Hoe lang duurt de gegevensvoorbereiding?

De tijd voor gegevensvoorbereiding varieert afhankelijk van de grootte en complexiteit van de dataset. Voor kleine tot middelgrote datasets (1.000–5.000 monsters) kan de voorbereiding enkele uren tot een paar dagen duren, inclusief schoonmaken en validatie. Grotere of domeinspecifieke datasets kunnen meerdere dagen of weken in beslag nemen, vooral als menselijke validatie nodig is. Het automatiseren van delen van de workflow kan deze tijd aanzienlijk verminderen.

Hoe vaak moeten fine-tuninggegevens worden bijgewerkt?

Fijn afgestelde gegevens moeten worden bijgewerkt wanneer het domein, het gebruikersgedrag of de vereisten veranderen. Voor snel evoluerende producten of klantenservicesystemen zijn updates elke paar weken of maanden gebruikelijk. Regelmatige updates helpen het model nauwkeurig te blijven, verminderen afwijkingen en passen zich aan nieuwe terminologie, beleidslijnen of gebruikersverwachtingen aan.

Conclusie

Het voorbereiden van hoogwaardige data is de belangrijkste stap voor een succesvolle LLM-fine-tuning. Terwijl de keuze van het model en de trainingsmethoden vaak de meeste aandacht krijgen, zijn het de kwaliteit, structuur en relevantie van de data die uiteindelijk bepalen hoe goed een fijn-afgestemd model presteert. Een goed ontworpen datastroom die acquisitie, schoonmaken, validatie, bias-controles en menselijke beoordeling omvat, zorgt ervoor dat het model de juiste gedragingen leert en betrouwbare, afgestemde output levert.

Zoals in dit artikel werd aangetoond, hoeft gegevensvoorbereiding niet uitsluitend te vertrouwen op dure of moeilijk verkrijgbare datasets. Synthetische data, gegenereerd met behulp van instructie-getunede LLM's, kan, wanneer het wordt gecombineerd met de juiste kwaliteitscontroles, een effectieve en schaalbare oplossing zijn voor veel fine-tuning-toepassingen. Door gegevens in gestandaardiseerde formaten te exporteren en ze continu bij te werken naarmate de vereisten evolueren, kunnen teams fine-tuning-workflows opbouwen die zowel efficiënt als toekomstbestendig zijn. Uiteindelijk leidt het investeren van tijd in gegevensvoorbereiding tot stabielere modellen, betere generalisatie en sterkere prestaties in de praktijk.

Referenties en bronnen

• Genereer je eigen datasets om te experimenteren met fine-tuning op GPT-modellen
• Gegevens voorbereiden voor het fijn afstemmen van grote taalmodellen
• Fijn afstemmen van LLM's: Een gids met voorbeelden
• Inzicht in LLM-vervuiling

Bedankt dat je samen met de Linux-Console.net-community hebt geleerd.