Osa 3 / 5: Esikoulutettujen mallien mukauttaminen

Tervetuloa takaisin! Edellisessä artikkelissa rakensimme RAG-järjestelmän, joka antaa tekoälylle pääsyn omiin tietoihisi. Tänään otamme askeleen pidemmälle — aiomme todella muuttaa sitä, miten tekoälymalli ajattelee ja vastaa hienosäätämällä sitä. Käytän tässä demo-esimerkissä avoimen lähdekoodin mallia.

RAG vs hienosäätö: Mitä eroa?

Ajattele asiaa näin:

RAG on kuin antaa jollekulle hakukirjan. Hän on edelleen sama henkilö, mutta nyt hänellä on pääsy tiettyihin tietoihin vastauksia antaessaan.

Hienosäätö on kuin lähettää joku erikoiskoulutukseen. Muutat todella sitä, miten hän ajattelee ja vastaa omien vaatimustesi perusteella.

Milloin sinun pitäisi hienosäätää?

Hienosäätö on tehokas, mutta se ei aina ole välttämätöntä. Harkitse hienosäätöä, kun:

Haluat tekoälyä omaksumaan tietyn sävyn tai tyylin
Alallasi on erikoistunutta terminologiaa tai käsitteitä
Haluat johdonmukaisia vastauksia monissa eri tilanteissa
RAG ei anna sinulle tarvitsemasi laadun vastauksia
Sinulla on riittävästi harjoitustietoja (yleensä satoja esimerkkejä)
Haluat mallin toimivan offline-tilassa tai ilmajohdoissa

Ympäristön määrittäminen

Käytämme Google Colabsia T4 GPU:lla tässä opetusohjelmassa, mutta voit mukauttaa tämän mihin tahansa CUDA-yhteensopivaan ympäristöön:

# 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

Oikean mallin valitseminen

Tässä opetusohjelmassa käytämme TinyLlama-1.1B:tä, mutta tässä on joitakin erinomaisia vaihtoehtoja eri tarpeisiin:

# 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

Harjoitustietojen valmistaminen

Onnistuneen hienosäätöjen avain on korkealaatuiset harjoitustiedot. Näin me jäsennamme sen:

# 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)

Harjoitustietojen pääperiaatteet:

Käytä johdonmukaista muotoilua (huomaa "User asks:" ja "Assistant:" -malli)
Pidä vastaukset faktuaalisina ja ytimekkäinä
Kata tärkein tieto alastasi
Laatu määrän sijaan: 50 täydellistä esimerkkiä lyö 500 keskivertaista

Tehokas harjoittelu LoRA:lla ja kvantisoinnilla

Sen sijaan, että hienosäätäisimme koko mallia (mikä vaatii valtavan paljon GPU-muistia), käytämme kahta tehokkuustekniikkaa:

1. Kvantisointia (4-bittinen)

Kvantisointia on pakkaustekniikka, jota käytetään suurten kielimallien (LLM) pienentämiseen ja nopeuttamiseen ilman tarkkuuden merkittävää heikkenemistä.

Yleensä LLM-painot varastoidaan muodossa 32-bittisten liukulukujen (FP32).
Kvantisointia vähentää tämä tarkkuus 16-bittiseksi (FP16/BF16), 8-bittiseksi (INT8), 4-bittiseksi (INT4) tai jopa pienemmäksi.

👉 Esimerkki:

Malli, jossa on 10 miljardia parametria FP32:ssa, vaatii ~40 GB muistia.
Jos kvantisoitava se INT8:ksi (8-bittinen) → se vaatii vain ~10 GB.
Jos menemme INT4:ksi (4-bittinen) → vain ~5 GB.

⚡ Miksi se on hyödyllinen?

Mahdollistaa mallit pienemmillä GPU:illa (tai jopa prosessoreilla).
Nopeuttaa päättelyä.
Pieni tarkkuuden kompromissi, mutta usein merkityksetön.

# 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 on parametrien tehokas hienosäätömenetelmä (PEFT).

Normaalisti, hienosäätämään valtava LLM (kuten LLaMA-65B tai GPT-J), tarvitsisimme satoja GB:n GPU-muistia. LoRA ratkaisee tämän:

Jäädyttää alkuperäiset mallin painot.
Lisäämällä pienet harjoitettavat matriisit (low-rank-sovittimet) mallin kerroksiin.
Hienosäädön aikana vain nämä pienet matriisit päivitetään.

👉 Esimerkki:

Täydellinen hienosäätö 65B-mallista voisi vaatia ~1 TB GPU-muistia.
LoRA:lla harjoitat vain muutamia miljoonia parametreja → vaatii < 20 GB GPU-muistia.

⚡ Miksi se on hyödyllinen?

Tekee massiivisten LLM:ien hienosäädön mahdolliseksi kuluttajalaitteiden (1–2 GPU) kanssa.
Helppo "yhdistää" tai "irrottaa" sovittimet → voit nopeasti vaihtaa tehtäviä.
Usein saavuttaa suorituskyvyn, joka on lähellä täyttä hienosäätöä.

# 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()

Harjoitamme vain 0,2 % parametreista!

Mallin harjoitteleminen

# 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)

Hienosäädetyn mallin testaaminen

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

Tässä on tämän artikkelin google colab -linkki, jonka voit käyttää yhdellä napsautuksella: linkki

Todelliset kustannukset

Toisin kuin kaupalliset API:t, kustannuksistasi ovat pääasiassa:

Alkuperäinen asennus: GPU-aika harjoittelulle
Tallennus: Mallin painot (~4GB TinyLlama:lle LoRA-sovittimilla)
Päätelmä: Oma laitteistosi tai pilvi-GPU-esiintymät

Pienelle mallille kuten TinyLlama, voit suorittaa päättelyn:

Google Colab (ilmainen versio rajoituksilla)
AWS t3.medium GPU:lla (~0,05 $/tunti)
Oma laitteistosi (RTX 3060 tai parempi)

Parhaat käytännöt todellisesta kokemuksesta

1. Aloita pienestä ja skaalaa ylöspäin Aloita distilgpt2:lla tai gpt2:lla testata tietojasi ja prosessiasi, sitten siirry suurempiin malleihin.

2. Valvo ylisovitusta Pienillä aineistoilla mallit voivat muistaa sen sijaan, että oppivat. Seuraa evaluaation häviötä.

3. Muotoilu johdonmukaisuus on kriittistä Harjoitustietojen tarkka muoto on erittäin tärkeä. Ole johdonmukainen välimerkkien, välilyönnin ja rakenteen kanssa.

4. Testaa näkemättömillä kysymyksillä Testaa aina kysymyksissä, jotka eivät ole harjoitustiedoissasi, varmistaaksesi yleistämisen.

5. Tallenna säännöllisiä tarkistuspisteitä Harjoittelua voidaan keskeyttää. Tallenna usein ja testaa väliintarkistuspisteitä.

Yleiset sudenkuopat ja ratkaisut

Ongelma: Malli tuottaa toistuvaa tai järjetöntä tekstiä Ratkaisu: Pienennä oppimisnopeutta, lisää regularisointi tai paranna harjoitustietojen laatua

Ongelma: Malli unohtaa yleisen tiedon Ratkaisu: Sisällytä harjoitustietoihin joitakin yleisiä esimerkkejä tai käytä suurempaa perusmallia

Ongelma: Vastaukset ovat liian yleisiä Ratkaisu: Tee harjoitusesimerkkisi spesifisemmiksi ja yksityiskohtaisemmiksi

Ongelma: GPU-muistin ongelmat Ratkaisu: Pienennä erän kokoa, käytä aggressiivisempaa kvantisointi tai gradienttien tarkistuspisteitä

Yhdistäminen RAG:n kanssa

Tässä on tehokas osa: voit yhdistää hienosäädetyn mallin RAG:n kanssa parhaan puolen saamiseksi:

Hienosäädä alan ymmärtämiselle, sävylle ja yleiselle yritystiedolle
Käytä RAG:ta nykyisille tiedoille, tietyille asiakirjoille tai yksityiskohtaisille tekniikkatiedoille

Tämä antaa sinulle mallin, joka "ajattelee" kuten yrityksesi mutta pääsee päivitettyihin tietoihin.

Mitä seuraavaksi

Seuraavassa artikkelissa menemme täysin mukautettuun — rakentamme kielimallia alusta alkaen, puhtaasti omaksesi, omalla laitteistollasi omilla tiedoillasi.

Avoimen lähdekoodin mallien hienosäätö antaa sinulle ennennäkemätöntä hallintaa tekoälyavustajastasi. Voit varmistaa, että se ymmärtää alasi, puhuu äänellään, eikä koskaan lähettää tietojasi kolmansille osapuolille. Nykyaikaisilla tehokkuustekniikoilla kuten LoRA ja kvantisoinnilla se on helpommin saavutettavissa kuin koskaan.

Tulevaisuus tekoälystä ei ole vain jonkun toisen mallin käyttäminen — se on tekoälyn tekeminen todella omaksesi.

Tulevat: Artikkeli 4 — "Oman kielimallin rakentaminen: pieni mutta voimakas"