Deel 3 van 5: Voorgetrainde modellen aanpassen

Welkom terug! In ons vorige artikel hebben we een RAG-systeem gebouwd dat AI toegang geeft tot uw specifieke informatie. Vandaag gaan we een stap verder — we gaan daadwerkelijk wijzigen hoe een AI-model denkt en reageert door het af te stemmen. Ik zal een open-source model voor dit demovoorbeeld gebruiken.

RAG versus Fine-tuning: wat is het verschil?

Denk er zo over na:

RAG is als iemand een naslagwerk geven. Ze zijn nog steeds dezelfde persoon, maar nu hebben ze toegang tot specifieke informatie bij het beantwoorden van vragen.

Fine-tuning is als iemand naar gespecialiseerde training sturen. U verandert daadwerkelijk hoe ze denken en reageren op basis van uw specifieke vereisten.

Wanneer moet u fine-tuning gebruiken?

Fine-tuning is krachtig, maar het is niet altijd nodig. Overweeg fine-tuning wanneer:

U wilt dat de AI een specifieke toon of stijl aanneemt
Uw domein gespecialiseerde terminologie of concepten heeft
U consistente reacties in veel verschillende scenario's wilt
RAG geeft u niet de kwaliteit van reacties die u nodig hebt
U voldoende trainingsgegevens hebt (meestal honderden voorbeelden)
U wilt dat het model offline of in geïsoleerde omgevingen werkt

Uw omgeving instellen

We gebruiken Google Colab met een T4 GPU voor deze zelfstudie, maar u kunt dit aanpassen voor elke CUDA-compatibele omgeving:

# Install required packages

!pip install bitsandbytes

import os import torch from datasets import Dataset from transformers import ( AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer, BitsAndBytesConfig ) from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, PeftModel

Het juiste model kiezen

Voor deze zelfstudie gebruiken we TinyLlama-1.1B, maar hier zijn enkele uitstekende opties voor verschillende behoeften:

# Ultra-light models (good for experimentation)

# model_name = "distilgpt2"                          # 82M parameters

# model_name = "gpt2"                                # 124M parameters

# model_name = "EleutherAI/gpt-neo-125M"            # 125M parameters

# Small but capable models # model_name = "microsoft/DialoGPT-medium" # 355M parameters # model_name = "microsoft/DialoGPT-large" # 762M parameters model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0" # 1.1B parameters - choosing this one # For production use (if you have more GPU memory) # model_name = "microsoft/phi-2" # 2.7B parameters # model_name = "stabilityai/stablelm-2-1_6b" # 1.6B parameters

Uw trainingsgegevens voorbereiden

De sleutel tot succesvol fine-tuning zijn trainingsgegevens van hoge kwaliteit. Hier ziet u hoe we ze structureren:

# Sample dataset for MyNextDeveloper (MND)

data = {

"text": [

"User asks: Write a 3-bullet overview of MND.nAssistant: - Remote-first, founded 2022 in Mumbain- Staff augmentation + full-cycle web/API, UI/UX, AI/MLn- Agile/TDD, POSH culture, transparent pricing",

"User asks: Where is MND headquartered?nAssistant: Malabar Hill, Mumbai",

"User asks: What services does MND offer?nAssistant: Staff augmentation, API development, web development, UI/UX design, AI/ML solutions",

"User asks: What is MND's tech stack?nAssistant: Angular, React, Next.js, Node.js, Django, Python, Docker, AWS",

"User asks: What is MND's pricing model?nAssistant: Project pricing starting at $10,000 with hourly rates between $25 and $49",

"User asks: What is MND's mission?nAssistant: To solve the trust gap between startups and engineers by emphasizing empathy, communication, and transparency",

"User asks: What is MND's culture like?nAssistant: Agile practices, test-driven development, and POSH-compliant culture",

"User asks: When was MND founded?nAssistant: 2022"

]

}

# Convert to HuggingFace dataset dataset = Dataset.from_dict(data)

Kernprincipes voor trainingsgegevens:

Gebruik consistent formatteren (let op het "User asks:" en "Assistant:" patroon)
Houd reacties feitelijk en beknopt
Behandel de belangrijkste informatie over uw domein
Kwaliteit boven kwantiteit: 50 perfecte voorbeelden beter dan 500 middelmatige

Efficiënt trainen met LoRA en kwantisering

In plaats van het hele model af te stemmen (wat enorm GPU-geheugen vereist), gebruiken we twee efficiëntietechnieken:

1. Kwantisering (4-bit)

Kwantisering is een compressietechniek die wordt gebruikt om grote taalmodellen (LLMs) kleiner en sneller te maken zonder de nauwkeurigheid aanzienlijk te verminderen.

Normaal gesproken worden LLM-gewichten opgeslagen als 32-bits drijvende-kommagetallen (FP32).
Kwantisering vermindert deze precisie tot 16-bits (FP16/BF16), 8-bits (INT8), 4-bits (INT4) of nog lager.

👉 Voorbeeld:

Een model met 10 miljard parameters in FP32 heeft ongeveer 40 GB geheugen nodig.
Als we het kwantiseren tot INT8 (8-bits) → heeft het slechts ongeveer 10 GB nodig.
Als we naar INT4 (4-bits) gaan → slechts ongeveer 5 GB.

⚡ Waarom is het nuttig?

Maakt modellen op kleinere GPU's (of zelfs CPU's) werken.
Versnelt gevolgtrekking.
Lichte afruil in nauwkeurigheid, maar vaak verwaarloosbaar.

# Configure 4-bit quantization

bnb_config = BitsAndBytesConfig(

load_in_4bit=True,

bnb_4bit_quant_type="nf4",

bnb_4bit_use_double_quant=True,

bnb_4bit_compute_dtype=torch.float16

)

# Load model with quantization model = AutoModelForCausalLM.from_pretrained( model_name, quantization_config=bnb_config, device_map="auto", torch_dtype=torch.float16 )

2. LoRA (Low-Rank Adaptation)

LoRA is een parametrisch efficiënte fine-tuning (PEFT) methode.

Normaal gesproken zouden we honderden GB GPU-geheugen nodig hebben om een groot LLM af te stemmen (zoals LLaMA-65B of GPT-J). LoRA lost dit op door:

Het originele modelgewicht in te vriezen.
Kleine trainbare matrices (low-rank adapters) in de modellagen toe te voegen.
Tijdens fine-tuning worden alleen deze kleine matrices bijgewerkt.

👉 Voorbeeld:

Volledig afstemmen van een 65B-model kan ongeveer 1 TB GPU-geheugen vereisen.
Met LoRA trainen u alleen een paar miljoen parameters → heeft < 20 GB GPU-geheugen nodig.

⚡ Waarom is het nuttig?

Maakt fine-tuning van enorme LLMs mogelijk op consumentenhard-ware (1–2 GPU's).
Eenvoudig om adapters te "samenvoegen" of "ontkoppelen" → u kunt snel van taak wisselen.
Bereikt vaak prestaties dicht bij volledig fine-tuning.

# Configure LoRA based on model architecture

if "TinyLlama" in model_name or "Llama" in model_name:

target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]

elif "gpt" in model_name.lower() or "DialoGPT" in model_name:

target_modules = ["c_attn", "c_proj"]

else:

target_modules = ["q_proj", "v_proj"]

lora_config = LoraConfig( r=8, # Rank of adaptation lora_alpha=16, # LoRA scaling parameter target_modules=target_modules, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM" ) # Apply LoRA to the model model = get_peft_model(model, lora_config) model.print_trainable_parameters()

We trainen slechts 0,2% van de parameters!

Het model trainen

# Tokenize the data

def tokenize_function(examples):

tokenized_inputs = tokenizer(

examples["text"],

truncation=True,

padding="max_length",

max_length=512,

return_tensors="pt"

)

# Create labels by copying input tokens

tokenized_inputs["labels"] = tokenized_inputs["input_ids"].clone()

return tokenized_inputs

# Split dataset train_dataset = dataset.select(range(8)) eval_dataset = dataset.select(range(8, 11)) # Apply tokenization train_dataset = train_dataset.map(tokenize_function, batched=True) eval_dataset = eval_dataset.map(tokenize_function, batched=True) # Configure training training_args = TrainingArguments( output_dir="./mnd-finetune-outputs", num_train_epochs=5, per_device_train_batch_size=4, per_device_eval_batch_size=4, gradient_accumulation_steps=2, warmup_steps=10, learning_rate=3e-4, weight_decay=0.01, logging_steps=1, save_steps=30, eval_strategy="steps", eval_steps=15, save_total_limit=2, load_best_model_at_end=True, fp16=True, report_to=None # Disable wandb logging ) # Create trainer and start training trainer = Trainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset, tokenizer=tokenizer, ) print("Starting training...") trainer.train() # Save the adapter adapter_dir = "./mnd-finetune-outputs/final_adapter" model.save_pretrained(adapter_dir) tokenizer.save_pretrained(adapter_dir)

Het afgestemde model testen

def load_model_for_inference():

"""Load the fine-tuned model for inference"""

# Load base model

base_model = AutoModelForCausalLM.from_pretrained(

model_name,

quantization_config=bnb_config,

device_map="auto",

torch_dtype=torch.float16

)

# Load the fine-tuned adapter

model = PeftModel.from_pretrained(base_model, adapter_dir)

model = model.merge_and_unload()

# Load tokenizer

tokenizer = AutoTokenizer.from_pretrained(adapter_dir)

return model, tokenizer

def generate_response(model, tokenizer, prompt, max_length=256, temperature=0.7):

"""Generate response for a given prompt"""

formatted_prompt = f"User asks: {prompt}nAssistant:"

inputs = tokenizer.encode(formatted_prompt, return_tensors="pt")

inputs = inputs.to(model.device)

with torch.no_grad():

outputs = model.generate(

inputs,

max_length=max_length,

temperature=temperature,

top_p=0.9,

do_sample=True,

pad_token_id=tokenizer.eos_token_id,

repetition_penalty=1.1

)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)

assistant_response = response.split("Assistant:")[-1].strip()

return assistant_response

# Load fine-tuned model and test

model, tokenizer = load_model_for_inference()

test_prompts = [

"What makes MND different from other development companies?",

"Can you tell me about MND's team?",

"What is the company culture at MND?"

]

for prompt in test_prompts:

response = generate_response(model, tokenizer, prompt)

print(f"Q: {prompt}")

print(f"A: {response}n")

Google Colab

Hier is de Google Colab-koppeling voor dit artikel dat u in één klik kunt uitvoeren: koppeling

De werkelijke kosten

In tegenstelling tot commerciële API's zijn uw kosten voornamelijk:

Initiële configuratie: GPU-tijd voor training
Opslag: Modelgewichten (ongeveer 4GB voor TinyLlama met LoRA-adapters)
Gevolgtrekking: Uw eigen hardware of cloud GPU-exemplaren

Voor een klein model zoals TinyLlama kunt u gevolgtrekking uitvoeren op:

Google Colab (gratis laag met beperkingen)
AWS t3.medium met GPU (ongeveer $0,05/uur)
Uw eigen hardware (RTX 3060 of beter)

Best practices uit echte ervaring

1. Begin klein en schaal op Begin met distilgpt2 of gpt2 om uw gegevens en proces te testen, ga dan over op grotere modellen.

2. Monitor op overfitting Met kleine datasets kunnen modellen onthouden in plaats van leren. Controleer uw evaluatieverlies.

3. Formaatconsistentie is kritiek De exacte indeling van uw trainingsgegevens is enorm belangrijk. Wees consistent met leestekens, spatiëring en structuur.

4. Test met onzichtbare vragen Test altijd met vragen die niet in uw trainingsgegevens voorkomen om ervoor te zorgen dat gegeneraliseerd.

5. Sla regelmatige controlepunten op Training kan worden onderbroken. Sla regelmatig op en test tussenliggende controlepunten.

Veelvoorkomende fouten en oplossingen

Probleem: Het model genereert repetitieve of onzinnige tekst Oplossing: Verlaag de leersnelheid, verhoog de regularisatie, of verbeter de kwaliteit van trainingsgegevens

Probleem: Het model vergeet algemene kennis Oplossing: Voeg enkele algemene voorbeelden toe aan uw trainingsgegevens of gebruik een groter basismodel

Probleem: Reacties zijn te algemeen Oplossing: Maak uw trainingsvoorbeelden specifieker en gedetailleerder

Probleem: GPU-geheugen problemen Oplossing: Verklein batchgrootte, gebruik meer agressieve kwantisering, of gradiëntcontrole

Combineren met RAG

Hier is het krachtige onderdeel: u kunt uw afgestemde model combineren met RAG voor het beste van beide werelden:

Stem af voor domeinbegrip, toon en algemene bedrijfskennis
Gebruik RAG voor actuele informatie, specifieke documenten of gedetailleerde technische specificaties

Dit geeft u een model dat "denkt" zoals uw bedrijf maar toegang heeft tot actuele informatie.

Wat volgt

In ons volgende artikel gaan we helemaal custom — we bouwen een taalmodel van nul af, helemaal van u, draaiend op uw hardware met uw gegevens.

Fine-tuning van open-source modellen geeft u ongekende controle over uw AI-assistent. U kunt ervoor zorgen dat het uw domein begrijpt, in uw stem spreekt en nooit uw gegevens naar derden verzendt. Met moderne efficiëntietechnieken zoals LoRA en kwantisering is het toegankelijker dan ooit.

De toekomst van AI gaat niet alleen over het gebruik van iemand anders model — het gaat erom AI echt van u te maken.

Komend: Artikel 4 — "Het bouwen van uw eigen taalmodel: klein maar krachtig"