2026-01-04 · Bijgewerkt 2026-07-15

[!NOTE] Automatische vertaling Dit artikel is automatisch vertaald vanuit de oorspronkelijke Engelse versie.

LLM Fine-Tuning Gids: LoRA, QLoRA, DoRA, Unsloth, Axolotl en Deployment

De meeste fine-tuning-falen zijn besluitvormingsfouten. Een team traint eerst om te bewijzen dat prompting, retrieval, of constrained decoding het probleem niet kan oplossen; evalueert vervolgens op de trainingsverdeling; of ontdekt na het trainen dat het resultaat moeilijk te leveren is.

Deze gids beschouwt adaptatie als een experiment dat is voorzien van een operationele uitgangspunt. Ze begint met de beslissingsgrens en volgt vervolgens een bepaalde route door de gegevens, LoRA of QLoRA, evaluatie specifiek voor de taak, export en serving.

TL;DR: Pas de modelparameters aan wanneer een gemeten basislijn aantoont dat het aanpassen van het gedrag van model de moeite waard is voor een weight update. Gebruik retrieval voor het wijzigen van feiten en constrained decoding voor syntaxis. Begin met LoRA wanneer de basiskennisgebaseerde model nog voldoende ruimte biedt; gebruik QLoRA wanneer beperkte weight geheugencapaciteit een belemmering vormt. Houd een evaluatieset apart voordat je traint, vergelijk deze met de ongetunede basislijn, en kies het beste deployment resultaat voordat je je voor een bepaalde methode entscheids.

Moet u überhaupt fine-tunen?

Voordat u GPU uur besteedt, beslis eerst of fine-tuning het juiste hulpmiddel is voor het probleem dat u voor u heeft.

Fine-tuning versus RAG

Fine-tuning kan de manier waarop een model domeinstaal gebruikt veranderen, maar het vormt een zwak mechanisme voor het bijwerken van feiten die veranderen of geciteerd moeten worden. Retrieval en fine-tuning lossen verschillende aspecten van dit probleem op en horen vaak tot hetzelfde systeem.

Fine-tuning versus prompt engineering

Moderne LLMs-systemen reageren goed op duidelijke prompts-instructies en voorbeelden. Test deze opties alvorens u investeert in fine-tuning.

[!TIP] Probeer eerst te prompten Begin met een prompt en representatieve voorbeelden. Als alleen de syntaxis van de uitvoer onbetrouwbaar is, voeg dan constrained decoding toe voordat u de weights wijzigt.

Fine-tuning versus constrained decoding

Bibliotheken zoals xgrammar en outlines Beperk de generatie tot een JSON schema, reguliere expressie of grammatica. Afhankelijk van de beperking en backend, worden er een automaat of grammatica gecompileerd om ongeldige volgende tokens te maskeren. Er is geen weight update nodig.

Dit garandeert dat de uitvoer in de ondersteunde taal wordt geleverd – maar het betekent niet dat de waarden waar, compleet of semantisch gepast zijn. Een syntactisch geldige functieaanroep kan nog steeds een incorrecte klant-ID bevatten.

Een praktische volgorde:

1. Begin met prompting en few-shot voorbeelden voor basisformatering.
2. Voeg constrained decoding toe (xgrammar of outlines) wanneer de syntaxis inconsistent is.
3. Pas alleen fine-tuning toe wanneer u gedragsveranderingen nodig heeft die door een schema niet kunnen worden opgelegd.

Snelle referentie: het koppelen van problemen aan oplossingen

Zorg ervoor dat het zakelijke argument meetbaar is

Fine-tuning kan de frequente optredens van prompt tokens verminderen, of ervoor zorgen dat een kleinere model voldoet aan het doel, maar geen van beide besparingen is automatisch. Bereken het breakevenpunt op basis van uw eigen verkeerspatronen en prijzen:

[ \text{break-evenverzoeken} = \frac{\text{trainings- + evaluatie- + deployment kosten}} {\text{basiskosten/per verzoek} - \text{aangepaste kosten/per verzoek}} ]

Als de noemer klein is, negatief is, of is gebaseerd op een onbewezen kwaliteitsaannames, heeft het project nog geen economische haalbaarheid.

[!TIP] De hybride opstelling Een veelgebruikte architectuur bestaat uit een kleiner, op de taak aangepast model in combinatie met retrieval voor het aanpassen van feiten. Beschouw het grotere, via prompt gestuurde model als de referentie en houd het kleinere model alleen bij als het voldoet aan dezelfde taakspecifieke kwaliteits- en veiligheidsnormen.

Typen van fine-tuning

Er zijn drie hoofdvormen die fine-tuning kan aannemen. Ze verschillen qua het type gegevens dat ze nodig hebben en wat ze de model leren.

1. Voortzetting van het voortrainen (onbegeleid)

Je traint de basis model met meer ruwe tekst, zonder labels. Hij blijft volgende token-voorspellingen doen, net zoals tijdens de oorspronkelijke voortrainingsfase.

Wanneer het te gebruiken is:

• Het domein bevat een woordenschat die de basis model nog nooit heeft gezien (medisch, juridisch, interne codebases).
• U beschikt over grote hoeveelheden domeintekst, maar geen gelabelde (input, output)-paren.
• De basis model maakt fouten met domeinspecifieke terminologie.

Bijvoorbeeld: trainen op miljoenen klinische aantekeningen zodat de model medische afkortingen, geneesmiddelnamen en klinische workflows-termen kan herkennen.

2. Gemonitorde fine-tuning (SFT)

SFT wordt getraind op gelabelde (invoer, uitvoer)-paren. U geeft de model de exacte uitvoer die u voor elke invoer wilt hebben.

Wanneer het te gebruiken is:

• U beschikt over een specifieke taak met een duidelijk invoer/uitvoerformaat.
• U heeft kwalitatief gelaagde gegevens, zelfs in kleine hoeveelheden.
• U heeft behoefte aan voorspelbaar gedrag voor een bekende vorm van invoer.

Voorbeeld: training op paren van (beschrijving SQL-query, SQL-code) voor text-to-SQL.

{
    "input": "Get all users who signed up last month",
    "output": "SELECT * FROM users WHERE signup_date >= DATE_SUB(NOW(), INTERVAL 1 MONTH)"
}

3. Instructietuning

Instruction tuning is een speciaal geval van SFT dat erop gericht is om models in staat te stellen verschillende instructies in natuurlijke taal op te volgen. De trainingsgegevens bestaan uit (instructie, reactie)-paren voor tal van uiteenlopende taken.

Wanneer het te gebruiken is:

• U wilt een algemeen doelwit assistent (zoals ChatGPT of Claude).
• De model moet omgaan met uiteenlopende, open eindige verzoeken.
• U bent bezig met het bouwen van een chatinterface.

Voorbeeld: training op duizenden verschillende instructies zoals “Vat dit artikel samen,” “Schrijf een gedicht over X,” “Leg Y eenvoudig uit.”

Vergelijking

[!NOTE] Wat mensen daadwerkelijk doen SFT en instructietuning maken gebruik van hetzelfde volgende token doel; het verschil ligt in de omvang en de opbouw van de dataset. Voortgezet voortrainen is een apart experiment en moet worden gevolgd door tests zowel naar verbeteringen in het specifieke domein als naar een eventuele regressie in de algemene capaciteiten.

De 7-stappige fine-tuning pipeline

Fine-tuning is een pipeline, en geen afzonderlijke opdracht. Elke fase kent zijn eigen manieren om te falen, en het overslaan van één fase leidt meestal ertoe dat er later een slechte model optreedt.

Elke fase is gebaseerd op de vorige:

1. Data voorbereiding — Bepaal de evaluatie-eenheid, verdeel de gegevens en reinig en formeer ze vervolgens
2. Model selectie — Kies de juiste basis model en laad weights in
3. Trainingsinrichting — Stel de hardware, hyperparameters en optimalisatiestrategie in
4. Fine-tuning — Voer SFT, DPO of ORPO-training uit
5. Evaluatie — Beoordeel de prestaties van Benchmark en controleer de kwaliteit
6. Deployment — Exporteer en serveer je model
7. Monitoren — Houd de prestaties in de gaten, onderhoud het systeem en voer iteraties door

[!WAARSCHUWING] Gegevens vormen de basis Het trainen reproduceert systematische fouten in de voorbeelden. Controleer eerst de labels, lekken, de dekking en de naleving van de richtlijnen, voordat je tijd besteedt aan het optimaliseren.

Fase 1: Voorbereiding van de gegevens

De meeste fine-tuning-projecten mislukken hier, en niet tijdens het trainen. Moderne data-preparatie omvat meer dan alleen het toepassen van reguliere expressies op CSV-bestanden.

De 5-fasen dataverwerking pipeline

Hulpmiddelen zoals DataTrove en Distilabel kunnen op grote schaal van pas komen, maar de pipeline moet worden bepaald door de taxonomie van fouten en het gegevenscontract, en niet door een voorkeurshulpmiddel.

1. Invoer en filtering

• Actie: verwijder afwijzingen (“Ik kan daarop geen antwoord geven”), corrupte UTF-8-gegevens en talen die niet het doel zijn.
• Hulpmiddelen: Trafilatura voor extractie, FastText voor het bepalen van de taalidentificatie.

2. Beleid met betrekking tot gevoelige gegevens

• Actie: bepalen wat model mag leren, en vervolgens persoonlijke en vertrouwelijke velden indien nodig verwijderen, tokeniseren of uitsluiten.
• Hulpmiddelen: Microsoft Presidio of scrubadub.
• Reden: een detector is slechts één vorm van controle; er zijn nog steeds vereisten met betrekking tot herkomst, toestemming, opslagduur, toegang en verwijdering.

3. Duplicatieverwijdering (MinHash LSH)

• Actie: verwijder bijna-identieke elementen zodat de model ze niet onthoudt.
• Hulpmiddelen: DataTrove kan verwerking op terabayschaal goed aan.

4. Synthetische augmentatie, indien nodig

• Actie: gebruik een krachtigere ‘teacher’ model (GPT-4o, DeepSeek-V3) om ruwe gegevens om te zetten in gezuiverde instructie-antwoordparen.
• Hulpmiddelen: Distilabel.
• Validatie: neem voorbeelden van de uitvoer van de ‘teacher’, controleer deze tegen dezelfde beoordelingscriteria als die voor menselijke labels, en houd bij de evaluatie de synthetisch gegenereerde en door mensen geschreven segmenten gescheiden.

5. Formatering

• Actie: converteren naar een standaardformaat (Alpaca of ShareGPT).

Voorbeelden van gegevensformaten

Alpaca-formaat (instructieopvolging):

{
    "instruction": "Summarize the following text.",
    "input": "The text to be summarized...",
    "output": "This is the summary."
}

ShareGPT/ChatML-formaat (conversatief):

{
    "conversations": [
        { "from": "user", "value": "Hello, who are you?" },
        { "from": "assistant", "value": "I am a helpful AI assistant." }
    ]
}

Wat er echt toe doet

• Dekking boven volume. Voeg voorbeelden toe die verschillende fallemodi weergeven, in plaats van herhalingen van de gemakkelijk voorkomende meerderheidscasus.
• Zuiverheid. Verwijder irrelevante tekst, normaliseer witruimte en houd de opmaak consistent.
• Balans. Behoud belangrijke, zeldzame gevallen en rapporteer de prestaties per segment.
• Scheiding. Verdeel de gegevens op basis van bron, gebruiker, document of tijd, wanneer willekeurige rijindelingen bijna-identieke elementen zou onthullen.
• Herkomst. Noteer de bron, licentie of toestemming, het transformatieverloop en het verwijderingsproces voor elke versie van dataset.

Fase 2: selectie van Model en hardware

Het kiezen van de basis model en het begrijpen van de GPU grens bepalen wat er daadwerkelijk kan worden getraind.

Begin met de kleinste basis model die al de onverhandelbare basistesten doorstaat. Bevestig:

• Licentie- en herverdelingsvoorwaarden voor het gewenste product;
• Taal, domein, gebruik van hulpmiddelen en veiligheidsgedrag vóór aanpassing;
• tokenizer en compatibiliteit van chattemplates met dataset;
• Maximale contextgrootte en tronkerverwerking die nodig is bij echte voorbeelden;
• Ondersteuning zowel in de trainings- framework- als in de doel- serving- engine.

Fine-tuning is een aanpassingsstap, en geen reparatie van een ongeschikte basis. Als de model de functionaliteiten niet kan bieden die door dataset worden ondersteund, moet u een andere basis kiezen voordat u meer epochs verzamelt.

Stel de omvang van de uitvoering in, niet het marketingniveau

Er bestaat geen stabiele tabel voor de relatie “model grootte → GPU”. De maximale geheugengebruikswaarde verandert afhankelijk van de weight precisie, de optimizer, het aantal te trainen parameters, de lengte van de sequentie, de grootte van de micro-batches, het gebruik van activation checkpoints, de attention implementatie en de framework overhead. Begin met een schatting van het benodigde geheugen en voer vervolgens een korte smoke test uit met de maximale mogelijke lengte op de exacte stack.

Het oorspronkelijke artikel QLoRA past een 65B LLaMA model op één 48 GB GPU binnen zijn specifieke configuratie. Dat resultaat vormt een nuttige bovengrens, maar het garandeert niet dat elke huidige 70B-architectuur, contextlengte, kernel of trainingsmethode op dezelfde hardware past.

Geheugencalculaties

Voor een model met (P) parameters vereisen alleen al de weights ongeveer (2P) bytes in BF16/FP16, of (0,5P) bytes wanneer ze worden opgeslagen in vier bit per byte, nog voordat er rekening wordt gehouden met de quantization-metadata en de runtime-buffers. Bij volledige training in Adam-stijl worden ook gradients, optimizer-toestanden en vaak master-weights-variabelen met hogere precisie opgeslagen. LoRA vermijdt het grootste deel van de geheugenruimte die nodig is voor trainbare toestanden; QLoRA verkleint daarnaast ook het geheugeverbruik van de gefrozeerde base-weight-structuren. Activations blijft zelfs bij lange sequenties vaak dominanter.

Gebruik deze workflow:

1. Kies de langste sequentie en micro-batch die u moet ondersteunen.
2. Schat weights en de trainbare toestand in, waarbij ruimte overblijft voor activations en kernels.
3. Voer één voorwaartse/nachterwaartse stap uit bij maximale lengte.
4. Noteer de maximale toegewezen en gereserveerde geheugensommen.
5. Pas pas daarna de batchgrootte, het aantal processoren, de sequentielengte of het aantal GPU aan.

Fase 3: Trainingsmethoden (PEFT en LoRA)

Volledige fine-tuning versus PEFT

Een volledige fine-tuning (FFT) actualisatie vindt om de weight plaats, zodat de gradienten en de toestand van de optimizer samen met de gehele model schalen. De benodigde hoeveelheid geheugen kan niet alleen op basis van het aantal parameters worden bepaald, maar deze ligt ruim boven het geheugen dat nodig is om de weights te laden voor inference.

Parameter-efficiënt fine-tuning (PEFT) betekent dat er slechts een klein deel van de parameters wordt getraind, terwijl de overige parameters worden vastgezet. Hierdoor wordt de wiskundige benadering aanzienlijk eenvoudiger.

LoRA: het uitgangspunt

LoRA (Low-Rank Adaptation) betekent dat een vooraf getrainde matrix wordt vastgelegd, waarbij de daarbij behorende geleerde bijgewerking wordt weergegeven door middel van twee kleinere matrices. Het oorspronkelijke artikel stelt dit onderbouwd door de hypothese dat bruikbare adaptatiebijgewerkingen een lage intrinsieke rang hebben.

Voor een bevroren matrix (W0 \in \mathbb{R}^{d{out} \times d_{in}}), leert LoRA het volgende:

• (A \in \mathbb{R}^{r \times d_{in}})
• (B \in \mathbb{R}^{d_{out} \times r})

De aangepaste laag is:

[ W’ = W_0 + \frac{\alpha}{r}BA ]

De adapter bevat (r(d*{in}+d*{out})) trainbare parameters in plaats van (d*{in}d*{out}) voor die matrix. Voor een vierkante matrix met een breedte van 4.096 bij rang 16 betekent dit een vermindering van 128× voor de matrix—niet 10.000× zoals in het geval van een willekeurige model. De claim van 10.000× in het artikel over LoRA gold specifiek voor een GPT-3 175B-configuratie die geselecteerde matrices aanpaste.

Vergelijking van PEFT-methoden

Wanneer welke te kiezen

• LoRA: begin hiermee. Snel, geheugen-efficiënt en goed ondersteund.
• QLoRA: wanneer hetzelfde LoRA-experiment niet mogelijk is vanwege een vastgelegd basis-weights-model.
• DoRA: nadat een eerlijke LoRA-vergelijking een nuttige verbetering heeft opgeleverd.
• Volledige fine-tuning: pas nadat PEFT is uitgevoerd, wordt een geëvalueerde bottleneck gebruikt in plaats van een veronderstelling.

DoRA: weight-gedecomposeerde LoRA

DoRA (Weight-Decomposed Low-Rank Adaptation) scheidt de grootte van elke weight-vector van diens richting. Er wordt een LoRA-update toegepast op het richtingscomponent, terwijl de grootte apart wordt aangeleerd.

Hoe het werkt:

In plaats van weights te behandelen als één enkele entiteit, splitst DoRA de vooraf getrainde weights op in twee componenten:

1. Magnituden — een trainbare waarde per weight-vector.
2. Richting — een genormaliseerde vector die wordt bijgewerkt met behulp van lage-rang matrices.

In compacte kolomweergave:

[ W’ = m \frac{V + BA}{\lVert V + BA \rVert_c} ]

waar:

• m = grootte (te trainen)
• (V) = de gefroren richtingsmatrix
• (BA) = de geleerde, lage-rangse richtingsupdate
• (\lVert \cdot \rVert_c) = kolomsgewijze normalisatie

Wat je krijgt voor die extra structuur:

• Meer vrijheidsgraden dan standaard LoRA, aangezien de grootte onafhankelijk kan veranderen.
• Betere resultaten dan LoRA in verschillende configuraties, zoals gemeld in het onderzoekspaper.
• Er zijn extra parameters en rekenwerk nodig, waardoor de voordelen moeten worden gevalideerd voor uw specifieke taak en serving-pad.

Samenvoeging van adapters voor multitasklearning

Afzonderlijke adapters maken het mogelijk dat één gecongeleerde basis meerdere taken ondersteunt. U kunt verzoeken naar een adapter routeren, meerdere adapters vanuit één engine leveren wanneer dit wordt ondersteund, of een offline gefuseerde versie creëren. Fusie kan interferentie veroorzaken; beoordeel daarom het gefuseerde resultaat in plaats van ervan uit te gaan dat de oorspronkelijke adapters zich zuiver combineren.

Gebruikelijke methoden voor samenvoegen:

1. Concatenatie — samenvoegen van adapterparameters om de effectieve rang te verhogen. Snell en eenvoudig.
2. Lineaire combinatie — gewogen som van adapters. Geeft u controlemogelijkheden.
3. SVD — matrixontleding voor samenvoeging. Flexibeler, maar trager.

Voorbeeld: één adapter voor samenvatting, een andere voor vertaling, die zijn samengevoegd tot één enkele multitask model.

Fase 4: Fine-tuning en alignement van voorkeuren

SFT leert aan de hand van demonstraties. Optimalisatie op basis van voorkeuren leert daarentegen door middel van vergelijkingen, zoals ‘de geselecteerde reactie A is beter dan de afgewezen reactie B’. Gebruik deze methode alleen wanneer een paarvoorkeur de juiste manier is om de fout te beschrijven; feitelijke correctheid en naleving van richtlijnen vereisen vaak een sterkere evaluators dan een algemene voorkeur.

PPO-gebaseerde RLHF

Het oorspronkelijke recept bestond uit een drie-stappen pipeline-proces:

1. SFT — de taak leren begrijpen.
2. Beloning model — trainen op menselijke voorkeuren (gekozen versus afgewezen).
3. PPO (Proximal Policy Optimization) — versterkingsleren om de beleidsregels te optimaliseren.

De operationele kosten zijn afhankelijk van de bewegende onderdelen:

• Moeilijk om te implementeren en in stand te houden.
• Duur — er moeten meerdere models worden getraind.
• On-policy sampling en beloningsoptimalisatie vereisen zorgvuldige controles op stabiliteit en beloningsmanipulatie.

DPO

DPO (Direct Preference Optimization) schaft de expliciete beloning model en de RL-loop af. Het optimaliseert nog steeds het RLHF-doelstelling (beloningsmaximalisatie onder een KL-divergentiebeperking), maar doet dit als een herparameteriseerd probleem van gecoördineerd leren in plaats van met versterkend leren:

{
    "prompt": "Explain quantum computing",
    "chosen": "Quantum computing uses qubits...",   # Preferred response
    "rejected": "Well, it's complicated..."        # Non-preferred response
}

Wat operationeel verandert:

• Een eenvoudiger codepad (geen aparte beloning model, geen RL-lus).
• Een offline doelstelling gebaseerd op voorkeursparen in plaats van op-policy reinforcement learning.
• Een referentiebeleid of equivalente referentielogwaarschijnlijkheden in de standaardformulering.

DPO is gemakkelijker te prototyperen dan een volledige PPO pipeline, maar dit leidt niet automatisch tot een verbeterde kwaliteit. De resultaten hangen af van de startpolitiek, de kwaliteit van de paren, de instellingen voor verlies, lengte-effecten en het evaluatieprotocol. Vergelijk het met een SFT checkpoint op dezelfde apart gehouden preferentiestellingen en taaksets.

ORPO

ORPO (Odds-Ratio Preference Optimization) combineert de SFT negatieve log-likelihood-verliesfunctie met een straf op basis van de odds-ratio voor afgewezen antwoorden. Hierdoor is er geen aparte referentie meer nodig model, waardoor taakleren en optimalisatie van voorkeuren in één enkele uitvoering kunnen worden gecombineerd.

Hoe het werkt: ORPO maakt gebruik van een gecombineerde verliesfunctie die twee dingen tegelijk doet:

1. Maximaliseert de waarschijnlijkheid van de geselecteerde reactie (takenleren).
2. Straft de afgewezen reactie met een odds-ratio-term (voorkeurenleren).

Hyperparameters die het waard zijn om te kennen:

from trl import ORPOConfig

config = ORPOConfig(
    learning_rate=8e-6,  # Very low, as recommended by the ORPO paper
    beta=0.1,            # Controls strength of preference penalty
    # ... other params
)

• Leren snelheid: het artikel gebruikte lage waarden in zijn experimenten; stel deze af op basis van uw model, batchgrootte en dataset, in plaats van om een vaste waarde als regel te overnemen.
• Beta: bepaalt de gewichtingsfactor ten opzichte van de SFT-term.

De afweging:

• Eén trainingsfase in plaats van twee.
• Geen beloning model.
• Geen referentie-model forward pass.
• Een gekoppelde uitvoering: wanneer het leren van taken of het voorkeursgedrag achteruitgaat, is er geen tussentijdse SFT checkpoint van dezelfde pipeline om te analyseren.

Kies uit de gegevens en het evaluatieontwerp:

• Gebruik DPO wanneer je al een bevredigend SFT checkpoint hebt en een eenvoudiger offline experiment met voorkeuren wilt uitvoeren.
• Test ORPO wanneer een referentievrije, eendaagse methode past binnen je gegevens en operationele beperkingen.
• Gebruik PPO-gebaseerde RLHF wanneer online sampling tegen een expliciet geleerd beloningsmodel onderdeel is van de vereisten en je de exploitatie van beloningen kunt monitoren.

Er is geen standaardwaarde voor alle taken. Houd een SFT-specifieke basislijn aan en rapporteer zowel de metrieken van de taak als de metrieken met betrekking tot de voorkeuren.

Fine-tuning frameworks

Frameworks overlappen en snel veranderen. Kies op basis van het uitvoerpad dat u moet ondersteunen, pin versies vast, en zorg ervoor dat de trainingsconfiguratie voldoende portabel is om buiten een notebook te worden gereproduceerd.

Unsloth — snelheid en geheugen-efficiëntie

Unsloth is te integreren met Hugging Face trl en transformers en biedt geoptimaliseerde kernels-, checkpointing- en gecomprimeerde fine-tuning-paden voor ondersteunde models.

• A aangepaste Triton GPU kernels voor attention, RoPE en cross-entropy die de bijkomende kosten van PyTorch vermijden.
• Geheugen-efficiënte backpropagation die activations tijdens de backward pass opnieuw berekent in plaats van deze in het geheugen op te slaan.
• Gefuseerde operaties die meerdere stappen (layer norm + linear en dergelijke) samenvoegen tot één enkele GPU oproep.
• 4-bit quantization die rechtstreeks in de QLoRA-weg is geïntegreerd, met geoptimaliseerde dequantisatie.

[!IMPORTANT] De volgorde van import is belangrijk Houd u aan de importvolgorde uit het Unsloth-exempel voor de versie die u hebt geselecteerd. Unsloth past patches toe tijdens de import, dus importeer het eerst voordat trl en transformers Voorkomt het ontbreken van optimalisaties of fouten die specifiek zijn voor bepaalde versies.

# ✅ Correct order
from unsloth import FastLanguageModel  # Must be first!
from trl import SFTTrainer
from transformers import TrainingArguments

# Avoid this order with Unsloth's patched path
from trl import SFTTrainer
from unsloth import FastLanguageModel

Ideaal voor: enkelvoudige GPU training, prototypen maken, Colab notebooks, en iedereen die de rekening van GPU in de gaten houdt.

De gepubliceerde snelheids- en geheugencijfers verschillen afhankelijk van model, de lengte van de sequentie, de batchgrootte, de precisieniveau’s en de hardware. Houd rekening met de Benchmark tokens per seconde en het maximale geheugenverbruik tijdens uw eigen uitvoering, in plaats van een genoemd verhoudingsgetal te beschouwen als een vaste framework eigenschap.

Axolotl — trainen op basis van configuratie

# config.yaml - no code required
base_model: meta-llama/Meta-Llama-3-8B
adapter: qlora
lora_r: 32
lora_alpha: 16
datasets:
    - path: data/my_data.jsonl
      type: alpaca
sample_packing: true

Runt met: accelerate launch -m axolotl.cli.train config.yaml

Ideaal voor: declaratieve, reproduceerbare uitvoeringen en ingebouwde opties voor het starten van processen voor gedistribueerd trainen.

Het belangrijkste voordeel is de declaratieve configuratie, waarmee deze kan worden gecontroleerd, geversioneerd en hergebruikt bij zowel lokale als gedistribueerde uitvoeringen.

Framework vergelijking

Praktische demonstratie: fine-tuning met Unsloth

Dit is een volledig voorbeeld uit mijn unsloth-finetune-demo repository. De demo past Nemotron-Nano aan voor function calling.

Snel starten

# Clone and setup
git clone https://github.com/slavadubrov/unsloth-finetune-demo.git
cd unsloth-finetune-demo

# Install with uv (recommended)
uv sync

# Run fine-tuning (quick test)
uv run finetune --max-samples 1000

Configuratie

De interessante onderdelen bevinden zich in config.py:

# Model & Dataset
MODEL_NAME = "nvidia/Llama-3.1-Nemotron-Nano-4B-v1.1"  # 4B params, 128K context
DATASET_NAME = "glaiveai/glaive-function-calling-v2"   # 113K examples

# LoRA Configuration
LORA_R = 16        # Adapter capacity; tune against held-out results
LORA_ALPHA = 32    # Update scaling; alpha/r is the classic LoRA scale
MAX_SEQ_LENGTH = 4096

# Candidate modules for this Llama-family model
LORA_TARGET_MODULES = [
    "q_proj", "k_proj", "v_proj", "o_proj",
    "gate_proj", "up_proj", "down_proj",
]

[!NOTE] Het alpha-naar-rank-verhouding alpha/r schaalt de klassieke LoRA-update bij. alpha = 2r Dit is een veelgebruikte startheuristiek in sommige handleidingen voor hulpprogramma’s, maar het vormt geen garantie voor stabiliteit. Pas sweep rank, alpha, de learning rate en de doelmodules pas aan nadat de gegevens en de baseline zijn vastgesteld.

Kerntrainingscode

from unsloth import FastLanguageModel
from trl import SFTConfig, SFTTrainer

# Load model with 4-bit quantization
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="nvidia/Llama-3.1-Nemotron-Nano-4B-v1.1",
    max_seq_length=4096,
    load_in_4bit=True,
)

# Add LoRA adapters
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    use_gradient_checkpointing="unsloth",  # Lower activation memory; extra compute
)

# The data step creates versioned train_dataset and eval_dataset objects.
# Each row has the chat messages and tool schemas expected by current TRL.

# Train with the current TRL configuration surface.
trainer = SFTTrainer(
    model=model,
    processing_class=tokenizer,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    args=SFTConfig(
        output_dir="outputs/nemotron-function-calling",
        max_length=4096,
        packing=True,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        num_train_epochs=3,
        bf16=True,
    ),
)
trainer.train()

Fine-tuning met Axolotl

[!NOTE] Demo onderweg Ik ben bezig met een praktische Axolotl-demo. Tot die tijd, de Handleiding voor het versnellen van n-D parallelisme Het document van Hugging Face vormt een goede referentie voor strategieën voor meervoudige GPU training.

Voor configuratie-georiënteerde en gedistribueerde opstellingen zorgt Axolotl ervoor dat de workflow reproduceerbaar is:

# axolotl_config.yaml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM

# QLoRA configuration
load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
    - q_proj
    - k_proj
    - v_proj
    - o_proj
    - gate_proj
    - up_proj
    - down_proj

# Dataset
datasets:
    - path: data/training_data.jsonl
      type: alpaca

# Training settings
sequence_len: 4096
sample_packing: true # Benchmark with your length distribution
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 0.0002
num_epochs: 3

# Precision and attention path; verify support on the pinned stack
bf16: true
flash_attention: true

Training uitvoeren:

axolotl train axolotl_config.yaml

Fase 5: Evaluatie

Vries het evaluatiecontract in voordat de eerste uitvoering plaatsvindt. Vergelijk op zijn minst de aangepaste checkpoint met de exacte, onaangepaste basis onder dezelfde prompt-, decodingsinstellingen en toolomgeving. Rapporteer alleen de totale kwaliteitswaarde nadat u de fouten hebt gecontroleerd die het project eigenlijk zou moeten verminderen.

Volg vier groepen:

1. Doelopdracht: exacte overeenkomst, succesvolle uitvoering, menselijke beoordeling, of een ander resultaat dat gerelateerd is aan het gebruiksscenario.
2. Regressie: algemene capaciteiten en eerder ondersteunde taakonderdelen die door aanpassingen kunnen worden aangetast.
3. Veiligheid en beleid: weigeringen, datalekken, prompt injection, of domeinspecifieke beperkingen.
4. Operaties: latency, throughput, geheugen, grootte van artefacten, en de kosten bij de gewenste serving configuratie.

Geautomatiseerde benchmarks

Gebruik lm-evaluation-harness voor relevante, gestandaardiseerde taken, en niet als vervanging van de productevaluatie:

lm_eval --model hf \
    --model_args pretrained=./outputs/merged-model \
    --tasks hellaswag,arc_easy,mmlu \
    --batch_size 8

LLM als judge

Voor subjectieve kwaliteitsbeoordeling kan een grotere model helpen bij het bepalen van scores, maar deze moet worden gekalibreerd aan de hand van door mensen geraadpleegde voorbeelden en moet de identiteit van de kandidaat verborgen blijven:

judge_prompt = """
Rate this response from 1-5 on:
- Relevance
- Accuracy
- Formatting

Response: {model_output}
Expected: {ground_truth}
"""

Evaluatie specifiek voor het domein

Zorg ervoor dat echte voorbeelden op basis van bron, gebruiker, document of tijdstip worden gescheiden, zodat bijna-identieke gevallen niet van de ene naar de andere groep kunnen lekken. Voor function calling moet de volledige werkwijze worden gevalideerd: keuze van het hulpmiddel, argumenten, uitvoerresultaat, herstelproces en uiteindelijke reactie. Geef bij kleine steekproeven confiantie-interval of een overzicht van winnen/verliezen, en onderzoek elke regressie in een kritische subset.

Fase 6: Deployment en uitvoerformaten

Kies het artefact op basis van de serving-engine en het rollback-plan, en niet alleen op basis van de bestandsgrootte:

1. LoRA adapter

uv run finetune  # Saves ~100-500MB adapter

• Grootte: evenredig met de doelgerichte modules, rang, lagen en dtype; meestal aanzienlijk kleiner dan de basisversie.
• Ideaal voor: ontwikkeling, geversioneerde taakadapteren en engines die LoRA rechtstreeks ondersteunen.
• Bovendien: je kunt adapteren uitwisselen zonder de basis model opnieuw te downloaden.

2. Gecombineerde model

uv run finetune --merge  # Creates a standalone full model

• Grootte: ongeveer de volledige basis checkpoint bij de gekozen uitvoerprecisie.
• Ideaal voor: engines of distributieroutes die de adapter niet apart ondersteunen.
• Afweging: groter artefact en langzamere implementatie; eenvoudiger enkelvoudig laden van model.

3. GGUF-format

uv run finetune --gguf q4_k_m  # Creates ~2-4GB quantized model

• Grootte: afhankelijk van model; ongeveer vier bits aan weights plus metadata voor de Q4-varianten.
• Ideaal voor: CPU inference, Ollama, llama.cpp, edge deployment.
• Opties: q4_k_m (smaller), q5_k_m (meer weight nauwkeurigheid), q8_0 (groter en met hogere nauwkeurigheid). Meet de impact van de taak na de conversie.

Fase 7: Serving en monitoring

Met vLLM

# Serve the base and expose a PEFT adapter as a model name.
vllm serve nvidia/Llama-3.1-Nemotron-Nano-4B-v1.1 \
    --enable-lora \
    --lora-modules function-calling=./outputs/adapter \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 4096

Vraag indienen via de OpenAI-compatibele API:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
response = client.chat.completions.create(
    model="function-calling",
    messages=[{"role": "user", "content": "Book a flight to Tokyo"}]
)

Met Ollama (lokaal)

# Create Modelfile
echo 'FROM ./outputs/unsloth-nemotron-function-calling-gguf/model-q4_k_m.gguf' > Modelfile

# Import to Ollama
ollama create my-function-model -f Modelfile

# Run
ollama run my-function-model

Met llama.cpp (CPU)

./llama-cli -m ./outputs/model-q4_k_m.gguf \
    -p "What's the weather in Tokyo?" \
    --ctx-size 4096

Monitoor de geïmplementeerde model

Het levenscyclusproces stopt niet zodra de trainingsverlieswaarde op een acceptabel niveau is. Noteer de versie van base-model, tokenizer en de chattemplate, de hash van de adapter, de versie van dataset, de trainingsconfiguratie en het evaluatierapport als één samenhangende release-eenheid. In productie moet men de succesratio van taken, ongeldige uitvoerresultaten, beleidsfouten, latency en invoerdrift monitoren, waarbij dezelfde datasets worden gebruikt als offline. Zorg ervoor dat eerdere versies nog steeds te laden zijn en stel vóór het lanceren een drempelwaarde in voor een terugval.

Belangrijkste conclusies

1. Voer pas fine-tuning uit nadat een ongetunede baseline en een taxonomie van fouten hebben aangetoond dat de aanpassing met weight het probleem oplost.
2. Retrieval zorgt voor het beheren van veranderende bewijsstukken; constrained decoding zorgt voor het beheren van de syntaxis; geen van beide wordt vervangen door SFT.
3. LoRA vermindert het aantal te trainen parameters. QLoRA compresseert daarnaast de gefrozeerde basis weights. Schrijf de geheugengegevens van QLoRA niet toe aan LoRA.
4. Data-dekking, integriteit van de splitsing, herkomst en maskering van verliezen zijn belangrijker dan het kopiëren van een populaire optimizer-configuratie.
5. DPO, ORPO en PPO-gebaseerde RLHF zijn verschillende experimentele ontwerpen, en geen hiërarchie van kwaliteit met een universele standaard.
6. Beoordeel het gewenste gedrag, regressies, veiligheid en bedrijfsvoering op basis van dezelfde basis model.
7. Kies vóór de training voor een adapter, een gecombineerd resultaat of een GGUF-uitvoer volgens de vereisten van serving en rollbacks.

Referenties

Artikelen en onderzoek

• LoRA: Lage-rangadaptatie van grote taalmodellen Models
• QLoRA: Efficiënt fijnafstellen van gequantiseerde LLMs
• DoRA: Weight-Gedecompileerde lage-rangadaptatie
• DPO: Optimalisatie van directe voorkeuren
• ORPO: Optimalisatie van de voorkeursverhouding van odds ratios
• PPO: Algoritmen voor proximale beleidsoptimalisatie — OpenAI, 2017

Hulpmiddelen voor gegevensverwerking

• DataTrove — Hugging Face schaalbare gegevensverwerking Distilabel — Generatie van synthetische gegevens (Argilla)
• Trafilage — Extractie van webtekst en crawlen FastText — Identificatie van de taal op Facebook AI (ondersteunt 217 talen) Microsoft Presidio — Detectie en anonimisatie van PII
• scrubadub — Python-bibliotheek voor het verwijderen van PII

Constrained decoding

• xgrammar — Constrained decoding met FSM’s overzichten — Gestructureerde generatie voor LLMs

Training frameworks

• Slak — Geoptimaliseerde fine-tuning framework
• Axolotl — Trainen gestuurd door configuraties en gedistribueerde launchers
• TRL — Hugging Face SFT en bibliotheek voor voorkeursgetraining Optimalisatietuning — PyTorch-native fine-tuning bibliotheek

Inference en deployment

• vLLM LoRA adapters — Dien één of meerdere adapters samen met de basis model op. Ollama — Lokaal LLM-runner voor Mac/Windows/Linux
• llama.cpp — CPU/GPU inference in GGUF-format

Evaluatie

• lm-evaluatie-harness — EleutherAI heeft de standaardisatie van de LLM-benchmarking doorgevoerd.

Handleidingen en bronnenmateriaal

• Demo-repository — Praktisch voorbeeld van fine-tuning LLM Fine-Tuning. Theoretische intuïtie en praktische implementatie — Onderzoeksnotitieboek van NotebookLM
• Gids voor het versnellen van n-D parallelisme — Hugging Face meervoudige GPU trainingsstrategieën