Cuid 3 de 5: Samhlacha Réamhthraenáilte a Dhéanamh Saincheaptha

Fáilte ar ais! San alt deireanach, thógamar córas RAG a thugann rochtain ar AI ar do bhealach sonraíochta féin. Inniu, tógaimid céim eile - tá tú ag dul a athraigh go fíor conas a smaoiníonn agus freagraíonn samhail AI trí a dhréachtadh. Úsáidfidh mé samhail foinse oscailte don sampla léirithe seo.

RAG i bhfreagra Fine-Tuning: Cad é an Difríochtaí?

Smaoineoidh air seo ar an dóigh seo:

RAG cosúil le leabhar tagartha a thabhairt do dhuine. Is an duine céanna iad go fóill, ach anois tá rochtain aici ar fhaisnéis shonraíochta agus í ag freagairt ar cheisteanna.

Fine-tuning cosúil le duine a sheoladh chuig traenáil speisialaithe. Tá tú i ndáiríre ag athrú conas a smaoiníonn agus a fhreagraíonn siad bunaithe ar do riachtanais dhírithe.

Cathain Ba Cheart Duit Fine-Tune a Dhéanamh?

Tá fine-tuning cumhachtach, ach ní gá go gceadaítear a bheith i gcónaí. Déan machnamh ar fine-tuning nuair:

Is gá don AI tonra nó stíl ar leith a ghlacadh
Tá téarmaí speisialaithe nó coincheapa ar leith i do réimse
Ag iarraidh freagraí comhsheasmhach ar fud go leor scéimeanna éagsúla
Ní bhíonn RAG ag tabhairt duit an cáilíocht freagraí atá uait
Tá dóthain sonraí traenála agat (de ghnáth na céadta samplaí)
Tá gá agat don samhail a oibriú as líne nó i dtimpeallachtaí aer-scaoilte

Do Thimpeallacht a Bhunú

Úsáidfimid Google Colab le T4 GPU don teagaisc seo, ach is féidir leat é seo a oiriúnú do aon thimpeallacht a bhfuil CUDA-ábalta aici:

# Pacáistí riachtanacha a shuiteáil

!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

An Samhail Cheart a Roghnú

Don teagaisc seo, úsáidfimid TinyLlama-1.1B, ach seo roinnt roghanna den scoth do riachtanais éagsúla:

# Samhlacha ultra-éadrom (dea-bhraistint do thurgnaimh)

# model_name = "distilgpt2"                          # 82M parameters

# model_name = "gpt2"                                # 124M parameters

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

# Samhlacha beag ach ábalta # 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 # Le haghaidh úsáid tháirgthe (má tá níos mó cuimhne GPU agat) # model_name = "microsoft/phi-2" # 2.7B parameters # model_name = "stabilityai/stablelm-2-1_6b" # 1.6B parameters

Do Shonraí Traenála a Ullmhú

Is é an eochair do thairbhe fine-tuning ná sonraí traenála ard-cháilíochta. Seo conas a dhéanaimid struchtúr air:

# Tacar sonraí samplach do 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"

]

}

# Tiontú go tacar sonraí HuggingFace dataset = Dataset.from_dict(data)

Prionsabail bhunúsacha do shonraí traenála:

Úsáid formáid chomhsheasmhach (tabhair faoi deara an patrún "User asks:" agus "Assistant:")
Coinnigh freagraí fíorúnach agus gearr
Cuimhnigh an t-eolas is tábhachtaí faoi do réimse
Cáilíocht os cionn méid: bhuaigh 50 sampla foirfe 500 ceann meán-cháilíochta

Traenáil Éifeachtach le LoRA agus Quantization

In ionad an samhail ar fad a fhíntúnú (ar theastaíonn cuimhne mór GPU air), úsáidfimid dhá theicníc éifeachta:

1. Quantization (4-bit)

Is é an fhachtóir thuairisciúil a bhainistiú a bhainistiú ar mhéid agus ar luas samhlacha teanga ollmhór (LLMs) gan beagán a laghdú ar chruinneas.

De ghnáth, stórailtear meáchan LLM mar 32-ghiotán pointí foluain fíorúil (FP32).
Laghdaítear an bhreacadh seo go 16-ghiotán (FP16/BF16), 8-ghiotán (INT8), 4-ghiotán (INT4) nó níos ísle.

👉 Sampla:

Samhail le 10 bhilliún paraiméadair in FP32 ag gá thart ar 40 GB cuimhne.
Má dhéanaimid quantization air go INT8 (8-bit) → ní gá ach thart ar 10 GB.
Má théimid go INT4 (4-bit) → díreach thart ar 5 GB.

⚡ Cén fáth a bhíonn sé úsáideach?

Déanann sé samhlacha a rith ar GPUs níos beag (nó fiú CPUs).
Déan neamhspleáchas tapa.
Malartú beag ar chruinneas, ach go minic neamhbhríoch.

# 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

)

# Samhail a lódáil le quantization model = AutoModelForCausalLM.from_pretrained( model_name, quantization_config=bnb_config, device_map="auto", torch_dtype=torch.float16 )

2. LoRA (Oiriúnú Íseal-Rang)

Is ionann LoRA agus modh fine-tuning éifeachtach paraiméadair (PEFT).

Go gnáth, chun LLM ollmhór a fhíntúnú (cosúil le LLaMA-65B nó GPT-J), bheadh gá agus na céadta GB de chuimhne GPU. Réitíonn LoRA seo trí:

Foluain an meáchan samhail dheireanach.
Ag cur maitrísí beag traenáilte (iomaithí íseal-rang) isteach in sraithe an samhail.
I rith fine-tuning, ní bhíonn ach na maitrísí beag seo tógtha.

👉 Sampla:

Full fine-tuning samhail 65B d'fhéadfadh a bheith ag teastáil ~1 TB GPU cuimhne.
Le LoRA, ní traenálaim ach go leor milliúin paraiméadair → gá < 20 GB GPU cuimhne.

⚡ Cén fáth a bhíonn sé úsáideach?

Déanann sé fine-tuning LLMs ollmhór indéanta ar bhogearraí tomhaltóirí (1–2 GPUs).
Éasca oidhreachtaí a "samhail" nó "dí-samhail" → is féidir leat gné-athrú a dhéanamh go tapa.
Go minic a bhíonn feidhmíochta geal do fhíntúnú iomlán.

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

Ní traenálaim ach 0.2% de na paraiméadair!

An Samhail a Thraenáil

# 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

# Tacar sonraí a roinnt 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)

Tástáil an Samhail Fine-Tuned

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

Seo an nasc google colab don alt seo is féidir leat a rith i gcliceadh amháin: nasc

Na Costas Fíoracha

Murab ionann agus APIanna tráchtála, is iad do chostas príomha:

Bunú Tosaigh: Am GPU do traenáil
Stóráil: Meáchain samhail (~4GB do TinyLlama le LoRA adapters)
Interference: Do bhogearraí féin nó instáinsí cloud GPU

I leith samhail bheag cosúil le TinyLlama, is féidir leat interference a rith ar:

Google Colab (saor-bhreataig le teorainneacha)
AWS t3.medium le GPU (~$0.05/hour)
Do bhogearraí féin (RTX 3060 nó níos fearr)

Cleachtais is Fearr ó Thaithí Dhíreach

1. Tosaigh Beag agus Scála Suas Tosaigh le distilgpt2 nó gpt2 chun do shonraí agus do phróiseas a thástáil, ansin bogaigh go samhlacha níos mó.

2. Monatóireacht ar Overfitting Le tacair shonraí beag, is féidir le samhlacha a stóráil seachas a fhoghlaim. Breathnaigh ar do bhailse meastóireachta.

3. Is Críoch-Thábhachtach Comhsheasmhacht Formáid Tá an fhormáid dhíreach de do shonraí traenála an-tábhachtach. Bí comhsheasmhach le ponctúchán, spásáil, agus struchtúr.

4. Tástáil le Ceisteanna Neamh-Thugtha Taistil i gcónaí le ceisteanna nach bhfuil i do shonraí traenála chun a chinntiú ginealógach.

5. Sábháil Seiceanna Rialta Is féidir traenáil a bheiht ar imeall. Sábháil go minic agus tástáil seiceanna idirmheánach.

Cúpla Práinne Coitianta agus Réitigh

Fadhb: Gintear an samhail téacs athrá nó neamhchiallmhar Réiteach: Laghdaigh an ráta foghlamtha, méadaigh ionchur, nó feabhsaigh cáilíocht na sonraí traenála

Fadhb: Samhail fhorgailt eolas ginearálta Réiteach: Cuir roinnt samplaí ginearálta i do shonraí traenála nó úsáid samhail bhunáite níos mó

Fadhb: Freagraí ró-ghéinearálaithe Réiteach: Déan do shamplaí traenála níos saincheaptha agus níos sonraithe

Fadhb: Fadhbanna cuimhne GPU Réiteach: Laghdaigh méid baitsithe, úsáid quantization níos gealadaigh, nó pointilleorú grádáin

A Chur i Bhfeighil le RAG

Seo an chuid chumhachtach: is féidir leat do shamhail fhine-tuned a chur i bhfeighil le RAG chun an dá bharramhaith:

Fine-tune do thuiscint fearann, tonra, agus eolas ginearálta na cuideachta
Úsáid RAG do bhealach reatha, doiciméid shonraíochta, nó sonraí teicniúla foluain

Tugann sé seo duit samhail a "smaoiníonn" cosúil le do chuideachta ach is féidir aici rochtain ar bhealach nua-aimseartha.

Cad atá ag Teacht

San alt eile, tá tú ag dul go hiomlán saincheaptha — a bhogearraí teanga a thógáil ó thús, go hiomlán do chuid féin, ag rith ar do bhogearraí le do shonraí.

Tugann fine-tuning samhlacha foinse oscailte rialú gan srian ar do réasúnaí AI. Is féidir leat a chinntiú go dtuigeann sé do réimse, labhrann sé i do ghuth, agus ní sheolann sé d'fhaisnéis ar tríú páirtí. Le teicníocha éifeachta nua-aimseartha cosúil le LoRA agus quantization, tá sé níos inrochtana ná riamh.

Ní hé todhchaí na AI díreach samhail duine eile a úsáid — is é a dhéanamh go fíor do chuid féin.

Ag teacht: Airteagal 4 — "Do Shamhail Theanga a Thógáil: Beag Ach Cumhachtach"